@stage-labs/metro 0.1.0-beta.267 → 0.1.0-beta.269

package/package.json

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

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

@@ -188,6 +188,7 @@ export class SharedCalls {
   private status(route: CallRoute, action: Action, status: SpeechStatus): void {
     if (this.terminal(action.status) || (status === 'started' && action.status === 'started')) return;
     action.status = status;
+    log.info({ actionId: action.actionId, status, at: Date.now() }, 'sdk-call: speech action');
     this.bridge?.notify({ type: 'speech', route, sourceId: action.sourceId, actionId: action.actionId, status });
   }
 }

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

@@ -12,17 +12,24 @@ const SPEECH_MS = 60_000;
 type Speech = Pick<Utterance, 'attach' | 'say' | 'end' | 'abort'>;
 type MakeSpeech = (failed: (reason: string) => void) => Speech;
 
-interface Playing {
+interface Queued {
   action: SharedSpeechAction;
+  queuedAt: number;
+}
+
+interface Playing extends Queued {
   utterance: Speech | null;
   timer: ReturnType<typeof setTimeout>;
   synthesized: boolean;
   started: boolean;
+  synthesisStartedAt: number;
+  firstAudioAt: number | null;
+  markedFrameResolvedAt: number | null;
 }
 
 export class SpeechQueue {
   private readonly player: Player;
-  private readonly waiting: SharedSpeechAction[] = [];
+  private readonly waiting: Queued[] = [];
   private current: Playing | null = null;
   private live = false;
   private closed = false;
@@ -45,6 +52,7 @@ export class SpeechQueue {
       const current = this.current;
       if (current === null || current.started) return;
       current.started = true;
+      current.markedFrameResolvedAt = Date.now();
       current.action.status('started');
     });
     this.player.whenIdle(() => {
@@ -66,7 +74,7 @@ export class SpeechQueue {
   enqueue(action: SharedSpeechAction): boolean {
     if (this.closed || action.text.trim() === '' || action.text.length > MAX_TEXT) return false;
     if (this.waiting.length + (this.current === null ? 0 : 1) >= MAX_QUEUED || !action.isValid()) return false;
-    this.waiting.push(action);
+    this.waiting.push({ action, queuedAt: Date.now() });
     queueMicrotask(() => {
       this.next();
     });
@@ -83,7 +91,10 @@ export class SpeechQueue {
   cancel(): void {
     const waiting = this.waiting.splice(0);
     this.settle('interrupted');
-    for (const action of waiting) action.status('interrupted');
+    for (const queued of waiting) {
+      this.report(queued, 'interrupted');
+      queued.action.status('interrupted');
+    }
   }
 
   close(): void {
@@ -96,15 +107,18 @@ export class SpeechQueue {
 
   private next(): void {
     if (!this.live || this.closed || this.current !== null) return;
-    const action = this.waiting.shift();
-    if (action === undefined) return;
+    const queued = this.waiting.shift();
+    if (queued === undefined) return;
+    const { action } = queued;
     if (!action.isValid()) {
+      this.report(queued, 'failed');
       action.status('failed');
       this.next();
       return;
     }
     const playing: Playing = {
-      action, utterance: null, synthesized: false, started: false,
+      ...queued, utterance: null, synthesized: false, started: false,
+      synthesisStartedAt: Date.now(), firstAudioAt: null, markedFrameResolvedAt: null,
       timer: setTimeout(() => {
         if (this.current === playing) this.fail('speech timed out');
       }, this.timeoutMs),
@@ -121,7 +135,9 @@ export class SpeechQueue {
       playing.utterance = utterance;
       utterance.attach({
         audio: (pcm, chars) => {
-          if (this.valid(playing)) this.player.push(pcm, chars);
+          if (this.current === playing && pcm.length > 0) playing.firstAudioAt ??= Date.now();
+          if (!this.valid(playing)) return;
+          this.player.push(pcm, chars);
         },
         done: () => {
           if (!this.valid(playing)) return;
@@ -157,6 +173,16 @@ export class SpeechQueue {
     this.onFailed();
   }
 
+  private report(queued: Queued, status: SpeechStatus, playing?: Playing): void {
+    log.info({
+      actionId: queued.action.actionId, status, queuedAt: queued.queuedAt,
+      synthesisStartedAt: playing?.synthesisStartedAt ?? null,
+      firstAudioAt: playing?.firstAudioAt ?? null,
+      markedFrameResolvedAt: playing?.markedFrameResolvedAt ?? null,
+      settledAt: Date.now(),
+    }, 'voice: speech timing');
+  }
+
   private settle(status: SpeechStatus): void {
     const current = this.current;
     this.current = null;
@@ -164,6 +190,7 @@ export class SpeechQueue {
     if (current !== null) {
       clearTimeout(current.timer);
       current.utterance?.abort();
+      this.report(current, status, current);
       current.action.status(status);
     }
     queueMicrotask(() => {

package/runtime/node_modules/@metro-labs/whatsapp/src/station.ts

@@ -2,7 +2,7 @@ import type { Station, Verb } from '@metro-labs/core/stations/types';
 import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
 import { tokenFiles } from './token-store.js';
 import { nameFiles } from './names.js';
-import { historyFiles } from './history-state.js';
+import { historyFiles } from './history-files.js';
 
 export const whatsappStation: Station = {
   name: 'whatsapp',

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.267"
+  "version": "0.1.0-beta.269"
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.267",
+  "version": "0.1.0-beta.269",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",

package/runtime/sdk-runner/src/input-timing.ts

@@ -63,6 +63,6 @@ export class InputTiming {
 
   private note(input: RunnerInput): void {
     this.changed({ ...input });
-    log.info({ input: input.id, kind: input.kind, state: input.state, queueAgeMs: (input.consumedAt ?? Date.now()) - input.acceptedAt }, 'sdk-runner: input lifecycle');
+    log.info({ input: input.id, kind: input.kind, state: input.state, acceptedAt: input.acceptedAt, dispatchedAt: input.dispatchedAt, consumedAt: input.consumedAt, firstOutputAt: input.firstOutputAt, completedAt: input.completedAt, queueAgeMs: (input.consumedAt ?? Date.now()) - input.acceptedAt }, 'sdk-runner: input lifecycle');
   }
 }

package/runtime/sdk-runner/src/rules.ts

@@ -3,6 +3,7 @@ import type { CallRoute, CallSource } from '@metro-labs/core/call';
 export const FRONT_RULES = `You are the orchestrator of this agent's persistent Agent SDK session. Typed chat, live call words (<call> blocks), and background worker reports share this conversation.
 - Be fast. When you can answer a chat message at once, make the reaction and the answer one response of parallel tool calls (react, then send), with no typing signal. Use typing only when the answer will take a while.
 - Stay light: talk, decide and delegate. Real work goes to background workers (Agent tool, subagent_type "worker", run_in_background: true); keep answering while they run, and relay what they report.
+- At the next safe tool boundary, answer pending live-call inputs before starting unrelated delegation or processing worker reports. Give a short, direct answer when possible; do not generate a long task prompt before replying to the caller. Never interrupt active writes or approvals, invent filler, or promise work is done before it is.
 - Plain assistant text is never spoken. Reply to a live <call> with mcp__metro__send using its exact line, text, and speech:{callId,generation,sourceId}. This sends speech only, not a chat post. Keep it short. Never paste a spoken reply or transcript into chat unless the owner explicitly requests a chat post.
 - Ordinary typed chat and worker results are never automatically spoken. For an explicit typed owner request to speak, use only that channel message's call_id, call_generation and call_source_id with its exact line as send speech:{callId:call_id,generation:call_generation,sourceId:call_source_id}. Without all three authorized live-call values, do not speak or guess a target. Do not reuse an earlier sourceId for a new reply.
 - A call ending invalidates its speech targets. Keep the chat session and background work running. Nothing is posted about a hangup unless requested. Speech status notifications are status only, never a request to speak.