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

package/package.json

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

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

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.265",
+  "version": "0.1.0-beta.267",
   "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/inbox.ts

@@ -17,7 +17,7 @@ export interface Unanswered {
 
 interface InboxHooks {
   ready?(): boolean;
-  dispatch?(): void;
+  dispatch?(message: SDKUserMessage): void;
   queue?(count: number, oldest: number | null): void;
   input?: InputWatch;
 }
@@ -94,8 +94,8 @@ export class Inbox implements AsyncIterable<SDKUserMessage> {
 
   cancel(uuids: readonly string[]): void {
     const ephemeral = uuids.filter((uuid) => this.kindOf(uuid) !== 'chat');
-    this.queue.cancel(new Set(ephemeral));
-    this.timing.finish(ephemeral, true);
+    const removed = this.queue.cancel(new Set(ephemeral));
+    this.timing.finish(removed, true);
     this.notify();
   }
 
@@ -121,7 +121,7 @@ export class Inbox implements AsyncIterable<SDKUserMessage> {
     while (!this.closed) {
       const next = (this.hooks.ready?.() ?? true) ? this.queue.take() : undefined;
       if (next !== undefined) {
-        this.hooks.dispatch?.();
+        this.hooks.dispatch?.(next);
         if (next.uuid !== undefined) this.timing.dispatch(next.uuid);
         this.notify();
         yield next;

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

@@ -55,11 +55,16 @@ export class InputQueue {
     return undefined;
   }
 
-  cancel(uuids: ReadonlySet<string>): void {
+  cancel(uuids: ReadonlySet<string>): string[] {
+    const removed: string[] = [];
     for (let index = this.items.length - 1; index >= 0; index -= 1) {
       const uuid = this.items[index]?.message.uuid;
-      if (uuid !== undefined && uuids.has(uuid)) this.remove(index);
+      if (uuid !== undefined && uuids.has(uuid)) {
+        this.remove(index);
+        removed.push(uuid);
+      }
     }
+    return removed;
   }
 
   private remove(index: number): Queued | undefined {

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

@@ -19,7 +19,9 @@ const MODEL_PINS: ReadonlySet<string> = new Set(['ANTHROPIC_MODEL', 'CLAUDE_CODE
 
 export function runnerEnv(env: NodeJS.ProcessEnv): Record<string, string | undefined> {
   const unpinned = Object.fromEntries(Object.entries(env).filter(([name]) => !MODEL_PINS.has(name)));
-  return { [STARTUP_WAIT]: '0', ...unpinned, DISABLE_AUTOUPDATER: '1' };
+  const terminals = new Set((env.CLAUDE_CODE_TERMINAL_MCP_TOOLS ?? '').split(',').map((name) => name.trim()).filter(Boolean));
+  terminals.add('mcp__metro__send');
+  return { [STARTUP_WAIT]: '0', ...unpinned, DISABLE_AUTOUPDATER: '1', CLAUDE_CODE_TERMINAL_MCP_TOOLS: [...terminals].join(',') };
 }
 
 export type ModelSettings = Parameters<Query['applyFlagSettings']>[0];
@@ -97,8 +99,8 @@ export class Runner {
   constructor(private readonly parts: RunnerParts) {
     this.watch = new SessionWatch(parts.readOnly);
     this.inbox = new Inbox((unanswered) => { this.keep(unanswered); }, {
-      ready: () => this.watch.safe,
-      dispatch: () => { this.watch.dispatched(); },
+      ready: () => this.watch.admitting,
+      dispatch: (message) => { this.watch.dispatched(message.uuid); },
       input: (input) => { parts.activity?.input(input); },
       queue: (count, oldest) => { parts.activity?.pending(count, oldest); },
     });
@@ -241,7 +243,7 @@ export class Runner {
   }
 
   private maybeCompact(resuming = false): void {
-    const busy = this.compactAsked !== null || !this.watch.safe || (!resuming && (this.calls.live || this.inbox.pending > 0));
+    const busy = this.compactAsked !== null || !this.watch.safe || !this.watch.admitting || (!resuming && (this.calls.live || this.inbox.pending > 0));
     if (!compactDue({ context: this.watch.context, floor: this.compactFloor, limit: this.parts.compactAt ?? COMPACT_AT, busy })) return;
     this.compactAsked = this.inbox.compact();
     log.info({ context: this.watch.context, resuming }, 'sdk-runner: compacting at a safe idle boundary');

package/runtime/sdk-runner/src/session-watch.ts

@@ -22,7 +22,6 @@ function toolResultIds(message: unknown): string[] {
   return message.content.filter(isRecord).filter((b) => b.type === 'tool_result' && typeof b.tool_use_id === 'string').map((b) => String(b.tool_use_id));
 }
 
-
 export class SessionWatch {
   private readonly writes = new Set<string>();
   private readonly idle: (() => void)[] = [];
@@ -30,6 +29,8 @@ export class SessionWatch {
   private compactingNow = false;
   private busy = false;
   private sessionStateSeen = false;
+  private requiresAction = false;
+  private awaitingInput: string | null = null;
   private lastContext = 0;
   private streamUsage: Record<string, unknown> = {};
 
@@ -49,11 +50,20 @@ export class SessionWatch {
 
   get safe(): boolean { return !this.busy && !this.writing && !this.compacting; }
 
-  dispatched(): void { this.busy = true; }
+  get admitting(): boolean {
+    return this.awaitingInput === null && !this.requiresAction && !this.compacting;
+  }
+
+  dispatched(uuid?: string): void {
+    this.busy = true;
+    this.awaitingInput = uuid ?? null;
+  }
+
   restoreContext(context: number): void { this.lastContext = context; }
 
   observe(m: Record<string, unknown>): void {
     if (m.parent_tool_use_id !== null && m.parent_tool_use_id !== undefined) return;
+    this.acknowledge(m);
     this.lifecycle(m);
     if (m.type === 'assistant' && isRecord(m.message)) this.assistant(m.message);
     else if (m.type === 'stream_event' && isRecord(m.event)) this.stream(m.event);
@@ -68,6 +78,11 @@ export class SessionWatch {
     return this.compactingNow ? new Promise((resolve) => { this.compacted.push(resolve); }) : Promise.resolve();
   }
 
+  private acknowledge(m: Record<string, unknown>): void {
+    if (this.awaitingInput === null) return;
+    if (startedCommand(m) === this.awaitingInput || uuidsOf(m)?.includes(this.awaitingInput)) this.awaitingInput = null;
+  }
+
   private lifecycle(m: Record<string, unknown>): void {
     if (m.type === 'system') this.system(m);
     else if (m.type === 'result' && !this.sessionStateSeen) {
@@ -78,11 +93,8 @@ export class SessionWatch {
   }
 
   private system(m: Record<string, unknown>): void {
-    if (m.subtype === 'session_state_changed') {
-      this.sessionStateSeen = true;
-      if (m.state === 'running' || m.state === 'requires_action') this.busy = true;
-      else if (m.state === 'idle') { this.busy = false; this.settle(); }
-    } else if (m.subtype === 'status') this.setCompacting(m.status === 'compacting');
+    if (m.subtype === 'session_state_changed') this.sessionState(m.state);
+    else if (m.subtype === 'status') this.setCompacting(m.status === 'compacting');
     else if (m.subtype === 'compact_boundary') {
       this.setCompacting(false);
       this.lastContext = 0;
@@ -90,6 +102,18 @@ export class SessionWatch {
     }
   }
 
+  private sessionState(state: unknown): void {
+    this.sessionStateSeen = true;
+    if (state === 'running' || state === 'requires_action') {
+      this.busy = true;
+      this.requiresAction = state === 'requires_action';
+    } else if (state === 'idle') {
+      this.busy = false;
+      this.requiresAction = false;
+      this.settle();
+    }
+  }
+
   private stream(event: Record<string, unknown>): void {
     if (event.type === 'message_start' && isRecord(event.message)) {
       this.streamUsage = isRecord(event.message.usage) ? event.message.usage : {};