@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.4

package/dist/channels/discord.js

@@ -1,8 +1,6 @@
 import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
 import { errMsg, log } from '../log.js';
-// Receive path: discord.js gateway, owned by the orchestrator.
-// Send path: raw REST against discord.com/api — no gateway login required,
-// so callers outside the orchestrator (e.g. cli.ts validation) stay one-shot.
+/** Receive: discord.js gateway. Send: raw REST so non-orchestrator callers stay one-shot. */
 const API_BASE = 'https://discord.com/api/v10';
 function token() {
     const t = process.env.DISCORD_BOT_TOKEN;
@@ -21,9 +19,7 @@ async function rest(method, path, body, timeoutMs = 30_000, retriesLeft = 2) {
         body: body !== undefined ? JSON.stringify(body) : undefined,
         signal: AbortSignal.timeout(timeoutMs),
     });
-    // 429: honor Discord's retry_after (seconds) and try again, up to a few
-    // hops. Common during streaming edits when the agent emits deltas faster
-    // than the per-channel edit cap.
+    /** 429: honor `retry_after` (seconds) and retry, up to a few hops. */
     if (res.status === 429 && retriesLeft > 0) {
         const retryAfter = Number(res.headers.get('retry-after')) || 1;
         log.debug({ path, retryAfter }, 'discord 429; backing off');
@@ -34,32 +30,23 @@ async function rest(method, path, body, timeoutMs = 30_000, retriesLeft = 2) {
         const text = await res.text().catch(() => '');
         throw new Error(`discord ${method} ${path}: ${res.status} ${text}`);
     }
-    // 204 No Content for typing/reactions/clear.
     if (res.status === 204)
         return undefined;
     return (await res.json());
 }
-// ---------- Receive path (gateway, discord.js) -----------------------------
 let client = null;
 function getClient() {
     if (client)
         return client;
     client = new Client({
-        intents: [
-            GatewayIntentBits.DirectMessages,
-            GatewayIntentBits.Guilds,
-            GatewayIntentBits.GuildMessages,
-            GatewayIntentBits.MessageContent,
-        ],
-        // DM channels arrive partial; without this messageCreate never fires.
+        intents: [GatewayIntentBits.DirectMessages, GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent],
+        /** DM channels arrive partial; without this messageCreate never fires. */
         partials: [Partials.Channel],
     });
     return client;
 }
 let onInboundHandler = () => { };
-export function onInbound(handler) {
-    onInboundHandler = handler;
-}
+export const onInbound = (handler) => { onInboundHandler = handler; };
 export async function shutdownGateway() {
     if (!client)
         return;
@@ -71,19 +58,10 @@ export async function startGateway() {
     c.on(Events.MessageCreate, m => {
         if (m.author.bot)
             return;
-        // Forward every human message; the orchestrator decides what to route
-        // where (scoped thread vs new bootstrap mention vs ignore). The bot's
-        // own @-mention is preserved in `m.content` so the orchestrator can
-        // make that decision from the same payload.
-        const tags = [...m.attachments.values()]
-            .map(a => {
-            if (a.contentType?.startsWith('image/'))
-                return '[image]';
-            if (a.contentType?.startsWith('audio/'))
-                return `[audio: ${a.name}]`;
-            return `[file: ${a.name}]`;
-        })
-            .join(' ');
+        /** Forward every human message; orchestrator decides routing. @-mention stays in content. */
+        const tags = [...m.attachments.values()].map(a => a.contentType?.startsWith('image/') ? '[image]'
+            : a.contentType?.startsWith('audio/') ? `[audio: ${a.name}]`
+                : `[file: ${a.name}]`).join(' ');
         const text = [m.content, tags].filter(Boolean).join(' ').trim();
         if (!text)
             return;
@@ -103,40 +81,24 @@ export async function getMe() {
     const me = await rest('GET', '/users/@me');
     return { username: me.username };
 }
+/** SUPPRESS_EMBEDS (1 << 2) — strip link unfurls from every bot message. */
+const SUPPRESS_EMBEDS = 1 << 2;
 export async function sendMessage(channelId, text) {
-    const sent = await rest('POST', `/channels/${channelId}/messages`, { content: text });
+    const sent = await rest('POST', `/channels/${channelId}/messages`, { content: text, flags: SUPPRESS_EMBEDS });
     return sent.id;
 }
-/**
- * Create a public thread anchored to an existing message. The user's
- * @-mention becomes the thread's starter, so the thread is visually
- * tied to the request that opened it. Returns the new thread's channel id.
- */
+/** Public thread anchored on `messageId`. Returns the new thread channel id. */
 export async function createThreadFromMessage(channelId, messageId, name) {
-    const created = await rest('POST', `/channels/${channelId}/messages/${messageId}/threads`, {
-        name,
-        auto_archive_duration: 1440,
-    });
+    const created = await rest('POST', `/channels/${channelId}/messages/${messageId}/threads`, { name, auto_archive_duration: 1440 });
     return created.id;
 }
 export async function editMessage(channelId, messageId, text) {
-    const sent = await rest('PATCH', `/channels/${channelId}/messages/${messageId}`, { content: text });
+    const sent = await rest('PATCH', `/channels/${channelId}/messages/${messageId}`, { content: text, flags: SUPPRESS_EMBEDS });
     return sent.id;
 }
-/**
- * Fetch all messages newer than `afterMessageId` in a channel. Used for
- * catchup-on-restart so messages sent while metro was down still get a
- * reply once it comes back. Caps at 100 messages — anything older than
- * that during downtime is dropped on the floor.
- */
+/** Catchup-on-restart: fetch messages newer than `afterMessageId` (cap 100). */
 export async function fetchMessagesSince(channelId, afterMessageId) {
     const msgs = await rest('GET', `/channels/${channelId}/messages?after=${afterMessageId}&limit=100`);
-    // Discord returns newest-first; flip to chronological so replay order
-    // matches what the user actually typed.
-    return [...msgs].reverse().map(m => ({
-        message_id: m.id,
-        text: m.content,
-        author_id: m.author.id,
-        author_is_bot: !!m.author.bot,
-    }));
+    /** Discord returns newest-first; flip to chronological for replay. */
+    return [...msgs].reverse().map(m => ({ message_id: m.id, text: m.content, author_id: m.author.id, author_is_bot: !!m.author.bot }));
 }

package/dist/channels/telegram.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { STATE_DIR } from '../paths.js';
 import { errMsg, log } from '../log.js';
+import { mdToTelegramHtml } from '../helpers/telegram-format.js';
 const API_BASE = 'https://api.telegram.org';
 function token() {
     const t = process.env.TELEGRAM_BOT_TOKEN;
@@ -10,23 +11,20 @@ function token() {
     return t;
 }
 async function tg(method, body, opts = {}) {
-    const timeout = opts.timeoutMs ?? 30_000;
-    const signals = [AbortSignal.timeout(timeout)];
+    const signals = [AbortSignal.timeout(opts.timeoutMs ?? 30_000)];
     if (opts.signal)
         signals.push(opts.signal);
-    const signal = AbortSignal.any(signals);
     const res = await fetch(`${API_BASE}/bot${token()}/${method}`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
-        signal,
+        signal: AbortSignal.any(signals),
     });
     const json = (await res.json());
     if (!json.ok)
         throw new Error(`telegram ${method}: ${json.description ?? 'unknown error'}`);
     return json.result;
 }
-// ---------- Identity (cached after getMe) ----------------------------------
 let botUsername = null;
 let botUserId = null;
 export async function getMe() {
@@ -36,17 +34,13 @@ export async function getMe() {
     return me;
 }
 let onInboundHandler = () => { };
-export function onInbound(handler) {
-    onInboundHandler = handler;
-}
+export const onInbound = (handler) => { onInboundHandler = handler; };
 const offsetFile = join(STATE_DIR, 'telegram-offset.json');
 let pollOffset = 0;
 let pollAbort = null;
 function loadOffset() {
     try {
-        if (!existsSync(offsetFile))
-            return 0;
-        return Number(readFileSync(offsetFile, 'utf8').trim()) || 0;
+        return existsSync(offsetFile) ? Number(readFileSync(offsetFile, 'utf8').trim()) || 0 : 0;
     }
     catch {
         return 0;
@@ -61,18 +55,14 @@ function saveOffset(o) {
     }
 }
 export async function startPolling() {
-    // A registered webhook short-circuits getUpdates — clear it defensively.
     await tg('deleteWebhook', { drop_pending_updates: false }).catch(() => { });
     const persisted = loadOffset();
     if (persisted > 0) {
-        // Resume from where we left off — telegram queues updates for ~24h, so
-        // any messages sent while metro was down come back through this poll.
         pollOffset = persisted;
         log.info({ offset: pollOffset }, 'telegram polling: resuming from persisted offset');
     }
     else {
-        // First-ever run: skip historical backlog by anchoring on the latest
-        // update id (-1 returns just the most recent one without consuming it).
+        /** First run: anchor on latest update id (-1 returns most recent without consuming). */
         const initial = await tg('getUpdates', { offset: -1, timeout: 0 });
         pollOffset = initial.length ? initial[0].update_id + 1 : 0;
         saveOffset(pollOffset);
@@ -102,26 +92,15 @@ async function pollLoop() {
     }
     log.info('telegram polling stopped');
 }
-export async function shutdownPolling() {
-    pollAbort?.abort();
-    pollAbort = null;
-}
+export async function shutdownPolling() { pollAbort?.abort(); pollAbort = null; }
 async function dispatchUpdate(u) {
     const m = u.message;
-    if (!m?.chat?.id || typeof m.message_id !== 'number') {
-        log.trace({ update_id: u.update_id }, 'telegram: non-message update');
+    if (!m?.chat?.id || typeof m.message_id !== 'number' || m.from?.is_bot)
         return;
-    }
-    if (m.from?.is_bot) {
-        log.trace({ chat: m.chat.id }, 'telegram: skipping bot author');
-        return;
-    }
-    const text = await messageToText(m);
-    if (!text) {
-        log.trace({ chat: m.chat.id }, 'telegram: no text/caption');
+    const text = messageToText(m);
+    if (!text)
         return;
-    }
-    const msg = {
+    onInboundHandler({
         chat_id: m.chat.id,
         message_id: m.message_id,
         message_thread_id: m.is_topic_message ? m.message_thread_id : undefined,
@@ -130,42 +109,27 @@ async function dispatchUpdate(u) {
         is_forum_topic: !!m.is_topic_message,
         in_forum: !!m.chat.is_forum,
         mentions_bot: detectMentionsBot(m),
-    };
-    log.debug({
-        chat: msg.chat_id,
-        topic: msg.message_thread_id,
-        is_private: msg.is_private,
-        is_forum_topic: msg.is_forum_topic,
-        in_forum: msg.in_forum,
-        mentions_bot: msg.mentions_bot,
-    }, 'telegram: inbound');
-    onInboundHandler(msg);
+    });
 }
 function detectMentionsBot(m) {
-    // In DMs, every message to the bot is implicitly addressed to it.
     if (m.chat?.type === 'private')
         return true;
     const text = m.text ?? m.caption ?? '';
-    const entities = m.entities ?? m.caption_entities ?? [];
-    for (const e of entities) {
+    for (const e of m.entities ?? m.caption_entities ?? []) {
         if (e.type === 'mention' && botUsername) {
-            const slice = text.substring(e.offset, e.offset + e.length);
-            if (slice.toLowerCase() === `@${botUsername.toLowerCase()}`)
+            if (text.substring(e.offset, e.offset + e.length).toLowerCase() === `@${botUsername.toLowerCase()}`)
                 return true;
         }
-        else if (e.type === 'text_mention' && e.user?.id === botUserId) {
+        else if (e.type === 'text_mention' && e.user?.id === botUserId)
             return true;
-        }
     }
     return false;
 }
-async function messageToText(m) {
+function messageToText(m) {
     if (m.text)
         return m.text;
     const caption = m.caption ?? '';
-    if (m.photo?.length)
-        return [caption, '[image]'].filter(Boolean).join(' ');
-    if (m.document?.mime_type?.startsWith('image/'))
+    if (m.photo?.length || m.document?.mime_type?.startsWith('image/'))
         return [caption, '[image]'].filter(Boolean).join(' ');
     if (m.voice)
         return [caption, '[voice]'].filter(Boolean).join(' ');
@@ -173,37 +137,53 @@ async function messageToText(m) {
         return [caption, '[audio]'].filter(Boolean).join(' ');
     return caption || null;
 }
-// ---------- Outbound (REST) ------------------------------------------------
-/**
- * Create a new forum topic in a supergroup. Returns the topic's
- * message_thread_id. Requires the bot to be an admin with the
- * `can_manage_topics` privilege.
- */
+/** Create a forum topic; requires `can_manage_topics` admin permission. */
 export async function createForumTopic(chatId, name) {
-    // Telegram caps topic names at 128 chars.
-    const trimmedName = name.slice(0, 128) || 'metro';
-    const r = await tg('createForumTopic', {
-        chat_id: chatId,
-        name: trimmedName,
-    });
+    const r = await tg('createForumTopic', { chat_id: chatId, name: name.slice(0, 128) || 'metro' });
     return r.message_thread_id;
 }
-export async function sendMessage(chatId, threadId, text) {
-    const body = { chat_id: chatId, text };
+/** Deep link `t.me/c/<id>/<topic>`; strips supergroup's `-100` prefix from chat id. */
+export function topicLink(chatId, topicId) {
+    const id = String(Math.abs(chatId)).replace(/^100/, '');
+    return `https://t.me/c/${id}/${topicId}`;
+}
+const isParseError = (err) => errMsg(err).includes("can't parse entities");
+const NO_PREVIEW = { link_preview_options: { is_disabled: true } };
+/** Send agent-style markdown as Telegram HTML, falling back to plain text on parse errors. */
+export async function sendMessage(chatId, threadId, text, replyToMessageId) {
+    const base = { chat_id: chatId, ...NO_PREVIEW };
     if (threadId !== undefined)
-        body.message_thread_id = threadId;
-    const r = await tg('sendMessage', body);
-    return r.message_id;
+        base.message_thread_id = threadId;
+    if (replyToMessageId !== undefined)
+        base.reply_parameters = { message_id: replyToMessageId };
+    try {
+        return (await tg('sendMessage', { ...base, text: mdToTelegramHtml(text), parse_mode: 'HTML' })).message_id;
+    }
+    catch (err) {
+        if (!isParseError(err))
+            throw err;
+        log.warn({ err: errMsg(err) }, 'telegram: HTML rejected, sending plain');
+        return (await tg('sendMessage', { ...base, text })).message_id;
+    }
 }
 export async function editMessageText(chatId, messageId, text) {
+    const base = { chat_id: chatId, message_id: messageId, ...NO_PREVIEW };
+    const swallow = (err) => { if (!errMsg(err).includes('message is not modified'))
+        throw err; };
     try {
-        await tg('editMessageText', { chat_id: chatId, message_id: messageId, text });
+        await tg('editMessageText', { ...base, text: mdToTelegramHtml(text), parse_mode: 'HTML' });
     }
     catch (err) {
-        // Telegram rejects edits that match the existing content — ignore that
-        // specific case so debounced no-op flushes don't surface as errors.
         if (errMsg(err).includes('message is not modified'))
             return;
-        throw err;
+        if (!isParseError(err))
+            throw err;
+        log.warn({ err: errMsg(err) }, 'telegram: HTML edit rejected, retrying plain');
+        try {
+            await tg('editMessageText', { ...base, text });
+        }
+        catch (e) {
+            swallow(e);
+        }
     }
 }

package/dist/cli.js

@@ -5,28 +5,27 @@ import { join } from 'node:path';
 import pkg from '../package.json' with { type: 'json' };
 import * as discord from './channels/discord.js';
 import * as telegram from './channels/telegram.js';
-import { readDotenv, writeDotenv } from './lib/dotenv.js';
 import { errMsg } from './log.js';
-import { CONFIG_ENV_FILE, configuredPlatforms, loadMetroEnv, STATE_DIR } from './paths.js';
+import { CONFIG_ENV_FILE, configuredPlatforms, loadMetroEnv, readDotenv, STATE_DIR, writeDotenv } from './paths.js';
 const USAGE = `metro — Telegram + Discord bridge for your Claude Code / Codex agent
 
 Usage:
   metro                                       Run the orchestrator daemon.
-                                              Each chat conversation gets its own
-                                              codex session, with streaming responses.
-  metro setup                                 Show config status (tokens).
-  metro setup telegram <token>                Save TELEGRAM_BOT_TOKEN (validated via getMe).
-  metro setup discord <token>                 Save DISCORD_BOT_TOKEN (validated via getMe).
+  metro setup [telegram|discord <token>]      Save token, or show status with no args.
   metro setup clear [telegram|discord|all]    Remove tokens.
-  metro doctor                                Health check: tokens + gateway reachability.
-  metro update                                Upgrade in place (npm/bun/pnpm auto-detected).
-  metro --version, -v                         Print version.
-  metro --help, -h                            This help.
+  metro doctor                                Health check.
+  metro update                                Upgrade in place.
+  metro --version | --help
 
-Exit codes:
-  0 success · 1 usage · 2 config (no tokens — run \`metro setup\`) · 3 upstream
+Exit codes: 0 success · 1 usage · 2 config · 3 upstream
 `;
-function exitErr(msg, code) { return Object.assign(new Error(msg), { code }); }
+const exitErr = (msg, code) => Object.assign(new Error(msg), { code });
+const isJson = (f) => f.json === true;
+const emit = (f, human, structured) => {
+    process.stdout.write(isJson(f) ? JSON.stringify(structured) + '\n' : human + '\n');
+};
+const maskToken = (t) => !t ? '' : t.length <= 8 ? '••••' : `${t.slice(0, 6)}…${t.slice(-2)}`;
+const TOKEN_KEYS = { telegram: 'TELEGRAM_BOT_TOKEN', discord: 'DISCORD_BOT_TOKEN' };
 function parseArgs(argv) {
     const positional = [];
     const flags = {};
@@ -52,18 +51,6 @@ function parseArgs(argv) {
     }
     return { positional, flags };
 }
-const isJson = (f) => f.json === true;
-const emitResult = (f, human, structured) => {
-    process.stdout.write(isJson(f) ? JSON.stringify(structured) + '\n' : human + '\n');
-};
-function maskToken(t) {
-    if (!t)
-        return '';
-    if (t.length <= 8)
-        return '••••';
-    return `${t.slice(0, 6)}…${t.slice(-2)}`;
-}
-const TOKEN_KEYS = { telegram: 'TELEGRAM_BOT_TOKEN', discord: 'DISCORD_BOT_TOKEN' };
 async function cmdSetup(positional, flags) {
     const [sub, value] = positional;
     if (!sub)
@@ -86,10 +73,8 @@ async function cmdSetup(positional, flags) {
         const env = readDotenv(CONFIG_ENV_FILE);
         env[TOKEN_KEYS[sub]] = trimmed;
         writeDotenv(CONFIG_ENV_FILE, env);
-        const human = identity
-            ? `saved ${TOKEN_KEYS[sub]} (verified as ${identity}) to ${CONFIG_ENV_FILE} (chmod 0600)`
-            : `saved ${TOKEN_KEYS[sub]} to ${CONFIG_ENV_FILE} (chmod 0600)`;
-        emitResult(flags, human, { ok: true, saved: TOKEN_KEYS[sub], verified_as: identity ?? null });
+        const human = `saved ${TOKEN_KEYS[sub]}${identity ? ` (verified as ${identity})` : ''} to ${CONFIG_ENV_FILE} (chmod 0600)`;
+        emit(flags, human, { ok: true, saved: TOKEN_KEYS[sub], verified_as: identity ?? null });
         return;
     }
     if (sub === 'clear') {
@@ -104,7 +89,7 @@ async function cmdSetup(positional, flags) {
         else
             throw new Error(`metro setup clear <telegram|discord|all> — got '${target}'`);
         writeDotenv(CONFIG_ENV_FILE, env);
-        emitResult(flags, `cleared ${target === 'all' ? 'all metro tokens' : TOKEN_KEYS[target]}`, { ok: true, cleared: target });
+        emit(flags, `cleared ${target === 'all' ? 'all metro tokens' : TOKEN_KEYS[target]}`, { ok: true, cleared: target });
         return;
     }
     throw new Error(`unknown setup subcommand '${sub}' (try: telegram, discord, clear)`);
@@ -117,57 +102,43 @@ async function cmdSetupStatus(flags) {
         process.stdout.write(JSON.stringify({
             version: pkg.version,
             config_env_file: CONFIG_ENV_FILE,
-            tokens: {
-                telegram: { set: !!tg, masked: maskToken(tg) },
-                discord: { set: !!dc, masked: maskToken(dc) },
-            },
+            tokens: { telegram: { set: !!tg, masked: maskToken(tg) }, discord: { set: !!dc, masked: maskToken(dc) } },
         }) + '\n');
         return;
     }
-    process.stdout.write(`metro ${pkg.version}\n\n` +
-        `config:  ${CONFIG_ENV_FILE}${existsSync(CONFIG_ENV_FILE) ? '' : ' (not yet written)'}\n\n` +
+    const cfgState = existsSync(CONFIG_ENV_FILE) ? '' : ' (not yet written)';
+    process.stdout.write(`metro ${pkg.version}\n\nconfig:  ${CONFIG_ENV_FILE}${cfgState}\n\n` +
         `  TELEGRAM_BOT_TOKEN  ${tg ? `set (${maskToken(tg)})` : 'not set'}\n` +
         `  DISCORD_BOT_TOKEN   ${dc ? `set (${maskToken(dc)})` : 'not set'}\n\n`);
-    if (!tg && !dc) {
-        process.stdout.write('Get started:\n' +
-            '  1. metro setup telegram <token>    # https://t.me/BotFather\n' +
-            '     metro setup discord <token>     # https://discord.com/developers/applications\n' +
-            '  2. metro doctor                    # verify\n' +
-            '  3. metro                           # run the orchestrator\n');
-    }
-    else {
-        process.stdout.write('Run `metro` to start the orchestrator, or `metro doctor` to verify.\n');
-    }
+    process.stdout.write(!tg && !dc
+        ? 'Get started:\n  1. metro setup telegram <token>   # https://t.me/BotFather\n     metro setup discord <token>     # https://discord.com/developers/applications\n  2. metro doctor\n  3. metro\n'
+        : 'Run `metro` to start the orchestrator, or `metro doctor` to verify.\n');
 }
 async function cmdDoctor(flags) {
     loadMetroEnv();
-    const checks = [];
     const cfg = configuredPlatforms();
-    checks.push({
-        name: 'tokens',
-        ok: cfg.telegram || cfg.discord,
-        detail: cfg.telegram || cfg.discord
-            ? `loaded from ${existsSync(CONFIG_ENV_FILE) ? CONFIG_ENV_FILE : 'process env'}`
-            : 'no platform configured — run `metro setup telegram|discord <token>`',
-    });
-    for (const [platform, getMe] of [['telegram', telegram.getMe], ['discord', discord.getMe]]) {
-        if (!cfg[platform]) {
-            checks.push({ name: platform, ok: null, detail: 'not configured' });
+    const checks = [{
+            name: 'tokens',
+            ok: cfg.telegram || cfg.discord,
+            detail: cfg.telegram || cfg.discord ? `loaded from ${existsSync(CONFIG_ENV_FILE) ? CONFIG_ENV_FILE : 'process env'}` : 'no platform configured — run `metro setup telegram|discord <token>`',
+        }];
+    for (const [p, getMe] of [['telegram', telegram.getMe], ['discord', discord.getMe]]) {
+        if (!cfg[p]) {
+            checks.push({ name: p, ok: null, detail: 'not configured' });
             continue;
         }
         try {
             const me = await getMe();
-            checks.push({ name: platform, ok: true, detail: `getMe → ${platform === 'telegram' ? '@' : ''}${me.username}` });
+            checks.push({ name: p, ok: true, detail: `getMe → ${p === 'telegram' ? '@' : ''}${me.username}` });
         }
         catch (err) {
-            checks.push({ name: platform, ok: false, detail: errMsg(err) });
+            checks.push({ name: p, ok: false, detail: errMsg(err) });
         }
     }
     const lockFile = join(STATE_DIR, '.tail-lock');
-    if (!existsSync(lockFile)) {
+    if (!existsSync(lockFile))
         checks.push({ name: 'orchestrator', ok: null, detail: 'not running' });
-    }
-    else {
+    else
         try {
             const pid = Number(readFileSync(lockFile, 'utf8').trim());
             if (!Number.isInteger(pid) || pid <= 0)
@@ -178,16 +149,12 @@ async function cmdDoctor(flags) {
         catch {
             checks.push({ name: 'orchestrator', ok: null, detail: 'stale lockfile (will auto-reclaim on next start)' });
         }
-    }
-    if (isJson(flags)) {
+    if (isJson(flags))
         process.stdout.write(JSON.stringify({ checks }) + '\n');
-    }
     else {
         process.stdout.write('metro doctor\n\n');
-        for (const c of checks) {
-            const icon = c.ok === true ? '✓' : c.ok === false ? '✗' : '–';
-            process.stdout.write(`  ${icon} ${c.name.padEnd(15)} ${c.detail}\n`);
-        }
+        for (const c of checks)
+            process.stdout.write(`  ${c.ok === true ? '✓' : c.ok === false ? '✗' : '–'} ${c.name.padEnd(15)} ${c.detail}\n`);
         process.stdout.write('\n');
     }
     if (checks.some(c => c.ok === false))
@@ -198,28 +165,23 @@ async function cmdUpdate(flags) {
     const res = await fetch('https://registry.npmjs.org/@stage-labs/metro', { signal: AbortSignal.timeout(15_000) });
     if (!res.ok)
         throw new Error(`npm registry: ${res.status}`);
-    const data = (await res.json());
-    const latest = data['dist-tags']?.[tag];
+    const latest = (await res.json())['dist-tags']?.[tag];
     if (!latest)
         throw new Error(`no '${tag}' dist-tag for @stage-labs/metro`);
-    if (latest === pkg.version) {
-        emitResult(flags, `already on ${pkg.version} (latest ${tag})`, { ok: true, current: pkg.version, latest, upgraded: false });
-        return;
-    }
+    if (latest === pkg.version)
+        return emit(flags, `already on ${pkg.version} (latest ${tag})`, { ok: true, current: pkg.version, latest, upgraded: false });
     const argv1 = process.argv[1] ?? '';
     const spec = `@stage-labs/metro@${tag}`;
     const argv = argv1.includes('/.bun/') || argv1.includes('\\bun\\') ? ['bun', 'add', '-g', spec]
         : argv1.includes('/pnpm/') || argv1.includes('\\pnpm\\') ? ['pnpm', 'add', '-g', spec]
             : ['npm', 'install', '-g', spec];
-    if (isJson(flags)) {
+    if (isJson(flags))
         process.stdout.write(JSON.stringify({ ok: true, current: pkg.version, latest, command: argv.join(' ') }) + '\n');
-    }
-    else {
+    else
         process.stdout.write(`metro ${pkg.version} → ${latest}\n$ ${argv.join(' ')}\n`);
-    }
     await new Promise((resolve, reject) => {
         const child = spawn(argv[0], argv.slice(1), { stdio: isJson(flags) ? 'ignore' : 'inherit' });
-        child.on('exit', code => (code === 0 ? resolve() : reject(new Error(`${argv[0]} exited ${code}`))));
+        child.on('exit', code => code === 0 ? resolve() : reject(new Error(`${argv[0]} exited ${code}`)));
         child.on('error', reject);
     });
 }
@@ -230,15 +192,10 @@ const COMMANDS = {
 };
 async function main() {
     const cmd = process.argv[2];
-    if (cmd === '--version' || cmd === '-v') {
-        process.stdout.write(`${pkg.version}\n`);
-        return;
-    }
-    if (cmd === '--help' || cmd === '-h') {
-        process.stdout.write(USAGE);
-        return;
-    }
-    // Bare `metro` runs the orchestrator (the daemon's the default).
+    if (cmd === '--version' || cmd === '-v')
+        return void process.stdout.write(`${pkg.version}\n`);
+    if (cmd === '--help' || cmd === '-h')
+        return void process.stdout.write(USAGE);
     if (!cmd) {
         await import('./orchestrator.js');
         return;
@@ -254,12 +211,10 @@ async function main() {
     }
     catch (err) {
         const code = err.code;
-        if (isJson(flags)) {
+        if (isJson(flags))
             process.stdout.write(JSON.stringify({ ok: false, error: errMsg(err), code: code ?? 1 }) + '\n');
-        }
-        else {
+        else
             process.stderr.write(`error: ${errMsg(err)}\n`);
-        }
         process.exit(typeof code === 'number' ? code : 1);
     }
 }

package/dist/{lib → helpers}/scope-cache.js

@@ -1,16 +1,4 @@
-// Per-machine cache of `scope_key → { agent thread ids, last-used }`.
-// Lets orchestrator restarts rejoin the same agent conversation in the
-// same Discord thread instead of starting from scratch. JSON file at
-// $STATE_DIR/scopes.json.
-//
-// One Discord thread can have up to one session per agent kind — when a
-// user explicitly switches via "with claude" / "with codex", a fresh
-// session is allocated for the new kind and stored alongside.
-//
-// Scope keys are platform-prefixed so the same store handles Discord and
-// Telegram without collisions:
-//   discord:<thread_channel_id>
-//   telegram:<chat_id>:<topic_id>
+/** Per-machine scope→{thread ids,last-used} cache. Keys: `discord:<id>` / `telegram:<chat>:<topic>`. */
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { errMsg, log } from '../log.js';
@@ -72,14 +60,6 @@ export function setLastSeen(scopeKey, messageId) {
 export function listScopes() {
     return Object.entries(read()).map(([scopeKey, entry]) => ({ scopeKey, entry }));
 }
-export function discordScopeKey(threadChannelId) {
-    return `discord:${threadChannelId}`;
-}
-export function discordChannelFromScopeKey(scopeKey) {
-    return scopeKey.startsWith('discord:') ? scopeKey.slice('discord:'.length) : null;
-}
-// Telegram scope: chat + optional forum-topic id. Use a sentinel ('main')
-// for non-topic chats so the key shape stays predictable.
-export function telegramScopeKey(chatId, topicId) {
-    return `telegram:${chatId}:${topicId ?? 'main'}`;
-}
+export const discordScopeKey = (threadChannelId) => `discord:${threadChannelId}`;
+export const discordChannelFromScopeKey = (scopeKey) => scopeKey.startsWith('discord:') ? scopeKey.slice('discord:'.length) : null;
+export const telegramScopeKey = (chatId, topicId) => `telegram:${chatId}:${topicId ?? 'main'}`;