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

package/dist/cli.js

@@ -34,9 +34,9 @@ const USAGE = `metro: run your agent on this machine
                   open Claude Code with the metro channel and the metro MCP server, its
                   inference routed through the daemon's model gateway (the Model page);
                   every argument is passed through the same
-  metro agent     run chat and background workers in one Agent SDK conversation,
+  metro agent     run chat, calls and background workers in one Agent SDK conversation,
                   when the Harness runner is Agent SDK, using the Model page's model;
-                  resume it after a restart; voice calls remain separate
+                  resume it after a restart; call audio runs independently
   metro agent --prepare [cli|sdk]
                   check the runner before selecting it; install the SDK runtime if needed,
                   without starting a session or connecting to chat

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.264",
+  "version": "0.1.0-beta.265",
   "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.264",
+  "version": "0.1.0-beta.265",
   "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/core/package.json

@@ -9,6 +9,7 @@
     "./events": "./src/events.ts",
     "./is-record": "./src/is-record.ts",
     "./runner-activity": "./src/runner-activity.ts",
+    "./call": "./src/call.ts",
     "./secure-fs": "./src/secure-fs.ts",
     "./version": "./src/version.ts",
     "./train-error": "./src/train-error.ts",

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

@@ -0,0 +1,81 @@
+import { isRecord } from './is-record.js';
+
+export const CALL_NOTICE = 'notifications/metro/call';
+export const CALL_STATE = 'notifications/metro/call_state';
+
+export interface CallState {
+  route: CallRoute | null;
+}
+
+export interface CallRoute {
+  agentId: string;
+  line: string;
+  from: string;
+  callId: string;
+  generation: string;
+}
+
+export interface SpeechTarget {
+  callId: string;
+  generation: string;
+  sourceId: string;
+}
+
+export interface CallSource {
+  route: CallRoute;
+  sourceId: string;
+}
+
+export type SpeechStatus = 'accepted' | 'queued' | 'started' | 'completed' | 'interrupted' | 'failed';
+
+export type CallNotice =
+  | { type: 'started'; route: CallRoute; sourceId: string }
+  | { type: 'heard'; route: CallRoute; sourceId: string; text: string }
+  | { type: 'ended'; route: CallRoute }
+  | { type: 'speech'; route: CallRoute; sourceId: string; actionId: string; status: SpeechStatus };
+
+const filled = (value: unknown): value is string => typeof value === 'string' && value.length > 0 && value.length <= 2048;
+
+export function callRoute(value: unknown): CallRoute | null {
+  if (!isRecord(value)) return null;
+  const { agentId, line, from, callId, generation } = value;
+  return filled(agentId) && filled(line) && filled(from) && filled(callId) && filled(generation)
+    ? { agentId, line, from, callId, generation }
+    : null;
+}
+
+export function callState(value: unknown): CallState | null {
+  if (!isRecord(value)) return null;
+  if (value.route === null) return { route: null };
+  const route = callRoute(value.route);
+  return route === null ? null : { route };
+}
+
+export function speechTarget(value: unknown): SpeechTarget | null {
+  if (!isRecord(value)) return null;
+  const { callId, generation, sourceId } = value;
+  return filled(callId) && filled(generation) && filled(sourceId) ? { callId, generation, sourceId } : null;
+}
+
+const STATUSES: readonly SpeechStatus[] = ['accepted', 'queued', 'started', 'completed', 'interrupted', 'failed'];
+
+const speechStatus = (value: unknown): SpeechStatus | null => STATUSES.find((status) => status === value) ?? null;
+
+function sourcedNotice(value: Record<string, unknown>, route: CallRoute, sourceId: string): CallNotice | null {
+  if (value.type === 'started') return { type: 'started', route, sourceId };
+  if (value.type === 'heard') return typeof value.text === 'string' && value.text.length <= 32_000 ? { type: 'heard', route, sourceId, text: value.text } : null;
+  if (value.type !== 'speech' || !filled(value.actionId)) return null;
+  const status = speechStatus(value.status);
+  return status === null ? null : { type: 'speech', route, sourceId, actionId: value.actionId, status };
+}
+
+export function callNotice(value: unknown): CallNotice | null {
+  if (!isRecord(value)) return null;
+  const route = callRoute(value.route);
+  if (route === null) return null;
+  if (value.type === 'ended') return { type: 'ended', route };
+  return filled(value.sourceId) ? sourcedNotice(value, route, value.sourceId) : null;
+}
+
+export const sameCall = (a: CallRoute, b: CallRoute): boolean =>
+  a.agentId === b.agentId && a.line === b.line && a.from === b.from && a.callId === b.callId && a.generation === b.generation;

package/runtime/node_modules/@metro-labs/core/src/runner-activity.ts

@@ -74,6 +74,17 @@ export interface RunnerFailure extends RunnerEvent {
   code: RunnerFailureCode;
 }
 
+export interface RunnerInput {
+  id: string;
+  kind: 'chat' | 'call' | 'note';
+  state: 'accepted' | 'consumed' | 'output' | 'completed' | 'cancelled';
+  acceptedAt: number;
+  dispatchedAt: number | null;
+  consumedAt: number | null;
+  firstOutputAt: number | null;
+  completedAt: number | null;
+}
+
 export interface RunnerActivity {
   pid: number;
   procStart?: string;
@@ -84,6 +95,9 @@ export interface RunnerActivity {
   sessionId: string | null;
   updatedAt: number;
   pending: number;
+  queueOldestAt?: number | null;
+  inputs?: RunnerInput[];
+  callState?: 'started' | 'ended' | 'accepted' | 'queued' | 'speaking' | 'completed' | 'interrupted' | 'failed';
   workers: number;
   approvals: number;
   tools: string[];
@@ -160,6 +174,28 @@ function failureFields(raw: Record<string, unknown>): Pick<RunnerActivity, 'last
   };
 }
 
+function input(raw: unknown): RunnerInput | null {
+  if (!isRecord(raw) || sessionId(raw.id) === null) return null;
+  const kind = (['chat', 'call', 'note'] as const).find((value) => value === raw.kind);
+  const state = (['accepted', 'consumed', 'output', 'completed', 'cancelled'] as const).find((value) => value === raw.state);
+  if (kind === undefined || state === undefined) return null;
+  return {
+    id: String(raw.id), kind, state, acceptedAt: count(raw.acceptedAt),
+    dispatchedAt: count(raw.dispatchedAt) || null, consumedAt: count(raw.consumedAt) || null,
+    firstOutputAt: count(raw.firstOutputAt) || null, completedAt: count(raw.completedAt) || null,
+  };
+}
+
+function inputFields(raw: Record<string, unknown>): Pick<RunnerActivity, 'inputs' | 'queueOldestAt' | 'callState'> {
+  const states = ['started', 'ended', 'accepted', 'queued', 'speaking', 'completed', 'interrupted', 'failed'] as const;
+  const callState = states.find((state) => state === raw.callState);
+  return {
+    ...(raw.inputs === undefined ? {} : { inputs: list(raw.inputs, input, 40) }),
+    ...(raw.queueOldestAt === undefined ? {} : { queueOldestAt: count(raw.queueOldestAt) || null }),
+    ...(callState === undefined ? {} : { callState }),
+  };
+}
+
 export function parseRunnerActivity(raw: unknown): RunnerActivity | null {
   if (!isRecord(raw) || raw.runner !== 'sdk' || !phase(raw.phase) || count(raw.pid) === 0 || count(raw.updatedAt) === 0) return null;
   return {
@@ -168,6 +204,6 @@ export function parseRunnerActivity(raw: unknown): RunnerActivity | null {
     pending: count(raw.pending), workers: count(raw.workers), approvals: count(raw.approvals),
     tools: list(raw.tools, name, 20), activeTools: list(raw.activeTools, tool, 20),
     tasks: list(raw.tasks, task, 30), events: list(raw.events, event, 40),
-    ...failureFields(raw),
+    ...failureFields(raw), ...inputFields(raw),
   };
 }

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

@@ -1,5 +1,6 @@
 import { errMsg, log } from '@metro-labs/core/log';
 import { previewMatches } from './preview.js';
+import { sameCall, speechTarget, type CallRoute, type CallSource } from '@metro-labs/core/call';
 
 export const NEEDS_APPROVAL = (where: string, tool: string): string =>
   `Needs the owner's approval for ${where} (${tool}). Make this exact call from a background worker so Claude Code asks the owner in chat, and wait for the answer. An approval given only in the terminal does not count.`;
@@ -15,6 +16,7 @@ export interface PendingPrompt {
   preview: string;
   line: string | undefined;
   at: number;
+  call?: CallSource;
 }
 
 interface Held extends PendingPrompt {
@@ -33,6 +35,9 @@ interface Grant {
   tool: string;
   preview: string;
   at: number;
+  owner: object;
+  requestId: string;
+  call?: CallSource;
 }
 
 const GRANT_TTL_MS = 10 * 60_000;
@@ -40,11 +45,22 @@ const GRANTS_MAX = 200;
 let grants: Grant[] = [];
 
 function grant(entry: Held, now = Date.now()): void {
-  grants = [...grants.filter((g) => now - g.at < GRANT_TTL_MS), { tool: entry.tool, preview: entry.preview, at: now }].slice(-GRANTS_MAX);
+  grants = [...grants.filter((g) => now - g.at < GRANT_TTL_MS), {
+    tool: entry.tool, preview: entry.preview, at: now, owner: entry.owner, requestId: entry.requestId,
+    ...(entry.call === undefined ? {} : { call: entry.call }),
+  }].slice(-GRANTS_MAX);
+}
+
+function speechMatches(grant: Grant, args: Record<string, unknown>): boolean {
+  if (args.speech === undefined) return grant.call === undefined;
+  const target = speechTarget(args.speech);
+  const bound = grant.call;
+  return target !== null && bound !== undefined && bound.route.line === args.line && bound.route.callId === target.callId &&
+    bound.route.generation === target.generation && bound.sourceId === target.sourceId;
 }
 
 export function takeGrant(toolMatches: (tool: string) => boolean, args: Record<string, unknown>, now = Date.now()): boolean {
-  const at = grants.findIndex((g) => now - g.at < GRANT_TTL_MS && toolMatches(g.tool) && previewMatches(g.preview, args));
+  const at = grants.findIndex((g) => now - g.at < GRANT_TTL_MS && toolMatches(g.tool) && speechMatches(g, args) && previewMatches(g.preview, args));
   if (at < 0) return false;
   grants = grants.filter((_, i) => i !== at);
   return true;
@@ -109,6 +125,23 @@ export async function answerPrompt(
 
 export function forgetPromptsOf(owner: object): void {
   for (const [id, entry] of held) if (entry.owner === owner) held.delete(id);
+  grants = grants.filter((entry) => entry.owner !== owner);
+}
+
+export function cancelPrompt(requestId: string, owner: object): void {
+  grants = grants.filter((entry) => entry.owner !== owner || entry.requestId !== requestId);
+  const entry = held.get(requestId);
+  if (entry?.owner !== owner) return;
+  held.delete(requestId);
+  entry.send('deny').catch((err: unknown) => {
+    log.warn({ requestId, err: errMsg(err) }, 'approvals: cancelled prompt could not be answered');
+  });
+}
+
+export function revokeCallPrompts(route: CallRoute): void {
+  grants = grants.filter((entry) => entry.call === undefined || !sameCall(entry.call.route, route));
+  for (const entry of held.values())
+    if (entry.call !== undefined && sameCall(entry.call.route, route)) cancelPrompt(entry.requestId, entry.owner);
 }
 
 export function settlePrompts(toolMatches: (tool: string) => boolean, args: Record<string, unknown>): void {

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

@@ -72,7 +72,7 @@ const emit = makeEmit();
 
 supervisor.onTrainEvent((env, train) => {
   if (isCallEvent(env)) {
-    onCallEvent(env);
+    onCallEvent(env, train);
     return;
   }
   const entry = trainEventToMetroEvent(env, train);

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

@@ -51,6 +51,7 @@ interface InboundDeps {
   getStations: () => Set<string>;
   senderAllowed: (from: string, line: string, verified?: boolean) => boolean;
   approves?: (station: string) => boolean;
+  callMeta?: (event: Record<string, unknown>) => () => Record<string, string>;
   answerPermission?: (requestId: string, behavior: 'allow' | 'deny', line: string, from: string) => Promise<boolean>;
 }
 
@@ -91,12 +92,7 @@ export class InboundRelay {
     return this.deps.mcp.notification({ method, params });
   }
 
-  private isDuplicate(
-    station: string,
-    line: string,
-    kind: string,
-    messageId: string,
-  ): boolean {
+  private isDuplicate(station: string, line: string, kind: string, messageId: string): boolean {
     if (!messageId) return false;
     const key = dedupeKey(station, line, kind, messageId);
     const now = Date.now();
@@ -129,6 +125,7 @@ export class InboundRelay {
         mime: p.mime ?? '',
         name: note.name,
         ...extra,
+        ...ctx.callMeta?.(),
       },
     });
   }
@@ -172,6 +169,7 @@ export class InboundRelay {
         from_name: e.fromName,
         ...displayNameMeta(e.fromDisplayName),
         ...e.reply,
+        ...e.callMeta?.(),
       },
     });
   }
@@ -201,13 +199,14 @@ export class InboundRelay {
     };
   }
 
-  private async routeAttachment(ev: Record<string, unknown>): Promise<boolean> {
+  private async routeAttachment(ev: Record<string, unknown>, replay: boolean): Promise<boolean> {
     const p = ev.payload as SavedMedia | undefined;
     if (!p) return false;
     const type = p.contentType;
     if (type !== 'attachmentSaved' && type !== 'attachmentFailed') return false;
     const ctx = this.mediaCtxFor(ev, p);
     if (!ctx) return true;
+    if (replay) ctx.callMeta = undefined;
     if (type === 'attachmentFailed') await this.surfaceMediaFailure(ctx, p);
     else await this.surfaceMedia(ctx, p);
     return true;
@@ -215,8 +214,9 @@ export class InboundRelay {
 
   private bufferAttachments(
     ev: Record<string, unknown>,
-    base: { line: string; from: string; station: string; text: string },
+    base: EventBase,
     atts: PendingAtt[],
+    replay: boolean,
   ): void {
     const id = str(ev.id);
     if (!id) return;
@@ -230,6 +230,7 @@ export class InboundRelay {
       fromName: str(ev.fromName),
       fromDisplayName: str(ev.fromDisplayName),
       reply: replyMeta(ev, this.sentIds),
+      callMeta: !replay && base.evType === 'msg' ? this.deps.callMeta?.(ev) : undefined,
       attachments: atts.map((a) => ({ kind: a.kind, name: a.name })),
       saved: new Set<number>(),
       timer: setTimeout(() => {
@@ -337,6 +338,7 @@ export class InboundRelay {
   private async emitMessage(
     ev: Record<string, unknown>,
     base: EventBase,
+    replay: boolean,
   ): Promise<void> {
     if (base.evType === 'msg' && base.text.trim() === '') {
       this.deps.log('drop: empty message', base.station, base.line, str(ev.messageId));
@@ -358,6 +360,7 @@ export class InboundRelay {
         from_name: str(ev.fromName),
         ...displayNameMeta(ev.fromDisplayName),
         ...replyMeta(ev, this.sentIds),
+        ...(!replay && base.evType === 'msg' ? this.deps.callMeta?.(ev)?.() : {}),
       },
     });
   }
@@ -366,7 +369,7 @@ export class InboundRelay {
     ev: Record<string, unknown>,
     replay = false,
   ): Promise<void> {
-    if (await this.routeAttachment(ev)) return;
+    if (await this.routeAttachment(ev, replay)) return;
 
     const base = this.routable(ev, replay);
     if (!base) return;
@@ -375,7 +378,7 @@ export class InboundRelay {
     const atts = (ev.payload as { attachments?: PendingAtt[] } | undefined)
       ?.attachments;
     if (Array.isArray(atts) && atts.length) {
-      this.bufferAttachments(ev, base, atts);
+      this.bufferAttachments(ev, base, atts, replay);
       return;
     }
 
@@ -383,7 +386,7 @@ export class InboundRelay {
       await this.handleReact(ev, base);
       return;
     }
-    await this.emitMessage(ev, base);
+    await this.emitMessage(ev, base, replay);
   }
 }
 

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

@@ -16,6 +16,7 @@ export interface PendingMsg {
   fromName: string;
   fromDisplayName: string;
   reply: Record<string, string>;
+  callMeta?: () => Record<string, string>;
   attachments: PendingAtt[];
   saved: Set<number>;
   timer: ReturnType<typeof setTimeout>;
@@ -32,6 +33,7 @@ export interface MediaCtx {
   fromName?: string;
   fromDisplayName?: string;
   reply?: Record<string, string>;
+  callMeta?: () => Record<string, string>;
 }
 
 export function capSet(set: Set<string>, max: number): void {
@@ -72,6 +74,7 @@ export function takeMediaCtx(buf: PendingMsg): MediaCtx {
     fromName: buf.fromName,
     fromDisplayName: buf.fromDisplayName,
     reply: buf.reply,
+    callMeta: buf.callMeta,
   };
   buf.text = '';
   return ctx;

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

@@ -0,0 +1,45 @@
+import { CALL_NOTICE, sameCall, type CallNotice, type CallRoute } from '@metro-labs/core/call';
+import { errMsg, log } from '@metro-labs/core/log';
+import { eventInScope } from '../agents/scope.js';
+import { revokeCallPrompts } from '../approvals/pending.js';
+import { sharedCalls } from '../voice/shared.js';
+import type { McpSession } from './session.js';
+
+export const callInScope = (scope: Set<string>, route: CallRoute): boolean =>
+  scope.has(route.agentId) && eventInScope(scope, route.line);
+
+export function connectCallBridge(current: () => McpSession | undefined): void {
+  let owner: McpSession | undefined;
+  let route: CallRoute | undefined;
+  const available = (wanted: CallRoute): boolean => {
+    const session = current();
+    return session !== undefined && session.streamAttached && session.server.getClientVersion()?.name === 'metro-sdk-runner' &&
+      callInScope(session.scope, wanted) && (route === undefined || owner === session);
+  };
+  const boundTo = (session: McpSession | undefined, wanted: CallRoute): boolean => session === owner && route !== undefined && sameCall(route, wanted);
+  const forgetEnded = (notice: CallNotice): void => {
+    if (notice.type === 'ended' && route !== undefined && sameCall(route, notice.route)) {
+      owner = undefined;
+      route = undefined;
+    }
+  };
+  sharedCalls.connect({
+    available,
+    notify: (notice: CallNotice): boolean => {
+      const session = current();
+      const bound = notice.type === 'started' ? available(notice.route) : boundTo(session, notice.route);
+      forgetEnded(notice);
+      if (session === undefined || !session.streamAttached || !callInScope(session.scope, notice.route) || !bound) return false;
+      if (notice.type === 'started') {
+        owner = session;
+        route = notice.route;
+      }
+      session.server.notification({ method: CALL_NOTICE, params: { ...notice, meta: { line: notice.route.line } } }).catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'sdk-call: notification failed');
+        sharedCalls.end(notice.route);
+      });
+      return true;
+    },
+    revoked: (ended) => { revokeCallPrompts(ended); },
+  });
+}

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

@@ -0,0 +1,25 @@
+import { callRoute, speechTarget, type CallSource } from '@metro-labs/core/call';
+import { isRecord } from '@metro-labs/core/is-record';
+import { readPreview } from '../approvals/preview.js';
+import { sharedCalls } from '../voice/shared.js';
+import { agentIdForLine } from '../agents/map.js';
+
+function boundCall(value: unknown, inScope: (line: string) => boolean): CallSource | null {
+  if (!isRecord(value)) return null;
+  const route = callRoute(value.route);
+  const sourceId = value.sourceId;
+  if (route === null || typeof sourceId !== 'string') return null;
+  const source = { route, sourceId };
+  return inScope(route.line) && sharedCalls.valid(source) ? source : null;
+}
+
+export function permissionCall(params: { call?: unknown; input_preview: string; tool_name: string }, inScope: (line: string) => boolean): CallSource | null | undefined {
+  if (params.call !== undefined) return boundCall(params.call, inScope);
+  if (params.tool_name !== 'mcp__metro__send') return undefined;
+  const { input } = readPreview(params.input_preview);
+  if (!isRecord(input) || input.speech === undefined) return undefined;
+  const target = speechTarget(input.speech);
+  if (target === null || typeof input.line !== 'string' || !inScope(input.line)) return null;
+  const agentId = agentIdForLine(input.line);
+  return agentId === undefined ? null : sharedCalls.source(input.line, target, new Set([agentId]));
+}

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

@@ -10,6 +10,7 @@ import { errResult, makeCtx, ok, toErr } from './ctx.js';
 import { runRead } from './read-tool.js';
 import { allowedAgents, currentIdentity } from './request-identity.js';
 import { str } from '@metro-labs/core/str';
+import { sendSpeech } from './speech-send.js';
 
 type Station = NonNullable<ReturnType<typeof stationForLine>>;
 
@@ -143,6 +144,7 @@ function noteSent(m: MessageArgs, messageId: string | undefined): void {
 }
 
 async function handleSend(m: MessageArgs): Promise<ToolResult> {
+  if (m.a.speech !== undefined) return sendSpeech(m.line, m.a);
   const text = m.a.text as string | undefined;
   const replyTo = m.a.reply_to as string | undefined;
   const requested = (m.a.attachments as CanonicalAttachment[] | undefined) ?? [];

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

@@ -6,6 +6,7 @@ import type {
 import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
 import { str } from '@metro-labs/core/str';
 import { eventInScope } from '../agents/scope.js';
+import { CALL_NOTICE, CALL_STATE } from '@metro-labs/core/call';
 
 const EVENT_STORE_MAX = 500;
 
@@ -14,6 +15,7 @@ interface StoredEvent {
   streamId: StreamId;
   message: JSONRPCMessage;
   line: string | undefined;
+  replays: boolean;
 }
 
 export interface ScopedReplay {
@@ -32,6 +34,8 @@ function frameLine(message: JSONRPCMessage): string | undefined {
   return str((meta as { line?: unknown }).line) || undefined;
 }
 
+const isCallNotice = (message: JSONRPCMessage): boolean => 'method' in message && (message.method === CALL_NOTICE || message.method === CALL_STATE);
+
 const encodeEventId = (streamId: StreamId, seq: number): EventId =>
   `${streamId}${SEP}${seq}`;
 
@@ -52,11 +56,13 @@ export class BoundedEventStore implements EventStore {
 
   storeEvent(streamId: StreamId, message: JSONRPCMessage): Promise<EventId> {
     const eventId = encodeEventId(streamId, ++this.seq);
+    const replays = !isCallNotice(message);
     this.events.push({
       eventId,
       streamId,
-      message,
-      line: frameLine(message),
+      message: replays ? message : { jsonrpc: message.jsonrpc, method: CALL_NOTICE },
+      line: replays ? frameLine(message) : undefined,
+      replays,
     });
     if (this.events.length > this.max) this.events.shift();
     return Promise.resolve(eventId);
@@ -79,6 +85,7 @@ export class BoundedEventStore implements EventStore {
         if (e.eventId === lastEventId) seen = true;
         continue;
       }
+      if (!e.replays) continue;
       if (e.line !== undefined && !eventInScope(scope, e.line)) {
         onWithheld?.(e.eventId, e.line);
         continue;

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

@@ -17,6 +17,7 @@ import {
 import { errMsg } from '@metro-labs/core/log';
 import { channelLog, type McpSession } from './session.js';
 import { SessionSlot } from './session-slot.js';
+import { connectCallBridge } from './call-bridge.js';
 
 const isInitialize = (b: unknown): boolean =>
   !!b &&
@@ -116,6 +117,7 @@ export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Pr
   const slot = new SessionSlot(options.liveEvents);
   const voiceSlot = new SessionSlot(false, 'voice');
   activeSlots = [slot, voiceSlot];
+  connectCallBridge(() => slot.current);
 
   const httpHandler = async (
     req: IncomingMessage,

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

@@ -45,13 +45,14 @@ function argText(value: unknown): string | undefined {
 
 function fieldText(key: string, value: unknown): string | undefined {
   if (key === 'attachments' && Array.isArray(value)) return `${String(value.length)} file(s)`;
-  return key === 'frame' || key === 'wallet' ? argText(value) : valueText(value);
+  return key === 'frame' || key === 'wallet' || key === 'speech' ? argText(value) : valueText(value);
 }
 
 function metroLines(tool: string, input: Record<string, unknown>): string[] {
   const lines = [`Approval needed: ${tool}`];
   const channel = channelOf(input);
   if (channel !== undefined) lines.push(`Channel: ${channel}`);
+  if (tool === 'send' && input.speech !== undefined) lines.push('Delivery: voice call only, no chat post');
   const keys = [...LEAD, ...Object.keys(input).filter((k) => !LEAD.includes(k))];
   for (const key of keys) {
     if (PLACE.has(key)) continue;

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

@@ -1,10 +1,11 @@
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { z } from 'zod';
 import type { InboundRelay } from '../channels/inbound.js';
-import { holdPrompt, type Behavior } from '../approvals/pending.js';
+import { cancelPrompt, holdPrompt, type Behavior } from '../approvals/pending.js';
 import { approversForLine, lineReceives } from '../agents/map.js';
 import { metroCall } from './ctx.js';
 import { promptBody } from './permission-prompt.js';
+import { permissionCall } from './call-permission.js';
 
 const PermissionRequestSchema = z.object({
   method: z.literal('notifications/claude/channel/permission_request'),
@@ -13,6 +14,7 @@ const PermissionRequestSchema = z.object({
     tool_name: z.string(),
     description: z.string(),
     input_preview: z.string(),
+    call: z.unknown().optional(),
   }),
 });
 
@@ -32,12 +34,12 @@ export interface PermissionRelayDeps {
   log: (...a: unknown[]) => void;
 }
 
-function relayLine(deps: PermissionRelayDeps, requestId: string): string | undefined {
+function relayLine(deps: PermissionRelayDeps, requestId: string, callLine?: string): string | undefined {
   if (!deps.live()) {
     deps.log('permission_request: live events are off, so no chat answer can arrive; held for the page only', requestId);
     return undefined;
   }
-  const line = deps.relay.knownLine;
+  const line = callLine ?? deps.relay.knownLine;
   if (!line) {
     deps.log('permission_request: no known line, held for the page only', requestId);
     return undefined;
@@ -59,12 +61,20 @@ function relayLine(deps: PermissionRelayDeps, requestId: string): string | undef
 
 export function registerPermissionRelay(deps: PermissionRelayDeps): void {
   const { mcp, log } = deps;
+  mcp.setNotificationHandler(z.object({ method: z.literal('notifications/metro/permission_cancel'), params: z.object({ request_id: z.string() }) }), (notice) => {
+    cancelPrompt(notice.params.request_id, mcp);
+  });
   const answer = (requestId: string) => async (behavior: Behavior): Promise<void> => {
     await mcp.notification({ method: 'notifications/claude/channel/permission', params: { request_id: requestId, behavior } });
   };
   mcp.setNotificationHandler(PermissionRequestSchema as never, async (n: PermissionRequest) => {
     const { params } = n;
-    const line = relayLine(deps, params.request_id);
+    const call = permissionCall(params, deps.inScope);
+    if (call === null) {
+      await answer(params.request_id)('deny');
+      return;
+    }
+    const line = relayLine(deps, params.request_id, call?.route.line);
     holdPrompt(
       {
         requestId: params.request_id,
@@ -73,6 +83,7 @@ export function registerPermissionRelay(deps: PermissionRelayDeps): void {
         preview: params.input_preview,
         line,
         at: Date.now(),
+        ...(call === undefined ? {} : { call }),
       },
       mcp,
       answer(params.request_id),