@stage-labs/metro 0.1.0-beta.240 → 0.1.0-beta.242

package/dist/cli.js

@@ -41,8 +41,9 @@ const USAGE = `metro: run your agent on this machine
   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
+                  streams its replies on stdout, with the agent's memory, skills, plugin,
+                  connectors and metro tools (on /mcp/voice, so the chat session keeps its
+                  slot) but no metro channel; tool approvals come back on stdout
   metro update    update to the newest published version (--check only reports)
   metro version   print this CLI's version
 

package/dist/mcp-config.js

@@ -2,20 +2,22 @@ import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 const METRO_SERVER = 'metro';
-export function metroMcpConfig(agentKey, port) {
+const CHAT_PATH = '/mcp';
+export const VOICE_MCP_PATH = '/mcp/voice';
+export function metroMcpConfig(agentKey, port, path = CHAT_PATH) {
     const servers = {
         [METRO_SERVER]: {
             type: 'http',
-            url: `http://127.0.0.1:${String(port)}/mcp`,
+            url: `http://127.0.0.1:${String(port)}${path}`,
             headers: { Authorization: `Bearer ${agentKey}` },
         },
     };
     return `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`;
 }
-export function writeMcpConfig(agentKey, port, base = tmpdir()) {
+export function writeMcpConfig(agentKey, port, base = tmpdir(), mcpPath = CHAT_PATH) {
     const dir = mkdtempSync(join(base, 'metro-claude-'));
     const path = join(dir, 'mcp.json');
-    writeFileSync(path, metroMcpConfig(agentKey, port), { mode: 0o600 });
+    writeFileSync(path, metroMcpConfig(agentKey, port, mcpPath), { mode: 0o600 });
     return {
         path,
         cleanup: () => {

package/dist/voice.js

@@ -1,14 +1,19 @@
-import { homedir } from 'node:os';
+import { homedir, tmpdir } from 'node:os';
 import { headlessEnv, PERMISSION_MODE_FLAG, runClaude } from './claude.js';
+import { localAgent } from './local.js';
+import { VOICE_MCP_PATH, writeMcpConfig } from './mcp-config.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.
+import { localPort } from './runtime.js';
+const VOICE_PROMPT = `You are on a live voice call through Metro. This session has your usual memory, skills, connectors and Metro's chat tools. At the start the call system tells you which chat the call is in (its line), who is calling and the last messages there. 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.
+- Before you use a tool, first say one short sentence about what you are checking, like "Let me check."
+- Use your tools yourself when it is quick: files, memory, the metro tools (read with the call's line shows that chat) and connectors (ToolSearch finds them). 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.
+- Your spoken words are your reply. Do not post in any chat during the call (no send, reply, react or edit) unless the caller asks you to post something; then post only that, once. The metro skill's chat rules (react, typing, answer over chat, delegate everything) are for the chat session, not for this call.
+- A tool that needs the owner's approval runs in a background worker. The approval is asked in the chat of the call; a spoken yes does not count.
 - 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) {
+- Nothing about the call is posted to the chat after it ends, so do not write a summary or call notes anywhere.`;
+export function voiceArgs(model, mode, prompt, mcpConfig) {
     return [
         '-p',
         '--input-format',
@@ -21,19 +26,31 @@ function voiceArgs(model, mode, prompt) {
         model,
         '--permission-mode',
         PERMISSION_MODE_FLAG[mode],
-        '--settings',
-        JSON.stringify({ enabledPlugins: { 'metro@metro': false } }),
-        '--strict-mcp-config',
+        '--permission-prompt-tool',
+        'stdio',
+        ...(mcpConfig === undefined ? [] : ['--mcp-config', mcpConfig]),
         '--no-session-persistence',
         '--append-system-prompt',
         prompt === null ? VOICE_PROMPT : `${prompt}\n\n${VOICE_PROMPT}`,
     ];
 }
+export const voiceEnv = (env) => ({
+    CLAUDE_CODE_MCP_STARTUP_WAIT_MS: '0',
+    ...env,
+    METRO_SESSION: 'voice',
+});
 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());
+    const agent = localAgent();
+    const mcp = agent === null ? null : writeMcpConfig(agent.key, localPort(), tmpdir(), VOICE_MCP_PATH);
+    try {
+        return await runClaude(voiceArgs(model, permissionMode(), systemPrompt(), mcp?.path), voiceEnv(await headlessEnv()));
+    }
+    finally {
+        mcp?.cleanup();
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.240",
+  "version": "0.1.0-beta.242",
   "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.240",
+  "version": "0.1.0-beta.242",
   "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/guard.mjs

@@ -23,6 +23,7 @@ const ORCHESTRATION = new Set([
 const IMAGE = /\.(png|jpe?g|gif|webp|bmp)$/i;
 const MCP = /^mcp__/;
 const METRO_MCP = /^mcp__metro__/;
+const VOICE = process.env.METRO_SESSION === 'voice';
 
 function answer(decision, reason) {
   process.stdout.write(
@@ -48,7 +49,10 @@ function verdict(payload, input) {
     return `${tool} blocks the session waiting on the terminal, and nobody is watching it. Decide with your best judgement and state the assumption, or ask over chat with the metro tools and keep working in the meantime.`;
   if (typeof payload.agent_id === 'string' && payload.agent_id !== '') return null;
   if (tool === 'Agent' && input.run_in_background === false)
-    return 'A foreground subagent blinds the main thread: it cannot see or acknowledge inbound metro messages until the agent finishes. Re-issue the identical Agent call with run_in_background: true, then wait for the task notification.';
+    return VOICE
+      ? 'On a voice call a foreground subagent leaves the caller in silence until it finishes. Re-issue the identical Agent call with run_in_background: true, tell the caller you will come back to it, and keep talking.'
+      : 'A foreground subagent blinds the main thread: it cannot see or acknowledge inbound metro messages until the agent finishes. Re-issue the identical Agent call with run_in_background: true, then wait for the task notification.';
+  if (VOICE) return null;
   if (ORCHESTRATION.has(tool)) return null;
   if (METRO_MCP.test(tool)) return null;
   if (MCP.test(tool))

package/runtime/marketplace/plugin/bin/session-start.mjs

@@ -24,7 +24,7 @@ function guidance() {
   return '';
 }
 
-const text = guidance();
+const text = process.env.METRO_SESSION === 'voice' ? '' : guidance();
 if (text !== '')
   process.stdout.write(
     `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: `This machine runs as a metro agent. Standing rules, kept in the metro skill:\n\n${text}` } })}\n`,

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

@@ -1,7 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import {
   closeSync,
-  mkdirSync,
   openSync,
   readFileSync,
   unlinkSync,
@@ -11,10 +10,11 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { log } from '@metro-labs/core/log';
+import { ensureSecureDir } from '@metro-labs/core/secure-fs';
 
 export const STATE_DIR =
   process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
-mkdirSync(STATE_DIR, { recursive: true });
+ensureSecureDir(STATE_DIR);
 
 
 export function trainsDir(): string {

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

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import {
   BodyTooLargeError,
   readBody as readBodyBuffer,
+  VOICE_MCP_PATH,
 } from '../routes/http.js';
 import {
   authenticate,
@@ -90,16 +91,19 @@ async function serveGet(
   if (served) session.replayMissed();
 }
 
-let activeSlot: SessionSlot | undefined;
+const isVoicePath = (req: IncomingMessage): boolean => (req.url ?? '').split('?')[0] === VOICE_MCP_PATH;
+
+let activeSlots: SessionSlot[] = [];
 
 export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Promise<{
   httpHandler: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
   startInbound: () => void;
   setLiveEvents: (on: boolean) => void;
 }> {
-  await activeSlot?.close();
+  await Promise.all(activeSlots.map((s) => s.close()));
   const slot = new SessionSlot(options.liveEvents);
-  activeSlot = slot;
+  const voiceSlot = new SessionSlot(false, 'voice');
+  activeSlots = [slot, voiceSlot];
 
   const httpHandler = async (
     req: IncomingMessage,
@@ -114,7 +118,7 @@ export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Pr
     if (!parsed.ok) return;
     await runWithIdentity(identity, async () => {
       const session = await resolveSession(
-        slot,
+        isVoicePath(req) ? voiceSlot : slot,
         req,
         parsed.body,
         identity,

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

@@ -17,3 +17,14 @@ export const MCP_INSTRUCTIONS =
   'needing approval must run in a background worker: on the main thread it is refused, so ' +
   'delegate that exact call and keep answering; the worker waits for the owner. Approval ' +
   'prompts are relayed to the chat; the owner answers "yes <id>"/"no <id>".';
+
+export const VOICE_MCP_INSTRUCTIONS =
+  "Metro's chat tools, opened for a live voice call. The caller hears what you say, so do not " +
+  'answer them with `send` or `reply` and do not post the call in a chat; post, react or act on ' +
+  'a channel only when the caller asks for it, once. `read` with a `line` (passed verbatim) ' +
+  'shows that chat; `group_info` and `list_members` show who is in it; `get_profile` with a ' +
+  '`from` names a sender. The owner may block a tool on an account or make it need approval ' +
+  '(`list_accounts` shows each `policy`). A blocked call errors. A call needing approval must ' +
+  'run in a background worker: on the main thread it is refused, so delegate that exact call ' +
+  'and keep talking; the worker waits while the owner is asked in the chat of the call, where ' +
+  'they answer "yes <id>"/"no <id>".';

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

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { currentBusSeq } from '@metro-labs/core/events';
 import { newReplayLedger } from '../channels/relay.js';
-import { McpSession, channelLog } from './session.js';
+import { McpSession, channelLog, type SessionKind } from './session.js';
 import { allowedAgents, type RequestIdentity } from './request-identity.js';
 
 export class SessionSlot {
@@ -10,7 +10,10 @@ export class SessionSlot {
   private started = false;
   private live: boolean;
 
-  constructor(live = true) {
+  constructor(
+    live = true,
+    private readonly kind: SessionKind = 'chat',
+  ) {
     this.live = live;
   }
 
@@ -50,6 +53,7 @@ export class SessionSlot {
     if (this.ledger.startAt < 0) this.ledger.startAt = currentBusSeq();
     const id = adoptId ?? randomUUID();
     const session = await McpSession.open({
+      kind: this.kind,
       id,
       scope: allowedAgents(identity),
       adopted: adoptId !== undefined,
@@ -61,7 +65,7 @@ export class SessionSlot {
     });
     this.session = session;
     if (this.started && this.live) session.startChannel();
-    channelLog('session: opened', 'id', id, 'adopted', adoptId !== undefined);
+    channelLog('session: opened', 'id', id, 'kind', this.kind, 'adopted', adoptId !== undefined);
     return session;
   }
 

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

@@ -7,7 +7,7 @@ import { errMsg } from '@metro-labs/core/log';
 import { allowlistForLine, mayApprove, senderPermitted } from '../agents/map.js';
 import { accountStationNames, stationByName } from '../stations/registry.js';
 import { eventInScope } from '../agents/scope.js';
-import { MCP_INSTRUCTIONS } from './instructions.js';
+import { MCP_INSTRUCTIONS, VOICE_MCP_INSTRUCTIONS } from './instructions.js';
 import { BoundedEventStore } from './event-store.js';
 import { registerPermissionRelay } from './permission-relay.js';
 import { registerToolHandlers, toolSchemaSignature } from './tool-dispatch.js';
@@ -47,7 +47,12 @@ function makeTransport(
   return t;
 }
 
+export type SessionKind = 'chat' | 'voice';
+
+const CHANNEL_CAPABILITIES = { experimental: { 'claude/channel': {}, 'claude/channel/permission': {} } };
+
 export interface SessionInit {
+  kind?: SessionKind;
   id: string;
   scope: Set<string>;
   adopted: boolean;
@@ -80,17 +85,12 @@ export class McpSession {
     this.onClosed = init.onClosed;
     this.eventStore = new BoundedEventStore();
     this.transport = makeTransport(init.id, this.eventStore, init.adopted);
+    const voice = init.kind === 'voice';
     this.server = new Server(
       { name: 'metro', version: '0.1.0' },
       {
-        capabilities: {
-          experimental: {
-            'claude/channel': {},
-            'claude/channel/permission': {},
-          },
-          tools: { listChanged: true },
-        },
-        instructions: MCP_INSTRUCTIONS,
+        capabilities: { ...(voice ? {} : CHANNEL_CAPABILITIES), tools: { listChanged: true } },
+        instructions: voice ? VOICE_MCP_INSTRUCTIONS : MCP_INSTRUCTIONS,
       },
     );
     registerToolHandlers(this.server, {
@@ -113,13 +113,14 @@ export class McpSession {
       approves,
       answerPermission,
     });
-    registerPermissionRelay({
-      mcp: this.server,
-      relay: this.relay,
-      inScope: (line) => this.inScope(line),
-      live: this.live,
-      log: channelLog,
-    });
+    if (!voice)
+      registerPermissionRelay({
+        mcp: this.server,
+        relay: this.relay,
+        inScope: (line) => this.inScope(line),
+        live: this.live,
+        log: channelLog,
+      });
     this.channel = new ChannelRelay({
       relay: this.relay,
       log: channelLog,

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

@@ -38,6 +38,7 @@ import { applyMcpCors, handleMcpPreflight } from '@metro-labs/http/cors';
 import { METRO_VERSION } from '@metro-labs/core/version';
 
 const LRU_CAP = 2_000;
+export const VOICE_MCP_PATH = '/mcp/voice';
 
 function dedupKey(
   e: Pick<MetroEvent, 'station' | 'line' | 'messageId'>,
@@ -213,7 +214,7 @@ export async function startWebhookServer(
 
 function isMcpPath(req: IncomingMessage): boolean {
   const path = (req.url ?? '').split('?')[0];
-  return path === '/' || path === '/mcp';
+  return path === '/' || path === '/mcp' || path === VOICE_MCP_PATH;
 }
 
 function flatHeaders(req: IncomingMessage): Record<string, string> {

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

@@ -0,0 +1,43 @@
+import { randomInt } from 'node:crypto';
+import { errMsg, log } from '@metro-labs/core/log';
+import { forgetPromptsOf, holdPrompt, type Behavior } from '../approvals/pending.js';
+import { promptBody } from '../mcp/permission-prompt.js';
+import type { ToolAsk } from './brain.js';
+
+const ID_LETTERS = 'abcdefghijkmnopqrstuvwxyz';
+const ID_LENGTH = 5;
+
+export const approvalId = (): string => Array.from({ length: ID_LENGTH }, () => ID_LETTERS[randomInt(ID_LETTERS.length)]).join('');
+
+export class CallApprovals {
+  private closed = false;
+
+  constructor(
+    private readonly line: string,
+    private readonly post: (text: string) => Promise<void>,
+  ) {}
+
+  ask(ask: ToolAsk, answer: (behavior: Behavior) => void): string | null {
+    if (this.closed) return null;
+    const id = approvalId();
+    const preview = JSON.stringify(ask.input);
+    holdPrompt(
+      { requestId: id, tool: ask.tool, description: ask.description, preview, line: this.line, at: Date.now() },
+      this,
+      (behavior) => {
+        answer(behavior);
+        return Promise.resolve();
+      },
+      this.post,
+    );
+    this.post(promptBody({ request_id: id, tool_name: ask.tool, description: ask.description, input_preview: preview })).catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'voice: could not ask for an approval in the chat of the call');
+    });
+    return id;
+  }
+
+  close(): void {
+    this.closed = true;
+    forgetPromptsOf(this);
+  }
+}

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

@@ -6,16 +6,40 @@ import { asAgent } from '../agent-user/user.js';
 import { metroCli } from '../claude/session.js';
 
 const CLOSE_GRACE_MS = 10_000;
+const DENIED = 'The owner did not approve this.';
+
+export interface ToolAsk {
+  requestId: string;
+  tool: string;
+  input: Record<string, unknown>;
+  description: string;
+  fromWorker: boolean;
+}
 
 export interface Thinking {
   turnStarted(): void;
   text(delta: string): void;
   tool(name: string): void;
-  turnEnded(text: string): void;
+  turnEnded(): void;
+  asked(ask: ToolAsk): void;
   exited(reason: string): void;
 }
 
 const record = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});
+const str = (value: unknown): string => (typeof value === 'string' ? value : '');
+
+export function toolAsk(msg: Record<string, unknown>): ToolAsk | null {
+  const request = record(msg.request);
+  const requestId = str(msg.request_id);
+  if (request.subtype !== 'can_use_tool' || requestId === '' || str(request.tool_name) === '') return null;
+  return {
+    requestId,
+    tool: str(request.tool_name),
+    input: record(request.input),
+    description: str(request.description) || str(request.decision_reason),
+    fromWorker: str(request.agent_id) !== '',
+  };
+}
 
 function streamEvent(msg: Record<string, unknown>, mind: Thinking): void {
   if (msg.parent_tool_use_id !== null && msg.parent_tool_use_id !== undefined) return;
@@ -26,19 +50,6 @@ 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 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 = '';
@@ -51,7 +62,7 @@ export class Brain {
     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.read(line);
       });
     });
     this.child.stderr.setEncoding('utf8');
@@ -69,14 +80,14 @@ export class Brain {
     });
   }
 
-  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`);
+    this.write(now ? { ...message, priority: 'now' } : message);
+  }
+
+  answer(ask: ToolAsk, behavior: 'allow' | 'deny'): void {
+    const response = behavior === 'allow' ? { behavior, updatedInput: ask.input } : { behavior, message: DENIED };
+    this.write({ type: 'control_response', response: { subtype: 'success', request_id: ask.requestId, response } });
   }
 
   close(): void {
@@ -87,6 +98,35 @@ export class Brain {
     }, CLOSE_GRACE_MS).unref();
   }
 
+  private write(message: Record<string, unknown>): void {
+    if (!this.gone && this.child.stdin.writable) this.child.stdin.write(`${JSON.stringify(message)}\n`);
+  }
+
+  private read(line: string): void {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const msg = record(parsed);
+    if (msg.type === 'system' && msg.subtype === 'init') this.mind.turnStarted();
+    else if (msg.type === 'stream_event') streamEvent(msg, this.mind);
+    else if (msg.type === 'result') this.mind.turnEnded();
+    else if (msg.type === 'control_request') this.control(msg);
+  }
+
+  private control(msg: Record<string, unknown>): void {
+    const ask = toolAsk(msg);
+    if (ask !== null) {
+      this.mind.asked(ask);
+      return;
+    }
+    const subtype = str(record(msg.request).subtype);
+    log.warn({ subtype }, 'voice: the agent session asked for something the call does not handle');
+    this.write({ type: 'control_response', response: { subtype: 'error', request_id: str(msg.request_id), error: `not supported on a voice call: ${subtype}` } });
+  }
+
   private exit(reason: string): void {
     if (this.gone) return;
     this.gone = true;

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

@@ -2,6 +2,7 @@ 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 { CallApprovals } from './approvals.js';
 import { Peer } from './peer.js';
 import { Talk } from './talk.js';
 import type { VoiceConfig } from './store.js';
@@ -14,6 +15,8 @@ const LEAVE_RETRY_MS = 3_000;
 
 interface CallStart {
   line: string;
+  lineName: string;
+  direct: boolean;
   from: string;
   callerName: string;
   callId: string;
@@ -28,9 +31,14 @@ export async function trainCall(action: string, args: Record<string, unknown>):
   return answer.result;
 }
 
+function speaker(row: Record<string, unknown>, start: CallStart): 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 {
   if (!isRecord(row) || typeof row.text !== 'string' || row.text.startsWith('[call')) return null;
-  const who = row.from === start.from ? start.callerName : 'you';
+  const who = speaker(row, start);
   return `${str(row.ts).slice(11, 16)} ${who}: ${row.text.replace(/\s+/g, ' ').slice(0, CONTEXT_CHARS)}`;
 }
 
@@ -45,9 +53,20 @@ async function recentChat(start: CallStart): Promise<string> {
   }
 }
 
-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.]`;
+function where(start: CallStart): 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 {
+  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)}.`,
+    `Line of this chat: ${start.line} (pass it verbatim to the metro tools, e.g. read, to look at or act on this chat).`,
+    `Caller: ${start.callerName} (${start.from}).`,
+    recent,
+    `Greet ${start.callerName} in a few words.]`,
+  ].join('\n');
 }
 
 export class Call {
@@ -65,6 +84,9 @@ export class Call {
     cfg: VoiceConfig,
     private readonly onOver: () => void,
   ) {
+    const approvals = new CallApprovals(start.line, async (text) => {
+      await trainCall('send', { line: start.line, text });
+    });
     this.talk = new Talk(
       cfg,
       (opus, timestamp, marker) => {
@@ -73,6 +95,7 @@ export class Call {
       (reason) => {
         this.hangUp(reason);
       },
+      approvals,
     );
     this.longest = setTimeout(() => {
       this.hangUp('the call reached one hour');
@@ -81,7 +104,13 @@ export class Call {
 
   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)));
+    recentChat(this.start)
+      .then((chat) => {
+        if (!this.over) this.talk.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(() => {
       this.hangUp('no offer arrived');
@@ -164,11 +193,8 @@ export class Call {
 
   private async wrapUp(reason: string): Promise<void> {
     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 });
+    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}.` });
   }
 }

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

@@ -59,7 +59,8 @@ function invite(env: TrainEvent, body: Record<string, unknown>): void {
   }
   current?.hangUp('the caller started a new call');
   const callerName = str(env.from_display_name) || str(env.from_name) || 'the caller';
-  const call = new Call({ line, from, callerName, callId, callerPeer }, readVoice(), () => {
+  const start = { line, lineName: str(env.line_name), direct: env.is_private === true, from, callerName, callId, callerPeer };
+  const call = new Call(start, readVoice(), () => {
     if (current === call) current = null;
   });
   current = call;

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

@@ -39,13 +39,14 @@ export function parsed(raw: string): Record<string, unknown> {
   }
 }
 
-function sttUrl(): string {
+export function sttUrl(language: string | null): string {
   const query = new URLSearchParams({
     model_id: 'scribe_v2_realtime',
     audio_format: 'pcm_16000',
     commit_strategy: 'vad',
     vad_silence_threshold_secs: String(VAD_SILENCE_SECS),
   });
+  if (language !== null) query.set('language_code', language);
   return `${elevenLabs()}/v1/speech-to-text/realtime?${query.toString()}`;
 }
 
@@ -54,8 +55,8 @@ export class Scribe {
   private buffer: Int16Array[] = [];
   private buffered = 0;
 
-  constructor(apiKey: string, private readonly heard: Heard) {
-    this.ws = new WebSocket(sttUrl(), { headers: { 'xi-api-key': apiKey } });
+  constructor(apiKey: string, language: string | null, private readonly heard: Heard) {
+    this.ws = new WebSocket(sttUrl(language), { headers: { 'xi-api-key': apiKey } });
     this.ws.on('message', (data) => {
       this.onMessage(wsText(data));
     });

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

@@ -13,9 +13,14 @@ export interface VoiceConfig {
   apiKey: string;
   voiceId: string;
   model: string;
+  language: string;
   enabled: boolean;
 }
 
+const DEFAULT_LANGUAGE = 'en';
+const AUTO_LANGUAGE = 'auto';
+const LANGUAGE_RE = /^(?:[a-z]{2,3}|auto)$/;
+
 const DEFAULT_VOICE_ID = 'EXAVITQu4vr4xnSDxMaL';
 const DEFAULT_VOICE_MODEL = 'anthropic:claude-sonnet-5-5';
 
@@ -34,6 +39,7 @@ export function parseVoice(raw: unknown): VoiceConfig {
     apiKey: text(r.apiKey),
     voiceId: text(r.voiceId),
     model: text(r.model),
+    language: LANGUAGE_RE.test(text(r.language)) ? text(r.language) : '',
     enabled: r.enabled !== false,
   };
 }
@@ -54,6 +60,11 @@ export function brainModel(cfg: VoiceConfig, models: ModelConfig = readModelConf
   return models.connections.some((c) => c.provider === 'anthropic') ? model : anthropic;
 }
 
+export function languageOf(cfg: VoiceConfig): string | null {
+  const language = cfg.language === '' ? DEFAULT_LANGUAGE : cfg.language;
+  return language === AUTO_LANGUAGE ? null : language;
+}
+
 export const voiceReady = (cfg: VoiceConfig): boolean => cfg.enabled && cfg.apiKey !== '';
 
 export function publicVoice(cfg: VoiceConfig): Record<string, unknown> {
@@ -63,8 +74,9 @@ export function publicVoice(cfg: VoiceConfig): Record<string, unknown> {
     hasKey: cfg.apiKey !== '',
     voiceId: cfg.voiceId,
     model: cfg.model,
+    language: cfg.language,
     enabled: cfg.enabled,
-    defaults: { voiceId: DEFAULT_VOICE_ID, model: DEFAULT_VOICE_MODEL },
+    defaults: { voiceId: DEFAULT_VOICE_ID, model: DEFAULT_VOICE_MODEL, language: DEFAULT_LANGUAGE },
   };
 }
 
@@ -82,6 +94,12 @@ function keyOf(body: Record<string, unknown>, current: string): string {
   return next === '' ? current : next;
 }
 
+function languageField(body: Record<string, unknown>, current: string): string {
+  const next = field(body, 'language', current).toLowerCase();
+  if (next !== '' && !LANGUAGE_RE.test(next)) throw new ApiError("language is a two or three letter ISO 639 code, or 'auto'", 400);
+  return next;
+}
+
 export function patchVoice(cfg: VoiceConfig, body: unknown): VoiceConfig {
   if (!isRecord(body)) throw new ApiError('the body must be a JSON object', 400);
   if (body.provider !== undefined && !isProvider(body.provider))
@@ -92,6 +110,7 @@ export function patchVoice(cfg: VoiceConfig, body: unknown): VoiceConfig {
     apiKey: keyOf(body, cfg.apiKey),
     voiceId: field(body, 'voiceId', cfg.voiceId),
     model: field(body, 'model', cfg.model),
+    language: languageField(body, cfg.language),
     enabled: typeof body.enabled === 'boolean' ? body.enabled : cfg.enabled,
   };
 }

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

@@ -1,15 +1,13 @@
 import { log } from '@metro-labs/core/log';
 import { downsample3, OpusIn, Player, type Playback } from './audio.js';
-import { Brain, type Thinking } from './brain.js';
+import type { CallApprovals } from './approvals.js';
+import { Brain, type Thinking, type ToolAsk } from './brain.js';
 import { Scribe, VAD_SILENCE_SECS } from './scribe.js';
 import { Utterance } from './speech.js';
 import { Chunker } from './speakable.js';
-import { brainModel, voiceIdOf, type VoiceConfig } from './store.js';
+import { brainModel, languageOf, voiceIdOf, type VoiceConfig } from './store.js';
 
 const BARGE_MIN_WORDS = 2;
-const NOTES_WAIT_MS = 60_000;
-const NOTES_PROMPT =
-  '[The call has ended. Write short call notes for the chat: what was discussed, what was decided and what you will follow up on. Plain text, at most 6 short lines, no title and no greeting. Reply with the notes only.]';
 
 interface Reply {
   utterance: Utterance;
@@ -23,6 +21,11 @@ interface Reply {
   firstPlayed: number | null;
 }
 
+const toolName = (tool: string): string => tool.split('__').pop() ?? tool;
+
+const approvalNote = (tool: string, id: string): string =>
+  `[The owner was asked in the chat of this call to approve ${toolName(tool)}; they answer "yes ${id}" or "no ${id}" there. Unless you already said so, tell the caller in one short sentence that it waits for their answer in the chat.]`;
+
 const wordsIn = (text: string): number => text.split(/\s+/).filter((word) => /\p{L}/u.test(word)).length;
 
 const since = (start: number | null, at: number | null): number | null =>
@@ -45,22 +48,19 @@ export class Talk implements Thinking {
   private reply: Reply | null = null;
   private cut: string | null = null;
   private muted = false;
-  private busy = false;
   private askedAt: number | null = null;
   private saidAt: number | null = null;
   private lastHeardAt: number | null = null;
   private readonly delays: number[] = [];
-  private notes: ((text: string) => void) | null = null;
-  private notesStarted = false;
   private live = false;
   private finished = false;
-  private heardCaller = false;
   private spoke = false;
 
   constructor(
     private readonly cfg: VoiceConfig,
     out: (opus: Buffer, timestamp: number, marker: boolean) => void,
     private readonly ended: (reason: string) => void,
+    private readonly approvals: CallApprovals,
   ) {
     const playback: Playback = {
       send: out,
@@ -73,7 +73,7 @@ export class Talk implements Thinking {
       this.firstPlayed();
     });
     this.brain = new Brain(brainModel(cfg), this);
-    this.scribe = new Scribe(cfg.apiKey, {
+    this.scribe = new Scribe(cfg.apiKey, languageOf(cfg), {
       partial: (text) => {
         this.partial(text);
       },
@@ -88,7 +88,6 @@ export class Talk implements Thinking {
   }
 
   prime(context: string): void {
-    this.busy = true;
     this.brain.tell(context);
   }
 
@@ -104,25 +103,23 @@ export class Talk implements Thinking {
     if (pcm !== null) this.scribe.send(downsample3(pcm));
   }
 
-  async finish(): Promise<string | null> {
-    if (this.finished) return null;
+  finish(): void {
+    if (this.finished) return;
     this.finished = true;
     this.live = false;
+    this.approvals.close();
     this.player.stop();
     this.scribe.close();
     this.reply?.utterance.abort();
     this.spare?.abort();
     this.opus.close();
-    const notes = this.heardCaller && this.brain.alive ? await this.callNotes() : null;
     this.brain.close();
-    return notes;
+    this.logReplyTime();
   }
 
   turnStarted(): void {
     this.muted = false;
-    this.busy = true;
-    if (this.notes !== null) this.notesStarted = true;
-    if (this.notes !== null || this.finished) return;
+    if (this.finished) return;
     this.reply = {
       utterance: this.takeUtterance(),
       said: '',
@@ -140,7 +137,7 @@ export class Talk implements Thinking {
 
   text(delta: string): void {
     const reply = this.reply;
-    if (this.muted || reply === null || this.notes !== null) return;
+    if (this.muted || reply === null) return;
     reply.firstText ??= performance.now();
     this.speak(reply, reply.chunker.add(delta));
   }
@@ -150,15 +147,7 @@ export class Talk implements Thinking {
     if (this.reply !== null && !this.muted) this.speak(this.reply, this.reply.chunker.flush());
   }
 
-  turnEnded(text: string): void {
-    this.busy = false;
-    const notes = this.notes;
-    if (notes !== null) {
-      if (!this.notesStarted) return;
-      this.notes = null;
-      notes(text);
-      return;
-    }
+  turnEnded(): void {
     const reply = this.reply;
     if (reply === null || this.muted) return;
     this.speak(reply, reply.chunker.flush());
@@ -169,10 +158,20 @@ export class Talk implements Thinking {
     );
   }
 
+  asked(ask: ToolAsk): void {
+    const id = this.finished ? null : this.approvals.ask(ask, (behavior) => {
+      this.brain.answer(ask, behavior);
+    });
+    if (id === null) {
+      this.brain.answer(ask, 'deny');
+      return;
+    }
+    log.info({ tool: ask.tool, worker: ask.fromWorker }, 'voice: a tool waits for the owner’s approval in the chat of the call');
+    this.brain.tell(approvalNote(ask.tool, id));
+  }
+
   exited(reason: string): void {
     log.warn({ reason }, 'voice: the agent session for the call ended');
-    this.notes?.('');
-    this.notes = null;
     this.ended(`agent session ${reason}`);
   }
 
@@ -214,11 +213,10 @@ export class Talk implements Thinking {
     if (this.reply !== null) this.reply.heard += chars;
   }
 
-  get replyTime(): string | null {
-    if (this.delays.length === 0) return null;
+  private logReplyTime(): void {
+    if (this.delays.length === 0) return;
     const sorted = [...this.delays].sort((a, b) => a - b);
-    const middle = sorted[Math.floor(sorted.length / 2)] ?? 0;
-    return `Reply time, from your last word heard to my first word sent: about ${(middle / 1000).toFixed(1)} s (middle of ${String(sorted.length)}).`;
+    log.info({ middleMs: Math.round(sorted[Math.floor(sorted.length / 2)] ?? 0), replies: sorted.length }, 'voice: reply time of the call, from the caller’s last word heard to the first reply audio sent');
   }
 
   private firstPlayed(): void {
@@ -246,7 +244,6 @@ export class Talk implements Thinking {
   }
 
   private committed(text: string): void {
-    this.heardCaller = true;
     if (this.interrupts(text)) this.cutOff();
     const note = this.cut;
     const now = this.muted;
@@ -254,22 +251,6 @@ export class Talk implements Thinking {
     this.askedAt = performance.now();
     this.saidAt = this.lastHeardAt ?? this.askedAt;
     this.lastHeardAt = null;
-    this.busy = true;
     this.brain.tell(note === null ? text : `${note}\n${text}`, now);
   }
-
-  private callNotes(): Promise<string | null> {
-    return new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        this.notes = null;
-        resolve(null);
-      }, NOTES_WAIT_MS);
-      this.notesStarted = false;
-      this.notes = (text) => {
-        clearTimeout(timer);
-        resolve(text.trim() === '' ? null : text.trim());
-      };
-      this.brain.tell(NOTES_PROMPT, this.busy);
-    });
-  }
 }

package/runtime/node_modules/@metro-labs/telegram/src/client.ts

@@ -1,9 +1,9 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { mkdirSync } from 'node:fs';
 import { TelegramClient } from '@mtcute/bun';
 import { TrainError } from '@metro-labs/core/train-error';
 import { errMsg } from '@metro-labs/core/log';
+import { ensureSecureDir } from '@metro-labs/core/secure-fs';
 import type { UserAccount } from './types.js';
 
 const STATE_DIR =
@@ -25,7 +25,7 @@ export interface UserClient {
 
 function storagePath(accountId: string): string {
   const dir = join(STATE_DIR, 'telegram');
-  mkdirSync(dir, { recursive: true });
+  ensureSecureDir(dir);
   return join(dir, `${accountId}.session`);
 }
 

package/runtime/node_modules/@metro-labs/xmtp/src/actions-conv.ts

@@ -57,7 +57,7 @@ const DELETED = { text: '[deletedMessage]', contentType: 'deletedMessage' };
 
 async function read(id: string, args: Args): Promise<void> {
   const { line, limit, before } = args as { line: string; limit?: number; before?: string };
-  const { conv } = await convOf(line);
+  const { acct, conv } = await convOf(line);
   if (!conv)
     throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
   const lim = Math.min(Math.max(1, limit ?? 20), 200);
@@ -73,6 +73,7 @@ async function read(id: string, args: Args): Promise<void> {
     id: m.id,
     ts: new Date(Number(m.sentAtNs / 1_000_000n)).toISOString(),
     from: `metro://xmtp/${acctId}/user/${m.senderInboxId}`,
+    ...(m.senderInboxId === acct.inboxId ? { self: true } : {}),
     ...(deleted.has(m.id) ? DELETED : { text: textOf(m), contentType: m.contentType?.typeId ?? 'unknown' }),
   }));
   respond(id, { result: { line, count: messages.length, messages } });

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.240"
+  "version": "0.1.0-beta.242"
 }