@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/calls/relay-server.ts

@@ -8,16 +8,15 @@
 
 import { randomInt } from "node:crypto";
 
-import type { AdmissionPolicy, TrustVerdict } from "@vellumai/gateway-client";
+import type { AdmissionPolicy } from "@vellumai/gateway-client";
 import type { ServerWebSocket } from "bun";
 
 import {
-  getGuardianDelivery,
-  voiceGuardianDisplayName,
-} from "../contacts/guardian-delivery-reader.js";
+  findGuardianForChannel,
+  listGuardianChannels,
+} from "../contacts/contact-store.js";
 import { getAssistantName } from "../daemon/identity-helpers.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
-import type { TrustContext } from "../daemon/trust-context.js";
 import { getCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
 import { addMessage } from "../memory/conversation-crud.js";
 import { revokeScopedApprovalGrantsForContext } from "../memory/scoped-approval-grants.js";
@@ -27,11 +26,6 @@ import {
   resolveActorTrust,
   toTrustContext,
 } from "../runtime/actor-trust-resolver.js";
-import {
-  trustContextFromVerdict,
-  verdictHasMemberIdentity,
-  verdictMemberUnresolvable,
-} from "../runtime/trust-verdict-consumer.js";
 import {
   composeVerificationVoice,
   GUARDIAN_VERIFY_TEMPLATE_KEYS,
@@ -56,10 +50,6 @@ import {
 import { ConversationRelayTransport } from "./call-transport.js";
 import { getChannelAdmissionPolicy } from "./channel-admission-reader.js";
 import { finalizeCall } from "./finalize-call.js";
-import {
-  getInboundTrustVerdict,
-  getPhoneCallerVerdict,
-} from "./inbound-trust-reader.js";
 import {
   classifyWaitUtterance,
   emitAccessRequestCallbackHandoff,
@@ -262,10 +252,6 @@ export class RelayConnection {
   private accessRequestWaitStartedAt: number = 0;
   private heartbeatSequence = 0;
 
-  // Guardian displayName primed from the gateway binding at setup, read
-  // synchronously by the heartbeat-driven wait-label path.
-  private primedGuardianDisplayName: string | undefined;
-
   // In-wait prompt handling state
   private lastInWaitReplyAt = 0;
   private static readonly IN_WAIT_REPLY_COOLDOWN_MS = 3000;
@@ -275,12 +261,6 @@ export class RelayConnection {
   private callbackOptIn = false;
   private callbackHandoffNotified = false;
 
-  // True while mid-call trust is being re-resolved (async). handlePrompt defers
-  // prompts to trustReResolvePending so a verified caller can't start a turn
-  // under the stale pre-verification trust context during the await window.
-  private trustReResolving = false;
-  private trustReResolvePending: RelayPromptMessage[] = [];
-
   constructor(ws: ServerWebSocket<RelayWebSocketData>, callSessionId: string) {
     this.ws = ws;
     this.callSessionId = callSessionId;
@@ -601,21 +581,12 @@ export class RelayConnection {
     const session = getCallSession(this.callSessionId);
     this.recordSetupBookkeeping(session, msg);
 
-    await this.primeGuardianDisplayName();
-
     // Resolve the phone channel's inbound admission floor. The reader fails
     // open to `null` by contract, so a transport hiccup admits the caller.
     const admissionPolicy = await getChannelAdmissionPolicy("phone");
 
-    // Verdict-first caller trust. routeSetup uses it when present and not
-    // resolutionFailed, else falls back to local resolution. The reader
-    // returns null on failure, so a gateway blip keeps the local path.
-    const isInbound = session?.initiatedFromConversationId == null;
-    const otherPartyNumber = isInbound ? msg.from : msg.to;
-    const verdict = await getPhoneCallerVerdict(otherPartyNumber);
-
     try {
-      await this.routeSetupOutcome(msg, session, admissionPolicy, verdict);
+      await this.routeSetupOutcome(msg, session, admissionPolicy);
     } catch (err) {
       // Never leave the connection stranded in "setting_up": a setup that
       // throws before reaching a terminal outcome would otherwise drop every
@@ -644,7 +615,6 @@ export class RelayConnection {
     msg: RelaySetupMessage,
     session: ReturnType<typeof getCallSession>,
     admissionPolicy: AdmissionPolicy | null,
-    verdict: TrustVerdict | null,
   ): Promise<void> {
     const { outcome, resolved } = routeSetup({
       callSessionId: this.callSessionId,
@@ -653,7 +623,6 @@ export class RelayConnection {
       to: msg.to,
       customParameters: msg.customParameters,
       admissionPolicy,
-      verdict,
     });
 
     const initialTrustContext = toTrustContext(
@@ -902,95 +871,6 @@ export class RelayConnection {
       );
   }
 
-  /**
-   * Re-resolve caller trust after a mid-call verification/activation. Prefers
-   * the gateway verdict (authoritative right after the gateway updated the
-   * binding); falls back to local resolution on a missing/failed/unusable
-   * verdict so a blip never drops the call. Mirrors the setup path's
-   * verdict-first-with-fallback condition.
-   */
-  private async resolveMidCallTrustContext(
-    assistantId: string,
-    fromNumber: string,
-  ): Promise<TrustContext> {
-    const verdict = await getInboundTrustVerdict({
-      channelType: "phone",
-      actorExternalId: fromNumber,
-    });
-
-    // Only a MEMBERLESS unknown verdict is treated as a stale gateway view and
-    // falls back to local: the caller was just activated, and invite redemption
-    // writes the channel assistant-side, so the gateway may not see the member
-    // yet — local resolution has it. A MEMBERFUL unknown verdict (blocked/revoked
-    // member, carrying contactId/channelId) is honored so its deny ACL is
-    // enforced; falling back could lose the gateway's member status if local
-    // state is stale.
-    const memberlessUnknown =
-      verdict?.trustClass === "unknown" && !verdictHasMemberIdentity(verdict);
-    const usable =
-      verdict &&
-      !verdict.resolutionFailed &&
-      !verdictMemberUnresolvable(verdict) &&
-      !memberlessUnknown;
-
-    if (usable) {
-      return trustContextFromVerdict(verdict, {
-        sourceChannel: "phone",
-        conversationExternalId: fromNumber,
-      });
-    }
-
-    return toTrustContext(
-      resolveActorTrust({
-        assistantId,
-        sourceChannel: "phone",
-        conversationExternalId: fromNumber,
-        actorExternalId: fromNumber,
-      }),
-      fromNumber,
-    );
-  }
-
-  /**
-   * Re-resolve mid-call trust and install it on the controller, deferring any
-   * prompt that arrives during the async window. Guards the gap between
-   * connectionState flipping to "connected" and the upgraded context landing so
-   * a verified caller never starts a turn under the stale pre-verification
-   * trust. Clears the guard in a finally and flushes buffered prompts under the
-   * new context, so an IPC error can't wedge the call.
-   */
-  private async reResolveAndApplyTrustContext(
-    assistantId: string,
-    fromNumber: string,
-  ): Promise<void> {
-    if (!this.controller) return;
-    this.trustReResolving = true;
-    try {
-      const context = await this.resolveMidCallTrustContext(
-        assistantId,
-        fromNumber,
-      );
-      this.controller.setTrustContext(context);
-    } finally {
-      this.trustReResolving = false;
-      this.flushDeferredPrompts();
-    }
-  }
-
-  /**
-   * Replay prompts buffered while trust was re-resolving. Runs after the
-   * upgraded context is installed so deferred utterances are answered under the
-   * correct trust.
-   */
-  private flushDeferredPrompts(): void {
-    if (this.trustReResolvePending.length === 0) return;
-    const pending = this.trustReResolvePending;
-    this.trustReResolvePending = [];
-    for (const msg of pending) {
-      void this.handlePrompt(msg);
-    }
-  }
-
   /**
    * Shared post-activation handoff for all trusted-contact success paths
    * (access-request approval, invite redemption, verification code).
@@ -998,7 +878,7 @@ export class RelayConnection {
    * transition copy, and marks the next utterance as opening-ack so the
    * LLM continues naturally.
    */
-  private async continueCallAfterTrustedContactActivation(params: {
+  private continueCallAfterTrustedContactActivation(params: {
     assistantId: string;
     fromNumber: string;
     activationReason?:
@@ -1013,25 +893,26 @@ export class RelayConnection {
      * address.
      */
     inviteeName?: string | null;
-  }): Promise<void> {
+  }): void {
     const { assistantId, fromNumber } = params;
 
     // Contact activation is handled by the gateway — the assistant no
     // longer writes contact/channel records on inbound voice calls.
 
-    // Reach connected and clear wait/verification flags before re-resolving
-    // trust, so a prompt buffered during re-resolution flushes onto the
-    // real-turn path, not the verification/wait branches.
-    this.connectionState = "connected";
-    this.verificationSessionActive = false;
-    this.inviteRedemptionActive = false;
-    this.accessRequestWaitActive = false;
-    updateCallSession(this.callSessionId, { status: "in_progress" });
+    const updatedTrust = resolveActorTrust({
+      assistantId,
+      sourceChannel: "phone",
+      conversationExternalId: fromNumber,
+      actorExternalId: fromNumber,
+    });
 
     if (this.controller) {
-      await this.reResolveAndApplyTrustContext(assistantId, fromNumber);
+      this.controller.setTrustContext(toTrustContext(updatedTrust, fromNumber));
     }
 
+    this.connectionState = "connected";
+    updateCallSession(this.callSessionId, { status: "in_progress" });
+
     const guardianLabel = this.resolveGuardianLabel();
     let handoffText: string;
 
@@ -1164,7 +1045,7 @@ export class RelayConnection {
     const assistantId = this.verificationAssistantId;
     const fromNumber = this.verificationFromNumber;
 
-    const result = await attemptVerificationCode({
+    const result = attemptVerificationCode({
       verificationAssistantId: assistantId,
       verificationFromNumber: fromNumber,
       enteredCode,
@@ -1210,7 +1091,15 @@ export class RelayConnection {
 
         // Update trust context on the controller so the LLM knows this is the guardian
         if (this.controller) {
-          await this.reResolveAndApplyTrustContext(assistantId, fromNumber);
+          const verifiedActorTrust = resolveActorTrust({
+            assistantId,
+            sourceChannel: "phone",
+            conversationExternalId: fromNumber,
+            actorExternalId: fromNumber,
+          });
+          this.controller.setTrustContext(
+            toTrustContext(verifiedActorTrust, fromNumber),
+          );
         }
 
         // Mark session as in-progress and transition to guardian conversation
@@ -1227,7 +1116,7 @@ export class RelayConnection {
             );
         }
       } else if (result.verificationType === "trusted_contact") {
-        await this.continueCallAfterTrustedContactActivation({
+        this.continueCallAfterTrustedContactActivation({
           assistantId,
           fromNumber,
           activationReason: "trusted_contact_verified",
@@ -1236,7 +1125,15 @@ export class RelayConnection {
         // Inbound guardian verification: binding already handled above,
         // proceed to normal call flow.
         if (this.controller) {
-          await this.reResolveAndApplyTrustContext(assistantId, fromNumber);
+          const verifiedActorTrust = resolveActorTrust({
+            assistantId,
+            sourceChannel: "phone",
+            conversationExternalId: fromNumber,
+            actorExternalId: fromNumber,
+          });
+          this.controller.setTrustContext(
+            toTrustContext(verifiedActorTrust, fromNumber),
+          );
           this.startNormalCallFlow(this.controller, true);
         }
       }
@@ -1399,7 +1296,7 @@ export class RelayConnection {
    * Creates a canonical access request, notifies the guardian, and
    * enters the bounded wait loop for the guardian decision.
    */
-  private async handleNameCaptureResponse(callerName: string): Promise<void> {
+  private handleNameCaptureResponse(callerName: string): void {
     if (!this.accessRequestAssistantId || !this.accessRequestFromNumber) {
       return;
     }
@@ -1420,7 +1317,7 @@ export class RelayConnection {
     // Create canonical access request and notify the guardian, including
     // the caller's spoken name and voice channel metadata.
     try {
-      const accessResult = await notifyGuardianOfAccessRequest({
+      const accessResult = notifyGuardianOfAccessRequest({
         canonicalAssistantId: this.accessRequestAssistantId,
         sourceChannel: "phone",
         conversationExternalId: this.accessRequestFromNumber,
@@ -1513,7 +1410,7 @@ export class RelayConnection {
       }
 
       if (request.status === "approved") {
-        void this.handleAccessRequestApproved();
+        this.handleAccessRequestApproved();
       } else if (request.status === "denied") {
         void this.handleAccessRequestDenied();
       }
@@ -1565,7 +1462,7 @@ export class RelayConnection {
    * Handle an approved access request: activate the caller as a trusted
    * contact, update runtime context, and continue with normal call flow.
    */
-  private async handleAccessRequestApproved(): Promise<void> {
+  private handleAccessRequestApproved(): void {
     this.clearAccessRequestWait();
 
     const assistantId = this.accessRequestAssistantId!;
@@ -1583,7 +1480,7 @@ export class RelayConnection {
       "Access request approved — caller activated and continuing call",
     );
 
-    await this.continueCallAfterTrustedContactActivation({
+    this.continueCallAfterTrustedContactActivation({
       assistantId,
       fromNumber,
       activationReason: "access_approved",
@@ -1791,7 +1688,7 @@ export class RelayConnection {
         "Voice invite redemption succeeded",
       );
 
-      await this.continueCallAfterTrustedContactActivation({
+      this.continueCallAfterTrustedContactActivation({
         assistantId: this.inviteRedemptionAssistantId,
         fromNumber: this.inviteRedemptionFromNumber,
         activationReason: "invite_redeemed",
@@ -1834,20 +1731,15 @@ export class RelayConnection {
    * Resolve a human-readable guardian label for voice wait copy.
    * Delegates to the shared resolveGuardianName() which checks the
    * guardian's per-user persona file (users/<slug>.md) first, then falls
-   * back to the primed gateway-binding displayName, then
-   * DEFAULT_USER_REFERENCE.
+   * back to Contact.displayName, then DEFAULT_USER_REFERENCE.
    */
   private resolveGuardianLabel(): string {
-    return resolveGuardianName(this.primedGuardianDisplayName);
-  }
+    // Look up the guardian contact for a displayName fallback
+    const voiceGuardian = findGuardianForChannel("phone");
+    const guardianChannels = voiceGuardian ? null : listGuardianChannels();
+    const guardianContact = voiceGuardian?.contact ?? guardianChannels?.contact;
 
-  /**
-   * Prime the guardian displayName from the gateway binding so the
-   * synchronous wait-label path can read it without an IPC round-trip.
-   */
-  private async primeGuardianDisplayName(): Promise<void> {
-    const list = await getGuardianDelivery();
-    this.primedGuardianDisplayName = voiceGuardianDisplayName(list);
+    return resolveGuardianName(guardianContact?.displayName);
   }
 
   /**
@@ -2025,15 +1917,6 @@ export class RelayConnection {
       return;
     }
 
-    // Defer (don't drop) prompts while trust is being re-resolved mid-call so a
-    // verified caller's first utterance runs under the upgraded context, not the
-    // stale pre-verification one. flushDeferredPrompts replays them in order
-    // once the new context lands.
-    if (this.trustReResolving) {
-      this.trustReResolvePending.push(msg);
-      return;
-    }
-
     // Prompts arriving before setup routing/ACL completes are dropped — never
     // persisted or emitted — so a not-yet-authorized caller's speech can't be
     // stored ahead of the admission floor / trust ACL decision.
@@ -2059,7 +1942,7 @@ export class RelayConnection {
         { callSessionId: this.callSessionId, callerName },
         "Name captured from unknown inbound caller",
       );
-      await this.handleNameCaptureResponse(callerName);
+      this.handleNameCaptureResponse(callerName);
       return;
     }
 

package/src/calls/relay-setup-router.ts

@@ -6,7 +6,7 @@
  * next — without performing any side effects itself.
  */
 
-import type { AdmissionPolicy, TrustVerdict } from "@vellumai/gateway-client";
+import type { AdmissionPolicy } from "@vellumai/gateway-client";
 
 import { getConfig } from "../config/loader.js";
 import { getContact } from "../contacts/contact-store.js";
@@ -21,10 +21,6 @@ import {
   type AdmissionPolicyResult,
   enforceAdmissionPolicy,
 } from "../runtime/routes/inbound-stages/admission-policy.js";
-import {
-  actorTrustContextFromVerdict,
-  verdictMemberUnresolvable,
-} from "../runtime/trust-verdict-consumer.js";
 import { getLogger } from "../util/logger.js";
 import type { CallSession } from "./types.js";
 
@@ -44,12 +40,6 @@ interface SetupContext {
    * preserving all pre-admission behavior.
    */
   admissionPolicy?: AdmissionPolicy | null;
-  /**
-   * Gateway-stamped caller trust verdict. When present and not
-   * `resolutionFailed`, the caller's trust is built from it; otherwise the
-   * router falls back to local resolution.
-   */
-  verdict?: TrustVerdict | null;
 }
 
 // ── Setup outcomes ───────────────────────────────────────────────────
@@ -122,32 +112,12 @@ export function routeSetup(ctx: SetupContext): {
   const isInbound = ctx.session?.initiatedFromConversationId == null;
   const otherPartyNumber = isInbound ? ctx.from : ctx.to;
 
-  // Verdict-first: build caller trust from the gateway verdict when present.
-  // Voice falls back to local resolution on a missing/failed verdict so a
-  // gateway blip does not drop a known guardian's call — the deliberate
-  // difference from the fail-closed text path.
-  //
-  // A verdict that claims a member (contactId/channelId) but whose ACL can't be
-  // reassembled (malformed/mixed-version status·policy) also falls back to local
-  // resolution, so voice never trusts a member it cannot ACL-check. A real
-  // stranger verdict (no member identity) still takes the verdict path —
-  // memberRecord null is correct there.
-  const usable =
-    ctx.verdict &&
-    !ctx.verdict.resolutionFailed &&
-    !verdictMemberUnresolvable(ctx.verdict);
-  const actorTrust = usable
-    ? actorTrustContextFromVerdict(ctx.verdict!, {
-        sourceChannel: "phone",
-        conversationExternalId: otherPartyNumber,
-        actorDisplayName: undefined,
-      })
-    : resolveActorTrust({
-        assistantId,
-        sourceChannel: "phone",
-        conversationExternalId: otherPartyNumber,
-        actorExternalId: otherPartyNumber || undefined,
-      });
+  const actorTrust = resolveActorTrust({
+    assistantId,
+    sourceChannel: "phone",
+    conversationExternalId: otherPartyNumber,
+    actorExternalId: otherPartyNumber || undefined,
+  });
 
   const resolved: SetupResolved = {
     assistantId,

package/src/calls/relay-verification.ts

@@ -112,9 +112,9 @@ type VerificationCallResult =
  * so the caller can apply side-effects (state mutations, TTS, session
  * updates) without this function needing access to the relay connection.
  */
-export async function attemptVerificationCode(
+export function attemptVerificationCode(
   params: VerificationCallParams,
-): Promise<VerificationCallResult> {
+): VerificationCallResult {
   const {
     verificationAssistantId,
     verificationFromNumber,
@@ -142,7 +142,7 @@ export async function attemptVerificationCode(
     let canonicalPrincipal: string | undefined;
 
     if (result.verificationType === "guardian") {
-      const existingBinding = await getGuardianBinding(
+      const existingBinding = getGuardianBinding(
         verificationAssistantId,
         "phone",
       );
@@ -155,7 +155,7 @@ export async function attemptVerificationCode(
         };
       } else {
         // Resolve canonical principal from the vellum channel binding
-        const vellumBinding = await getGuardianBinding(
+        const vellumBinding = getGuardianBinding(
           verificationAssistantId,
           "vellum",
         );

package/src/calls/stt-hints.ts

@@ -1,8 +1,9 @@
-import { findContactByAddress, listContacts } from "../contacts/contact-store.js";
 import {
-  getGuardianDelivery,
-  voiceGuardianDisplayName,
-} from "../contacts/guardian-delivery-reader.js";
+  findContactByAddress,
+  findGuardianForChannel,
+  listContacts,
+  listGuardianChannels,
+} from "../contacts/contact-store.js";
 import { getAssistantName } from "../daemon/identity-helpers.js";
 import { DEFAULT_USER_REFERENCE, resolveGuardianName } from "../prompts/user-reference.js";
 import { getLogger } from "../util/logger.js";
@@ -118,7 +119,7 @@ export function buildSttHints(input: SttHintsInput): string {
  * {@link buildSttHints}. All DB lookups are best-effort — errors are
  * logged but never propagate so hints can never fail a call.
  */
-export async function resolveCallHints(
+export function resolveCallHints(
   session: {
     task: string | null;
     toNumber: string;
@@ -128,14 +129,16 @@ export async function resolveCallHints(
     inviteGuardianName: string | null;
   } | null,
   staticHints: string[],
-): Promise<string> {
+): string {
   const assistantName = getAssistantName();
 
-  // Resolve the guardian displayName from the gateway binding for STT vocabulary.
+  // Look up the guardian contact for a displayName fallback (mirrors relay-server pattern)
   let guardianDisplayName: string | undefined;
   try {
-    const list = await getGuardianDelivery();
-    guardianDisplayName = voiceGuardianDisplayName(list);
+    const voiceGuardian = findGuardianForChannel("phone");
+    const guardianChannels = voiceGuardian ? null : listGuardianChannels();
+    const guardianContact = voiceGuardian?.contact ?? guardianChannels?.contact;
+    guardianDisplayName = guardianContact?.displayName;
   } catch (err) {
     logger.warn({ err }, "Failed to look up guardian contact for STT hints");
   }

package/src/calls/twilio-routes.ts

@@ -55,7 +55,6 @@ import {
   updateCallSession,
 } from "./call-store.js";
 import { getChannelAdmissionPolicy } from "./channel-admission-reader.js";
-import { getPhoneCallerVerdict } from "./inbound-trust-reader.js";
 import { routeSetup } from "./relay-setup-router.js";
 import { resolveCallHints } from "./stt-hints.js";
 import { resolveTelephonySttRouting } from "./telephony-stt-routing.js";
@@ -299,7 +298,7 @@ async function processVoiceWebhook(
       "Inbound voice webhook — creating/reusing session",
     );
 
-    const { session } = await createInboundVoiceSession({
+    const { session } = createInboundVoiceSession({
       callSid,
       fromNumber: callerFrom,
       toNumber: callerTo,
@@ -485,21 +484,12 @@ async function buildVoiceWebhookTwiml(
   // admits the caller.
   const admissionPolicy = await getChannelAdmissionPolicy("phone");
 
-  // Verdict-first caller trust so this preflight matches handleSetup's ACL.
-  // routeSetup uses it when present and not resolutionFailed, else falls back
-  // to local resolution. The reader returns null on failure, keeping the
-  // local path on a gateway blip.
-  const isInbound = sessionContext?.direction !== "outbound";
-  const otherPartyNumber = isInbound ? from : to;
-  const verdict = await getPhoneCallerVerdict(otherPartyNumber);
-
   const { outcome } = routeSetup({
     callSessionId,
     session: session ?? null,
     from,
     to,
     admissionPolicy,
-    verdict,
   });
 
   // The media-stream transport supports normal_call and deny (which speaks
@@ -532,7 +522,7 @@ async function buildVoiceWebhookTwiml(
 /**
  * Build ConversationRelay TwiML for Twilio-native STT providers.
  */
-async function buildConversationRelayTwiml(
+function buildConversationRelayTwiml(
   callSessionId: string,
   profile: ReturnType<typeof resolveVoiceQualityProfile>,
   sessionContext: {
@@ -545,8 +535,8 @@ async function buildConversationRelayTwiml(
   } | null,
   verificationSessionId: string | null | undefined,
   sttAttrs: { transcriptionProvider: string; speechModel: string | undefined },
-): Promise<string> {
-  const rawHints = await resolveCallHints(sessionContext, profile.hints);
+): string {
+  const rawHints = resolveCallHints(sessionContext, profile.hints);
 
   const speechConfig: TwilioRelaySpeechConfig = {
     transcriptionProvider: sttAttrs.transcriptionProvider,

package/src/channels/types.ts

@@ -1,16 +1,26 @@
-import {
-  CHANNEL_IDS,
-  type ChannelId,
-  isChannelId,
-} from "@vellumai/service-contracts/channels";
+export const CHANNEL_IDS = [
+  "telegram",
+  "phone",
+  "vellum",
+  "whatsapp",
+  "slack",
+  "email",
+  "platform",
+  "a2a",
+] as const;
 
-// The assistant understands the full canonical channel set, so it adopts the
-// shared vocabulary wholesale. `parseChannelId` stays local — it is only used
-// daemon-side and is a thin convenience over the shared guard.
-export { CHANNEL_IDS, type ChannelId, isChannelId };
+export type ChannelId = (typeof CHANNEL_IDS)[number];
+
+export function isChannelId(value: unknown): value is ChannelId {
+  return (
+    typeof value === "string" &&
+    (CHANNEL_IDS as readonly string[]).includes(value)
+  );
+}
 
 export function parseChannelId(value: unknown): ChannelId | null {
-  return isChannelId(value) ? value : null;
+  if (isChannelId(value)) return value;
+  return null;
 }
 
 export interface TurnChannelContext {

package/src/cli/commands/__tests__/cache.test.ts

@@ -88,15 +88,8 @@ mock.module("../../../util/logger.js", () => ({
 }));
 
 mock.module("../../lib/cache-fs.js", () => ({
-  readFileSync: (path: string | number, encoding?: BufferEncoding) => {
-    // Stdin must be read via fd 0, not by reopening "/dev/stdin": a spawned
-    // subprocess whose stdin is a pipe (Bun.spawn stdin:"pipe") cannot reopen
-    // its read-end by path — open("/dev/stdin") fails ENXIO. Throwing here on
-    // the path makes any regression to path-based reading fail loudly.
+  readFileSync: (path: string, encoding?: BufferEncoding) => {
     if (path === "/dev/stdin") {
-      throw new Error("ENXIO: no such device or address, open '/dev/stdin'");
-    }
-    if (path === 0) {
       if (mockStdinContent === null) {
         throw new Error("EAGAIN: resource temporarily unavailable");
       }