@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.321

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

@@ -0,0 +1,45 @@
+import { CALL_NOTICE, sameCall, type CallNotice, type CallRoute } from '@metro-labs/core/call';
+import { errMsg, log } from '@metro-labs/core/log';
+import { eventInScope } from '../agents/scope.js';
+import { revokeCallPrompts } from '../approvals/pending.js';
+import { sharedCalls } from '../voice/shared.js';
+import type { McpSession } from './session.js';
+
+export const callInScope = (scope: Set<string>, route: CallRoute): boolean =>
+  scope.has(route.agentId) && eventInScope(scope, route.line);
+
+export function connectCallBridge(current: () => McpSession | undefined): void {
+  let owner: McpSession | undefined;
+  let route: CallRoute | undefined;
+  const available = (wanted: CallRoute): boolean => {
+    const session = current();
+    return session !== undefined && session.streamAttached && session.server.getClientVersion()?.name === 'metro-sdk-runner' &&
+      callInScope(session.scope, wanted) && (route === undefined || owner === session);
+  };
+  const boundTo = (session: McpSession | undefined, wanted: CallRoute): boolean => session === owner && route !== undefined && sameCall(route, wanted);
+  const forgetEnded = (notice: CallNotice): void => {
+    if (notice.type === 'ended' && route !== undefined && sameCall(route, notice.route)) {
+      owner = undefined;
+      route = undefined;
+    }
+  };
+  sharedCalls.connect({
+    available,
+    notify: (notice: CallNotice): boolean => {
+      const session = current();
+      const bound = notice.type === 'started' ? available(notice.route) : boundTo(session, notice.route);
+      forgetEnded(notice);
+      if (session === undefined || !session.streamAttached || !callInScope(session.scope, notice.route) || !bound) return false;
+      if (notice.type === 'started') {
+        owner = session;
+        route = notice.route;
+      }
+      session.server.notification({ method: CALL_NOTICE, params: { ...notice, meta: { line: notice.route.line } } }).catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'sdk-call: notification failed');
+        sharedCalls.end(notice.route);
+      });
+      return true;
+    },
+    revoked: (ended) => { revokeCallPrompts(ended); },
+  });
+}

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

@@ -0,0 +1,25 @@
+import { callRoute, speechTarget, type CallSource } from '@metro-labs/core/call';
+import { isRecord } from '@metro-labs/core/is-record';
+import { readPreview } from '../approvals/preview.js';
+import { sharedCalls } from '../voice/shared.js';
+import { agentIdForLine } from '../agents/map.js';
+
+function boundCall(value: unknown, inScope: (line: string) => boolean): CallSource | null {
+  if (!isRecord(value)) return null;
+  const route = callRoute(value.route);
+  const sourceId = value.sourceId;
+  if (route === null || typeof sourceId !== 'string') return null;
+  const source = { route, sourceId };
+  return inScope(route.line) && sharedCalls.valid(source) ? source : null;
+}
+
+export function permissionCall(params: { call?: unknown; input_preview: string; tool_name: string }, inScope: (line: string) => boolean): CallSource | null | undefined {
+  if (params.call !== undefined) return boundCall(params.call, inScope);
+  if (params.tool_name !== 'mcp__metro__send') return undefined;
+  const { input } = readPreview(params.input_preview);
+  if (!isRecord(input) || input.speech === undefined) return undefined;
+  const target = speechTarget(input.speech);
+  if (target === null || typeof input.line !== 'string' || !inScope(input.line)) return null;
+  const agentId = agentIdForLine(input.line);
+  return agentId === undefined ? null : sharedCalls.source(input.line, target, new Set([agentId]));
+}

package/runtime/node_modules/@metro-labs/{mcp → daemon}/src/mcp/call-tools.ts

@@ -1,14 +1,16 @@
 import { stationForLine } from '../stations/registry.js';
-import { kindOf, toCanonical } from '../stations/attachments.js';
+import { kindOf, toCanonical } from '@metro-labs/core/stations/attachments';
 import {
   cleanupAttachments,
   resolveAttachments,
   type ResolvedAttachment,
 } from '../stations/attach-resolve.js';
-import type { CanonicalAttachment, ToolResult } from '../stations/types.js';
-import { errResult, makeCtx, ok, okJson, toErr } from './ctx.js';
+import type { CanonicalAttachment, ToolResult } from '@metro-labs/core/stations/types';
+import { errResult, makeCtx, ok, toErr } from './ctx.js';
+import { runRead } from './read-tool.js';
 import { allowedAgents, currentIdentity } from './request-identity.js';
-import { str } from './str.js';
+import { str } from '@metro-labs/core/str';
+import { sendSpeech } from './speech-send.js';
 
 type Station = NonNullable<ReturnType<typeof stationForLine>>;
 
@@ -16,6 +18,7 @@ interface MessageArgs {
   line: string;
   a: Record<string, unknown>;
   ctx: ReturnType<typeof makeCtx>;
+  onSent?: (messageId: string) => void;
   station: Station;
 }
 
@@ -30,8 +33,14 @@ const withId = (text: string, messageId: string | undefined): string =>
 interface Sent {
   labels: string[];
   messageId?: string;
+  thread?: string;
 }
 
+const threadOf = (response: { result: unknown }, asked: string): string | undefined => {
+  const line = (response.result as { line?: unknown } | null)?.line;
+  return typeof line === 'string' && line !== '' && line !== asked ? line : undefined;
+};
+
 const deliveredLabels = (response: { result: unknown }): string[] => {
   const list = (response.result as { attachments?: unknown } | null)
     ?.attachments;
@@ -52,6 +61,25 @@ function assertDelivered(
     );
 }
 
+const STAGE_PARTS = ['frame', 'wallet'] as const;
+
+const stagePartsIn = (m: MessageArgs): string[] => STAGE_PARTS.filter((key) => m.a[key] !== undefined);
+
+const stagePartArgs = (m: MessageArgs): Record<string, unknown> =>
+  Object.fromEntries(stagePartsIn(m).map((key) => [key, m.a[key]]));
+
+const sentLabels = (m: MessageArgs, text: string | undefined): string[] => [
+  ...(text ? ['text'] : []),
+  ...stagePartsIn(m),
+];
+
+function nativeBody(m: MessageArgs, text: string | undefined, replyTo: string | undefined): Record<string, unknown> {
+  const body: Record<string, unknown> = { line: m.line, ...stagePartArgs(m) };
+  if (text) body.text = text;
+  if (text && replyTo) body.replyTo = replyTo;
+  return body;
+}
+
 async function sendNative(
   m: MessageArgs,
   text: string | undefined,
@@ -59,16 +87,9 @@ async function sendNative(
   atts: ResolvedAttachment[],
 ): Promise<Sent> {
   const { line, ctx, station } = m;
-  const labels: string[] = [];
+  const labels = sentLabels(m, text);
   let messageId: string | undefined;
-  if (text) {
-    const response = await ctx.call(
-      'send',
-      replyTo ? { line, text, replyTo } : { line, text },
-    );
-    messageId = messageIdOf(response);
-    labels.push('text');
-  }
+  if (labels.length) messageId = messageIdOf(await ctx.call('send', nativeBody(m, text, replyTo)));
   if (!atts.length) return { labels, messageId };
   const delivered = station.sendAttachments
     ? await station.sendAttachments(line, atts, ctx)
@@ -85,19 +106,21 @@ async function sendForwarded(
   atts: ResolvedAttachment[],
 ): Promise<Sent> {
   const { line, ctx, station } = m;
-  const args: Record<string, unknown> = { line };
+  const args: Record<string, unknown> = { line, ...stagePartArgs(m) };
   if (text) args.text = text;
+  if (typeof m.a.subject === 'string' && m.a.subject.trim() !== '') args.subject = m.a.subject;
   if (replyTo) args.replyTo = replyTo;
   if (atts.length) args.attachments = atts.map(toCanonical);
   const response = await ctx.call('send', args);
   const messageId = messageIdOf(response);
-  const labels: string[] = [];
-  if (text) labels.push('text');
-  if (!atts.length) return { labels, messageId };
-  const delivered = deliveredLabels(response);
-  assertDelivered(station, delivered, atts);
-  labels.push(...delivered);
-  return { labels, messageId };
+  const thread = threadOf(response, line);
+  const labels = sentLabels(m, text);
+  if (atts.length) {
+    const delivered = deliveredLabels(response);
+    assertDelivered(station, delivered, atts);
+    labels.push(...delivered);
+  }
+  return thread === undefined ? { labels, messageId } : { labels, messageId, thread };
 }
 
 const unsupported = (station: Station, atts: CanonicalAttachment[]): string =>
@@ -105,14 +128,28 @@ const unsupported = (station: Station, atts: CanonicalAttachment[]): string =>
     .map((a) => kindOf(a.mime ?? '', a.path ?? a.url ?? a.name ?? ''))
     .join(', ')}); send a link in \`text\` instead`;
 
+const NOTHING_TO_SEND = 'send requires `text`, `attachments`, `frame` or `wallet`';
+
+function refusal(m: MessageArgs, text: string | undefined, requested: CanonicalAttachment[]): string | undefined {
+  const stageOnly = stagePartsIn(m);
+  if (!text && !requested.length && !stageOnly.length) return NOTHING_TO_SEND;
+  if (stageOnly.length && m.station.sendsFrames !== true)
+    return `${m.station.name} cannot send \`${stageOnly.join('` or `')}\`; that is Stage (XMTP) only`;
+  if (requested.length && m.station.attachmentMode === 'none') return unsupported(m.station, requested);
+  return undefined;
+}
+
+function noteSent(m: MessageArgs, messageId: string | undefined): void {
+  if (messageId !== undefined) m.onSent?.(messageId);
+}
+
 async function handleSend(m: MessageArgs): Promise<ToolResult> {
+  if (m.a.speech !== undefined) return sendSpeech(m.line, m.a);
   const text = m.a.text as string | undefined;
   const replyTo = m.a.reply_to as string | undefined;
   const requested = (m.a.attachments as CanonicalAttachment[] | undefined) ?? [];
-  if (!text && !requested.length)
-    return errResult('send requires `text` or `attachments`');
-  if (requested.length && m.station.attachmentMode === 'none')
-    return errResult(unsupported(m.station, requested));
+  const refused = refusal(m, text, requested);
+  if (refused !== undefined) return errResult(refused);
   const atts = await resolveAttachments(requested, {
     allowed: allowedAgents(currentIdentity()),
   });
@@ -123,21 +160,16 @@ async function handleSend(m: MessageArgs): Promise<ToolResult> {
     const sent = native
       ? await sendNative(m, text, replyTo, atts)
       : await sendForwarded(m, text, replyTo, atts);
-    if (!sent.labels.length)
-      return errResult('send requires `text` or `attachments`');
-    return ok(withId(`sent: ${sent.labels.join(', ')}`, sent.messageId));
+    if (!sent.labels.length) return errResult(NOTHING_TO_SEND);
+    noteSent(m, sent.messageId);
+    const done = withId(`sent: ${sent.labels.join(', ')}`, sent.messageId);
+    return ok(sent.thread === undefined ? done : `${done} — new thread line: ${sent.thread}`);
   } finally {
     await cleanupAttachments(atts);
   }
 }
 
-async function handleRead({ line, a, ctx }: MessageArgs): Promise<ToolResult> {
-  const args: Record<string, unknown> = { line };
-  if (typeof a.limit === 'number') args.limit = a.limit;
-  if (a.before) args.before = str(a.before);
-  if (a.since) args.since = str(a.since);
-  return okJson(await ctx.call('read', args));
-}
+const handleRead = ({ a, station }: MessageArgs): Promise<ToolResult> => runRead(station, a);
 
 type MessageHandler = (m: MessageArgs) => Promise<ToolResult>;
 
@@ -158,7 +190,7 @@ const MESSAGE_VERBS: Record<string, VerbSpec> = {
 };
 
 function makeVerbHandler(verb: string, spec: VerbSpec): MessageHandler {
-  return async ({ line, a, ctx }) => {
+  return async ({ line, a, ctx, onSent }) => {
     const payload: Record<string, unknown> = { line };
     for (const [snake, camel] of spec.args) {
       const value = str(a[snake]);
@@ -169,21 +201,34 @@ function makeVerbHandler(verb: string, spec: VerbSpec): MessageHandler {
       payload[camel] = value;
     }
     const response = await ctx.call(verb, payload);
-    return ok(withId(spec.success, messageIdOf(response)));
+    const messageId = messageIdOf(response);
+    if (verb === 'reply' && messageId !== undefined) onSent?.(messageId);
+    return ok(withId(spec.success, messageId));
   };
 }
 
+const handleTyping = async ({ line, ctx }: MessageArgs): Promise<ToolResult> => {
+  await ctx.call('typing', { line });
+  return ok('typing shown');
+};
+
 const MESSAGE_HANDLERS: Record<string, MessageHandler> = {
   send: handleSend,
   read: handleRead,
+  typing: handleTyping,
   ...Object.fromEntries(
     Object.entries(MESSAGE_VERBS).map(([verb, spec]) => [verb, makeVerbHandler(verb, spec)]),
   ),
 };
 
+export interface ToolHooks {
+  onSent?: (messageId: string) => void;
+}
+
 export async function dispatchMessageTool(
   name: string,
   a: Record<string, unknown>,
+  hooks: ToolHooks = {},
 ): Promise<ToolResult> {
   const line = str(a.line);
   if (!line) return errResult(`${name} requires \`line\``);
@@ -195,8 +240,13 @@ export async function dispatchMessageTool(
   }
   const handler = MESSAGE_HANDLERS[name];
   if (!handler) return errResult(`unknown tool: ${name}`);
+  const verbs: ReadonlySet<string> = station.messageVerbs;
+  if (!verbs.has(name))
+    return errResult(
+      `${station.name} does not support ${name}; it supports ${[...verbs].join(', ')}.`,
+    );
   try {
-    return await handler({ line, a, ctx: makeCtx(station.name), station });
+    return await handler({ line, a, ctx: makeCtx(station.name), station, onSent: hooks.onSent });
   } catch (e) {
     return toErr(name, e);
   }

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

@@ -0,0 +1,80 @@
+import { channelOptions, type ChannelList } from '@metro-labs/core/stations/channel-directory';
+import type { ToolResult } from '@metro-labs/core/stations/types';
+import { str } from '@metro-labs/core/str';
+import { stationByName } from '../stations/registry.js';
+import { callTargetDenied } from '../agents/scope.js';
+import { errResult, makeCtx, okJson, toErr } from './ctx.js';
+import { stationOfAccount } from './read-tool.js';
+import type { ToolDef } from './tool-def.js';
+
+export const LIST_CHANNELS_TOOL: ToolDef = {
+  name: 'list_channels',
+  group: 'read',
+  description:
+    'Discover existing conversations for one account from list_accounts, returning metadata only. ' +
+    'Args: account (required), query?, limit? (1 to 100, default 50), cursor?. Query matches names, ids or lines ' +
+    'case-insensitively. Returns {account, station, channels:[{id, line, name?, kind:direct|group|channel|thread}], ' +
+    'capability:{supported, complete, source:remote|local|mixed|unsupported, reason?}, next_cursor?}. ' +
+    'Use each returned line with other Metro tools. Follow next_cursor with the same account and query. ' +
+    'Check capability: local or partial directories are not exhaustive, and unsupported is not an empty account. ' +
+    'No recent message is required. Receive messages Off does not disable discovery; read policies still apply.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      account: { type: 'string', minLength: 1, description: 'An account id from list_accounts.' },
+      query: { type: 'string', maxLength: 200, description: 'Case-insensitive name, id or line substring.' },
+      limit: { type: 'integer', minimum: 1, maximum: 100, default: 50, description: 'Maximum channels per page.' },
+      cursor: { type: 'string', minLength: 1, maxLength: 2048, description: 'The next_cursor from the previous page.' },
+    },
+    required: ['account'],
+  },
+};
+
+export function channelScopeDenied(allowed: Set<string>, a: Record<string, unknown>): boolean {
+  const account = str(a.account);
+  const station = account ? stationOfAccount(account) : undefined;
+  return station === undefined || stationByName(station) === undefined || callTargetDenied(allowed, station, { account });
+}
+
+export function channelArgsError(a: Record<string, unknown>): ToolResult | undefined {
+  if (typeof a.account !== 'string' || !a.account.trim())
+    return errResult('list_channels requires `account` from list_accounts');
+  try {
+    channelOptions(a);
+    return undefined;
+  } catch (e) {
+    return toErr('list_channels', e);
+  }
+}
+
+export async function dispatchListChannels(a: Record<string, unknown>): Promise<ToolResult> {
+  const account = str(a.account);
+  const name = stationOfAccount(account);
+  const station = name === undefined ? undefined : stationByName(name);
+  if (station === undefined) return errResult('list_channels requires a unique account from list_accounts');
+  if (!station.hasTrain || station.discoversChannels !== true) {
+    const list: ChannelList = {
+      channels: [],
+      capability: {
+        supported: false,
+        complete: false,
+        source: 'unsupported',
+        reason: `${station.name} does not support channel discovery`,
+      },
+    };
+    return okJson({ account, station: station.name, ...list });
+  }
+  try {
+    const { limit, cursor } = channelOptions(a);
+    const args = {
+      account,
+      limit,
+      ...(a.query === undefined ? {} : { query: str(a.query) }),
+      ...(cursor === undefined ? {} : { cursor }),
+    };
+    const { result } = await makeCtx(station.name).call('listChannels', args);
+    return okJson({ ...result as ChannelList, account, station: station.name });
+  } catch (e) {
+    return toErr('list_channels', e);
+  }
+}

package/runtime/node_modules/@metro-labs/{mcp → daemon}/src/mcp/ctx.ts

@@ -1,8 +1,8 @@
 import { readFile } from 'node:fs/promises';
-import { forwardTrainCall } from '../daemon/train-call.js';
-import { errMsg, log } from '../daemon/log.js';
-import { TrainError } from '../daemon/train-error.js';
-import { type ToolContext, type ToolResult } from '../stations/types.js';
+import { forwardTrainCall } from '../stations/train-call.js';
+import { errMsg, log } from '@metro-labs/core/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { type ToolContext, type ToolResult } from '@metro-labs/core/stations/types';
 
 export async function metroCall(
   train: string,

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

@@ -0,0 +1,102 @@
+import { createHash } from 'node:crypto';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { bufferedSince } from '@metro-labs/core/events';
+import { STATIONS } from '@metro-labs/core/station-names';
+import { accountEnabled, accountFromLine, knownAccounts } from '../agents/map.js';
+import { eventInScope } from '../agents/scope.js';
+import type { GetStreamDiagnostic } from './raw-get-stream.js';
+
+export const MCP_STATUS_PATH = '/mcp/status';
+
+export const diagnosticTag = (value: string): string =>
+  createHash('sha256').update(value).digest('hex').slice(0, 16);
+
+export interface SessionDiagnostic {
+  tag: string;
+  openedAt: string;
+  transportInitialized: boolean;
+  clientInitializedAt: string | null;
+  client: { kind: 'claude-code' | 'metro-sdk-runner' | 'other'; tag: string } | null;
+  subscribed: boolean;
+  streamAttached: boolean;
+  lastStreamAttachedAt: string | null;
+  lastStreamDetachedAt: string | null;
+  stream: GetStreamDiagnostic | null;
+}
+
+export interface SlotDiagnostic {
+  started: boolean;
+  liveEvents: boolean;
+  current: SessionDiagnostic | null;
+  replacements: { at: string; reason: 'initialize' | 'adopt'; tag: string; previous: SessionDiagnostic | null }[];
+}
+
+interface DiagnosticSlot {
+  diagnostics: (scope: Set<string>) => SlotDiagnostic;
+}
+
+export interface IncomingDiagnostic extends SlotDiagnostic {
+  version: 1;
+  observedAt: string;
+  accounts: {
+    station: string;
+    tag: string;
+    receiveEnabled: boolean;
+    bufferedEvents: number;
+    latestEventAt: string | null;
+    latestEventTag: string | null;
+  }[];
+}
+
+export function clientDiagnostic(client: { name: string; version: string } | undefined): SessionDiagnostic['client'] {
+  if (client === undefined) return null;
+  const kind = client.name === 'claude-code' || client.name === 'metro-sdk-runner' ? client.name : 'other';
+  return { kind, tag: diagnosticTag(JSON.stringify([client.name, client.version])) };
+}
+
+const eventDate = (raw: unknown): string | null => {
+  if (typeof raw !== 'string') return null;
+  const time = Date.parse(raw);
+  return Number.isFinite(time) ? new Date(time).toISOString() : null;
+};
+
+const eventTag = (messageId: unknown, id: unknown): string | null => {
+  const value = typeof messageId === 'string' && messageId !== '' ? messageId : id;
+  return typeof value === 'string' && value !== '' ? diagnosticTag(value) : null;
+};
+
+export function incomingDiagnostic(slot: DiagnosticSlot, scope: Set<string>): IncomingDiagnostic {
+  const events = bufferedSince(-1).filter(({ event }) => typeof event.line === 'string' && eventInScope(scope, event.line));
+  const accounts = knownAccounts().filter((account) => scope.has(account.agentId) && STATIONS.some((station) => station === account.station));
+  return {
+    version: 1,
+    observedAt: new Date().toISOString(),
+    ...slot.diagnostics(scope),
+    accounts: accounts.map((account) => {
+      const buffered = events.filter(({ event }) => {
+        const target = accountFromLine(event.line);
+        return target?.station === account.station && target.accountId === account.id;
+      });
+      const latest = buffered.at(-1)?.event;
+      return {
+        station: account.station,
+        tag: diagnosticTag(JSON.stringify([account.station, account.id])),
+        receiveEnabled: accountEnabled(account.station, account.id),
+        bufferedEvents: buffered.length,
+        latestEventAt: latest === undefined ? null : eventDate(latest.ts),
+        latestEventTag: latest === undefined ? null : eventTag(latest.messageId, latest.id),
+      };
+    }),
+  };
+}
+
+export function handleIncomingDiagnostic(req: IncomingMessage, res: ServerResponse, slot: DiagnosticSlot, scope: Set<string>): boolean {
+  if ((req.url ?? '').split('?')[0] !== MCP_STATUS_PATH) return false;
+  if (req.method !== 'GET') {
+    res.writeHead(405, { allow: 'GET' }).end();
+    return true;
+  }
+  const body = JSON.stringify(incomingDiagnostic(slot, scope));
+  res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' }).end(body);
+  return true;
+}

package/runtime/node_modules/@metro-labs/{mcp → daemon}/src/mcp/event-store.ts

@@ -4,31 +4,38 @@ import type {
   StreamId,
 } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
-import { frameInScope, frameLine } from './frame-scope.js';
+import { str } from '@metro-labs/core/str';
+import { eventInScope } from '../agents/scope.js';
+import { CALL_NOTICE, CALL_STATE } from '@metro-labs/core/call';
 
-export const EVENT_STORE_MAX = 500;
+const EVENT_STORE_MAX = 500;
 
 interface StoredEvent {
   eventId: EventId;
   streamId: StreamId;
   message: JSONRPCMessage;
   line: string | undefined;
-  owner: Set<string>;
-}
-
-export interface EventStoreDeps {
-  scopeOf: () => Set<string>;
-  max?: number;
+  replays: boolean;
 }
 
 export interface ScopedReplay {
   send: (eventId: EventId, message: JSONRPCMessage) => Promise<void>;
-  scope: Set<string> | undefined;
+  scope: Set<string>;
   onWithheld?: (eventId: EventId, line: string | undefined) => void;
 }
 
 const SEP = '_';
 
+function frameLine(message: JSONRPCMessage): string | undefined {
+  const params: unknown = (message as { params?: unknown }).params;
+  if (typeof params !== 'object' || params === null) return undefined;
+  const meta: unknown = (params as { meta?: unknown }).meta;
+  if (typeof meta !== 'object' || meta === null) return undefined;
+  return str((meta as { line?: unknown }).line) || undefined;
+}
+
+const isCallNotice = (message: JSONRPCMessage): boolean => 'method' in message && (message.method === CALL_NOTICE || message.method === CALL_STATE);
+
 const encodeEventId = (streamId: StreamId, seq: number): EventId =>
   `${streamId}${SEP}${seq}`;
 
@@ -40,23 +47,22 @@ const decodeStreamId = (eventId: EventId): StreamId | undefined => {
 
 export class BoundedEventStore implements EventStore {
   private readonly max: number;
-  private readonly scopeOf: () => Set<string>;
   private readonly events: StoredEvent[] = [];
   private seq = 0;
 
-  constructor(deps: EventStoreDeps) {
-    this.scopeOf = deps.scopeOf;
-    this.max = deps.max ?? EVENT_STORE_MAX;
+  constructor(max = EVENT_STORE_MAX) {
+    this.max = max;
   }
 
   storeEvent(streamId: StreamId, message: JSONRPCMessage): Promise<EventId> {
     const eventId = encodeEventId(streamId, ++this.seq);
+    const replays = !isCallNotice(message);
     this.events.push({
       eventId,
       streamId,
-      message,
-      line: frameLine(message),
-      owner: new Set(this.scopeOf()),
+      message: replays ? message : { jsonrpc: message.jsonrpc, method: CALL_NOTICE },
+      line: replays ? frameLine(message) : undefined,
+      replays,
     });
     if (this.events.length > this.max) this.events.shift();
     return Promise.resolve(eventId);
@@ -72,7 +78,6 @@ export class BoundedEventStore implements EventStore {
   ): Promise<StreamId> {
     const streamId = decodeStreamId(lastEventId);
     if (streamId === undefined) return '';
-    const allowed = scope ?? new Set<string>();
     let seen = false;
     for (const e of this.events) {
       if (e.streamId !== streamId) continue;
@@ -80,7 +85,8 @@ export class BoundedEventStore implements EventStore {
         if (e.eventId === lastEventId) seen = true;
         continue;
       }
-      if (!frameInScope(allowed, e)) {
+      if (!e.replays) continue;
+      if (e.line !== undefined && !eventInScope(scope, e.line)) {
         onWithheld?.(e.eventId, e.line);
         continue;
       }

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

@@ -0,0 +1,44 @@
+export const frameSchema = {
+  type: 'object',
+  description:
+    'Stage (XMTP) only: a frame, a small interactive view. Stage shows it in the chat at image size ' +
+    '(400 x 400 at most, its start screen, clipped with a fade) and opens it full screen on a tap; its ' +
+    'buttons work only there. `widget` is OpenAI ChatKit widget JSON (a Card, ListView ' +
+    'or Basic root, 64K characters at most); a missing `title` or `description` is taken from the ' +
+    'widget. Or give `screens` instead of `widget` for several screens in one frame. A tap there comes back ' +
+    'to you as a reply to the frame: "Frame action: <type> <payload ' +
+    "JSON>\". It is sent after the text, and the message_id returned is the frame's. The stage " +
+    'skill lists the widget nodes, with an example.',
+  properties: {
+    widget: {
+      type: 'object',
+      description:
+        'ChatKit widget JSON, e.g. {"type":"Card","children":[{"type":"Title","value":"Deploy?"},' +
+        '{"type":"Button","label":"Ship it","onClickAction":{"type":"deploy","payload":{"env":"prod"}}}]}.',
+      additionalProperties: true,
+    },
+    screens: {
+      type: 'object',
+      description:
+        'Instead of `widget`: up to 50 screens by id, each a widget or {"title", "widget"}, 64K ' +
+        'characters in all. An action {"type":"frame.open","payload":{"screen":"<id>"}} opens a ' +
+        'screen and {"type":"frame.back"} goes back, in Stage, with no message to you.',
+      additionalProperties: true,
+    },
+    start: { type: 'string', description: 'Required with `screens`: the id of the first screen.' },
+    title: { type: 'string', description: 'Card title in the chat (200 characters at most).' },
+    description: { type: 'string', description: 'Card description in the chat (1000 characters at most).' },
+    source: {
+      type: 'object',
+      description:
+        'Optional: {"url": "https://…"}, a node URL that serves this widget live (2048 characters at most). ' +
+        "Stage then sends the frame's actions to that node, not to you, and the node's reply replaces the " +
+        'frame on that device, with no message to you. Only an action with "handler": "client" (e.g. ' +
+        '{"type": "ask", "handler": "client"}) still comes back to you as a Frame action; without a source, ' +
+        "every action does. Refresh is in the frame's three-dot menu, so a node needs no Refresh button. " +
+        'Add to dashboard on the frame then adds a live widget loaded from that URL instead of a copy.',
+      properties: { url: { type: 'string' } },
+      required: ['url'],
+    },
+  },
+} as const;

package/runtime/node_modules/@metro-labs/{mcp → daemon}/src/mcp/group-tools.ts

@@ -5,9 +5,9 @@ import type {
   MemberOutcome,
   Station,
   ToolResult,
-} from '../stations/types.js';
+} from '@metro-labs/core/stations/types';
 import { makeCtx, okJson, toErr } from './ctx.js';
-import { str } from './str.js';
+import { str } from '@metro-labs/core/str';
 
 export interface GroupOpResult {
   op: GroupOp;