@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { hostname } from 'node:os';
 import { claimCode, claimRuntime, mcpServers, NotSignedIn, whoisAuthorized, } from './api.js';
-import { askLine } from './prompt.js';
+import { askSecret } from './prompt.js';
 import { clearToken, credentialsPath, metroUrl, metroWebUrl, writeToken, } from './store.js';
-import { detach, probe, runningPid, stop, tail } from './control.js';
+import { detach, lockedBy, probe, runningPid, stopAll, tail } from './control.js';
 import { assertAgentId, daemonPlan, localUrl, readRunToken, runDaemon, runtimeDir, writeRunToken, } from './runtime.js';
 import { update } from './update.js';
 import { currentVersion } from './version.js';
@@ -11,8 +11,8 @@ const USAGE = `metro — the command line for your MCP connectors
 
   metro start <agent-id> [--detach]
                   run that agent's stations on this machine
-  metro stop <agent-id>
-                  stop the daemon started with --detach
+  metro stop [agent-id]
+                  stop every metro daemon on this machine, however it was started
   metro status <agent-id>
                   is it running, and is it healthy
   metro logs <agent-id> [-f]
@@ -40,7 +40,7 @@ function hostLabel() {
 }
 async function authorizeRuntime(agentId) {
     process.stderr.write(`Authorize this machine at ${metroWebUrl()}/#/authorize/${agentId}\n`);
-    const code = (await askLine('Paste the code: ')).trim();
+    const code = (await askSecret('Paste the code (input is hidden): ')).trim();
     if (code === '')
         throw new Error('no code given');
     const claimed = await claimRuntime(code, hostLabel());
@@ -50,8 +50,9 @@ async function authorizeRuntime(agentId) {
 }
 async function start(argv) {
     const agentId = assertAgentId(argv[0]);
-    if (runningPid(agentId) !== null)
-        throw new Error(`metro is already running for ${agentId} — stop it first`);
+    if (runningPid(agentId) !== null || lockedBy() !== null)
+        throw new Error('a metro daemon is already running on this machine. ' +
+            'Stop it first: metro stop');
     const dir = runtimeDir();
     const token = readRunToken(agentId) ?? (await authorizeRuntime(agentId));
     const detached = argv.includes('--detach');
@@ -65,10 +66,15 @@ async function start(argv) {
     return 0;
 }
 async function stopDaemon(argv) {
-    const agentId = assertAgentId(argv[0]);
-    const stopped = await stop(agentId);
-    process.stderr.write(stopped ? `Stopped metro for ${agentId}\n` : `metro is not running for ${agentId}\n`);
-    return stopped ? 0 : 1;
+    const agentId = argv[0] === undefined ? undefined : assertAgentId(argv[0]);
+    const stopped = await stopAll(agentId);
+    if (stopped.length === 0) {
+        process.stderr.write('no metro daemon is running on this machine\n');
+        return 1;
+    }
+    for (const d of stopped)
+        process.stderr.write(`Stopped metro (pid ${String(d.pid)}, via ${d.via})\n`);
+    return 0;
 }
 async function status(argv) {
     const agentId = assertAgentId(argv[0]);
@@ -90,7 +96,7 @@ function logs(argv) {
 }
 async function login() {
     process.stderr.write(`Choose a connector collection at ${metroWebUrl()}/#/authorize\n`);
-    const { token, email, collection } = await claimCode(await askLine('Paste the code here: '));
+    const { token, email, collection } = await claimCode(await askSecret('Paste the code here (input is hidden): '));
     writeToken(token);
     process.stderr.write(`Authorized '${collection}' for ${email}. Stored in ${credentialsPath()}\n`);
 }

package/dist/control.js

@@ -1,5 +1,5 @@
-import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { execFileSync, spawn } from 'node:child_process';
+import { existsSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 const STATE = () => join(homedir(), '.metro');
@@ -58,22 +58,78 @@ export function detach(opts) {
     writePid(opts.agentId, pid);
     return pid;
 }
-export async function stop(agentId, waitMs = 10_000) {
-    const pid = runningPid(agentId);
-    if (pid === null)
-        return false;
+async function stopPid(pid, waitMs) {
     process.kill(pid, 'SIGTERM');
     const until = Date.now() + waitMs;
     while (Date.now() < until) {
-        if (!isAlive(pid)) {
-            clearPid(agentId);
-            return true;
-        }
+        if (!isAlive(pid))
+            return;
         await new Promise((r) => setTimeout(r, 100));
     }
     process.kill(pid, 'SIGKILL');
-    clearPid(agentId);
-    return true;
+}
+const lockPath = () => process.env.METRO_STATE_DIR?.trim()
+    ? join(process.env.METRO_STATE_DIR.trim(), '.tail-lock')
+    : join(homedir(), '.cache', 'metro', '.tail-lock');
+function commandOf(pid) {
+    try {
+        return execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return '';
+    }
+}
+const looksLikeMetro = (command) => command.includes('server.ts') || command.includes('metro');
+export function lockedBy() {
+    let pid;
+    try {
+        pid = Number(readFileSync(lockPath(), 'utf8').trim());
+    }
+    catch {
+        return null;
+    }
+    if (!Number.isInteger(pid) || pid <= 0 || !isAlive(pid))
+        return null;
+    return looksLikeMetro(commandOf(pid)) ? pid : null;
+}
+function trackedAgents(agentId) {
+    const tracked = new Set();
+    if (agentId !== undefined)
+        tracked.add(agentId);
+    try {
+        for (const name of readdirSync(STATE())) {
+            const found = /^run-(.+)\.pid$/.exec(name);
+            if (found?.[1] !== undefined)
+                tracked.add(found[1]);
+        }
+    }
+    catch {
+        return tracked;
+    }
+    return tracked;
+}
+export async function stopAll(agentId, waitMs = 10_000) {
+    const stopped = [];
+    const seen = new Set();
+    for (const id of trackedAgents(agentId)) {
+        const pid = runningPid(id);
+        if (pid === null || seen.has(pid))
+            continue;
+        seen.add(pid);
+        await stopPid(pid, waitMs);
+        clearPid(id);
+        stopped.push({ pid, via: id });
+    }
+    const holder = lockedBy();
+    if (holder !== null && !seen.has(holder)) {
+        await stopPid(holder, waitMs);
+        rmSync(lockPath(), { force: true });
+        stopped.push({ pid: holder, via: 'the machine lock' });
+    }
+    return stopped;
 }
 export function tail(agentId, follow) {
     const path = logPath(agentId);

package/dist/prompt.js

@@ -1,4 +1,6 @@
 import { createInterface } from 'node:readline';
+const CTRL_C = '\u0003';
+const BACKSPACE = '\u007f';
 export function askLine(question) {
     const rl = createInterface({ input: process.stdin, output: process.stderr });
     return new Promise((resolve) => {
@@ -8,3 +10,52 @@ export function askLine(question) {
         });
     });
 }
+export function feedSecret(value, chunk) {
+    let out = value;
+    for (const ch of chunk) {
+        if (ch === CTRL_C)
+            return { kind: 'cancelled' };
+        if (ch === '\r' || ch === '\n')
+            return { kind: 'done', value: out };
+        if (ch === BACKSPACE || ch === '\b') {
+            out = out.slice(0, -1);
+            continue;
+        }
+        if (ch >= ' ')
+            out += ch;
+    }
+    return { kind: 'more', value: out };
+}
+export function askSecret(question) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY)
+        return askLine(question);
+    process.stderr.write(question);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    return new Promise((resolve, reject) => {
+        let value = '\u0003';
+        const finish = () => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.off('data', onData);
+            process.stderr.write('\n');
+        };
+        const onData = (chunk) => {
+            const step = feedSecret(value, chunk);
+            if (step.kind === 'cancelled') {
+                finish();
+                reject(new Error('cancelled'));
+                return;
+            }
+            if (step.kind === 'done') {
+                finish();
+                resolve(step.value.trim());
+                return;
+            }
+            value = step.value;
+        };
+        stdin.on('data', onData);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.21",
+  "version": "0.1.0-beta.23",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@metro-labs/discord",
+  "name": "@metro-labs/discord-bot",
   "version": "0.1.0",
   "private": true,
   "type": "module",

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/accounts.ts

@@ -10,8 +10,8 @@ import { emit } from './wire.js';
 import { API } from './api-base.js';
 
 const ACCOUNTS_FILE =
-  process.env.DISCORD_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'discord-accounts.json');
+  process.env.DISCORD_BOT_ACCOUNTS_FILE ??
+  join(homedir(), '.metro', 'discord-bot-accounts.json');
 
 export interface AccountConfig {
   id: string;
@@ -20,9 +20,9 @@ export interface AccountConfig {
 }
 
 export const { loadAccounts } = makeAccountStore<AccountConfig>({
-  prefix: 'discord',
+  prefix: 'discord-bot',
   file: ACCOUNTS_FILE,
-  allowlistEnv: ['DISCORD_ONLY_ACCOUNTS', 'DISCORD_ACCOUNTS'],
+  allowlistEnv: ['DISCORD_BOT_ONLY_ACCOUNTS', 'DISCORD_BOT_ACCOUNTS'],
   validate(raw, die) {
     const seen = new Set<string>();
     for (const a of raw) {
@@ -67,11 +67,11 @@ export async function rest<T = unknown>(
   if (!acct) throw new Error(`unknown account '${accountId}'`);
   const headers: Record<string, string> = {
     Authorization: `Bot ${acct.cfg.token}`,
-    'User-Agent': 'metro-discord-train (https://github.com/bonustrack/stage)',
+    'User-Agent': 'metro-discord-bot-train (https://github.com/bonustrack/stage)',
   };
   if (body !== undefined && !isForm)
     headers['Content-Type'] = 'application/json';
-  emit({ op: 'log', text: `discord[${accountId}] api ${method} ${path}` });
+  emit({ op: 'log', text: `discord-bot[${accountId}] api ${method} ${path}` });
   const res = await fetch(`${API}${path}`, {
     method,
     headers,
@@ -80,17 +80,17 @@ export async function rest<T = unknown>(
   });
   emit({
     op: 'log',
-    text: `discord[${accountId}] api ${method} ${path} -> ${res.status}`,
+    text: `discord-bot[${accountId}] api ${method} ${path} -> ${res.status}`,
   });
   if (!res.ok) {
     const text = await res.text().catch(() => '');
-    throw new Error(`discord ${method} ${path}: ${res.status} ${text}`);
+    throw new Error(`discord-bot ${method} ${path}: ${res.status} ${text}`);
   }
   return restResult<T>(res);
 }
 
 export function lineOf(accountId: string, channelId: string): string {
-  return `metro://discord/${accountId}/${channelId}`;
+  return `metro://discord-bot/${accountId}/${channelId}`;
 }
 
 export function parseLine(
@@ -109,7 +109,7 @@ export function routeOf(
   account?: string,
 ): { accountId: string; channelId: string } {
   const parsed = parseLine(line);
-  if (!parsed) throw new Error(`bad discord line: ${line}`);
+  if (!parsed) throw new Error(`bad discord-bot line: ${line}`);
   const accountId = account ?? parsed.accountId;
   if (!accounts.has(accountId))
     throw new Error(`unknown account '${accountId}' in line ${line}`);

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/actions.ts

@@ -267,7 +267,7 @@ async function download(
   for (const att of msg.attachments) {
     const res = await fetch(att.url, { signal: AbortSignal.timeout(60_000) });
     if (!res.ok)
-      throw new Error(`discord download ${res.status} for ${att.url}`);
+      throw new Error(`discord-bot download ${res.status} for ${att.url}`);
     assertContentLength(res.headers.get('content-length'));
     const buf = await res.arrayBuffer();
     const path = `${outDir}/${messageId}-${att.filename}`;

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/attachments.ts

@@ -19,7 +19,7 @@ export async function saveDiscordAttachment(
 ): Promise<SavedAttachment> {
   const res = await fetch(a.url, { signal: AbortSignal.timeout(60_000) });
   if (!res.ok)
-    throw new Error(`discord attachment fetch ${res.status} for ${a.url}`);
+    throw new Error(`discord-bot attachment fetch ${res.status} for ${a.url}`);
   assertContentLength(res.headers.get('content-length'));
   const data = new Uint8Array(await res.arrayBuffer());
   return saveBufferToCache(data, messageId, index, {

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/format.ts

@@ -29,7 +29,7 @@ function emitAttachmentSaved(
         kind: 'inbound',
         id: mintId(),
         ts: new Date().toISOString(),
-        station: 'discord',
+        station: 'discord-bot',
         line,
         from: SELF_URI,
         text: `📎 saved: ${saved.path}`,
@@ -46,7 +46,7 @@ function emitAttachmentSaved(
     })
     .catch((err: unknown) =>
       process.stderr.write(
-        `discord attachment save failed: ${err instanceof Error ? err.message : String(err)}\n`,
+        `discord-bot attachment save failed: ${err instanceof Error ? err.message : String(err)}\n`,
       ),
     );
 }
@@ -102,10 +102,10 @@ export function messageEnvelope(
     kind: 'inbound',
     id: envId,
     ts: new Date(m.createdTimestamp).toISOString(),
-    station: 'discord',
+    station: 'discord-bot',
     line,
     line_name: 'name' in m.channel ? m.channel.name : undefined,
-    from: `metro://discord/${accountId}/user/${m.author.id}`,
+    from: `metro://discord-bot/${accountId}/user/${m.author.id}`,
     from_name: m.author.username,
     from_display_name: m.author.globalName ?? undefined,
     message_id: m.id,
@@ -129,9 +129,9 @@ export function reactionEnvelope(
     kind: 'react',
     id: mintId(),
     ts: new Date().toISOString(),
-    station: 'discord',
+    station: 'discord-bot',
     line: lineOf(accountId, r.message.channelId),
-    from: `metro://discord/${accountId}/user/${u.id}`,
+    from: `metro://discord-bot/${accountId}/user/${u.id}`,
     from_name: u.username,
     from_display_name: u.globalName ?? undefined,
     message_id: r.message.id,
@@ -162,7 +162,7 @@ function outbound(
     kind,
     id: mintId(),
     ts: new Date().toISOString(),
-    station: 'discord',
+    station: 'discord-bot',
     line,
     from: SELF_URI,
     to: line,

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/group-actions.ts

@@ -17,7 +17,7 @@ export async function groupCreateHandler(
         capability: {
           supported: false,
           reason:
-            'discord create_group requires `parent` (the metro:// line of the channel to open the thread under)',
+            'discord-bot create_group requires `parent` (the metro:// line of the channel to open the thread under)',
         },
       },
     });

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/index.ts

@@ -19,7 +19,7 @@ import { mintId } from './wire.js';
 import { readCalls } from '@metro-labs/mcp/trains/protocol';
 import { handleCall } from './actions.js';
 
-readCalls('discord', handleCall);
+readCalls('discord-bot', handleCall);
 
 function makeClient(): Client {
   return new Client({
@@ -47,9 +47,9 @@ function onEdit(accountId: string, m: Message): void {
     kind: 'edit',
     id: mintId(),
     ts: new Date(m.editedTimestamp ?? Date.now()).toISOString(),
-    station: 'discord',
+    station: 'discord-bot',
     line: lineOf(accountId, m.channelId),
-    from: `metro://discord/${accountId}/user/${m.author.id}`,
+    from: `metro://discord-bot/${accountId}/user/${m.author.id}`,
     from_name: m.author.username,
     from_display_name: m.author.globalName ?? undefined,
     message_id: m.id,
@@ -80,7 +80,7 @@ async function bootAccount(cfg: AccountConfig): Promise<void> {
       if (env) emitInbound(accountId, env);
     })().catch((err: unknown) => {
       process.stderr.write(
-        `discord[${accountId}] reaction handler failed: ${errMsg(err)}\n`,
+        `discord-bot[${accountId}] reaction handler failed: ${errMsg(err)}\n`,
       );
     });
   });
@@ -91,12 +91,12 @@ async function bootAccount(cfg: AccountConfig): Promise<void> {
         onEdit(accountId, _new.partial ? await _new.fetch() : _new);
       } catch (err) {
         process.stderr.write(
-          `discord[${accountId}] message update fetch failed: ${errMsg(err)}\n`,
+          `discord-bot[${accountId}] message update fetch failed: ${errMsg(err)}\n`,
         );
       }
     })().catch((err: unknown) => {
       process.stderr.write(
-        `discord[${accountId}] message update handler failed: ${errMsg(err)}\n`,
+        `discord-bot[${accountId}] message update handler failed: ${errMsg(err)}\n`,
       );
     });
   });
@@ -104,7 +104,7 @@ async function bootAccount(cfg: AccountConfig): Promise<void> {
   accounts.set(accountId, { cfg, client });
   await client.login(cfg.token);
   process.stderr.write(
-    `discord[${accountId}] ready — ${client.user?.tag ?? '?'} (owner=${cfg.owner ?? '(broadcast)'})\n`,
+    `discord-bot[${accountId}] ready — ${client.user?.tag ?? '?'} (owner=${cfg.owner ?? '(broadcast)'})\n`,
   );
 }
 
@@ -114,14 +114,14 @@ for (const cfg of cfgs) {
     await bootAccount(cfg);
   } catch (err) {
     process.stderr.write(
-      `discord[${cfg.id}] boot FAILED: ${errMsg(err)}\n`,
+      `discord-bot[${cfg.id}] boot FAILED: ${errMsg(err)}\n`,
     );
   }
 }
 if (accounts.size === 0) {
-  process.stderr.write('discord: no accounts booted, exiting\n');
+  process.stderr.write('discord-bot: no accounts booted, exiting\n');
   process.exit(2);
 }
 process.stderr.write(
-  `discord train ready — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
+  `discord-bot train ready — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
 );

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/station.ts

@@ -1,7 +1,7 @@
 import type { GroupOp, Station, Verb } from '@metro-labs/mcp/stations/types';
 
-export const discordStation: Station = {
-  name: 'discord',
+export const discordBotStation: Station = {
+  name: 'discord-bot',
   hasAccounts: true,
   hasTrain: true,
   messageVerbs: new Set<Verb>([

package/runtime/node_modules/@metro-labs/{discord → discord-bot}/src/voice-transcribe.ts

@@ -178,10 +178,10 @@ function emitTranscript(
     kind: 'inbound',
     id: mintId(),
     ts: new Date().toISOString(),
-    station: 'discord',
-    line: `metro://discord/${s.accountId}/voice/${s.channelId}`,
+    station: 'discord-bot',
+    line: `metro://discord-bot/${s.accountId}/voice/${s.channelId}`,
     line_name: 'voice',
-    from: `metro://discord/${s.accountId}/user/${userId}`,
+    from: `metro://discord-bot/${s.accountId}/user/${userId}`,
     from_name: speakerName(s, userId),
     message_id: stamp,
     text,
@@ -228,7 +228,7 @@ async function handleSpeaker(s: Session, userId: string): Promise<void> {
     await transcribeUtterance(s, userId, pcmPath, wavPath, stamp);
   } catch (err) {
     process.stderr.write(
-      `discord voice transcribe error (${userId}): ${errMsg(err)}\n`,
+      `discord-bot voice transcribe error (${userId}): ${errMsg(err)}\n`,
     );
   } finally {
     s.active.delete(userId);
@@ -258,14 +258,14 @@ export function startTranscription(
   s.onStart = (userId: string) => {
     handleSpeaker(s, userId).catch((err: unknown) => {
       process.stderr.write(
-        `discord[${accountId}] voice speaker failed: ${errMsg(err)}\n`,
+        `discord-bot[${accountId}] voice speaker failed: ${errMsg(err)}\n`,
       );
     });
   };
   receiver.speaking.on('start', s.onStart);
   sessions.set(guildId, s);
   process.stderr.write(
-    `discord[${accountId}] voice transcription armed on ${channelId}\n`,
+    `discord-bot[${accountId}] voice transcription armed on ${channelId}\n`,
   );
 }
 

package/runtime/node_modules/@metro-labs/mcp/package.json

@@ -42,9 +42,9 @@
     "test": "tsc --noEmit && DYLD_FALLBACK_LIBRARY_PATH=/usr/lib METRO_STATE_DIR=\"$(mktemp -d /tmp/metro-test.XXXXXX)\" bun test test/"
   },
   "dependencies": {
-    "@metro-labs/discord": "workspace:*",
+    "@metro-labs/discord-bot": "workspace:*",
     "@metro-labs/telegram": "workspace:*",
-    "@metro-labs/telegram-user": "workspace:*",
+    "@metro-labs/telegram-bot": "workspace:*",
     "@metro-labs/webhook": "workspace:*",
     "@metro-labs/whatsapp": "workspace:*",
     "@metro-labs/xmtp": "workspace:*",

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

@@ -102,18 +102,23 @@ interface KeyPayload {
   command: string | null;
 }
 
-function credentials(key: string): KeyPayload {
+const LOCAL_MCP_ENDPOINT = 'http://127.0.0.1:8420/mcp';
+
+function credentials(key: string, heldLocally: boolean): KeyPayload {
+  const url = heldLocally
+    ? `${LOCAL_MCP_ENDPOINT}?token=${key}`
+    : `${mcpEndpoint()}?token=${key}`;
   return {
     key,
-    endpoint: `${mcpEndpoint()}?token=${key}`,
-    command: mcpAddCommand(key),
+    endpoint: url,
+    command: `claude mcp add --transport http ${SERVER_NAME} "${url}"`,
   };
 }
 
-function keyPayload(agent: AgentSummary): KeyPayload {
+function keyPayload(agent: AgentSummary, heldLocally: boolean): KeyPayload {
   const value = agent.owned ? agent.key : null;
   if (value === null) return { key: null, endpoint: null, command: null };
-  return credentials(value);
+  return credentials(value, heldLocally);
 }
 
 function livenessPayload(
@@ -139,7 +144,7 @@ function agentPayload(
     owned: agent.owned,
     runtime: agent.owned ? (runtimes.get(agent.id) ?? null) : null,
     ...livenessPayload(agent, live),
-    ...keyPayload(agent),
+    ...keyPayload(agent, agent.owned && runtimes.has(agent.id)),
   };
 }
 
@@ -219,7 +224,7 @@ async function handleCreate(
   sendJson(req, res, 201, {
     id: created.id,
     name: created.name,
-    ...credentials(created.key),
+    ...credentials(created.key, false),
   });
 }
 
@@ -231,6 +236,7 @@ async function handleResetKey(
   id: string,
 ): Promise<void> {
   const reset = await deps.resetKey(session.email, id);
+  const held = (await deps.runtimes([id])).has(id);
   log.info(
     { agent: reset.name, id: reset.id, owner: session.email },
     'agent-api: reset agent key',
@@ -239,7 +245,7 @@ async function handleResetKey(
     id: reset.id,
     name: reset.name,
     reset: true,
-    ...credentials(reset.key),
+    ...credentials(reset.key, held),
   });
 }
 

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

@@ -144,11 +144,9 @@ async function applyStations(removed: StationName[]): Promise<void> {
 
 async function syncLocal(): Promise<void> {
   if (localSource === null) return;
-  const before = new Set(supervisor.running());
-  const { active, removed } = await reloadFrom(localSource);
+  const { removed, changed } = await reloadFrom(localSource);
   await applyStations(removed);
-  for (const station of active)
-    if (before.has(station)) supervisor.requestReload(station);
+  for (const station of changed) supervisor.requestReload(station);
 }
 
 async function stopLocalStations(): Promise<void> {