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

package/package.json

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

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

package/runtime/sdk-runner/runner.json

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

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 : {};