@stage-labs/metro 0.1.0-beta.236 → 0.1.0-beta.238

package/dist/claude.js

@@ -9,7 +9,7 @@ import { localPort, localUrl } from './runtime.js';
 import { keepInSession, takeBackConversation } from './background.js';
 const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
 const FRESH_PROMPT_FLAGS = ['--system-prompt-snapshot', 'off'];
-const PERMISSION_MODE_FLAG = { auto: 'auto', bypass: 'bypassPermissions' };
+export const PERMISSION_MODE_FLAG = { auto: 'auto', bypass: 'bypassPermissions' };
 const KEY_HEADER = 'x-metro-key';
 const PROBE_MS = 3_000;
 const AUTH_STATUS_MS = 20_000;

package/dist/cli.js

@@ -8,6 +8,7 @@ import { update } from './update.js';
 import { serve } from './serve.js';
 import { service, serviceStopHint } from './service.js';
 import { currentVersion } from './version.js';
+import { voiceSession } from './voice.js';
 const USAGE = `metro: run your agent on this machine
 
   metro serve [--port <n>] [--owner <organization id>]
@@ -37,6 +38,11 @@ const USAGE = `metro: run your agent on this machine
                   the last run, Claude Code reads the memory skill (or the file given) and
                   files them into its memory, with no metro tools and writes only inside
                   the memory folder
+  metro voice --model <model>
+                  the agent's side of a voice call, which the daemon starts when a call
+                  comes in: Claude Code reads the call's words as stream-json on stdin and
+                  streams its replies on stdout, with the agent's memory, skills and tools
+                  but no metro channel
   metro update    update to the newest published version (--check only reports)
   metro version   print this CLI's version
 
@@ -71,6 +77,7 @@ const COMMANDS = {
     tail: () => tailEvents(process.argv.slice(3)),
     claude: () => launchClaude(process.argv.slice(3)),
     memory: () => memoryRoutine(memoryPaths(process.env, process.argv[3])),
+    voice: () => voiceSession(process.argv.slice(3)),
     update: () => update(process.argv.slice(3)),
     version: async () => {
         process.stdout.write(`${currentVersion()}\n`);

package/dist/voice.js

@@ -0,0 +1,39 @@
+import { homedir } from 'node:os';
+import { headlessEnv, PERMISSION_MODE_FLAG, runClaude } from './claude.js';
+import { permissionMode, systemPrompt } from './route.js';
+const VOICE_PROMPT = `You are on a live voice call through Metro. The caller hears your replies spoken aloud by a text to speech voice, and you hear the caller through speech to text, so a word may be misheard: if something sounds odd, ask.
+- Speak like a person on the phone: short sentences, usually one to three. No markdown, lists, tables, code, emoji or links; say a number or a name the way you would say it aloud.
+- Start with the answer. Do not repeat the question.
+- Before you use a tool, first say one short sentence about what you are checking.
+- Look things up yourself with Read, Grep or Glob when it is quick. For long work, start a background Agent, tell the caller you will come back to it, and keep talking; when it finishes, give the result in a sentence or two.
+- Text in [square brackets] comes from the call system, not from the caller.
+- You cannot send chat messages during the call. When the call ends, you will be asked for call notes, which are posted to the chat.`;
+function voiceArgs(model, mode, prompt) {
+    return [
+        '-p',
+        '--input-format',
+        'stream-json',
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        '--include-partial-messages',
+        '--model',
+        model,
+        '--permission-mode',
+        PERMISSION_MODE_FLAG[mode],
+        '--settings',
+        JSON.stringify({ enabledPlugins: { 'metro@metro': false } }),
+        '--strict-mcp-config',
+        '--no-session-persistence',
+        '--append-system-prompt',
+        prompt === null ? VOICE_PROMPT : `${prompt}\n\n${VOICE_PROMPT}`,
+    ];
+}
+export async function voiceSession(argv) {
+    const at = argv.indexOf('--model');
+    const model = at < 0 ? '' : (argv[at + 1] ?? '');
+    if (model === '')
+        throw new Error('metro voice needs --model <model>');
+    process.chdir(homedir());
+    return runClaude(voiceArgs(model, permissionMode(), systemPrompt()), await headlessEnv());
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.236",
+  "version": "0.1.0-beta.238",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.236",
+  "version": "0.1.0-beta.238",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/node_modules/@metro-labs/daemon/package.json

@@ -35,6 +35,8 @@
     "@metro-labs/whatsapp": "workspace:*",
     "@metro-labs/xmtp": "workspace:*",
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "opusscript": "^0.1.1",
+    "werift": "^0.24.4",
     "ws": "^8.18.0",
     "zod": "^3.23.8"
   },

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

@@ -52,6 +52,7 @@ import type { StationName } from '@metro-labs/core/station-names';
 import { startUploadReaper } from '../files/upload-store.js';
 import { startAttachReaper } from '../files/attach-reaper.js';
 import { startCloudWatchPublisher } from '../server/cloudwatch.js';
+import { isCallEvent, onCallEvent } from '../voice/calls.js';
 
 installCrashGuard();
 acquireLock(join(STATE_DIR, '.tail-lock'));
@@ -67,6 +68,10 @@ const supervisor = new TrainSupervisor();
 const emit = makeEmit();
 
 supervisor.onTrainEvent((env, train) => {
+  if (isCallEvent(env)) {
+    onCallEvent(env);
+    return;
+  }
   const entry = trainEventToMetroEvent(env, train);
   if (entry) emit(entry);
 });

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

@@ -110,13 +110,17 @@ export function hasConversation(home: string, dir = claudeDir()): boolean {
   );
 }
 
-function metroCommand(deps: SessionDeps, home: string): string[] {
+export function metroCli(args: string[], fixed?: string[]): string[] {
   const bin = process.env.METRO_CLI_BIN?.trim() ?? '';
   const runtime = agentUser() === null ? process.execPath : 'node';
-  const base = deps.metro ?? (bin === '' ? ['metro', 'claude'] : [runtime, bin, 'claude']);
-  const continues = (deps.continues ?? hasConversation)(home);
+  const base = fixed ?? (bin === '' ? ['metro', ...args] : [runtime, bin, ...args]);
   const env = Object.entries(sessionEnv()).map(([k, v]) => `${k}=${v}`);
-  const command = env.length === 0 || deps.metro !== undefined ? base : ['env', ...env, ...base];
+  return env.length === 0 || fixed !== undefined ? base : ['env', ...env, ...base];
+}
+
+function metroCommand(deps: SessionDeps, home: string): string[] {
+  const command = metroCli(['claude'], deps.metro);
+  const continues = (deps.continues ?? hasConversation)(home);
   return continues ? [...command, '-c'] : command;
 }
 

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

@@ -21,6 +21,7 @@ import { handleTerminalRequest, type TerminalApiDeps } from '../terminal/api.js'
 import { handleSchedulesRequest } from '../agent-user/schedules-api.js';
 import { handleFilesRequest } from '../agent-user/files-api.js';
 import { handleVaultRequest } from '../vault/api.js';
+import { handleVoiceRequest } from '../voice/api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
@@ -58,6 +59,7 @@ export function handleSessionApis(
     () => handleSchedulesRequest(req, res),
     () => handleFilesRequest(req, res),
     () => handleVaultRequest(req, res),
+    () => handleVoiceRequest(req, res),
     ...when(apis.ownerApi, (d) => handleOwnerRequest(req, res, d)),
     ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
     ...when(apis.modelApi, (d) => handleModelRequest(req, res, d)),

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

@@ -0,0 +1,14 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { readJsonBody, sessionRoute } from '@metro-labs/http/api-http';
+import { patchVoice, publicVoice, readVoice, writeVoice } from './store.js';
+
+const PATH = '/api/voice';
+
+async function answer(req: IncomingMessage): Promise<unknown> {
+  if (req.method === 'PUT') writeVoice(patchVoice(readVoice(), await readJsonBody(req)));
+  return publicVoice(readVoice());
+}
+
+export function handleVoiceRequest(req: IncomingMessage, res: ServerResponse): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET', 'PUT'] }, admin: ['PUT'], label: 'voice-api' }, () => answer(req));
+}

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

@@ -0,0 +1,153 @@
+import OpusScript from 'opusscript';
+import { errMsg, log } from '@metro-labs/core/log';
+
+const RATE = 48_000;
+const FRAME = 960;
+const FRAME_MS = 20;
+const MAX_LATE_FRAMES = 5;
+
+interface Frame {
+  pcm: Int16Array;
+  chars: number;
+}
+
+export function downsample3(pcm: Int16Array): Int16Array {
+  const out = new Int16Array(Math.floor(pcm.length / 3));
+  for (let i = 0; i < out.length; i += 1)
+    out[i] = Math.round(((pcm[i * 3] ?? 0) + (pcm[i * 3 + 1] ?? 0) + (pcm[i * 3 + 2] ?? 0)) / 3);
+  return out;
+}
+
+export function upsample2(pcm: Int16Array, carry: number): Int16Array {
+  const out = new Int16Array(pcm.length * 2);
+  let prev = carry;
+  for (let i = 0; i < pcm.length; i += 1) {
+    const cur = pcm[i] ?? 0;
+    out[i * 2] = Math.round((prev + cur) / 2);
+    out[i * 2 + 1] = cur;
+    prev = cur;
+  }
+  return out;
+}
+
+export const pcmOf = (bytes: Buffer): Int16Array => {
+  const copy = Buffer.from(bytes);
+  return new Int16Array(copy.buffer, copy.byteOffset, Math.floor(copy.length / 2));
+};
+
+export const bytesOf = (pcm: Int16Array): Buffer => Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+
+export class OpusIn {
+  private readonly decoder = new OpusScript(RATE, 1, OpusScript.Application.VOIP);
+
+  decode(packet: Buffer): Int16Array | null {
+    try {
+      return pcmOf(this.decoder.decode(packet));
+    } catch (err) {
+      log.debug({ err: errMsg(err) }, 'voice: an audio packet could not be decoded');
+      return null;
+    }
+  }
+
+  close(): void {
+    this.decoder.delete();
+  }
+}
+
+export interface Playback {
+  send(opus: Buffer, timestamp: number, marker: boolean): void;
+  played(chars: number): void;
+}
+
+export class Player {
+  private readonly encoder = new OpusScript(RATE, 1, OpusScript.Application.VOIP);
+  private readonly queue: Frame[] = [];
+  private pending = new Int16Array(0);
+  private pendingChars = 0;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private started = 0;
+  private sent = 0;
+  private speaking = false;
+  private onIdle: (() => void) | null = null;
+  private onFirst: (() => void) | null = null;
+
+  constructor(private readonly out: Playback) {}
+
+  get busy(): boolean {
+    return this.queue.length > 0 || this.pending.length > 0;
+  }
+
+  whenFirstPlayed(fn: () => void): void {
+    this.onFirst = fn;
+  }
+
+  whenIdle(fn: () => void): void {
+    this.onIdle = fn;
+  }
+
+  push(pcm: Int16Array, chars: number): void {
+    const joined = new Int16Array(this.pending.length + pcm.length);
+    joined.set(this.pending);
+    joined.set(pcm, this.pending.length);
+    let at = 0;
+    for (; at + FRAME <= joined.length; at += FRAME) this.queue.push({ pcm: joined.slice(at, at + FRAME), chars: 0 });
+    this.pending = joined.slice(at);
+    this.pendingChars += chars;
+    const last = this.queue.at(-1);
+    if (last !== undefined && this.pending.length === 0) {
+      last.chars += this.pendingChars;
+      this.pendingChars = 0;
+    }
+  }
+
+  finish(): void {
+    if (this.pending.length === 0) return;
+    const pcm = new Int16Array(FRAME);
+    pcm.set(this.pending);
+    this.queue.push({ pcm, chars: this.pendingChars });
+    this.pending = new Int16Array(0);
+    this.pendingChars = 0;
+  }
+
+  clear(): void {
+    this.queue.length = 0;
+    this.pending = new Int16Array(0);
+    this.pendingChars = 0;
+  }
+
+  start(): void {
+    if (this.timer !== null) return;
+    this.started = performance.now();
+    this.sent = 0;
+    this.tick();
+  }
+
+  stop(): void {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+    this.encoder.delete();
+  }
+
+  private tick(): void {
+    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();
+    const next = this.started + this.sent * FRAME_MS;
+    this.timer = setTimeout(() => {
+      this.tick();
+    }, Math.max(0, next - performance.now()));
+  }
+
+  private sendOne(): void {
+    const frame = this.queue.shift();
+    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);
+    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?.();
+  }
+}

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

@@ -0,0 +1,95 @@
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { drainLines } from '@metro-labs/core/trains/protocol';
+import { asAgent } from '../agent-user/user.js';
+import { metroCli } from '../claude/session.js';
+
+const CLOSE_GRACE_MS = 10_000;
+
+export interface Thinking {
+  turnStarted(): void;
+  text(delta: string): void;
+  tool(name: string): void;
+  turnEnded(text: string): void;
+  exited(reason: string): void;
+}
+
+const record = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});
+
+function streamEvent(msg: Record<string, unknown>, mind: Thinking): void {
+  if (msg.parent_tool_use_id !== null && msg.parent_tool_use_id !== undefined) return;
+  const event = record(msg.event);
+  const delta = record(event.delta);
+  if (event.type === 'content_block_delta' && delta.type === 'text_delta' && typeof delta.text === 'string') mind.text(delta.text);
+  const block = record(event.content_block);
+  if (event.type === 'content_block_start' && block.type === 'tool_use') mind.tool(typeof block.name === 'string' ? block.name : 'tool');
+}
+
+function readBrainLine(line: string, mind: Thinking): void {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const msg = record(parsed);
+  if (msg.type === 'system' && msg.subtype === 'init') mind.turnStarted();
+  else if (msg.type === 'stream_event') streamEvent(msg, mind);
+  else if (msg.type === 'result') mind.turnEnded(typeof msg.result === 'string' ? msg.result : '');
+}
+
+export class Brain {
+  private readonly child: ChildProcessWithoutNullStreams;
+  private out = '';
+  private gone = false;
+
+  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: '/' });
+    this.child.stdout.setEncoding('utf8');
+    this.child.stdout.on('data', (chunk: string) => {
+      this.out = drainLines('voice-brain', this.out + chunk, (line) => {
+        readBrainLine(line, this.mind);
+      });
+    });
+    this.child.stderr.setEncoding('utf8');
+    this.child.stderr.on('data', (chunk: string) => {
+      log.debug({ text: chunk.slice(0, 500) }, 'voice: brain stderr');
+    });
+    this.child.stdin.on('error', (err) => {
+      log.debug({ err: errMsg(err) }, 'voice: brain stdin closed');
+    });
+    this.child.on('error', (err) => {
+      this.exit(`could not start: ${errMsg(err)}`);
+    });
+    this.child.on('exit', (code, signal) => {
+      this.exit(`exited (${String(code ?? signal)})`);
+    });
+  }
+
+  get alive(): boolean {
+    return !this.gone;
+  }
+
+  tell(text: string, now = false): void {
+    if (this.gone) return;
+    const message = { type: 'user', message: { role: 'user', content: text }, parent_tool_use_id: null, session_id: '' };
+    this.child.stdin.write(`${JSON.stringify(now ? { ...message, priority: 'now' } : message)}\n`);
+  }
+
+  close(): void {
+    if (this.gone) return;
+    this.child.stdin.end();
+    setTimeout(() => {
+      if (!this.gone) this.child.kill('SIGKILL');
+    }, CLOSE_GRACE_MS).unref();
+  }
+
+  private exit(reason: string): void {
+    if (this.gone) return;
+    this.gone = true;
+    this.mind.exited(reason);
+  }
+}

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

@@ -0,0 +1,156 @@
+import { randomUUID } from 'node:crypto';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { forwardTrainCall } from '../stations/train-call.js';
+import { Peer } from './peer.js';
+import { Talk } from './talk.js';
+import type { VoiceConfig } from './store.js';
+
+const OFFER_WAIT_MS = 45_000;
+const LONGEST_CALL_MS = 60 * 60_000;
+const CONTEXT_MESSAGES = 12;
+const CONTEXT_CHARS = 400;
+
+interface CallStart {
+  line: string;
+  from: string;
+  callerName: string;
+  callId: string;
+  callerPeer: string;
+}
+
+const str = (value: unknown): string => (typeof value === 'string' ? value : '');
+
+async function trainCall(action: string, args: Record<string, unknown>): Promise<unknown> {
+  const answer = await forwardTrainCall('xmtp', action, args);
+  if (answer.error !== undefined) throw new Error(answer.error);
+  return answer.result;
+}
+
+function contextLine(row: unknown, start: CallStart): string | null {
+  if (!isRecord(row) || typeof row.text !== 'string' || row.text.startsWith('[call')) return null;
+  const who = row.from === start.from ? start.callerName : 'you';
+  return `${str(row.ts).slice(11, 16)} ${who}: ${row.text.replace(/\s+/g, ' ').slice(0, CONTEXT_CHARS)}`;
+}
+
+async function recentChat(start: CallStart): Promise<string> {
+  try {
+    const result = await trainCall('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) {
+    log.warn({ err: errMsg(err) }, 'voice: could not read the chat before the call');
+    return '';
+  }
+}
+
+function opening(start: CallStart, chat: string): string {
+  const recent = chat === '' ? '' : ` Recent chat messages before the call, oldest first (times in UTC):\n${chat}\n`;
+  return `[A voice call with ${start.callerName} is starting on Stage, in your chat with them.${recent} Greet ${start.callerName} in a few words.]`;
+}
+
+export class Call {
+  private readonly selfPeer = randomUUID();
+  private readonly startedAt = Date.now();
+  private readonly talk: Talk;
+  private peer: Peer | null = null;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private longest: ReturnType<typeof setTimeout>;
+  private over = false;
+
+  constructor(
+    readonly start: CallStart,
+    cfg: VoiceConfig,
+    private readonly onOver: () => void,
+  ) {
+    this.talk = new Talk(
+      cfg,
+      (opus, timestamp, marker) => {
+        this.peer?.sendOpus(opus, timestamp, marker);
+      },
+      (reason) => {
+        this.hangUp(reason);
+      },
+    );
+    this.longest = setTimeout(() => {
+      this.hangUp('the call reached one hour');
+    }, LONGEST_CALL_MS);
+  }
+
+  async begin(): Promise<void> {
+    log.info({ line: this.start.line, callId: this.start.callId }, 'voice: answering a call');
+    this.talk.prime(opening(this.start, await recentChat(this.start)));
+    await this.signal({ kind: 'join', callId: this.start.callId, from: this.selfPeer });
+    this.timer = setTimeout(() => {
+      this.hangUp('no offer arrived');
+    }, OFFER_WAIT_MS);
+  }
+
+  signalled(raw: Record<string, unknown>): void {
+    if (raw.callId !== this.start.callId || this.over) return;
+    const fromCaller = raw.from === this.start.callerPeer;
+    if (raw.kind === 'offer' && fromCaller && raw.to === this.selfPeer && this.peer === null && typeof raw.sdp === 'string')
+      this.answer(this.start.callerPeer, raw.sdp).catch((err: unknown) => {
+        this.hangUp(`answering failed: ${errMsg(err)}`);
+      });
+    else if (raw.kind === 'leave' && fromCaller) this.end('the caller hung up', false);
+  }
+
+  hangUp(reason: string): void {
+    this.end(reason, true);
+  }
+
+  private async answer(to: string, offer: string): Promise<void> {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.peer = new Peer({
+      audio: (opus) => {
+        this.talk.hear(opus);
+      },
+      state: (state) => {
+        this.stateChanged(state);
+      },
+    });
+    const sdp = await this.peer.answer(offer);
+    if (this.over) return;
+    await this.signal({ kind: 'answer', callId: this.start.callId, from: this.selfPeer, to, sdp });
+  }
+
+  private stateChanged(state: string): void {
+    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 });
+  }
+
+  private end(reason: string, sendLeave: boolean): void {
+    if (this.over) return;
+    this.over = true;
+    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.wrapUp(reason, sendLeave)
+      .catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'voice: wrapping up the call failed');
+      })
+      .finally(() => {
+        this.onOver();
+      });
+  }
+
+  private async wrapUp(reason: string, sendLeave: boolean): Promise<void> {
+    if (sendLeave)
+      await this.signal({ kind: 'leave', callId: this.start.callId, from: this.selfPeer }).catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'voice: could not send the hang-up');
+      });
+    this.peer?.close();
+    const notes = await this.talk.finish();
+    const minutes = Math.max(1, Math.round((Date.now() - this.startedAt) / 60_000));
+    const timing = this.talk.replyTime === null ? '' : `\n${this.talk.replyTime}`;
+    const failure = reason.startsWith('the caller') || reason === 'no offer arrived' ? null : `The voice call ended: ${reason}.`;
+    const text = [failure, notes === null ? null : `Call notes (${String(minutes)} min):\n${notes}${timing}`].filter((part) => part !== null).join('\n\n');
+    if (text !== '') await trainCall('send', { line: this.start.line, text });
+  }
+}

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

@@ -0,0 +1,54 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import type { TrainEvent } from '@metro-labs/core/trains/protocol';
+import { lineReceives, mayApprove } from '../agents/map.js';
+import { Call } from './call.js';
+import { readVoice, voiceReady } from './store.js';
+
+const INVITE_FRESH_MS = 60_000;
+const CALL_TYPES = new Set(['callInvite', 'callSignal']);
+
+let current: Call | null = null;
+
+const record = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});
+const str = (value: unknown): string => (typeof value === 'string' ? value : '');
+
+const contentTypeOf = (env: TrainEvent): string => str(record(env.payload).contentType);
+
+export const isCallEvent = (env: TrainEvent): boolean => CALL_TYPES.has(contentTypeOf(env));
+
+function refusal(env: TrainEvent, line: string, from: string): string | null {
+  if (current !== null) return 'already in a call';
+  const sent = Date.parse(str(env.ts));
+  if (Number.isNaN(sent) || Date.now() - sent > INVITE_FRESH_MS) return 'the invite is too old';
+  if (!voiceReady(readVoice())) return 'voice is off or has no API key on the Voice page';
+  if (!lineReceives(line) || !mayApprove(line, from)) return 'the caller is not someone who can approve for this channel';
+  return null;
+}
+
+function invite(env: TrainEvent, body: Record<string, unknown>): void {
+  const line = str(env.line);
+  const from = str(env.from);
+  const callId = str(body.callId);
+  const callerPeer = str(body.from);
+  if (callId === '' || callerPeer === '') return;
+  const refused = refusal(env, line, from);
+  if (refused !== null) {
+    log.info({ line, reason: refused }, 'voice: a call came in and is not answered');
+    return;
+  }
+  const callerName = str(env.from_display_name) || str(env.from_name) || 'the caller';
+  const call = new Call({ line, from, callerName, callId, callerPeer }, readVoice(), () => {
+    if (current === call) current = null;
+  });
+  current = call;
+  call.begin().catch((err: unknown) => {
+    call.hangUp(`starting failed: ${errMsg(err)}`);
+  });
+}
+
+export function onCallEvent(env: TrainEvent): void {
+  const body = record(record(env.payload).call);
+  if (contentTypeOf(env) === 'callInvite') invite(env, body);
+  else if (current !== null && env.line === current.start.line) current.signalled(body);
+}