@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -1,7 +1,8 @@
-import { randomBytes } from 'node:crypto';
-import { Line } from '../stations/lines.js';
+import { Line } from './lines.js';
+import { errMsg, log } from './log.js';
 
-export { userSelf, daemonSelf, selfLine } from './identity.js';
+export const userSelf = (): Line =>
+  (process.env.METRO_FROM ?? 'metro://user') as Line;
 
 export type StructuredEvent =
   | { type: 'msg' }
@@ -24,6 +25,10 @@ export interface MetroEvent {
   text?: string;
   messageId?: string;
   replyTo?: string;
+  isPrivate?: boolean;
+  mentionsSelf?: boolean;
+  replyToSelf?: boolean;
+  senderVerified?: boolean;
   payload?: unknown;
   display?: string;
   event?: StructuredEvent;
@@ -71,8 +76,7 @@ export function formatDisplay(e: MetroEvent): string {
   return `${headerFor('📩', [e.station, e.fromName ?? e.from, e.lineName])}\n> ${body}`;
 }
 
-export const mintId = (): string =>
-  `msg_${randomBytes(6).toString('base64url')}`;
+export { mintId } from './ids.js';
 
 export type BusListener = (event: MetroEvent, busSeq: number) => void;
 
@@ -83,6 +87,50 @@ export interface BufferedEvent {
 
 export const BUS_BUFFER_MAX = 500;
 
+export interface RunEventMetadata {
+  isPrivate?: boolean;
+  senderVerified?: boolean;
+  mentionsSelf?: boolean;
+  replyToSelf?: boolean;
+  emoji?: string;
+  removed?: boolean;
+  targetId?: string;
+  attachmentCount?: number;
+  attachmentTypes?: ('image' | 'video' | 'audio' | 'file')[];
+  attachmentStatus?: 'saved' | 'failed';
+  attachmentFor?: string;
+}
+
+export interface RunEvent {
+  id: string;
+  seq: number;
+  ts: string;
+  kind: StructuredEvent['type'];
+  direction: 'inbound' | 'outbound' | 'system';
+  agentId: string;
+  station: string;
+  accountId: string | null;
+  line: string;
+  lineName?: string;
+  from?: string;
+  fromName?: string;
+  fromDisplayName?: string;
+  to?: string;
+  text?: string;
+  truncated: boolean;
+  messageId?: string;
+  replyTo?: string;
+  metadata: RunEventMetadata;
+}
+
+export interface RunEventsPage {
+  events: RunEvent[];
+  cursor: string;
+  hasMore: boolean;
+  reset: boolean;
+  retention: { capacity: number; oldestAt: string | null; oldestSeq: number | null };
+}
+
 const listeners = new Set<BusListener>();
 const buffer: BufferedEvent[] = [];
 let busSeq = 0;
@@ -96,7 +144,7 @@ export function publishEvent(event: MetroEvent): void {
     try {
       fn(event, seq);
     } catch (err) {
-      console.error('[metro-bus] listener threw for busSeq', seq, err);
+      log.error({ busSeq: seq, err: errMsg(err) }, 'bus: a listener threw');
     }
   }
 }

package/runtime/node_modules/@metro-labs/{mcp/src/db → core/src}/ids.ts

@@ -1,10 +1,17 @@
-import { randomBytes } from 'node:crypto';
+import { randomBytes, randomInt } from 'node:crypto';
 
 const ID_BYTES = 8;
 const REROLLS = 16;
+const APPROVAL_LETTERS = 'abcdefghijkmnopqrstuvwxyz';
+const APPROVAL_LENGTH = 5;
+
+export const approvalId = (): string => Array.from({ length: APPROVAL_LENGTH }, () => APPROVAL_LETTERS[randomInt(APPROVAL_LETTERS.length)]).join('');
 
 export const ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{10}$/;
 
+export const mintId = (): string =>
+  `msg_${randomBytes(6).toString('base64url')}`;
+
 export function newId(): string {
   for (let attempt = 0; attempt < REROLLS; attempt += 1) {
     const id = randomBytes(ID_BYTES).toString('base64url');
@@ -17,3 +24,5 @@ export function parseId(raw: unknown): string | null {
   if (typeof raw !== 'string') return null;
   return ID_RE.test(raw) ? raw : null;
 }
+
+export const AGENT_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{1,31}$/;

package/runtime/node_modules/@metro-labs/core/src/is-record.ts

@@ -0,0 +1,2 @@
+export const isRecord = (v: unknown): v is Record<string, unknown> =>
+  typeof v === 'object' && v !== null && !Array.isArray(v);

package/runtime/node_modules/@metro-labs/{mcp/src/stations → core/src}/lines.ts

@@ -5,50 +5,40 @@ const PREFIX = 'metro://';
 const build = (station: string, ...seg: (string | number)[]): Line =>
   asLine(`${PREFIX}${station}/${seg.map(String).join('/')}`);
 
-export function parseAccountScoped(
+function parseAccountScoped(
   line: Line | string,
   station: string,
   validate?: (resource: string) => boolean,
 ): { accountId: string; resource: string } | null {
   const p = Line.parse(line);
-  if (p?.station !== station) return null;
-  let accountId: string, resource: string;
-  if (p.path.length === 2 && p.path[0] !== undefined && p.path[1] !== undefined) {
-    accountId = p.path[0];
-    resource = p.path[1];
-  } else if (p.path.length === 1 && p.path[0] !== undefined) {
-    accountId = 'default';
-    resource = p.path[0];
-  } else return null;
+  if (p?.station !== station || p.path.length !== 2) return null;
+  const [accountId, resource] = p.path;
+  if (accountId === undefined || resource === undefined) return null;
   if (validate && !validate(resource)) return null;
   return { accountId, resource };
 }
 
 const isSnowflake = (s: string): boolean => /^\d+$/.test(s);
+const isThreemaResource = (s: string): boolean =>
+  /^(?:[A-Z0-9]{8}|\*[A-Z0-9]{7})(?:-[0-9a-f]{16})?$/i.test(s);
+const isMailResource = (s: string): boolean => /^[A-Za-z0-9=_%.@+-]+$/.test(s);
 const isSignedInt = (s: string): boolean => /^-?\d+$/.test(s);
 
-function splitTelegramAccount(path: string[]): { accountId: string; rest: string[] } {
-  const first = path[0];
-  if (path.length >= 2 && first !== undefined && !isSignedInt(first))
-    return { accountId: first, rest: path.slice(1) };
-  return { accountId: 'default', rest: path };
-}
+const topicPart = (topicId: string | undefined): { topicId?: number } | null => {
+  if (topicId === undefined) return {};
+  return isSnowflake(topicId) ? { topicId: Number(topicId) } : null;
+};
 
 function parseTelegramLine(
   line: Line | string,
 ): { accountId: string; chatId: number; topicId?: number } | null {
   const p = Line.parse(line);
   if (p?.station !== 'telegram-bot') return null;
-  const { accountId, rest } = splitTelegramAccount(p.path);
-  const [chatId, topicId] = rest;
-  if (rest.length < 1 || rest.length > 2 || chatId === undefined || !isSignedInt(chatId))
-    return null;
-  if (topicId !== undefined && !isSnowflake(topicId)) return null;
-  return {
-    accountId,
-    chatId: Number(chatId),
-    ...(topicId !== undefined ? { topicId: Number(topicId) } : {}),
-  };
+  const [accountId, chatId, topicId, ...extra] = p.path;
+  if (accountId === undefined || chatId === undefined || extra.length > 0) return null;
+  if (!isSignedInt(chatId)) return null;
+  const topic = topicPart(topicId);
+  return topic === null ? null : { accountId, chatId: Number(chatId), ...topic };
 }
 
 export const Line = {
@@ -79,4 +69,10 @@ export const Line = {
     parseAccountScoped(line, 'discord-bot', isSnowflake),
 
   parseTelegram: (line: Line | string) => parseTelegramLine(line),
+
+  parseThreema: (line: Line | string) =>
+    parseAccountScoped(line, 'threema', isThreemaResource),
+
+  parseMail: (line: Line | string, station: 'outlook' | 'gmail') =>
+    parseAccountScoped(line, station, isMailResource),
 };

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

@@ -3,7 +3,7 @@ import { join, parse as parsePath } from 'node:path';
 import { errMsg, log } from './log.js';
 import { coerceErrorInfo, type TrainErrorInfo } from './train-error.js';
 import type { StructuredEvent } from './events.js';
-import type { CallMsg } from '../stations/station-runtime.js';
+import type { CallMsg } from './stations/station-runtime.js';
 
 export {
   TrainError,
@@ -11,7 +11,7 @@ export {
   type TrainErrorInfo,
 } from './train-error.js';
 
-export const CALL_TIMEOUT_MS = 60_000;
+const CALL_TIMEOUT_MS = 60_000;
 
 export interface Pending {
   resolve: (r: TrainCallResponse) => void;
@@ -24,7 +24,7 @@ export interface CallTarget {
   proc: ({ stdin?: unknown } & Record<string, unknown>) | null;
 }
 
-export const STDOUT_LINE_MAX = 4 * 1024 * 1024;
+const STDOUT_LINE_MAX = 4 * 1024 * 1024;
 
 export type TrainEvent = {
   station?: string;
@@ -37,6 +37,9 @@ export type TrainEvent = {
   message_id?: string;
   reply_to?: string;
   is_private?: boolean;
+  mentions_self?: boolean;
+  reply_to_self?: boolean;
+  sender_verified?: boolean;
   text?: string;
   emoji?: string;
   payload?: unknown;
@@ -149,7 +152,7 @@ export function readCalls(
   });
 }
 
-export function encodeCall(id: string, action: string, args: unknown): string {
+function encodeCall(id: string, action: string, args: unknown): string {
   return JSON.stringify({ op: 'call', id, action, args }) + '\n';
 }
 

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

@@ -0,0 +1,270 @@
+import { isRecord } from './is-record.js';
+
+const PHASES = ['starting', 'idle', 'working', 'approval', 'compacting', 'stopped', 'error'] as const;
+const TASK_STATES = ['pending', 'running', 'completed', 'failed', 'stopped', 'paused', 'unknown'] as const;
+const EVENTS = ['turn_started', 'turn_finished', 'turn_failed', 'tool_started', 'tool_finished', 'tool_failed', 'task_started', 'task_completed', 'task_failed', 'task_stopped', 'task_updated', 'compacting', 'compacted', 'compact_failed', 'api_retry', 'approval_waiting', 'approval_ended', 'permission_denied', 'session_failed'] as const;
+export type RunnerPhase = (typeof PHASES)[number];
+export type RunnerTaskState = (typeof TASK_STATES)[number];
+export type RunnerEventKind = (typeof EVENTS)[number];
+
+const FAILURE = {
+  authentication: 'The provider refused authentication. Check the Model page.',
+  billing: 'The provider refused billing. Check the Model page.',
+  rate_limit: 'The provider rate limit was reached. Retry later or check the Model page.',
+  provider_unavailable: 'The provider is unavailable. Retry later or check the Model page.',
+  invalid_request: 'The provider rejected the request. Check Conversations and the Model page.',
+  output_limit: 'The model reached its output token limit. Check Conversations.',
+  provider_error: 'SDK turn failed (provider_error). Check Conversations and the Model page.',
+  error_during_execution: 'SDK turn failed (error_during_execution). Check Conversations and the Model page.',
+  error_max_turns: 'SDK turn failed (error_max_turns). Check Conversations and the Model page.',
+  error_max_budget_usd: 'SDK turn failed (error_max_budget_usd). Check Conversations and the Model page.',
+  error_max_structured_output_retries: 'SDK turn failed (error_max_structured_output_retries). Check Conversations and the Model page.',
+  read_token_limit: 'Read exceeded its token limit. Read a smaller range with offset and limit, or search the file.',
+  tool_error: 'A tool failed. See its result in Conversations.',
+  task_error: 'A background task failed. See Conversations and Terminal.',
+  compact_error: 'Conversation compaction failed.',
+  status_unavailable: 'The SDK status file cannot be written. Check its path and permissions before starting.',
+  saved_state: 'The saved Agent SDK state cannot be read. Restore it before starting.',
+  executable: 'The SDK executable could not start. Prepare the SDK runtime again.',
+  module: 'The SDK runtime could not load a required module. Prepare the SDK runtime again.',
+  configuration: 'The SDK launch configuration is missing or invalid. Check Harness and the Model page before starting.',
+  process_exit: 'The SDK process exited unexpectedly. Check its reported exit code or signal before retrying.',
+  connection: 'The SDK connection failed. Check the server and provider connection.',
+  session_ended: 'The Agent SDK session ended unexpectedly.',
+  interrupted: 'The SDK stopped before finishing a chat request. Check Conversations before retrying; actions may already have run.',
+  session_error: 'The Agent SDK session failed. Check Terminal and the Model page.',
+} as const;
+export type RunnerFailureCode = keyof typeof FAILURE;
+
+const ERROR_CODES = ['ENOENT', 'EACCES', 'EPERM', 'ENOEXEC', 'ENOMEM', 'ERR_MODULE_NOT_FOUND', 'MODULE_NOT_FOUND', 'ERR_DLOPEN_FAILED', 'ECONNREFUSED', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN', 'ETIMEDOUT', 'CERT_HAS_EXPIRED', 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'] as const;
+const SIGNALS = ['SIGTERM', 'SIGKILL', 'SIGSEGV', 'SIGABRT', 'SIGBUS', 'SIGILL', 'SIGINT', 'SIGHUP', 'SIGPIPE'] as const;
+
+const ERROR_NAME_RE = /^[A-Z][A-Za-z0-9]{0,39}Error$/;
+
+export interface RunnerDiagnostic {
+  source: 'exception' | 'stderr';
+  errorName?: string;
+  errorCode?: (typeof ERROR_CODES)[number];
+  httpStatus?: number;
+  exitCode?: number;
+  signal?: (typeof SIGNALS)[number];
+}
+
+const boundedNumber = (value: unknown, min: number, max: number): number | undefined => typeof value === 'number' && Number.isInteger(value) && value >= min && value <= max ? value : undefined;
+
+const errorNameOf = (value: unknown): string | undefined => typeof value === 'string' && value !== 'Error' && ERROR_NAME_RE.test(value) ? value : undefined;
+
+export function runnerDiagnostic(raw: unknown): RunnerDiagnostic | undefined {
+  if (!isRecord(raw) || (raw.source !== 'exception' && raw.source !== 'stderr')) return undefined;
+  const errorCode = ERROR_CODES.find((code) => code === raw.errorCode);
+  const signal = SIGNALS.find((value) => value === raw.signal);
+  const httpStatus = boundedNumber(raw.httpStatus, 400, 599);
+  const exitCode = boundedNumber(raw.exitCode, 0, 255);
+  const errorName = errorNameOf(raw.errorName);
+  return {
+    source: raw.source,
+    ...(errorName === undefined ? {} : { errorName }),
+    ...(errorCode === undefined ? {} : { errorCode }),
+    ...(httpStatus === undefined ? {} : { httpStatus }),
+    ...(exitCode === undefined ? {} : { exitCode }),
+    ...(signal === undefined ? {} : { signal }),
+  };
+}
+
+export function runnerFailureSummary(code: RunnerFailureCode, tool: string | null = null, diagnostic?: RunnerDiagnostic): string {
+  const summary = code === 'tool_error' && name(tool) !== null ? `${tool} failed. See its result in Conversations.` : FAILURE[code];
+  const safe = runnerDiagnostic(diagnostic);
+  if (safe === undefined) return summary;
+  const details = [safe.errorName, safe.errorCode, safe.httpStatus === undefined ? null : `HTTP ${safe.httpStatus}`, safe.exitCode === undefined ? null : `exit ${safe.exitCode}`, safe.signal].filter((value) => value !== undefined && value !== null);
+  return details.length === 0 ? summary : `${summary} Observed: ${details.join(', ')} (${safe.source === 'stderr' ? 'startup stderr' : 'exception'}).`;
+}
+
+export interface RunnerTask {
+  id: string;
+  kind: string | null;
+  agent: string | null;
+  description?: string | null;
+  lastObservedModel?: string | null;
+  status: RunnerTaskState;
+  background: boolean;
+  startedAt: number;
+  firstStartedAt?: number;
+  updatedAt: number;
+  endedAt: number | null;
+  lastTool: string | null;
+  toolUses: number;
+  durationMs: number;
+}
+
+export interface RunnerTool {
+  id: string;
+  name: string;
+  taskId: string | null;
+  worker?: boolean;
+  startedAt: number;
+}
+
+export interface RunnerEvent {
+  id?: string;
+  at: number;
+  kind: RunnerEventKind;
+  tool: string | null;
+  toolUseId?: string;
+  taskId: string | null;
+  code?: RunnerFailureCode;
+  diagnostic?: RunnerDiagnostic;
+}
+
+export interface RunnerFailure extends RunnerEvent {
+  id: string;
+  code: RunnerFailureCode;
+}
+
+export interface RunnerInput {
+  id: string;
+  kind: 'chat' | 'call' | 'note';
+  state: 'accepted' | 'consumed' | 'output' | 'completed' | 'cancelled';
+  acceptedAt: number;
+  dispatchedAt: number | null;
+  consumedAt: number | null;
+  firstOutputAt: number | null;
+  completedAt: number | null;
+}
+
+export interface RunnerActivity {
+  pid: number;
+  procStart?: string;
+  cancelSignal?: 'SIGUSR2';
+  runner: 'sdk';
+  phase: RunnerPhase;
+  mainPhase: RunnerPhase;
+  mainStartedAt: number | null;
+  sessionId: string | null;
+  updatedAt: number;
+  pending: number;
+  queueOldestAt?: number | null;
+  inputs?: RunnerInput[];
+  callState?: 'started' | 'ended' | 'accepted' | 'queued' | 'speaking' | 'completed' | 'interrupted' | 'failed';
+  workers: number;
+  approvals: number;
+  tools: string[];
+  activeTools: RunnerTool[];
+  tasks: RunnerTask[];
+  events: RunnerEvent[];
+  lastError: string | null;
+  activeFailure?: RunnerFailure | null;
+  lastFailure?: RunnerFailure | null;
+}
+
+const count = (value: unknown): number => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : 0;
+const phase = (value: unknown): value is RunnerPhase => PHASES.some((p) => p === value);
+const taskState = (value: unknown): value is RunnerTaskState => TASK_STATES.some((s) => s === value);
+const eventKind = (value: unknown): value is RunnerEventKind => EVENTS.some((e) => e === value);
+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),
+    ...(count(raw.firstStartedAt) > 0 ? { firstStartedAt: count(raw.firstStartedAt) } : {}),
+    ...(raw.description === undefined ? {} : { description: runnerTaskDescription(raw.description) }),
+    ...(raw.lastObservedModel === undefined ? {} : { lastObservedModel: runnerTaskModel(raw.lastObservedModel) }),
+  };
+}
+
+function tool(raw: unknown): RunnerTool | null {
+  if (!isRecord(raw) || !name(raw.id) || !name(raw.name)) return null;
+  return { id: String(raw.id), name: String(raw.name), taskId: name(raw.taskId), startedAt: count(raw.startedAt), ...(typeof raw.worker === 'boolean' ? { worker: raw.worker } : {}) };
+}
+
+export const runnerFailureCode = (value: unknown): value is RunnerFailureCode => typeof value === 'string' && Object.hasOwn(FAILURE, value);
+const failureKind = (value: RunnerEventKind): boolean => ['turn_failed', 'tool_failed', 'task_failed', 'compact_failed', 'session_failed'].includes(value);
+
+function event(raw: unknown): RunnerEvent | null {
+  if (!isRecord(raw) || !eventKind(raw.kind) || count(raw.at) === 0) return null;
+  const diagnostic = runnerDiagnostic(raw.diagnostic);
+  return {
+    at: count(raw.at), kind: raw.kind, tool: name(raw.tool), taskId: name(raw.taskId),
+    ...(name(raw.id) === null ? {} : { id: String(raw.id) }),
+    ...(name(raw.toolUseId) === null ? {} : { toolUseId: String(raw.toolUseId) }),
+    ...(failureKind(raw.kind) && runnerFailureCode(raw.code) ? { code: raw.code, ...(diagnostic === undefined ? {} : { diagnostic }) } : {}),
+  };
+}
+
+function failure(raw: unknown): RunnerFailure | null {
+  const parsed = event(raw);
+  return parsed?.id !== undefined && parsed.code !== undefined ? { ...parsed, id: parsed.id, code: parsed.code } : null;
+}
+
+function safeError(raw: unknown): string | null {
+  if (typeof raw !== 'string' || raw.length === 0) return null;
+  const known = Object.values(FAILURE).find((text) => text === raw);
+  if (known !== undefined) return known;
+  const tool = /^([A-Za-z0-9_.:-]{1,128}) failed\. See its result in Conversations\.$/.exec(raw)?.[1];
+  return tool === undefined ? FAILURE.session_error : runnerFailureSummary('tool_error', tool);
+}
+
+function list<T>(raw: unknown, parse: (item: unknown) => T | null, max: number): T[] {
+  if (!Array.isArray(raw)) return [];
+  return raw.map(parse).filter((item): item is T => item !== null).slice(0, max);
+}
+
+function processIdentity(value: unknown): Pick<RunnerActivity, 'procStart'> {
+  return typeof value === 'string' && /^\d{1,32}$/.test(value) ? { procStart: value } : {};
+}
+
+function failureFields(raw: Record<string, unknown>): Pick<RunnerActivity, 'lastError' | 'activeFailure' | 'lastFailure'> {
+  const activeFailure = failure(raw.activeFailure);
+  return {
+    lastError: Object.hasOwn(raw, 'activeFailure') ? activeFailure === null ? null : runnerFailureSummary(activeFailure.code, activeFailure.tool, activeFailure.diagnostic) : safeError(raw.lastError),
+    ...(Object.hasOwn(raw, 'activeFailure') ? { activeFailure } : {}),
+    ...(Object.hasOwn(raw, 'lastFailure') ? { lastFailure: failure(raw.lastFailure) } : {}),
+  };
+}
+
+function input(raw: unknown): RunnerInput | null {
+  if (!isRecord(raw) || sessionId(raw.id) === null) return null;
+  const kind = (['chat', 'call', 'note'] as const).find((value) => value === raw.kind);
+  const state = (['accepted', 'consumed', 'output', 'completed', 'cancelled'] as const).find((value) => value === raw.state);
+  if (kind === undefined || state === undefined) return null;
+  return {
+    id: String(raw.id), kind, state, acceptedAt: count(raw.acceptedAt),
+    dispatchedAt: count(raw.dispatchedAt) || null, consumedAt: count(raw.consumedAt) || null,
+    firstOutputAt: count(raw.firstOutputAt) || null, completedAt: count(raw.completedAt) || null,
+  };
+}
+
+function inputFields(raw: Record<string, unknown>): Pick<RunnerActivity, 'inputs' | 'queueOldestAt' | 'callState'> {
+  const states = ['started', 'ended', 'accepted', 'queued', 'speaking', 'completed', 'interrupted', 'failed'] as const;
+  const callState = states.find((state) => state === raw.callState);
+  return {
+    ...(raw.inputs === undefined ? {} : { inputs: list(raw.inputs, input, 40) }),
+    ...(raw.queueOldestAt === undefined ? {} : { queueOldestAt: count(raw.queueOldestAt) || null }),
+    ...(callState === undefined ? {} : { callState }),
+  };
+}
+
+export function parseRunnerActivity(raw: unknown): RunnerActivity | null {
+  if (!isRecord(raw) || raw.runner !== 'sdk' || !phase(raw.phase) || count(raw.pid) === 0 || count(raw.updatedAt) === 0) return null;
+  return {
+    runner: 'sdk', pid: count(raw.pid), ...processIdentity(raw.procStart), phase: raw.phase, mainPhase: phase(raw.mainPhase) ? raw.mainPhase : raw.phase,
+    ...(raw.cancelSignal === 'SIGUSR2' ? { cancelSignal: raw.cancelSignal } : {}),
+    mainStartedAt: count(raw.mainStartedAt) || null, sessionId: sessionId(raw.sessionId), updatedAt: count(raw.updatedAt),
+    pending: count(raw.pending), workers: count(raw.workers), approvals: count(raw.approvals),
+    tools: list(raw.tools, name, 20), activeTools: list(raw.activeTools, tool, 20),
+    tasks: list(raw.tasks, task, 30), events: list(raw.events, event, 40),
+    ...failureFields(raw), ...inputFields(raw),
+  };
+}

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

@@ -38,6 +38,23 @@ export function writeSecure(path: string, data: string): void {
   chmodIfExists(path, 0o600);
 }
 
+function modeOf(path: string): number | null {
+  try {
+    return statSync(path).mode & 0o777;
+  } catch {
+    return null;
+  }
+}
+
+export function writeAtomic(path: string, data: string, mode?: number): void {
+  const chosen = mode ?? modeOf(path) ?? 0o644;
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.metro-${String(process.pid)}.tmp`;
+  writeFileSync(tmp, data, { mode: chosen });
+  chmodSync(tmp, chosen);
+  renameSync(tmp, path);
+}
+
 export function readJson<T>(
   path: string,
   fallback: T,

package/runtime/node_modules/@metro-labs/core/src/skill-source.ts

@@ -0,0 +1,96 @@
+import { join } from 'node:path';
+import { isRecord } from './is-record.js';
+
+export const SKILL_NAME = /^[a-z0-9][a-z0-9-]{0,63}$/;
+export const SKILL_HASH = /^[a-f0-9]{64}$/;
+export const SKILL_COMMIT = /^[a-f0-9]{40}$/;
+export const SKILL_FILE_MAX = 256 * 1024;
+export const SKILL_TOTAL_MAX = 8 * 1024 * 1024;
+export const SKILL_FILES_MAX = 256;
+export const SKILL_MANIFEST_MAX = 128 * 1024;
+
+export interface SkillSource {
+  repository: string;
+  ref: string;
+  folder: string;
+}
+
+export interface SkillFile {
+  path: string;
+  size: number;
+  sha256: string;
+  executable?: boolean;
+}
+
+export interface SkillGeneration {
+  id: string;
+  source: (SkillSource & { repositoryId: number; commit: string }) | null;
+  createdAt: string;
+  skills: { name: string; description: string }[];
+  files: SkillFile[];
+}
+
+export interface SkillActivation {
+  generation: string | null;
+  loading: string | null;
+  rollback?: string | null;
+  appliedAt: string | null;
+  problem: string | null;
+  shadowed: string[];
+}
+
+export const skillSourceRoot = (claudeDir: string): string => join(claudeDir, 'metro-github');
+export const skillRelease = (root: string, id: string): string => {
+  if (!SKILL_HASH.test(id)) throw new Error('Invalid skills generation.');
+  return join(root, 'releases', id);
+};
+
+export function skillPath(path: string): boolean {
+  const parts = path.split('/');
+  return path.length <= 240 && parts.length >= 2 && parts.length <= 8 && SKILL_NAME.test(parts[0] ?? '') &&
+    parts.every((part) => /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(part)) &&
+    !parts.slice(1, -1).includes('SKILL.md') && !(parts.length > 2 && parts.at(-1) === 'SKILL.md');
+}
+
+function manifestSkill(value: unknown): SkillGeneration['skills'][number] {
+  if (!isRecord(value) || typeof value.name !== 'string' || !SKILL_NAME.test(value.name) || typeof value.description !== 'string' || value.description.length > 1024) throw new Error('Invalid skill name or description.');
+  return { name: value.name, description: value.description };
+}
+
+function fileSize(value: unknown): number {
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > SKILL_FILE_MAX) throw new Error('Invalid skills file size.');
+  return value;
+}
+
+function manifestFile(value: unknown): SkillFile {
+  if (!isRecord(value)) throw new Error('Invalid skills file.');
+  if (typeof value.path !== 'string' || !skillPath(value.path) || typeof value.sha256 !== 'string' || !SKILL_HASH.test(value.sha256)) throw new Error('Invalid skills file path or hash.');
+  return { path: value.path, size: fileSize(value.size), sha256: value.sha256, ...(value.executable === true ? { executable: true } : {}) };
+}
+
+function manifestSource(s: unknown): SkillGeneration['source'] {
+  if (s === null) return null;
+  if (!isRecord(s) || typeof s.repository !== 'string' || typeof s.ref !== 'string' || typeof s.folder !== 'string' || typeof s.repositoryId !== 'number' || typeof s.commit !== 'string' || !SKILL_COMMIT.test(s.commit)) throw new Error('Invalid skills provenance.');
+  return { repository: s.repository, ref: s.ref, folder: s.folder, repositoryId: s.repositoryId, commit: s.commit };
+}
+
+function checkFiles(skills: SkillGeneration['skills'], files: SkillFile[]): void {
+  if (files.reduce((sum, file) => sum + file.size, 0) > SKILL_TOTAL_MAX || new Set(files.map((f) => f.path.toLowerCase())).size !== files.length || new Set(skills.map((s) => s.name)).size !== skills.length) throw new Error('Duplicate or oversized skills files.');
+  if (files.some((f) => !skills.some((s) => f.path.startsWith(`${s.name}/`))) || skills.some((s) => !files.some((f) => f.path === `${s.name}/SKILL.md`))) throw new Error('Every skill needs its own SKILL.md.');
+}
+
+function boundedGeneration(generation: SkillGeneration): SkillGeneration {
+  if (Buffer.byteLength(JSON.stringify(generation)) > SKILL_MANIFEST_MAX) throw new Error('Skills manifest is too large.');
+  return generation;
+}
+
+export function skillGeneration(raw: unknown): SkillGeneration {
+  if (!isRecord(raw) || typeof raw.id !== 'string' || !SKILL_HASH.test(raw.id) || typeof raw.createdAt !== 'string' || !Array.isArray(raw.skills) || !Array.isArray(raw.files)) throw new Error('Invalid skills manifest.');
+  if (raw.skills.length > 64 || raw.files.length > SKILL_FILES_MAX) throw new Error('Skills manifest is too large.');
+  const skills = raw.skills.map(manifestSkill);
+  const files = raw.files.map(manifestFile);
+  const source = manifestSource(raw.source);
+  checkFiles(skills, files);
+  if (source === null) checkFiles([], files);
+  return boundedGeneration({ id: raw.id, source, createdAt: raw.createdAt, skills, files });
+}

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

@@ -0,0 +1,14 @@
+export const STATIONS = [
+  'xmtp',
+  'telegram-bot',
+  'telegram',
+  'discord-bot',
+  'whatsapp',
+  'threema',
+  'outlook',
+  'gmail',
+  'webhook',
+] as const;
+
+export type StationName = (typeof STATIONS)[number];
+