@stage-labs/metro 0.1.0-beta.264 → 0.1.0-beta.266

package/runtime/node_modules/@metro-labs/daemon/src/mcp/session.ts

@@ -12,6 +12,8 @@ import { BoundedEventStore } from './event-store.js';
 import { registerPermissionRelay } from './permission-relay.js';
 import { registerToolHandlers, toolSchemaSignature } from './tool-dispatch.js';
 import { web, type RawGetSink } from './raw-get-stream.js';
+import { sharedCalls } from '../voice/shared.js';
+import { CALL_STATE } from '@metro-labs/core/call';
 
 export const channelLog = (...a: unknown[]): void => {
   console.error('[metro-mcp]', ...a);
@@ -76,9 +78,11 @@ export class McpSession {
   private issuedSchema: string | undefined;
   private announcing = false;
   private readonly onClosed: (session: McpSession) => void;
+  private readonly kind: SessionKind;
 
   private constructor(init: SessionInit) {
     this.id = init.id;
+    this.kind = init.kind ?? 'chat';
     this.scope = init.scope;
     this.live = init.live;
     this.issuedSchema = init.adopted ? undefined : toolSchemaSignature();
@@ -112,6 +116,7 @@ export class McpSession {
       senderAllowed,
       approves,
       answerPermission,
+      callMeta: (event) => voice ? () => ({}) : sharedCalls.bindChat(event, this.scope),
     });
     if (!voice)
       registerPermissionRelay({
@@ -167,7 +172,20 @@ export class McpSession {
 
   bindSink(sink: RawGetSink | undefined): void {
     this.sink = sink;
-    if (sink !== undefined) this.announceToolSchema();
+    if (sink !== undefined) {
+      this.announceCallState();
+      this.announceToolSchema();
+    }
+  }
+
+  private announceCallState(): void {
+    if (this.kind !== 'chat' || !this.streamAttached || this.server.getClientVersion()?.name !== 'metro-sdk-runner') return;
+    const active = sharedCalls.snapshot();
+    const route = active !== null && this.scope.has(active.agentId) && eventInScope(this.scope, active.line) ? active : null;
+    this.server.notification({ method: CALL_STATE, params: { route, ...(route === null ? {} : { meta: { line: route.line } }) } }).catch((err: unknown) => {
+      channelLog('session: call state notification failed', errMsg(err));
+      if (route !== null) sharedCalls.end(route);
+    });
   }
 
   private get schemaNoticeDue(): boolean {
@@ -206,6 +224,7 @@ export class McpSession {
   async close(): Promise<void> {
     if (this.closed) return;
     this.closed = true;
+    if (this.kind === 'chat') sharedCalls.revoke();
     this.onClosed(this);
     forgetPromptsOf(this.server);
     this.dropStream();

package/runtime/node_modules/@metro-labs/daemon/src/mcp/speech-schema.ts

@@ -0,0 +1,11 @@
+export const speechSchema = {
+  type: 'object',
+  description: 'Speak text only in the exact active Stage call, without posting it in chat. Copy callId, generation and sourceId from its authenticated call input or call_id, call_generation and call_source_id from the requesting channel message. Use only for a call reply or an explicit owner request to speak in that call. Normal chat and worker results stay silent. One action per source; retries do not repeat speech. Accepted or queued is not heard. Completed means audio transport drained, not proof the caller heard it.',
+  properties: {
+    callId: { type: 'string' },
+    generation: { type: 'string' },
+    sourceId: { type: 'string' },
+  },
+  required: ['callId', 'generation', 'sourceId'],
+  additionalProperties: false,
+} as const;

package/runtime/node_modules/@metro-labs/daemon/src/mcp/speech-send.ts

@@ -0,0 +1,15 @@
+import { speechTarget } from '@metro-labs/core/call';
+import type { ToolResult } from '@metro-labs/core/stations/types';
+import { sharedCalls } from '../voice/shared.js';
+import { allowedAgents, currentIdentity } from './request-identity.js';
+import { errResult, okJson } from './ctx.js';
+
+export function sendSpeech(line: string, args: Record<string, unknown>): ToolResult {
+  const target = speechTarget(args.speech);
+  if (target === null) return errResult('Call speech needs callId, generation and sourceId from its authenticated source.');
+  if (['reply_to', 'subject', 'attachments', 'frame', 'wallet', 'account'].some((key) => args[key] !== undefined))
+    return errResult('Call speech cannot include chat content, media or an account override. Nothing was sent.');
+  if (typeof args.text !== 'string') return errResult('Call speech needs text.');
+  const receipt = sharedCalls.speak(line, target, args.text, allowedAgents(currentIdentity()));
+  return okJson({ speech: receipt, delivery: 'Audio transport status only. No proof the caller heard it. No chat message was posted.' });
+}

package/runtime/node_modules/@metro-labs/daemon/src/mcp/tool-schemas.ts

@@ -1,5 +1,6 @@
 import type { ToolDef } from './tool-def.js';
 import { attachmentItem, CREATE_UPLOAD_TOOL } from './attachment-schema.js';
+import { speechSchema } from './speech-schema.js';
 
 const lineProp = {
   type: 'string',
@@ -34,7 +35,7 @@ export const COMMON_TOOLS: ToolDef[] = [
     group: 'write',
     description:
       'Send a message (and/or media) to a Metro conversation. Args: line, text?, reply_to?, ' +
-      'subject?, attachments?, frame?, wallet?. The station is derived from the line. Outlook and Gmail: send to ' +
+      'subject?, attachments?, frame?, wallet?, speech?. `speech` speaks text only in an authorized active call, never posts it in chat. The station is derived from the line. Outlook and Gmail: send to ' +
       'metro://<outlook|gmail>/<account>/<email address> to start a new email (subject defaults to the ' +
       'first line of text); the result names the new thread line. Each attachment names EXACTLY ONE ' +
       'source, and the choice matters: `upload` (an `upload_id` from `create_upload`, the ' +
@@ -54,6 +55,7 @@ export const COMMON_TOOLS: ToolDef[] = [
           type: 'string',
           description: 'The message text (optional if sending only media).',
         },
+        speech: speechSchema,
         reply_to: {
           type: 'string',
           description: 'Optional message_id to quote/reply to.',

package/runtime/node_modules/@metro-labs/daemon/src/voice/audio.ts

@@ -5,6 +5,7 @@ const RATE = 48_000;
 const FRAME = 960;
 const FRAME_MS = 20;
 const MAX_LATE_FRAMES = 5;
+const MAX_QUEUED_FRAMES = 3_000;
 
 interface Frame {
   pcm: Int16Array;
@@ -55,7 +56,7 @@ export class OpusIn {
 }
 
 export interface Playback {
-  send(opus: Buffer, timestamp: number, marker: boolean): void;
+  send(opus: Buffer, timestamp: number, marker: boolean): void | Promise<void>;
   played(chars: number): void;
 }
 
@@ -70,11 +71,15 @@ export class Player {
   private speaking = false;
   private onIdle: (() => void) | null = null;
   private onFirst: (() => void) | null = null;
+  private onFailed: ((reason: string) => void) | null = null;
+  private generation = 0;
+  private inFlight = 0;
+  private closed = false;
 
   constructor(private readonly out: Playback) {}
 
   get busy(): boolean {
-    return this.queue.length > 0 || this.pending.length > 0;
+    return this.queue.length > 0 || this.pending.length > 0 || this.inFlight > 0;
   }
 
   whenFirstPlayed(fn: () => void): void {
@@ -85,7 +90,16 @@ export class Player {
     this.onIdle = fn;
   }
 
+  whenFailed(fn: (reason: string) => void): void {
+    this.onFailed = fn;
+  }
+
   push(pcm: Int16Array, chars: number): void {
+    if (this.closed) return;
+    if (this.queue.length + this.inFlight + Math.ceil((this.pending.length + pcm.length) / FRAME) > MAX_QUEUED_FRAMES) {
+      this.failed('audio queue is full');
+      return;
+    }
     const joined = new Int16Array(this.pending.length + pcm.length);
     joined.set(this.pending);
     joined.set(pcm, this.pending.length);
@@ -101,7 +115,7 @@ export class Player {
   }
 
   finish(): void {
-    if (this.pending.length === 0) return;
+    if (this.closed || this.pending.length === 0) return;
     const pcm = new Int16Array(FRAME);
     pcm.set(this.pending);
     this.queue.push({ pcm, chars: this.pendingChars });
@@ -110,28 +124,36 @@ export class Player {
   }
 
   clear(): void {
+    this.generation += 1;
+    this.inFlight = 0;
+    this.speaking = false;
     this.queue.length = 0;
     this.pending = new Int16Array(0);
     this.pendingChars = 0;
   }
 
   start(): void {
-    if (this.timer !== null) return;
+    if (this.closed || this.timer !== null) return;
     this.started = performance.now();
     this.sent = 0;
     this.tick();
   }
 
   stop(): void {
+    if (this.closed) return;
+    this.closed = true;
     if (this.timer !== null) clearTimeout(this.timer);
     this.timer = null;
+    this.clear();
     this.encoder.delete();
   }
 
   private tick(): void {
+    if (this.closed) return;
     const due = Math.floor((performance.now() - this.started) / FRAME_MS) + 1;
     if (due - this.sent > MAX_LATE_FRAMES) this.sent = due - 1;
-    while (this.sent < due) this.sendOne();
+    while (!this.closed && this.sent < due) this.sendOne();
+    if (this.closed) return;
     const next = this.started + this.sent * FRAME_MS;
     this.timer = setTimeout(() => {
       this.tick();
@@ -143,11 +165,29 @@ export class Player {
     const marker = frame !== undefined && !this.speaking;
     this.speaking = frame !== undefined;
     const pcm = frame?.pcm ?? new Int16Array(FRAME);
-    this.out.send(this.encoder.encode(bytesOf(pcm), FRAME), (this.sent * FRAME) >>> 0, marker);
+    const timestamp = (this.sent * FRAME) >>> 0;
     this.sent += 1;
-    if (frame === undefined) return;
-    if (marker) this.onFirst?.();
-    if (frame.chars > 0) this.out.played(frame.chars);
-    if (!this.busy) this.onIdle?.();
+    const generation = this.generation;
+    if (frame !== undefined) this.inFlight += 1;
+    try {
+      const sent = this.out.send(this.encoder.encode(bytesOf(pcm), FRAME), timestamp, marker);
+      Promise.resolve(sent).then(() => {
+        if (this.closed || generation !== this.generation || frame === undefined) return;
+        this.inFlight -= 1;
+        if (marker) this.onFirst?.();
+        if (frame.chars > 0) this.out.played(frame.chars);
+        if (!this.busy) this.onIdle?.();
+      }).catch((err: unknown) => {
+        if (!this.closed && generation === this.generation) this.failed(errMsg(err));
+      });
+    } catch (err) {
+      if (!this.closed && generation === this.generation) this.failed(errMsg(err));
+    }
+  }
+
+  private failed(reason: string): void {
+    this.clear();
+    log.warn({ reason }, 'voice: audio playback failed');
+    this.onFailed?.(reason);
   }
 }

package/runtime/node_modules/@metro-labs/daemon/src/voice/brain.ts

@@ -50,15 +50,21 @@ function streamEvent(msg: Record<string, unknown>, mind: Thinking): void {
   if (event.type === 'content_block_start' && block.type === 'tool_use') mind.tool(typeof block.name === 'string' ? block.name : 'tool');
 }
 
+function startBrain(model: string): ChildProcessWithoutNullStreams {
+  const [command = 'metro', ...args] = metroCli(['voice', '--model', model]);
+  const [file, argv] = asAgent(command, args);
+  return spawn(file, argv, { stdio: ['pipe', 'pipe', 'pipe'], cwd: '/' });
+}
+
 export class Brain {
   private readonly child: ChildProcessWithoutNullStreams;
   private out = '';
   private gone = false;
+  private closing = false;
+  private killTimer: ReturnType<typeof setTimeout> | undefined;
 
-  constructor(model: string, private readonly mind: Thinking) {
-    const [command = 'metro', ...args] = metroCli(['voice', '--model', model]);
-    const [file, argv] = asAgent(command, args);
-    this.child = spawn(file, argv, { stdio: ['pipe', 'pipe', 'pipe'], cwd: '/' });
+  constructor(model: string, private readonly mind: Thinking, launch = startBrain) {
+    this.child = launch(model);
     this.child.stdout.setEncoding('utf8');
     this.child.stdout.on('data', (chunk: string) => {
       this.out = drainLines('voice-brain', this.out + chunk, (line) => {
@@ -91,18 +97,22 @@ export class Brain {
   }
 
   close(): void {
-    if (this.gone) return;
+    if (this.gone || this.closing) return;
+    this.closing = true;
     this.child.stdin.end();
-    setTimeout(() => {
+    this.child.kill('SIGTERM');
+    this.killTimer = setTimeout(() => {
       if (!this.gone) this.child.kill('SIGKILL');
-    }, CLOSE_GRACE_MS).unref();
+    }, CLOSE_GRACE_MS);
+    this.killTimer.unref();
   }
 
   private write(message: Record<string, unknown>): void {
-    if (!this.gone && this.child.stdin.writable) this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    if (!this.gone && !this.closing && this.child.stdin.writable) this.child.stdin.write(`${JSON.stringify(message)}\n`);
   }
 
   private read(line: string): void {
+    if (this.closing || this.gone) return;
     let parsed: unknown;
     try {
       parsed = JSON.parse(line);
@@ -130,6 +140,7 @@ export class Brain {
   private exit(reason: string): void {
     if (this.gone) return;
     this.gone = true;
-    this.mind.exited(reason);
+    clearTimeout(this.killTimer);
+    if (!this.closing) this.mind.exited(reason);
   }
 }

package/runtime/node_modules/@metro-labs/daemon/src/voice/call.ts

@@ -1,9 +1,13 @@
 import { randomUUID } from 'node:crypto';
+import type { CallRoute } from '@metro-labs/core/call';
 import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
 import { forwardTrainCall } from '../stations/train-call.js';
 import { CallApprovals } from './approvals.js';
-import { Peer } from './peer.js';
+import type { Playback } from './audio.js';
+import { Peer, type PeerEvents } from './peer.js';
+import { SharedTalk } from './shared-talk.js';
+import { endSharedCall, hearSharedCall, openSharedCall, sharedCallsSelected, type SharedCallTransport } from './shared.js';
 import { Talk } from './talk.js';
 import type { VoiceConfig } from './store.js';
 
@@ -12,8 +16,11 @@ const LONGEST_CALL_MS = 60 * 60_000;
 const CONTEXT_MESSAGES = 12;
 const CONTEXT_CHARS = 400;
 const LEAVE_RETRY_MS = 3_000;
+const SIGNAL_WAIT_MS = 2_000;
 
-interface CallStart {
+export interface CallStart {
+  agentId: string;
+  sourceId: string;
   line: string;
   lineName: string;
   direct: boolean;
@@ -23,6 +30,23 @@ interface CallStart {
   callerPeer: string;
 }
 
+type CallAudio = Pick<Talk, 'connect' | 'hear' | 'finish'>;
+type CallPeer = Pick<Peer, 'answer' | 'sendOpus' | 'close'>;
+type ContextStart = Omit<CallStart, 'agentId' | 'sourceId'>;
+
+export interface CallDependencies {
+  train: typeof trainCall;
+  peer(events: PeerEvents): CallPeer;
+  cli(cfg: VoiceConfig, out: Playback['send'], ended: (reason: string) => void, approvals: CallApprovals): CallAudio & Pick<Talk, 'prime'>;
+  shared(cfg: VoiceConfig, out: Playback['send'], ended: (reason: string) => void, heard: (text: string, sourceId: string) => void): CallAudio & SharedCallTransport;
+  selected: typeof sharedCallsSelected;
+  open: typeof openSharedCall;
+  heard: typeof hearSharedCall;
+  ended: typeof endSharedCall;
+  signalWaitMs: number;
+  leaveRetryMs: number;
+}
+
 const str = (value: unknown): string => (typeof value === 'string' ? value : '');
 
 export async function trainCall(action: string, args: Record<string, unknown>): Promise<unknown> {
@@ -31,20 +55,33 @@ export async function trainCall(action: string, args: Record<string, unknown>):
   return answer.result;
 }
 
-function speaker(row: Record<string, unknown>, start: CallStart): string {
+const dependencies: CallDependencies = {
+  train: trainCall,
+  peer: (events) => new Peer(events),
+  cli: (cfg, out, ended, approvals) => new Talk(cfg, out, ended, approvals),
+  shared: (cfg, out, ended, heard) => new SharedTalk(cfg, out, ended, heard),
+  selected: sharedCallsSelected,
+  open: openSharedCall,
+  heard: hearSharedCall,
+  ended: endSharedCall,
+  signalWaitMs: SIGNAL_WAIT_MS,
+  leaveRetryMs: LEAVE_RETRY_MS,
+};
+
+function speaker(row: Record<string, unknown>, start: ContextStart): string {
   if (row.self === true) return 'you';
   return row.from === start.from ? start.callerName : `another member (${str(row.from)})`;
 }
 
-function contextLine(row: unknown, start: CallStart): string | null {
+function contextLine(row: unknown, start: ContextStart): string | null {
   if (!isRecord(row) || typeof row.text !== 'string' || row.text.startsWith('[call')) return null;
   const who = speaker(row, start);
   return `${str(row.ts).slice(11, 16)} ${who}: ${row.text.replace(/\s+/g, ' ').slice(0, CONTEXT_CHARS)}`;
 }
 
-async function recentChat(start: CallStart): Promise<string> {
+async function recentChat(start: CallStart, train: typeof trainCall): Promise<string> {
   try {
-    const result = await trainCall('read', { line: start.line, limit: CONTEXT_MESSAGES });
+    const result = await train('read', { line: start.line, limit: CONTEXT_MESSAGES });
     const rows = isRecord(result) && Array.isArray(result.messages) ? result.messages : [];
     return rows.map((row) => contextLine(row, start)).filter((l): l is string => l !== null).join('\n');
   } catch (err) {
@@ -53,12 +90,12 @@ async function recentChat(start: CallStart): Promise<string> {
   }
 }
 
-function where(start: CallStart): string {
+function where(start: ContextStart): string {
   if (start.lineName !== '') return `the group chat "${start.lineName}"`;
   return start.direct ? `your direct chat with ${start.callerName}` : 'a group chat with no name';
 }
 
-export function opening(start: CallStart, chat: string): string {
+export function opening(start: ContextStart, chat: string): string {
   const recent = chat === '' ? 'No earlier messages were found there.' : `Recent messages there before the call, oldest first (times in UTC):\n${chat}`;
   return [
     `[A voice call with ${start.callerName} is starting on Stage, in ${where(start)}.`,
@@ -70,49 +107,77 @@ export function opening(start: CallStart, chat: string): string {
 }
 
 export class Call {
+  readonly route: CallRoute;
   private readonly selfPeer = randomUUID();
   private readonly startedAt = Date.now();
-  private readonly talk: Talk;
-  private peer: Peer | null = null;
+  private readonly talk: CallAudio;
+  private readonly shared: SharedCallTransport | null;
+  private readonly prime: ((context: string) => void) | null;
+  private readonly deps: CallDependencies;
+  private peer: CallPeer | null = null;
   private timer: ReturnType<typeof setTimeout> | null = null;
-  private longest: ReturnType<typeof setTimeout>;
+  private readonly longest: ReturnType<typeof setTimeout>;
   private over = false;
+  private begun = false;
   private left: Promise<void> = Promise.resolve();
 
   constructor(
     readonly start: CallStart,
     cfg: VoiceConfig,
     private readonly onOver: () => void,
+    deps: Partial<CallDependencies> = {},
   ) {
-    const approvals = new CallApprovals(start.line, async (text) => {
-      await trainCall('send', { line: start.line, text });
-    });
-    this.talk = new Talk(
-      cfg,
-      (opus, timestamp, marker) => {
-        this.peer?.sendOpus(opus, timestamp, marker);
-      },
-      (reason) => {
-        this.hangUp(reason);
-      },
-      approvals,
-    );
+    this.deps = { ...dependencies, ...deps };
+    this.route = Object.freeze({ agentId: start.agentId, line: start.line, from: start.from, callId: start.callId, generation: randomUUID() });
+    const out: Playback['send'] = (opus, timestamp, marker) => {
+      if (this.over || this.peer === null) return Promise.reject(new Error('call audio is not connected'));
+      return this.peer.sendOpus(opus, timestamp, marker);
+    };
+    const ended = (reason: string): void => {
+      this.hangUp(reason);
+    };
+    if (this.deps.selected()) {
+      const shared = this.deps.shared(cfg, out, ended, (text, sourceId) => {
+        if (!this.over) this.deps.heard(this.route, text, sourceId);
+      });
+      this.talk = shared;
+      this.shared = shared;
+      this.prime = null;
+    } else {
+      const approvals = new CallApprovals(start.line, async (text) => {
+        await this.deps.train('send', { line: start.line, text });
+      });
+      const cli = this.deps.cli(cfg, out, ended, approvals);
+      this.talk = cli;
+      this.shared = null;
+      this.prime = (context) => {
+        cli.prime(context);
+      };
+    }
     this.longest = setTimeout(() => {
       this.hangUp('the call reached one hour');
     }, LONGEST_CALL_MS);
   }
 
   async begin(): Promise<void> {
+    if (this.over || this.begun) return;
+    this.begun = true;
     log.info({ line: this.start.line, callId: this.start.callId }, 'voice: answering a call');
-    recentChat(this.start)
-      .then((chat) => {
-        if (!this.over) this.talk.prime(opening(this.start, chat));
-      })
-      .catch((err: unknown) => {
+    if (this.shared !== null) {
+      if (!this.deps.open(this.route, this.start.sourceId, this.shared)) throw new Error('the shared conversation is unavailable');
+    } else {
+      recentChat(this.start, this.deps.train).then((chat) => {
+        if (!this.over) this.prime?.(opening(this.start, chat));
+      }).catch((err: unknown) => {
         log.warn({ err: errMsg(err) }, 'voice: could not start the agent on the call');
       });
+    }
     await this.signal({ kind: 'join', callId: this.start.callId, from: this.selfPeer });
-    this.timer = setTimeout(() => {
+    if (this.over) {
+      await this.sendLeave();
+      return;
+    }
+    if (this.peer === null) this.timer = setTimeout(() => {
       this.hangUp('no offer arrived');
     }, OFFER_WAIT_MS);
   }
@@ -138,9 +203,9 @@ export class Call {
 
   private async answer(to: string, offer: string): Promise<void> {
     if (this.timer !== null) clearTimeout(this.timer);
-    this.peer = new Peer({
+    this.peer = this.deps.peer({
       audio: (opus) => {
-        this.talk.hear(opus);
+        if (!this.over) this.talk.hear(opus);
       },
       state: (state) => {
         this.stateChanged(state);
@@ -152,13 +217,14 @@ export class Call {
   }
 
   private stateChanged(state: string): void {
+    if (this.over) return;
     log.info({ state, afterMs: Date.now() - this.startedAt }, 'voice: call connection');
     if (state === 'connected') this.talk.connect();
     else if (state === 'failed' || state === 'closed') this.hangUp(`the connection ${state}`);
   }
 
   private signal(signal: Record<string, unknown>): Promise<unknown> {
-    return trainCall('callSignal', { line: this.start.line, signal });
+    return this.deps.train('callSignal', { line: this.start.line, signal });
   }
 
   private end(reason: string): void {
@@ -167,34 +233,42 @@ export class Call {
     if (this.timer !== null) clearTimeout(this.timer);
     clearTimeout(this.longest);
     log.info({ reason, seconds: Math.round((Date.now() - this.startedAt) / 1000) }, 'voice: call over');
-    this.left = this.sendLeave();
-    this.left
-      .then(() => this.wrapUp(reason))
-      .catch((err: unknown) => {
-        log.warn({ err: errMsg(err) }, 'voice: wrapping up the call failed');
-      })
-      .finally(() => {
-        this.onOver();
-      });
+    this.talk.finish();
+    this.peer?.close();
+    if (this.shared !== null) this.deps.ended(this.route);
+    this.onOver();
+    this.left = this.sendLeave().then(async () => {
+      if (this.shared !== null || reason.startsWith('the caller') || reason === 'no offer arrived') return;
+      await this.deps.train('send', { line: this.start.line, text: `The voice call ended: ${reason}.` });
+    }).catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'voice: wrapping up the call failed');
+    });
   }
 
   private async sendLeave(): Promise<void> {
-    const leave = { kind: 'leave', callId: this.start.callId, from: this.selfPeer };
     try {
-      await this.signal(leave);
+      await this.leaveOnce();
     } catch (err) {
       log.warn({ err: errMsg(err) }, 'voice: could not send the hang-up, trying once more');
-      await new Promise((r) => setTimeout(r, LEAVE_RETRY_MS));
-      await this.signal(leave).catch((again: unknown) => {
+      await new Promise((r) => setTimeout(r, this.deps.leaveRetryMs));
+      await this.leaveOnce().catch((again: unknown) => {
         log.warn({ err: errMsg(again) }, 'voice: could not send the hang-up; the next start sends it');
       });
     }
   }
 
-  private async wrapUp(reason: string): Promise<void> {
-    this.peer?.close();
-    this.talk.finish();
-    if (reason.startsWith('the caller') || reason === 'no offer arrived') return;
-    await trainCall('send', { line: this.start.line, text: `The voice call ended: ${reason}.` });
+  private async leaveOnce(): Promise<void> {
+    const leave = { kind: 'leave', callId: this.start.callId, from: this.selfPeer };
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const capped = new Promise<never>((_resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error('hang-up signal timed out'));
+      }, this.deps.signalWaitMs);
+    });
+    try {
+      await Promise.race([this.signal(leave), capped]);
+    } finally {
+      clearTimeout(timer);
+    }
   }
 }