@vellumai/assistant 0.4.2 → 0.4.4

package/src/__tests__/trusted-contact-lifecycle-notifications.test.ts

@@ -34,7 +34,6 @@ mock.module('../util/platform.js', () => ({
   getDbPath: () => join(testDir, 'test.db'),
   getLogPath: () => join(testDir, 'test.log'),
   ensureDataDir: () => {},
-  normalizeAssistantId: (id: string) => id === 'self' ? 'self' : id,
   readHttpToken: () => 'test-bearer-token',
 }));
 
@@ -82,6 +81,7 @@ mock.module('../runtime/approval-message-composer.js', () => ({
   composeApprovalMessageGenerative: async () => 'mock generative message',
 }));
 
+import { getResolver } from '../approvals/guardian-request-resolvers.js';
 import {
   createApprovalRequest,
   createBinding,
@@ -489,6 +489,16 @@ describe('trusted contact activated notification signal', () => {
     expect(activatedSignals.length).toBe(0);
   });
 
+  test('voice access_request resolver has registered handler for access_request kind', () => {
+    // The access_request resolver is registered during module load. When the
+    // source channel is 'voice', it should directly activate the member via
+    // upsertMember (no verification session). This test validates the resolver
+    // is registered and accessible.
+    const resolver = getResolver('access_request');
+    expect(resolver).toBeDefined();
+    expect(resolver!.kind).toBe('access_request');
+  });
+
   test('member is persisted BEFORE activated signal is emitted', async () => {
     // Set up a guardian binding
     createBinding({

package/src/__tests__/trusted-contact-multichannel.test.ts

@@ -29,7 +29,6 @@ mock.module('../util/platform.js', () => ({
   getDbPath: () => join(testDir, 'test.db'),
   getLogPath: () => join(testDir, 'test.log'),
   ensureDataDir: () => {},
-  normalizeAssistantId: (id: string) => id === 'self' ? 'self' : id,
   readHttpToken: () => 'test-bearer-token',
 }));
 

package/src/__tests__/trusted-contact-verification.test.ts

@@ -32,7 +32,6 @@ mock.module('../util/platform.js', () => ({
   getDbPath: () => join(testDir, 'test.db'),
   getLogPath: () => join(testDir, 'test.log'),
   ensureDataDir: () => {},
-  normalizeAssistantId: (id: string) => id === 'self' ? 'self' : id,
   readHttpToken: () => 'test-bearer-token',
 }));
 

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

@@ -86,25 +86,14 @@ describe('twilio-config', () => {
     expect(config.phoneNumber).toBe('+15558888888');
   });
 
-  test('resolves assistant-scoped phone number when assistantId is provided', () => {
+  test('returns global phone number when assistantPhoneNumbers mapping exists', () => {
     mockLoadConfigResult = {
       sms: {
         phoneNumber: '+15551234567',
         assistantPhoneNumbers: { 'ast-1': '+15557777777' },
       },
     };
-    const config = getTwilioConfig('ast-1');
-    expect(config.phoneNumber).toBe('+15557777777');
-  });
-
-  test('falls back to global phone number when assistant has no dedicated number', () => {
-    mockLoadConfigResult = {
-      sms: {
-        phoneNumber: '+15551234567',
-        assistantPhoneNumbers: { 'ast-1': '+15557777777' },
-      },
-    };
-    const config = getTwilioConfig('ast-unknown');
+    const config = getTwilioConfig();
     expect(config.phoneNumber).toBe('+15551234567');
   });
 });

package/src/__tests__/twilio-routes.test.ts

@@ -704,19 +704,20 @@ describe('twilio webhook routes', () => {
       expect(res.status).toBe(400);
     });
 
-    test('inbound webhook with forwarded assistantId creates session with correct assistantId', async () => {
+    test('inbound webhook creates session with internal scope assistantId', async () => {
       const req = makeInboundVoiceRequest({
         CallSid: 'CA_inbound_assist_1',
         From: '+14155551234',
         To: '+15550001111',
       });
 
-      const res = await handleVoiceWebhook(req, 'my-assistant-id');
+      const res = await handleVoiceWebhook(req);
 
       expect(res.status).toBe(200);
       const session = getCallSessionByCallSid('CA_inbound_assist_1');
       expect(session).not.toBeNull();
-      expect(session!.assistantId).toBe('my-assistant-id');
+      // Daemon always uses internal scope — external assistant IDs are not leaked into session state.
+      expect(session!.assistantId).toBe('self');
     });
 
     test('outbound call flow remains non-regressed with callSessionId present', async () => {

package/src/__tests__/update-bulletin.test.ts

@@ -53,7 +53,6 @@ mock.module('../util/platform.js', () => ({
   getInterfacesDir: () => '',
   getClipboardCommand: () => null,
   readLockfile: () => null,
-  normalizeAssistantId: (id: string) => id,
   writeLockfile: () => {},
   readPlatformToken: () => null,
   readSessionToken: () => null,

package/src/agent/loop.ts

@@ -41,7 +41,7 @@ export type AgentEvent =
 
 const DEFAULT_CONFIG: AgentLoopConfig = {
   maxTokens: 16000,
-  maxToolUseTurns: 60,
+  maxToolUseTurns: 0,
   minTurnIntervalMs: 150,
 };
 

package/src/approvals/guardian-decision-primitive.ts

@@ -35,6 +35,7 @@ import {
   type GuardianApprovalRequest,
   updateApprovalDecision,
 } from '../memory/channel-guardian-store.js';
+import { DAEMON_INTERNAL_ASSISTANT_ID } from '../runtime/assistant-scope.js';
 import type {
   ApprovalAction,
   ApprovalDecisionResult,
@@ -52,6 +53,7 @@ import {
   type ActorContext,
   type ChannelDeliveryContext,
   getResolver,
+  type ResolverEmissionContext,
 } from './guardian-request-resolvers.js';
 
 const log = getLogger('guardian-decision-primitive');
@@ -233,7 +235,7 @@ export function mintCanonicalRequestGrant(params: {
   }
 
   const result = mintGrantFromDecision({
-    assistantId: 'self',
+    assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
     scopeMode: 'tool_signature',
     toolName: request.toolName,
     inputDigest: request.inputDigest,
@@ -294,10 +296,12 @@ export interface ApplyCanonicalGuardianDecisionParams {
   userText?: string;
   /** Optional channel delivery context — present when the decision arrived via a channel message. */
   channelDeliveryContext?: ChannelDeliveryContext;
+  /** Optional emission context threaded to handleConfirmationResponse for correct source attribution. */
+  emissionContext?: ResolverEmissionContext;
 }
 
 export type CanonicalDecisionResult =
-  | { applied: true; requestId: string; grantMinted: boolean; resolverFailed?: boolean; resolverFailureReason?: string }
+  | { applied: true; requestId: string; grantMinted: boolean; resolverFailed?: boolean; resolverFailureReason?: string; resolverReplyText?: string }
   | { applied: false; reason: 'not_found' | 'already_resolved' | 'identity_mismatch' | 'invalid_action' | 'expired'; detail?: string };
 
 /**
@@ -318,7 +322,7 @@ export type CanonicalDecisionResult =
 export async function applyCanonicalGuardianDecision(
   params: ApplyCanonicalGuardianDecisionParams,
 ): Promise<CanonicalDecisionResult> {
-  const { requestId, action, actorContext, userText, channelDeliveryContext } = params;
+  const { requestId, action, actorContext, userText, channelDeliveryContext, emissionContext } = params;
 
   // 1. Look up the canonical request
   const request = getCanonicalGuardianRequest(requestId);
@@ -426,6 +430,7 @@ export async function applyCanonicalGuardianDecision(
   // 5. Dispatch to kind-specific resolver
   let resolverFailed = false;
   let resolverFailureReason: string | undefined;
+  let resolverReplyText: string | undefined;
   const resolver = getResolver(request.kind);
   if (resolver) {
     const resolverResult = await resolver.resolve({
@@ -433,6 +438,7 @@ export async function applyCanonicalGuardianDecision(
       decision: { action: effectiveAction, userText },
       actor: actorContext,
       channelDeliveryContext,
+      emissionContext,
     });
 
     if (!resolverResult.ok) {
@@ -451,6 +457,8 @@ export async function applyCanonicalGuardianDecision(
       // still being informed that the resolver had an issue.
       resolverFailed = true;
       resolverFailureReason = resolverResult.reason;
+    } else {
+      resolverReplyText = resolverResult.guardianReplyText;
     }
   } else {
     log.info(
@@ -493,5 +501,6 @@ export async function applyCanonicalGuardianDecision(
     requestId,
     grantMinted,
     ...(resolverFailed ? { resolverFailed, resolverFailureReason } : {}),
+    ...(resolverReplyText ? { resolverReplyText } : {}),
   };
 }

package/src/approvals/guardian-request-resolvers.ts

@@ -12,18 +12,27 @@
  */
 
 import { answerCall } from '../calls/call-domain.js';
-import type { CanonicalGuardianRequest } from '../memory/canonical-guardian-store.js';
+import { getGatewayInternalBaseUrl } from '../config/env.js';
+import { type CanonicalGuardianRequest,getCanonicalGuardianRequest } from '../memory/canonical-guardian-store.js';
+import { upsertMember } from '../memory/ingress-member-store.js';
 import { emitNotificationSignal } from '../notifications/emit-signal.js';
 import { addRule } from '../permissions/trust-store.js';
+import { DAEMON_INTERNAL_ASSISTANT_ID } from '../runtime/assistant-scope.js';
 import type { ApprovalAction } from '../runtime/channel-approval-types.js';
 import { createOutboundSession } from '../runtime/channel-guardian-service.js';
 import { deliverChannelReply } from '../runtime/gateway-client.js';
 import * as pendingInteractions from '../runtime/pending-interactions.js';
 import { getTool } from '../tools/registry.js';
+import { TC_GRANT_WAIT_MAX_MS } from '../tools/tool-approval-handler.js';
 import { getLogger } from '../util/logger.js';
+import { readHttpToken } from '../util/platform.js';
 
 const log = getLogger('guardian-request-resolvers');
 
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -58,6 +67,13 @@ export interface ChannelDeliveryContext {
   bearerToken?: string;
 }
 
+/** Emission context threaded from callers to handleConfirmationResponse. */
+export interface ResolverEmissionContext {
+  source?: 'button' | 'inline_nl' | 'auto_deny' | 'timeout' | 'system';
+  causedByRequestId?: string;
+  decisionText?: string;
+}
+
 /** Context passed to each resolver after CAS resolution succeeds. */
 export interface ResolverContext {
   /** The canonical request record (already resolved to its terminal status). */
@@ -68,13 +84,27 @@ export interface ResolverContext {
   actor: ActorContext;
   /** Optional channel delivery context — present when the decision arrived via a channel message. */
   channelDeliveryContext?: ChannelDeliveryContext;
+  /** Optional emission context threaded to handleConfirmationResponse for correct source attribution. */
+  emissionContext?: ResolverEmissionContext;
 }
 
 /** Discriminated result from a resolver. */
 export type ResolverResult =
-  | { ok: true; applied: true; grantMinted?: boolean }
+  | { ok: true; applied: true; grantMinted?: boolean; guardianReplyText?: string }
   | { ok: false; reason: string };
 
+function resolveDeliverCallbackUrlForChannel(channel: string): string | null {
+  switch (channel) {
+    case 'telegram':
+    case 'sms':
+    case 'whatsapp':
+    case 'slack':
+      return `${getGatewayInternalBaseUrl()}/deliver/${channel}`;
+    default:
+      return null;
+  }
+}
+
 /** Interface that kind-specific resolvers implement. */
 export interface GuardianRequestResolver {
   /** The request kind this resolver handles (matches canonical_guardian_requests.kind). */
@@ -133,11 +163,13 @@ const pendingInteractionResolver: GuardianRequestResolver = {
         decision.action === 'approve_always' &&
         details &&
         details.persistentDecisionsAllowed !== false &&
-        details.allowlistOptions?.length &&
-        details.scopeOptions?.length
+        details.allowlistOptions?.length
       ) {
         const pattern = details.allowlistOptions[0].pattern;
-        const scope = details.scopeOptions[0].scope;
+        // Non-scoped tools (web_fetch, network_request, etc.) have empty
+        // scopeOptions — default to 'everywhere' so approve_always still
+        // persists a trust rule instead of silently degrading to one-time.
+        const scope = details.scopeOptions?.length ? details.scopeOptions[0].scope : 'everywhere';
         const tool = getTool(details.toolName);
         const executionTarget = tool?.origin === 'skill' ? details.executionTarget : undefined;
         addRule(details.toolName, pattern, scope, 'allow', 100, { executionTarget });
@@ -160,7 +192,7 @@ const pendingInteractionResolver: GuardianRequestResolver = {
 
     // Map action to the permission system's UserDecision type and notify session.
     const userDecision = decision.action === 'reject' ? 'deny' as const : 'allow' as const;
-    resolved.session.handleConfirmationResponse(request.id, userDecision);
+    resolved.session.handleConfirmationResponse(request.id, userDecision, undefined, undefined, undefined, ctx.emissionContext);
 
     log.info(
       {
@@ -277,8 +309,11 @@ const accessRequestResolver: GuardianRequestResolver = {
     const channel = request.sourceChannel ?? 'unknown';
     const requesterExternalUserId = request.requesterExternalUserId ?? '';
     const requesterChatId = request.requesterChatId ?? request.requesterExternalUserId ?? '';
+    const requesterLabel = requesterExternalUserId || requesterChatId || 'the requester';
     const decidedByExternalUserId = ctx.actor.externalUserId ?? '';
-    const assistantId = channelDeliveryContext?.assistantId ?? 'self';
+    const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
+    const desktopDeliverUrl = resolveDeliverCallbackUrlForChannel(channel);
+    const desktopBearerToken = readHttpToken() ?? undefined;
 
     if (decision.action === 'reject') {
       log.info(
@@ -335,12 +370,59 @@ const accessRequestResolver: GuardianRequestResolver = {
           contextPayload: deniedPayload,
           dedupeKey: `trusted-contact:denied:${request.id}`,
         });
+      } else if (desktopDeliverUrl && requesterChatId) {
+        try {
+          await deliverChannelReply(desktopDeliverUrl, {
+            chatId: requesterChatId,
+            text: 'Your access request has been denied by the guardian.',
+            assistantId,
+          }, desktopBearerToken);
+        } catch (err) {
+          log.error({ err, requesterChatId }, 'Failed to notify requester of access request denial (desktop decision path)');
+        }
+      }
+
+      return {
+        ok: true,
+        applied: true,
+        ...(ctx.actor.isTrusted ? { guardianReplyText: `Access denied for ${requesterLabel}.` } : {}),
+      };
+    }
+
+    // Voice approvals: directly activate the trusted contact without minting
+    // a verification session. The caller is already on the line and the
+    // relay server's in-call wait loop will detect the approved status.
+    if (channel === 'voice') {
+      try {
+        upsertMember({
+          assistantId,
+          sourceChannel: 'voice',
+          externalUserId: requesterExternalUserId,
+          externalChatId: requesterChatId,
+          status: 'active',
+          policy: 'allow',
+        });
+      } catch (err) {
+        log.error(
+          { err, requesterExternalUserId },
+          'Access request resolver: failed to activate voice caller as trusted contact',
+        );
       }
 
+      log.info(
+        {
+          event: 'resolver_access_request_voice_approved',
+          requestId: request.id,
+          channel,
+          requesterExternalUserId,
+        },
+        'Access request resolver: voice approval — direct trusted-contact activation (no verification session)',
+      );
+
       return { ok: true, applied: true };
     }
 
-    // On approve: mint an identity-bound verification session so the
+    // Non-voice approvals: mint an identity-bound verification session so the
     // requester can verify their identity.
     const session = createOutboundSession({
       assistantId,
@@ -365,6 +447,7 @@ const accessRequestResolver: GuardianRequestResolver = {
 
     // Deliver the verification code to the guardian and notify the requester
     // when channel delivery context is available (channel message path).
+    let requesterNotified = false;
     if (channelDeliveryContext) {
       let codeDelivered = true;
 
@@ -395,6 +478,7 @@ const accessRequestResolver: GuardianRequestResolver = {
               + 'Please enter the 6-digit verification code you receive from the guardian.',
             assistantId,
           }, channelDeliveryContext.bearerToken);
+          requesterNotified = true;
         } catch (err) {
           log.error({ err, requesterChatId }, 'Failed to notify requester of access request approval');
         }
@@ -434,9 +518,29 @@ const accessRequestResolver: GuardianRequestResolver = {
           dedupeKey: `trusted-contact:verification-sent:${session.sessionId}`,
         });
       }
+    } else if (desktopDeliverUrl && requesterChatId) {
+      try {
+        await deliverChannelReply(desktopDeliverUrl, {
+          chatId: requesterChatId,
+          text: 'Your access request has been approved! '
+            + 'Please enter the 6-digit verification code you receive from the guardian.',
+          assistantId,
+        }, desktopBearerToken);
+        requesterNotified = true;
+      } catch (err) {
+        log.error({ err, requesterChatId }, 'Failed to notify requester of access request approval (desktop decision path)');
+      }
     }
 
-    return { ok: true, applied: true };
+    const verificationReplyText = requesterNotified
+      ? `Access approved for ${requesterLabel}. Give them this verification code: ${session.secret}. The code expires in 10 minutes.`
+      : `Access approved for ${requesterLabel}. Give them this verification code: ${session.secret}. The code expires in 10 minutes. I could not notify them automatically, so please tell them to send the code manually.`;
+
+    return {
+      ok: true,
+      applied: true,
+      ...(ctx.actor.isTrusted ? { guardianReplyText: verificationReplyText } : {}),
+    };
   },
 };
 
@@ -461,7 +565,7 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
   async resolve(ctx: ResolverContext): Promise<ResolverResult> {
     const { request, decision, channelDeliveryContext } = ctx;
     const requesterChatId = request.requesterChatId ?? request.requesterExternalUserId ?? '';
-    const assistantId = channelDeliveryContext?.assistantId ?? 'self';
+    const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
 
     if (decision.action === 'reject') {
       log.info(
@@ -495,7 +599,61 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
       'Tool grant request resolver: approved (grant minting deferred to canonical primitive)',
     );
 
-    if (channelDeliveryContext && requesterChatId) {
+    // Re-read the canonical request to check whether an inline grant waiter
+    // has already claimed this request. When followupState is
+    // 'inline_wait_active', the requester's original tool call is blocking
+    // on the grant and will resume automatically — sending a "please retry"
+    // notification would be stale and confusing (and could cause duplicate
+    // attempts or one-time-grant denials).
+    //
+    // Staleness guard: the inline_wait_active marker is persisted in DB and
+    // can outlive the actual waiter if the daemon crashes or restarts during
+    // the wait. To avoid permanently suppressing the retry notification, we
+    // treat the marker as stale if the encoded start timestamp is older than
+    // the maximum wait budget plus a 30s buffer.
+    const INLINE_WAIT_STALENESS_BUFFER_MS = 30_000;
+    const freshRequest = getCanonicalGuardianRequest(request.id);
+    const followupState = freshRequest?.followupState ?? '';
+    let inlineWaitActive = followupState.startsWith('inline_wait_active');
+    if (inlineWaitActive && freshRequest) {
+      // The followupState encodes the wall-clock epoch when the inline wait
+      // started (e.g. 'inline_wait_active:1700000000000'). We use this
+      // instead of updatedAt because resolveCanonicalGuardianRequest sets
+      // updatedAt = now during CAS resolution, making updatedAt always fresh
+      // by the time this resolver runs.
+      const colonIdx = followupState.indexOf(':');
+      const waitStartMs = colonIdx !== -1 ? Number(followupState.slice(colonIdx + 1)) : NaN;
+      const markerAgeMs = Number.isFinite(waitStartMs)
+        ? Date.now() - waitStartMs
+        : Infinity; // Treat unparseable timestamps as stale for safety.
+      const stalenessThresholdMs = TC_GRANT_WAIT_MAX_MS + INLINE_WAIT_STALENESS_BUFFER_MS;
+      if (markerAgeMs > stalenessThresholdMs) {
+        log.warn(
+          {
+            event: 'resolver_tool_grant_request_stale_inline_wait',
+            requestId: request.id,
+            toolName: request.toolName,
+            markerAgeMs,
+            stalenessThresholdMs,
+            waitStartMs,
+          },
+          'inline_wait_active marker is stale (daemon likely crashed during wait) — sending retry notification',
+        );
+        inlineWaitActive = false;
+      }
+    }
+
+    if (inlineWaitActive) {
+      log.info(
+        {
+          event: 'resolver_tool_grant_request_skip_retry_notification',
+          requestId: request.id,
+          toolName: request.toolName,
+          followupState: freshRequest?.followupState,
+        },
+        'Skipping requester retry notification — inline grant wait is active and will resume the original invocation',
+      );
+    } else if (channelDeliveryContext && requesterChatId) {
       try {
         await deliverChannelReply(channelDeliveryContext.replyCallbackUrl, {
           chatId: requesterChatId,

package/src/calls/call-constants.ts

@@ -41,6 +41,35 @@ export function getUserConsultationTimeoutMs(): number {
   return getConfig().calls.userConsultTimeoutSeconds * 1000;
 }
 
+export function getTtsPlaybackDelayMs(): number {
+  return getConfig().calls.ttsPlaybackDelayMs;
+}
+
+export function getAccessRequestPollIntervalMs(): number {
+  return getConfig().calls.accessRequestPollIntervalMs;
+}
+
+export function getGuardianWaitUpdateInitialIntervalMs(): number {
+  return getConfig().calls.guardianWaitUpdateInitialIntervalMs;
+}
+
+export function getGuardianWaitUpdateInitialWindowMs(): number {
+  return getConfig().calls.guardianWaitUpdateInitialWindowMs;
+}
+
+export function getGuardianWaitUpdateSteadyMinIntervalMs(): number {
+  return getConfig().calls.guardianWaitUpdateSteadyMinIntervalMs;
+}
+
+export function getGuardianWaitUpdateSteadyMaxIntervalMs(): number {
+  return getConfig().calls.guardianWaitUpdateSteadyMaxIntervalMs;
+}
+
+export function getSilenceTimeoutMs(): number {
+  return 30 * 1000; // 30 seconds
+}
+
+/** @deprecated Use getSilenceTimeoutMs() for mockability in tests. */
 export const SILENCE_TIMEOUT_MS = 30 * 1000; // 30 seconds
 
 // Legacy named exports for backward compatibility (use functions above for config-backed values)

package/src/calls/call-controller.ts

@@ -18,10 +18,11 @@ import {
   listCanonicalGuardianDeliveries,
 } from '../memory/canonical-guardian-store.js';
 import { revokeScopedApprovalGrantsForContext } from '../memory/scoped-approval-grants.js';
+import { DAEMON_INTERNAL_ASSISTANT_ID } from '../runtime/assistant-scope.js';
 import { computeToolApprovalDigest } from '../security/tool-approval-digest.js';
 import { getLogger } from '../util/logger.js';
 import { readHttpToken } from '../util/platform.js';
-import { getMaxCallDurationMs, getUserConsultationTimeoutMs, SILENCE_TIMEOUT_MS } from './call-constants.js';
+import { getMaxCallDurationMs, getSilenceTimeoutMs, getUserConsultationTimeoutMs } from './call-constants.js';
 import { persistCallCompletionMessage } from './call-conversation-messages.js';
 import { addPointerMessage, formatDuration } from './call-pointer-messages.js';
 import { fireCallCompletionNotifier, fireCallQuestionNotifier, fireCallTranscriptNotifier,registerCallController, unregisterCallController } from './call-state.js';
@@ -245,7 +246,7 @@ export class CallController {
     this.task = task;
     this.isInbound = !task;
     this.broadcast = opts?.broadcast;
-    this.assistantId = opts?.assistantId ?? 'self';
+    this.assistantId = opts?.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID;
     this.guardianContext = opts?.guardianContext ?? null;
 
     // Resolve the conversation ID from the call session
@@ -1048,8 +1049,15 @@ export class CallController {
   private resetSilenceTimer(): void {
     if (this.silenceTimer) clearTimeout(this.silenceTimer);
     this.silenceTimer = setTimeout(() => {
+      // During guardian wait states, the relay heartbeat timer handles
+      // periodic updates — suppress the generic "Are you still there?"
+      // which is confusing when the caller is waiting on a decision.
+      if (this.relay.getConnectionState() === 'awaiting_guardian_decision') {
+        log.debug({ callSessionId: this.callSessionId }, 'Silence timeout suppressed during guardian wait');
+        return;
+      }
       log.info({ callSessionId: this.callSessionId }, 'Silence timeout triggered');
       this.relay.sendTextToken('Are you still there?', true);
-    }, SILENCE_TIMEOUT_MS);
+    }, getSilenceTimeoutMs());
   }
 }