@stage-labs/metro 0.1.0-beta.266 → 0.1.0-beta.268

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.266",
+  "version": "0.1.0-beta.268",
   "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.266",
+  "version": "0.1.0-beta.268",
   "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/src/runner-activity.ts

@@ -41,6 +41,8 @@ export interface RunnerTask {
   id: string;
   kind: string | null;
   agent: string | null;
+  description?: string | null;
+  lastObservedModel?: string | null;
   status: RunnerTaskState;
   background: boolean;
   startedAt: number;
@@ -116,12 +118,23 @@ const eventKind = (value: unknown): value is RunnerEventKind => EVENTS.some((e)
 const name = (value: unknown): string | null => typeof value === 'string' && /^[A-Za-z0-9_.:-]{1,128}$/.test(value) ? value : null;
 const sessionId = (value: unknown): string | null => typeof value === 'string' && /^[0-9a-f-]{36}$/.test(value) ? value : null;
 
+export function runnerTaskDescription(value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  const line = value.split(/\r|\n|\p{Zl}|\p{Zp}/u, 1)[0] ?? '';
+  const description = line.replace(/[\p{Cc}\p{Cf}]/gu, ' ').replace(/\s+/g, ' ').trim().slice(0, 160).trim();
+  return description.length > 0 ? description : null;
+}
+
+export const runnerTaskModel = (value: unknown): string | null => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9_.:/@+[\]-]{0,127}$/.test(value) ? value : null;
+
 function task(raw: unknown): RunnerTask | null {
   if (!isRecord(raw) || !name(raw.id) || !taskState(raw.status)) return null;
   return {
     id: String(raw.id), kind: name(raw.kind), agent: name(raw.agent), status: raw.status, background: raw.background === true,
     startedAt: count(raw.startedAt), updatedAt: count(raw.updatedAt), endedAt: count(raw.endedAt) || null,
     lastTool: name(raw.lastTool), toolUses: count(raw.toolUses), durationMs: count(raw.durationMs),
+    ...(raw.description === undefined ? {} : { description: runnerTaskDescription(raw.description) }),
+    ...(raw.lastObservedModel === undefined ? {} : { lastObservedModel: runnerTaskModel(raw.lastObservedModel) }),
   };
 }
 

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/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.266"
+  "version": "0.1.0-beta.268"
 }

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

@@ -41,6 +41,8 @@ export interface RunnerTask {
   id: string;
   kind: string | null;
   agent: string | null;
+  description?: string | null;
+  lastObservedModel?: string | null;
   status: RunnerTaskState;
   background: boolean;
   startedAt: number;
@@ -116,12 +118,23 @@ const eventKind = (value: unknown): value is RunnerEventKind => EVENTS.some((e)
 const name = (value: unknown): string | null => typeof value === 'string' && /^[A-Za-z0-9_.:-]{1,128}$/.test(value) ? value : null;
 const sessionId = (value: unknown): string | null => typeof value === 'string' && /^[0-9a-f-]{36}$/.test(value) ? value : null;
 
+export function runnerTaskDescription(value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  const line = value.split(/\r|\n|\p{Zl}|\p{Zp}/u, 1)[0] ?? '';
+  const description = line.replace(/[\p{Cc}\p{Cf}]/gu, ' ').replace(/\s+/g, ' ').trim().slice(0, 160).trim();
+  return description.length > 0 ? description : null;
+}
+
+export const runnerTaskModel = (value: unknown): string | null => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9_.:/@+[\]-]{0,127}$/.test(value) ? value : null;
+
 function task(raw: unknown): RunnerTask | null {
   if (!isRecord(raw) || !name(raw.id) || !taskState(raw.status)) return null;
   return {
     id: String(raw.id), kind: name(raw.kind), agent: name(raw.agent), status: raw.status, background: raw.background === true,
     startedAt: count(raw.startedAt), updatedAt: count(raw.updatedAt), endedAt: count(raw.endedAt) || null,
     lastTool: name(raw.lastTool), toolUses: count(raw.toolUses), durationMs: count(raw.durationMs),
+    ...(raw.description === undefined ? {} : { description: runnerTaskDescription(raw.description) }),
+    ...(raw.lastObservedModel === undefined ? {} : { lastObservedModel: runnerTaskModel(raw.lastObservedModel) }),
   };
 }
 

package/runtime/sdk-runner/runner.json

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

package/runtime/sdk-runner/src/activity-tasks.ts

@@ -1,16 +1,19 @@
 import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
-import type { RunnerEventKind, RunnerTask, RunnerTaskState } from '@metro-labs/core/runner-activity';
+import { isRecord } from '@metro-labs/core/is-record';
+import { runnerTaskDescription, runnerTaskModel, type RunnerEventKind, type RunnerTask, type RunnerTaskState } from '@metro-labs/core/runner-activity';
 
 export const activityName = (name: unknown): string | null => typeof name === 'string' && /^[A-Za-z0-9_.:-]{1,128}$/.test(name) ? name : null;
 const live = (task: RunnerTask): boolean => ['running', 'pending', 'paused'].includes(task.status);
 const terminal = (status: RunnerTaskState): boolean => ['completed', 'failed', 'stopped'].includes(status);
 type System = Extract<SDKMessage, { type: 'system' }>;
 type Emit = (kind: RunnerEventKind, tool?: string | null, taskId?: string | null) => void;
+type Metadata = Pick<RunnerTask, 'description' | 'lastObservedModel'>;
 
 export class ActivityTasks {
   private readonly tasks = new Map<string, RunnerTask>();
   private readonly parents = new Map<string, string>();
   private readonly hidden = new Map<string, string>();
+  private readonly pending = new Map<string, Metadata>();
   constructor(private readonly emit: Emit) {}
 
   snapshot(): RunnerTask[] {
@@ -34,6 +37,41 @@ export class ActivityTasks {
     }
   }
 
+  launch(id: string, input: unknown): void {
+    if (!isRecord(input)) return;
+    const description = runnerTaskDescription(input.description);
+    if (description !== null) this.metadata(id, { description });
+  }
+
+  model(parent: string, value: unknown): void {
+    const lastObservedModel = runnerTaskModel(value);
+    if (lastObservedModel !== null) this.metadata(parent, { lastObservedModel });
+  }
+
+  private metadata(parent: string, fields: Metadata): void {
+    if (!activityName(parent) || this.isHidden(parent)) return;
+    const id = this.taskFor(parent);
+    const task = id === null ? undefined : this.tasks.get(id);
+    if (task !== undefined) { Object.assign(task, fields); return; }
+    const known = this.pending.get(parent);
+    this.pending.delete(parent);
+    const oldest = this.pending.keys().next();
+    if (this.pending.size >= 200 && !oldest.done) this.pending.delete(oldest.value);
+    this.pending.set(parent, { ...known, ...fields });
+  }
+
+  private link(parent: string, id: string): void {
+    this.parents.set(parent, id);
+    const task = this.tasks.get(id);
+    if (task !== undefined) Object.assign(task, this.pending.get(parent));
+    this.pending.delete(parent);
+  }
+
+  private describe(task: RunnerTask, value: unknown): void {
+    const description = runnerTaskDescription(value);
+    if (description !== null) task.description = description;
+  }
+
   stop(): void {
     for (const task of this.tasks.values()) if (live(task)) this.status(task, 'stopped');
   }
@@ -61,6 +99,7 @@ export class ActivityTasks {
       const oldest = this.hidden.keys().next();
       if (this.hidden.size >= 400 && !oldest.done) this.hidden.delete(oldest.value);
       this.hidden.set(key, id);
+      this.pending.delete(key);
     }
   }
 
@@ -71,7 +110,7 @@ export class ActivityTasks {
     for (const [key, taskId] of this.hidden) {
       if (taskId !== id) continue;
       this.hidden.delete(key);
-      this.parents.set(key, id);
+      this.link(key, id);
     }
     return task;
   }
@@ -80,18 +119,20 @@ export class ActivityTasks {
     if (message.ambient || message.skip_transcript) { this.hide(message.task_id, message.tool_use_id); return; }
     const task = this.get(message.task_id);
     if (!task) return;
-    task.kind = activityName(message.task_type);
-    task.agent = activityName(message.subagent_type);
+    task.kind = activityName(message.task_type) ?? task.kind;
+    task.agent = activityName(message.subagent_type) ?? task.agent;
     task.background = message.is_backgrounded === true;
     task.startedAt = Date.now();
     task.endedAt = null;
-    if (message.tool_use_id) this.parents.set(message.tool_use_id, task.id);
+    if (message.tool_use_id) this.link(message.tool_use_id, task.id);
+    this.describe(task, message.description);
     this.status(task, 'running');
   }
 
   private progress(message: Extract<System, { subtype: 'task_progress' }>): void {
     const task = this.tasks.get(message.task_id);
     if (!task || terminal(task.status)) return;
+    if (message.tool_use_id) this.link(message.tool_use_id, task.id);
     task.lastTool = activityName(message.last_tool_name);
     task.toolUses = message.usage.tool_uses;
     task.durationMs = message.usage.duration_ms;
@@ -101,15 +142,17 @@ export class ActivityTasks {
   private patch(message: Extract<System, { subtype: 'task_updated' }>): void {
     const task = this.tasks.get(message.task_id);
     if (!task) return;
+    this.describe(task, message.patch.description);
     if (message.patch.is_backgrounded !== undefined) task.background = message.patch.is_backgrounded;
     if (message.patch.status) this.status(task, message.patch.status === 'killed' ? 'stopped' : message.patch.status);
     task.updatedAt = Date.now();
   }
 
   private end(message: Extract<System, { subtype: 'task_notification' }>): void {
-    if (message.ambient || message.skip_transcript) { this.hide(message.task_id); return; }
+    if (message.ambient || message.skip_transcript) { this.hide(message.task_id, message.tool_use_id); return; }
     const task = this.get(message.task_id);
     if (!task) return;
+    if (message.tool_use_id) this.link(message.tool_use_id, task.id);
     if (message.usage) {
       task.durationMs = message.usage.duration_ms;
       task.toolUses = message.usage.tool_uses;
@@ -123,7 +166,9 @@ export class ActivityTasks {
     for (const row of message.tasks) {
       if (row.ambient) { this.hide(row.task_id); continue; }
       const task = this.show(row.task_id);
-      if (!task || terminal(task.status)) continue;
+      if (!task) continue;
+      this.describe(task, row.description);
+      if (terminal(task.status)) continue;
       task.kind = activityName(row.task_type);
       task.background = true;
       this.status(task, 'running');

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

@@ -251,15 +251,21 @@ export class Activity {
   private content(message: Extract<SDKMessage, { type: 'assistant' | 'user' }>): void {
     const content = message.message.content;
     const parent = message.parent_tool_use_id ?? null;
-    if (parent === null && message.type === 'assistant') {
-      this.turn();
-      if (message.error !== undefined) this.providerCode = message.error === 'unknown' ? null : PROVIDER_ERRORS[message.error];
-    }
+    if (message.type === 'assistant') this.assistant(message, parent);
     if (Array.isArray(content)) for (const block of content) if (isRecord(block)) this.block(block, parent);
   }
 
+  private assistant(message: Extract<SDKMessage, { type: 'assistant' }>, parent: string | null): void {
+    if (parent !== null) { this.tasks.model(parent, message.message.model); return; }
+    this.turn();
+    if (message.error !== undefined) this.providerCode = message.error === 'unknown' ? null : PROVIDER_ERRORS[message.error];
+  }
+
   private block(block: Record<string, unknown>, parent: string | null): void {
-    if (block.type === 'tool_use' && typeof block.id === 'string') this.tool(block.id, block.name, parent);
+    if (block.type === 'tool_use' && typeof block.id === 'string') {
+      if (block.name === 'Agent' || block.name === 'Task') this.tasks.launch(block.id, block.input);
+      this.tool(block.id, block.name, parent);
+    }
     else if (block.type === 'tool_result' && typeof block.tool_use_id === 'string') this.finish(block.tool_use_id, block.is_error === true, parent, block.content);
   }
 

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.