@stage-labs/metro 0.1.0-beta.263 → 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/dist/runtime-install.js

@@ -1,7 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { localStations } from './local.js';
 import { STORE_ENTRY, daemonEntry, findBun, runtimeDir } from './runtime.js';
 const MANIFEST_FILE = 'stations.json';
@@ -24,6 +24,7 @@ export function readManifest(path) {
     return {
         core: ranges(raw.core),
         stations: Object.fromEntries(Object.entries(stations).map(([name, deps]) => [name, ranges(deps)])),
+        ...(raw.patchedDependencies === undefined ? {} : { patchedDependencies: ranges(raw.patchedDependencies) }),
     };
 }
 export function dependenciesFor(manifest, stations) {
@@ -32,7 +33,19 @@ export function dependenciesFor(manifest, stations) {
         Object.assign(out, manifest.stations[station] ?? {});
     return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a.localeCompare(b)));
 }
-const packageText = (deps) => `${JSON.stringify({ name: 'metro-runtime', private: true, dependencies: deps }, null, 2)}\n`;
+function packageText(deps, patches) {
+    const patchedDependencies = Object.fromEntries(Object.entries(deps).flatMap(([name, version]) => {
+        const key = `${name}@${version}`;
+        const path = patches[key];
+        return path === undefined ? [] : [[key, path]];
+    }));
+    return `${JSON.stringify({
+        name: 'metro-runtime',
+        private: true,
+        dependencies: deps,
+        ...(Object.keys(patchedDependencies).length === 0 ? {} : { patchedDependencies }),
+    }, null, 2)}\n`;
+}
 export function readOrNull(path) {
     try {
         return readFileSync(path, 'utf8');
@@ -63,8 +76,8 @@ function syncSources(sources, store) {
         writeFileSync(join(store, 'runtime.json'), stamp);
     return true;
 }
-export function installDependencies(store, deps, bun, log) {
-    const wanted = packageText(deps);
+export function installDependencies(store, deps, bun, log, patches = {}) {
+    const wanted = packageText(deps, patches);
     const marker = join(store, 'node_modules', '.metro-installed');
     if (existsSync(marker) && readOrNull(join(store, 'package.json')) === wanted)
         return false;
@@ -92,6 +105,10 @@ export function prepareRuntime(opts = {}) {
         });
     mkdirSync(join(store, 'trains'), { recursive: true });
     syncSources(sources, store);
-    installDependencies(store, dependenciesFor(manifest, localStations(opts.agents)), opts.bun ?? findBun(), log);
+    for (const path of Object.values(manifest.patchedDependencies ?? {})) {
+        mkdirSync(dirname(join(store, path)), { recursive: true });
+        copyFileSync(join(sources, path), join(store, path));
+    }
+    installDependencies(store, dependenciesFor(manifest, localStations(opts.agents)), opts.bun ?? findBun(), log, manifest.patchedDependencies);
     return { dir: store, entry: daemonEntry(store), trains: join(store, 'trains'), manifest: manifestPath };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.263",
+  "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.263",
+  "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/marketplace/plugin/bin/policy.mjs

@@ -36,7 +36,7 @@ function targets(snap, name, input) {
   if (Array.isArray(snap.ungated) && snap.ungated.includes(name)) return [];
   const account = text(input.account);
   const line = text(input[LINE_FIELD[name] ?? 'line']);
-  if (line) return fromLine(line, name in LINE_FIELD ? '' : account);
+  if (line) return fromLine(line, name in LINE_FIELD || name === 'list_members' ? '' : account);
   const owners = isRecord(snap.owners) ? snap.owners : {};
   const station = (STATION_ARG.has(name) ? text(input.station) : text(owners[name])) || (account ? stationOfAccount(snap, account) : undefined);
   if (!station) return [];

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/core/src/stations/train-boot.ts

@@ -1,4 +1,4 @@
-import { errMsg } from '../log.js';
+import { errMsg, logFatalSync } from '../log.js';
 import { readCalls } from '../protocol.js';
 import { TrainError } from '../train-error.js';
 import type { CallMsg } from './station-runtime.js';
@@ -18,12 +18,33 @@ export interface ClientTrain<A extends { id: string }, C> {
   loadAccounts: () => A[];
   createClient: (account: A) => C;
   startInbound: (client: C) => Promise<void>;
+  disconnectClient?: (client: C) => Promise<void>;
   makeHandleCall: (clientFor: (accountId: string) => C) => (msg: CallMsg) => Promise<void>;
 }
 
 export function runClientTrain<A extends { id: string }, C>(train: ClientTrain<A, C>): void {
   const clients = new Map<string, C>();
+  let stopping = false;
+  if (train.disconnectClient) {
+    const disconnect = train.disconnectClient;
+    const shutdown = (): void => {
+      if (stopping) return;
+      stopping = true;
+      process.stdin.pause();
+      Promise.allSettled([...clients.values()].map(async (client) => { await disconnect(client); })).then((results) => {
+        const errors = results.flatMap((result) => result.status === 'rejected' ? [errMsg(result.reason)] : []);
+        if (errors.length) logFatalSync({ station: train.station, errors }, 'train: shutdown failed');
+        process.exit(errors.length ? 1 : 0);
+      }).catch((err: unknown) => {
+        logFatalSync({ station: train.station, err: errMsg(err) }, 'train: shutdown failed');
+        process.exit(1);
+      });
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+  }
   const clientFor = (accountId: string): C => {
+    if (stopping) throw new TrainError('train_stopping', `${train.station} is shutting down`);
     const known = clients.get(accountId);
     if (known !== undefined) return known;
     const account = train.accounts.get(accountId);

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;