@stage-labs/metro 0.1.0-beta.295 → 0.1.0-beta.297

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.295",
+  "version": "0.1.0-beta.297",
   "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.295",
+  "version": "0.1.0-beta.297",
   "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/daemon/src/agent-user/provision.ts

@@ -10,9 +10,11 @@ import { watchAgentView } from './view.js';
 import { closeMetroHome } from './metro-home.js';
 import { mustHelper } from '../metro-user/privilege.js';
 import { stagedPluginVersion } from '../claude/plugin-install.js';
+import { CLAUDE_CODE_VERSION } from '../claude/pinned.js';
+import { pinClaudeCode } from '../claude/version.js';
 
 const INSTALL_MS = 10 * 60_000;
-const INSTALLER = 'curl -fsSL https://claude.ai/install.sh | bash';
+const INSTALLER = `curl -fsSL https://claude.ai/install.sh | bash -s ${CLAUDE_CODE_VERSION}`;
 
 export type Provisioned = 'off' | 'failed' | 'ready';
 
@@ -55,6 +57,14 @@ function installClaude(user: AgentUser): Promise<void> {
   });
 }
 
+function pinCheckedClaude(): void {
+  try {
+    pinClaudeCode();
+  } catch (err) {
+    log.warn({ want: CLAUDE_CODE_VERSION, err: errMsg(err) }, 'agent-user: could not install the Claude Code version metro was checked with; keeping the installed one');
+  }
+}
+
 function copyMarketplace(user: AgentUser, env: NodeJS.ProcessEnv): void {
   const store = env.METRO_RUNTIME_STORE?.trim() ?? '';
   const from = join(store, 'marketplace');
@@ -71,6 +81,7 @@ export async function provisionAgentUser(env: NodeJS.ProcessEnv = process.env):
     const user = ensureUser();
     if (user === null) throw new Error(`the user ${AGENT_NAME} could not be found after creating it`);
     await installClaude(user);
+    pinCheckedClaude();
     copyMarketplace(user, env);
     watchAgentView();
     return 'ready';

package/runtime/node_modules/@metro-labs/daemon/src/claude/api.ts

@@ -212,9 +212,9 @@ function answer(method: string, path: string, query: URLSearchParams, dir: strin
 function versionAnswer(req: IncomingMessage, deps: ClaudeApiDeps): Promise<unknown> {
   const version: VersionDeps = { ...deps.version, session: deps.version?.session ?? deps.session };
   const method = req.method ?? 'GET';
-  if (method === 'GET') return claudeVersion(version);
+  if (method === 'GET') return Promise.resolve(claudeVersion(version));
   if (method !== 'POST') throw new ApiError('method not allowed', 405);
-  return updateClaude(version);
+  return Promise.resolve(updateClaude(version));
 }
 
 const SINGLETONS: Record<string, (req: IncomingMessage, deps: ClaudeApiDeps, session: ApiSession) => Promise<unknown>> = {

package/runtime/node_modules/@metro-labs/daemon/src/claude/channel-check.ts

@@ -0,0 +1,56 @@
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { existsSync, readdirNames, readRange } from '../agent-user/agent-fs.js';
+
+const HEAD_BYTES = 64 * 1024;
+const SKIPPED_RE = /Channel notifications skipped: ([^"\\]+)/;
+const REGISTERED = 'Channel notifications registered';
+const NAME_RE = /^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z\.jsonl$/;
+const SLACK_MS = 5_000;
+
+export interface ChannelState {
+  registered: boolean;
+  reason: string | null;
+}
+
+let state: ChannelState | null = null;
+
+export const channelState = (): ChannelState | null => state;
+
+export function forgetChannelState(): void {
+  state = null;
+}
+
+export const mcpLogDir = (home: string): string =>
+  join(home, '.cache', 'claude-cli-nodejs', home.replace(/[^a-zA-Z0-9]/g, '-'), 'mcp-logs-metro');
+
+const openedAt = (name: string): number => {
+  const m = NAME_RE.exec(name);
+  return m === null ? Number.NaN : Date.parse(`${m[1] ?? ''}T${m[2] ?? ''}:${m[3] ?? ''}:${m[4] ?? ''}.${m[5] ?? ''}Z`);
+};
+
+export function readChannelState(home: string, since: number): ChannelState | null {
+  const dir = mcpLogDir(home);
+  if (!existsSync(dir)) return null;
+  const newest = readdirNames(dir).filter((name) => openedAt(name) >= since - SLACK_MS).sort().at(-1);
+  if (newest === undefined) return null;
+  const head = readRange(join(dir, newest), 0, HEAD_BYTES).toString('utf8');
+  const skipped = SKIPPED_RE.exec(head);
+  if (skipped !== null) return { registered: false, reason: skipped[1]?.trim() ?? null };
+  return head.includes(REGISTERED) ? { registered: true, reason: null } : null;
+}
+
+export function noteChannelState(home: string, since: number): boolean {
+  let found: ChannelState | null;
+  try {
+    found = readChannelState(home, since);
+  } catch (err) {
+    log.debug({ err: errMsg(err) }, 'claude-session: could not read the metro MCP log of Claude Code');
+    return false;
+  }
+  if (found === null) return false;
+  state = found;
+  if (found.registered) log.info('claude-session: Claude Code registered the metro channel');
+  else log.error({ reason: found.reason }, 'claude-session: Claude Code skipped the metro channel, so chat messages do not reach the session');
+  return true;
+}

package/runtime/node_modules/@metro-labs/daemon/src/claude/pinned.ts

@@ -0,0 +1,16 @@
+import { spawnSync } from 'node:child_process';
+import { errMsg } from '@metro-labs/core/log';
+import { asAgent } from '../agent-user/user.js';
+
+export const CLAUDE_CODE_VERSION = '2.1.289';
+
+const INSTALL_TIMEOUT_MS = 5 * 60_000;
+const TAIL = 400;
+
+export function installClaudeCode(bin: string): void {
+  const run = spawnSync(...asAgent(bin, ['install', CLAUDE_CODE_VERSION]), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: INSTALL_TIMEOUT_MS });
+  const failed = `claude install ${CLAUDE_CODE_VERSION} failed`;
+  if (run.error !== undefined) throw new Error(`${failed}: ${errMsg(run.error)}`);
+  if (run.status === 0) return;
+  throw new Error(`${failed}: ${`${run.stderr}${run.stdout}`.trim().slice(-TAIL)}`);
+}

package/runtime/node_modules/@metro-labs/daemon/src/claude/session.ts

@@ -18,6 +18,7 @@ import { harnessRunner, isHarnessRunner, sdkAllowed, SDK_NEEDS_KEY, type Harness
 import { claudeAccount, claudeInstalled } from './login.js';
 import { trustFolder } from './onboarding.js';
 import { inSessionScope } from './memory.js';
+import { channelState, forgetChannelState, noteChannelState, type ChannelState } from './channel-check.js';
 import { runningAsRoot } from '../metro-user/privilege.js';
 import { agentExtraEnv, agentUser, agentUserExpected, agentViewDir, asAgent, claudeHome } from '../agent-user/user.js';
 
@@ -59,6 +60,7 @@ export interface SessionStatus {
   blocked: string | null;
   lastStartedAt: string | null;
   lastError: string | null;
+  channels?: ChannelState | null;
 }
 
 export interface SessionSnapshot {
@@ -212,12 +214,15 @@ function noteLaunchLines(pane: string, seen: Set<string>): void {
     }
 }
 
-function confirmChannels(tmux: string, until: number): void {
+function confirmChannels(tmux: string, home: string, startedAt: number): void {
+  const until = startedAt + CONFIRM_WAIT_MS;
   const seen = new Set<string>();
   let confirmed = false;
+  let checked = false;
   const tick = (): void => {
     const pane = capturePane(tmux);
     noteLaunchLines(pane, seen);
+    checked ||= noteChannelState(home, startedAt);
     if (!confirmed && pane.includes(WARNING) && pane.includes('server:metro')) {
       spawnSync(...asAgent(tmux, ['send-keys', '-t', SESSION_NAME, 'Enter']), { stdio: 'ignore' });
       log.info('claude-session: confirmed the development channels dialog for server:metro');
@@ -230,6 +235,7 @@ function confirmChannels(tmux: string, until: number): void {
 
 function recordStart(deps: SessionDeps, tmux: string, now: number, run: { error?: Error; status: number | null; stderr: string }): void {
   memory.lastStartedAt = now;
+  forgetChannelState();
   if (run.error !== undefined || run.status !== 0) {
     memory.lastError = run.error === undefined ? `tmux new-session exited ${String(run.status)}: ${run.stderr.trim()}` : errMsg(run.error);
     log.warn({ err: memory.lastError }, 'claude-session: tmux could not start');
@@ -238,7 +244,7 @@ function recordStart(deps: SessionDeps, tmux: string, now: number, run: { error?
   memory.lastError = null;
   const agents = deps.agents ?? agentsDir();
   writeState(agents, { version: deps.version ?? METRO_VERSION, runner: harnessRunner(agents) });
-  confirmChannels(tmux, now + CONFIRM_WAIT_MS);
+  confirmChannels(tmux, sessionHome(deps), now);
 }
 
 function tmuxLaunch(deps: SessionDeps, tmux: string, args: string[]): [string, string[]] {
@@ -296,6 +302,7 @@ export function sessionStatus(deps: SessionDeps = {}): SessionStatus {
     autostart: autostartEnabled(deps.agents ?? agentsDir()),
     blocked: sessionBlocked(deps),
     lastError: memory.lastError,
+    channels: channelState(),
   };
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/claude/version.ts

@@ -3,31 +3,23 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { ApiError } from '@metro-labs/http/api-error';
 import { errMsg, log } from '@metro-labs/core/log';
-import { isRecord } from '@metro-labs/core/is-record';
 import { sessionRunning, stopSession, type SessionDeps } from './session.js';
 import { agentUser, asAgent, claudeBin } from '../agent-user/user.js';
+import { CLAUDE_CODE_VERSION, installClaudeCode } from './pinned.js';
 
-const LATEST_URL = 'https://registry.npmjs.org/@anthropic-ai/claude-code/latest';
 const VERSION_RE = /(\d+)\.(\d+)\.(\d+)/;
-const CACHE_MS = 10 * 60_000;
-const INSTALL_TIMEOUT_MS = 5 * 60_000;
-const TAIL = 400;
 
 export interface VersionDeps {
   claude?: string;
-  fetchImpl?: typeof fetch;
   session?: SessionDeps;
-  now?: () => number;
 }
 
 export interface ClaudeVersion {
   installed: string | null;
-  latest: string | null;
+  latest: string;
   newer: boolean;
 }
 
-let cached: { latest: string | null; at: number } | null = null;
-
 function candidates(deps: VersionDeps): string[] {
   if (deps.claude !== undefined) return [deps.claude];
   return agentUser() === null ? ['claude', join(homedir(), '.local', 'bin', 'claude')] : [claudeBin()];
@@ -51,48 +43,9 @@ function located(deps: VersionDeps): { bin: string; installed: string } | null {
   return null;
 }
 
-export function newerThan(a: string, b: string): boolean {
-  const left = a.split('.').map(Number);
-  const right = b.split('.').map(Number);
-  for (let i = 0; i < 3; i += 1) {
-    const d = (left[i] ?? 0) - (right[i] ?? 0);
-    if (d !== 0) return d > 0;
-  }
-  return false;
-}
-
-async function latestClaudeVersion(deps: VersionDeps = {}): Promise<string | null> {
-  const now = (deps.now ?? Date.now)();
-  if (cached !== null && now - cached.at < CACHE_MS) return cached.latest;
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  let latest: string | null = null;
-  try {
-    const res = await fetchImpl(LATEST_URL, { headers: { accept: 'application/json' }, redirect: 'manual' });
-    const body: unknown = res.ok ? await res.json() : null;
-    latest = isRecord(body) && typeof body.version === 'string' ? parse(body.version) : null;
-  } catch (err) {
-    log.warn({ err: errMsg(err) }, 'claude-version: could not read the latest version from npm');
-  }
-  cached = { latest, at: now };
-  return latest;
-}
-
-export function forgetClaudeVersion(): void {
-  cached = null;
-}
-
-export async function claudeVersion(deps: VersionDeps = {}): Promise<ClaudeVersion> {
+export function claudeVersion(deps: VersionDeps = {}): ClaudeVersion {
   const installed = located(deps)?.installed ?? null;
-  const latest = await latestClaudeVersion(deps);
-  return { installed, latest, newer: installed !== null && latest !== null && newerThan(latest, installed) };
-}
-
-function install(bin: string): void {
-  const run = spawnSync(...asAgent(bin, ['install', 'latest']), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: INSTALL_TIMEOUT_MS });
-  if (run.error !== undefined) throw new ApiError(`claude install latest failed: ${errMsg(run.error)}`, 502);
-  if (run.status === 0) return;
-  const said = `${run.stderr ?? ''}${run.stdout ?? ''}`.trim().slice(-TAIL);
-  throw new ApiError(`claude install latest failed: ${said}`, 502);
+  return { installed, latest: CLAUDE_CODE_VERSION, newer: installed !== null && installed !== CLAUDE_CODE_VERSION };
 }
 
 function restartIfChanged(changed: boolean, session: SessionDeps): boolean {
@@ -101,13 +54,23 @@ function restartIfChanged(changed: boolean, session: SessionDeps): boolean {
   return true;
 }
 
-export async function updateClaude(deps: VersionDeps = {}): Promise<ClaudeVersion & { restarted: boolean }> {
+export function updateClaude(deps: VersionDeps = {}): ClaudeVersion & { restarted: boolean } {
   const found = located(deps);
   if (found === null) throw new ApiError('Claude Code is not installed on this machine', 404);
-  install(found.bin);
-  forgetClaudeVersion();
-  const after = await claudeVersion(deps);
+  try {
+    installClaudeCode(found.bin);
+  } catch (err) {
+    throw new ApiError(errMsg(err), 502);
+  }
+  const after = claudeVersion(deps);
   const restarted = restartIfChanged(after.installed !== null && after.installed !== found.installed, deps.session ?? {});
   log.info({ from: found.installed, to: after.installed, restarted }, 'claude-version: Claude Code updated');
   return { ...after, restarted };
 }
+
+export function pinClaudeCode(deps: VersionDeps = {}): void {
+  const found = located(deps);
+  if (found === null || found.installed === CLAUDE_CODE_VERSION) return;
+  installClaudeCode(found.bin);
+  log.info({ from: found.installed, to: located(deps)?.installed ?? null }, 'claude-version: installed the Claude Code version metro was checked with');
+}

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/daemon/src/mcp/index.ts

@@ -8,6 +8,7 @@ import {
   authenticate,
   runWithIdentity,
   type RequestIdentity,
+  allowedAgents,
 } from './request-identity.js';
 import {
   headerValue,
@@ -18,6 +19,7 @@ import { errMsg } from '@metro-labs/core/log';
 import { channelLog, type McpSession } from './session.js';
 import { SessionSlot } from './session-slot.js';
 import { connectCallBridge } from './call-bridge.js';
+import { handleIncomingDiagnostic } from './diagnostics.js';
 
 const isInitialize = (b: unknown): boolean =>
   !!b &&
@@ -128,6 +130,7 @@ export async function createMetroMcp(options: { liveEvents?: boolean } = {}): Pr
       res.writeHead(401).end('unauthorized');
       return;
     }
+    if (handleIncomingDiagnostic(req, res, slot, allowedAgents(identity))) return;
     const parsed = await readOrReject(req, res);
     if (!parsed.ok) return;
     await runWithIdentity(identity, async () => {

package/runtime/node_modules/@metro-labs/daemon/src/mcp/raw-get-stream.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import { randomUUID } from 'node:crypto';
 import type {
   StreamableHTTPServerTransport,
   EventId,
@@ -49,10 +50,19 @@ export const headerValue = (
   return typeof raw === 'string' ? raw : undefined;
 };
 
+export interface GetStreamDiagnostic {
+  tag: string;
+  openedAt: string;
+  attachedAt: string | null;
+  closedAt: string | null;
+  ownsMapping: boolean;
+}
+
 export interface RawGetSink {
   closed: boolean;
   attach: (transport: StreamableHTTPServerTransport) => void;
   close: () => void;
+  diagnostics: () => GetStreamDiagnostic;
 }
 
 const streamEnded = (sink: RawGetSink, res: ServerResponse): boolean =>
@@ -99,10 +109,8 @@ export interface ServeOpts {
   previous?: () => RawGetSink | undefined;
 }
 
-export async function serveStandaloneGet(opts: ServeOpts): Promise<void> {
-  const { transport, eventStore, scope, req, res, log, registerSink } = opts;
+function primeStream(transport: StreamableHTTPServerTransport, res: ServerResponse): void {
   const sessionId = web(transport)?.sessionId;
-
   res.writeHead(200, {
     'content-type': 'text/event-stream',
     'cache-control': 'no-cache, no-transform',
@@ -113,13 +121,23 @@ export async function serveStandaloneGet(opts: ServeOpts): Promise<void> {
   res.flushHeaders?.();
   res.write(RETRY_DIRECTIVE);
   res.write(COMMENT);
+}
+
+export async function serveStandaloneGet(opts: ServeOpts): Promise<void> {
+  const { transport, eventStore, scope, req, res, log, registerSink } = opts;
+  primeStream(transport, res);
 
   let active = transport;
   let entry: StreamEntry | undefined;
+  const tag = randomUUID();
+  const openedAt = new Date().toISOString();
+  let attachedAt: string | null = null;
+  let closedAt: string | null = null;
   const timers: { keepalive?: ReturnType<typeof setInterval> } = {};
   const closeStream = (): void => {
     if (sink.closed) return;
     sink.closed = true;
+    closedAt = new Date().toISOString();
     if (timers.keepalive) clearInterval(timers.keepalive);
     const mapping = web(active)?._streamMapping;
     if (entry !== undefined && mapping?.get(STANDALONE_STREAM_ID) === entry) {
@@ -150,8 +168,16 @@ export async function serveStandaloneGet(opts: ServeOpts): Promise<void> {
         cleanup: closeStream,
       };
       web(next)?._streamMapping?.set(STANDALONE_STREAM_ID, entry);
+      attachedAt = new Date().toISOString();
     },
     close: closeStream,
+    diagnostics: () => ({
+      tag,
+      openedAt,
+      attachedAt,
+      closedAt,
+      ownsMapping: entry !== undefined && web(active)?._streamMapping?.get(STANDALONE_STREAM_ID) === entry,
+    }),
   };
 
   res.on('close', closeStream);

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

@@ -4,6 +4,18 @@ import { errMsg } from '@metro-labs/core/log';
 import { newReplayLedger } from '../channels/relay.js';
 import { McpSession, channelLog, type SessionKind } from './session.js';
 import { allowedAgents, type RequestIdentity } from './request-identity.js';
+import { diagnosticTag, type SessionDiagnostic, type SlotDiagnostic } from './diagnostics.js';
+
+interface SlotReplacement {
+  at: string;
+  reason: 'initialize' | 'adopt';
+  tag: string;
+  scope: Set<string>;
+  previousScope: Set<string>;
+  previous: SessionDiagnostic | null;
+}
+
+const sharesScope = (left: Set<string>, right: Set<string>): boolean => [...left].some((id) => right.has(id));
 
 export class SessionSlot {
   private session: McpSession | undefined;
@@ -11,6 +23,7 @@ export class SessionSlot {
   private started = false;
   private live: boolean;
   private changing: Promise<void> = Promise.resolve();
+  private readonly replacements: SlotReplacement[] = [];
 
   constructor(
     live = true,
@@ -27,6 +40,20 @@ export class SessionSlot {
     return this.live;
   }
 
+  diagnostics(scope: Set<string>): SlotDiagnostic {
+    return {
+      started: this.started,
+      liveEvents: this.live,
+      current: this.session !== undefined && sharesScope(scope, this.session.scope) ? this.session.diagnostics() : null,
+      replacements: this.replacements.filter((replacement) => sharesScope(scope, replacement.scope)).map((replacement) => ({
+        at: replacement.at,
+        reason: replacement.reason,
+        tag: replacement.tag,
+        previous: sharesScope(scope, replacement.previousScope) ? replacement.previous : null,
+      })),
+    };
+  }
+
   startInbound(): void {
     if (this.started) return;
     this.started = true;
@@ -59,8 +86,27 @@ export class SessionSlot {
     return changed;
   }
 
+  private previousSlot(): Pick<SlotReplacement, 'previous' | 'previousScope'> {
+    return {
+      previous: this.session?.diagnostics() ?? null,
+      previousScope: this.session?.scope ?? new Set<string>(),
+    };
+  }
+
+  private recordReplacement(session: McpSession, adoptId: string | undefined, previous: Pick<SlotReplacement, 'previous' | 'previousScope'>): void {
+    this.replacements.push({
+      at: new Date().toISOString(),
+      reason: adoptId === undefined ? 'initialize' : 'adopt',
+      tag: diagnosticTag(session.id),
+      scope: session.scope,
+      ...previous,
+    });
+    if (this.replacements.length > 8) this.replacements.shift();
+  }
+
   private async replace(identity: RequestIdentity, adoptId?: string): Promise<McpSession> {
     if (adoptId !== undefined && this.session?.id === adoptId) return this.session;
+    const previous = this.previousSlot();
     await this.session?.close();
     if (this.ledger.startAt < 0) this.ledger.startAt = currentBusSeq();
     const id = adoptId ?? randomUUID();
@@ -81,6 +127,7 @@ export class SessionSlot {
       },
     });
     this.session = session;
+    this.recordReplacement(session, adoptId, previous);
     if (this.started && this.live) session.startChannel();
     channelLog('session: opened', 'id', id, 'kind', this.kind, 'adopted', adoptId !== undefined);
     return session;

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

@@ -15,6 +15,7 @@ import { registerToolHandlers, toolSchemaSignature } from './tool-dispatch.js';
 import { web, type RawGetSink } from './raw-get-stream.js';
 import { sharedCalls } from '../voice/shared.js';
 import { CALL_STATE } from '@metro-labs/core/call';
+import { clientDiagnostic, diagnosticTag, type SessionDiagnostic } from './diagnostics.js';
 
 export const channelLog = (...a: unknown[]): void => {
   console.error('[metro-mcp]', ...a);
@@ -84,6 +85,10 @@ export class McpSession {
   private announcing = false;
   private readonly onClosed: (session: McpSession) => void;
   private readonly kind: SessionKind;
+  private readonly openedAt = new Date().toISOString();
+  private clientInitializedAt: string | null = null;
+  private lastStreamAttachedAt: string | null = null;
+  private lastStreamDetachedAt: string | null = null;
 
   private constructor(init: SessionInit) {
     this.id = init.id;
@@ -102,6 +107,9 @@ export class McpSession {
         instructions: voice ? VOICE_MCP_INSTRUCTIONS : MCP_INSTRUCTIONS,
       },
     );
+    this.server.oninitialized = (): void => {
+      this.clientInitializedAt = new Date().toISOString();
+    };
     registerToolHandlers(this.server, {
       markCurrent: (): void => {
         this.issuedSchema = toolSchemaSignature();
@@ -159,6 +167,21 @@ export class McpSession {
     return this.sink;
   }
 
+  diagnostics(): SessionDiagnostic {
+    return {
+      tag: diagnosticTag(this.id),
+      openedAt: this.openedAt,
+      transportInitialized: web(this.transport)?._initialized === true,
+      clientInitializedAt: this.clientInitializedAt,
+      client: clientDiagnostic(this.server.getClientVersion()),
+      subscribed: this.unsubscribe !== undefined,
+      streamAttached: this.streamAttached,
+      lastStreamAttachedAt: this.lastStreamAttachedAt,
+      lastStreamDetachedAt: this.lastStreamDetachedAt,
+      stream: this.sink?.diagnostics() ?? null,
+    };
+  }
+
   inScope(line: string): boolean {
     return this.streamAttached && eventInScope(this.scope, line);
   }
@@ -181,8 +204,10 @@ export class McpSession {
       sink?.close();
       return;
     }
+    if (sink === undefined && this.sink !== undefined) this.lastStreamDetachedAt = new Date().toISOString();
     this.sink = sink;
     if (sink !== undefined) {
+      this.lastStreamAttachedAt = new Date().toISOString();
       this.announceCallState();
       this.announceToolSchema();
     }
@@ -227,6 +252,7 @@ export class McpSession {
 
   dropStream(): void {
     const sink = this.sink;
+    if (sink !== undefined) this.lastStreamDetachedAt = new Date().toISOString();
     this.sink = undefined;
     sink?.close();
   }

package/runtime/node_modules/@metro-labs/daemon/src/routes/http.ts

@@ -12,6 +12,7 @@ import {
   type ServerResponse,
 } from 'node:http';
 import { Line } from '@metro-labs/core/lines';
+import { MCP_STATUS_PATH } from '../mcp/diagnostics.js';
 import { errMsg, log } from '@metro-labs/core/log';
 import {
   classifyEvent,
@@ -214,7 +215,7 @@ export async function startWebhookServer(
 
 function isMcpPath(req: IncomingMessage): boolean {
   const path = (req.url ?? '').split('?')[0];
-  return path === '/' || path === '/mcp' || path === VOICE_MCP_PATH;
+  return path === '/' || path === '/mcp' || path === VOICE_MCP_PATH || path === MCP_STATUS_PATH;
 }
 
 function flatHeaders(req: IncomingMessage): Record<string, string> {

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.295"
+  "version": "0.1.0-beta.297"
 }

package/runtime/sdk-runner/runner.json

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