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

package/dist/cli.js

@@ -1,73 +1,32 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
-import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { existsSync, readFileSync } from 'node:fs';
+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 { buildSendBody, tg } from './channels/telegram.js';
-import { parseAddress } from './lib/address.js';
 import { readDotenv, writeDotenv } from './lib/dotenv.js';
-import { errMsg, log } from './log.js';
-import { CONFIG_ENV_FILE, configuredPlatforms, loadMetroEnv, STATE_DIR, skillDir, } from './paths.js';
-// ---------------- USAGE ----------------------------------------------------
-const USAGE = `metro — Telegram + Discord bridge for your agent
+import { errMsg } from './log.js';
+import { CONFIG_ENV_FILE, configuredPlatforms, loadMetroEnv, STATE_DIR } from './paths.js';
+const USAGE = `metro — Telegram + Discord bridge for your Claude Code / Codex agent
 
 Usage:
-  metro                                       Inbound stream (long-running; run in the background).
-  metro setup […]                             Manage tokens and the agent skill (see below).
-  metro doctor                                Health check across tokens, gateways, and skills.
-  metro reply    --to=<addr> [--text=<t>]     Quote-reply, threading under the original. Clears 👀.
-  metro react    --to=<addr> --emoji=<e>      Set or clear ('') a reaction.
-  metro edit     --to=<addr> [--text=<t>]     Edit a message the bot previously sent.
-  metro send     --to=<addr> [--text=<t>]     Send a proactive message (no reply context).
-                                                <addr> is channel-only: <platform>:<chat_id> (no /message_id).
-  metro download --to=<addr> [--out=<dir>]    Download image attachments to disk.
-  metro fetch    --to=<addr> [--limit=N]      Recent-message lookback (Discord only).
-  metro update                                Upgrade in place (npm/bun/pnpm auto-detected).
-
-setup verbs:
-  metro setup                                 Status: tokens, skills, what's next.
-  metro setup telegram <token>                Save TELEGRAM_BOT_TOKEN (validated via getMe; --no-validate skips).
-  metro setup discord <token>                 Save DISCORD_BOT_TOKEN (validated via getMe; --no-validate skips).
+  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 clear [telegram|discord|all]    Remove tokens.
-  metro setup skill [--project] [--clear]     Install (or remove) the agent skill.
-
-Address format:
-  telegram:<chat_id>/<message_id>      e.g. telegram:-100123456789/4567
-  discord:<channel_id>/<message_id>    e.g. discord:1234567890/9876543210
-  discord:<channel_id>                 fetch only (no message id)
-
-Common flags:
-  --json              machine-parseable output (single JSON line/array)
-  --version, -v       print the metro version
-  --help, -h          print this help
-
-reply / edit Telegram extras:
-  --parse-mode=HTML|MarkdownV2  --no-link-preview  --buttons-json='[[{"text":"…","url":"…"}]]'
+  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.
 
 Exit codes:
-  0  success
-  1  usage error (bad flags, unknown subcommand)
-  2  configuration error (no tokens — run \`metro setup\`)
-  3  upstream error (rate limit, auth, network — retry once, then surface)
-
-Codex push (opt-in):
-  Set METRO_CODEX_RC to the codex app-server URL — metro will push each
-  inbound into the agent's history via JSON-RPC \`turn/start\`, the Codex
-  equivalent of Claude Code's Monitor.
-
-  Three terminals share the same URL (codex 0.130's TUI --remote only
-  accepts ws://):
-
-    codex app-server --listen ws://127.0.0.1:8421       # daemon
-    METRO_CODEX_RC=ws://127.0.0.1:8421 metro            # bridge
-    codex --remote ws://127.0.0.1:8421                  # TUI
+  0 success · 1 usage · 2 config (no tokens — run \`metro setup\`) · 3 upstream
 `;
-function exitErr(message, code) {
-    return Object.assign(new Error(message), { code });
-}
+function exitErr(msg, code) { return Object.assign(new Error(msg), { code }); }
 function parseArgs(argv) {
     const positional = [];
     const flags = {};
@@ -93,91 +52,17 @@ function parseArgs(argv) {
     }
     return { positional, flags };
 }
-const isJson = (flags) => flags.json === true;
-function emitResult(flags, human, structured) {
-    process.stdout.write(isJson(flags) ? JSON.stringify(structured) + '\n' : human + '\n');
-}
-function resolveAddr(flags, requireMessage) {
-    const addr = parseAddress(String(flags.to), requireMessage);
-    if (!configuredPlatforms()[addr.platform]) {
-        throw exitErr(`platform '${addr.platform}' is not configured (missing token)`, 2);
-    }
-    return addr;
-}
-function tgMessageId(addr) {
-    const n = Number(addr.messageId);
-    if (!Number.isInteger(n))
-        throw new Error(`telegram message_id must be an integer: ${addr.messageId}`);
-    return n;
-}
-// Tell tail.ts to stop refreshing the typing indicator (the agent has replied).
-function signalReplyComplete(platform, chat) {
-    const dir = join(STATE_DIR, '.typing-stop');
-    try {
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(join(dir, `${platform}_${chat}`), '');
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'typing stop-signal write failed');
-    }
-}
-async function clearReaction(addr) {
-    if (addr.platform === 'telegram') {
-        await tg('setMessageReaction', { chat_id: addr.chat, message_id: tgMessageId(addr), reaction: [] });
-    }
-    else {
-        await discord.setReaction(addr.chat, addr.messageId, '');
-    }
-}
-async function readStdinText() {
-    if (process.stdin.isTTY)
-        return '';
-    const chunks = [];
-    for await (const c of process.stdin)
-        chunks.push(c);
-    return Buffer.concat(chunks).toString('utf8');
-}
-async function resolveText(flags) {
-    if (typeof flags.text === 'string')
-        return flags.text;
-    const stdin = (await readStdinText()).replace(/\n$/, '');
-    if (!stdin)
-        throw new Error('--text is required (or pipe text on stdin)');
-    return stdin;
-}
-function readTelegramOpts(flags) {
-    const opts = {};
-    if (flags['parse-mode']) {
-        const v = String(flags['parse-mode']);
-        if (v !== 'HTML' && v !== 'MarkdownV2')
-            throw new Error("--parse-mode must be 'HTML' or 'MarkdownV2'");
-        opts.parseMode = v;
-    }
-    if (flags['no-link-preview'])
-        opts.disableLinkPreview = true;
-    if (flags['buttons-json'])
-        opts.buttons = JSON.parse(String(flags['buttons-json']));
-    return opts;
-}
-function maskToken(token) {
-    if (!token)
+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 (token.length <= 8)
+    if (t.length <= 8)
         return '••••';
-    return `${token.slice(0, 6)}…${token.slice(-2)}`;
+    return `${t.slice(0, 6)}…${t.slice(-2)}`;
 }
-const EXT_FROM_MIME = {
-    'image/png': 'png',
-    'image/jpeg': 'jpg',
-    'image/gif': 'gif',
-    'image/webp': 'webp',
-};
-// Path to the SKILL.md bundled with the npm package. dist/cli.js → ../skills/metro/SKILL.md.
-const BUNDLED_SKILL = join(dirname(fileURLToPath(import.meta.url)), '..', 'skills', 'metro', 'SKILL.md');
-const SKILL_RUNTIMES = ['claude-code', 'codex'];
-const SKILL_SCOPES = ['user', 'project'];
-const skillFile = (runtime, scope) => join(skillDir(runtime, scope), 'SKILL.md');
-// ---------------- setup ----------------------------------------------------
 const TOKEN_KEYS = { telegram: 'TELEGRAM_BOT_TOKEN', discord: 'DISCORD_BOT_TOKEN' };
 async function cmdSetup(positional, flags) {
     const [sub, value] = positional;
@@ -189,17 +74,13 @@ async function cmdSetup(positional, flags) {
         const trimmed = value.trim();
         let identity;
         if (!flags['no-validate']) {
-            // Validate against the platform before persisting — catches typos /
-            // wrong-token-from-portal / rotated tokens at the earliest moment.
             process.env[TOKEN_KEYS[sub]] = trimmed;
             try {
-                identity = sub === 'telegram'
-                    ? `@${(await telegram.getMe()).username}`
-                    : (await discord.getMe()).username;
+                identity = sub === 'telegram' ? `@${(await telegram.getMe()).username}` : (await discord.getMe()).username;
             }
             catch (err) {
                 delete process.env[TOKEN_KEYS[sub]];
-                throw exitErr(`token rejected by ${sub}: ${errMsg(err)} (re-run with --no-validate to save anyway)`, 3);
+                throw exitErr(`token rejected by ${sub}: ${errMsg(err)} (use --no-validate to save anyway)`, 3);
             }
         }
         const env = readDotenv(CONFIG_ENV_FILE);
@@ -208,7 +89,7 @@ async function cmdSetup(positional, flags) {
         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], path: CONFIG_ENV_FILE, verified_as: identity ?? null });
+        emitResult(flags, human, { ok: true, saved: TOKEN_KEYS[sub], verified_as: identity ?? null });
         return;
     }
     if (sub === 'clear') {
@@ -218,30 +99,20 @@ async function cmdSetup(positional, flags) {
             delete env.TELEGRAM_BOT_TOKEN;
             delete env.DISCORD_BOT_TOKEN;
         }
-        else if (target === 'telegram' || target === 'discord') {
+        else if (target === 'telegram' || target === 'discord')
             delete env[TOKEN_KEYS[target]];
-        }
-        else {
+        else
             throw new Error(`metro setup clear <telegram|discord|all> — got '${target}'`);
-        }
         writeDotenv(CONFIG_ENV_FILE, env);
-        const human = `cleared ${target === 'all' ? 'all metro tokens' : TOKEN_KEYS[target]} from ${CONFIG_ENV_FILE}`;
-        emitResult(flags, human, { ok: true, cleared: target, path: CONFIG_ENV_FILE });
+        emitResult(flags, `cleared ${target === 'all' ? 'all metro tokens' : TOKEN_KEYS[target]}`, { ok: true, cleared: target });
         return;
     }
-    if (sub === 'skill')
-        return cmdSetupSkill(flags);
-    throw new Error(`unknown setup subcommand '${sub}' (try: telegram, discord, clear, skill)`);
-}
-function readSkillState() {
-    return Object.fromEntries(SKILL_RUNTIMES.map(r => [r, Object.fromEntries(SKILL_SCOPES.map(s => [s, existsSync(skillFile(r, s))]))]));
+    throw new Error(`unknown setup subcommand '${sub}' (try: telegram, discord, clear)`);
 }
 async function cmdSetupStatus(flags) {
     loadMetroEnv();
     const tg = process.env.TELEGRAM_BOT_TOKEN ?? '';
     const dc = process.env.DISCORD_BOT_TOKEN ?? '';
-    const skills = readSkillState();
-    const anySkill = SKILL_RUNTIMES.some(r => SKILL_SCOPES.some(s => skills[r][s]));
     if (isJson(flags)) {
         process.stdout.write(JSON.stringify({
             version: pkg.version,
@@ -250,64 +121,27 @@ async function cmdSetupStatus(flags) {
                 telegram: { set: !!tg, masked: maskToken(tg) },
                 discord: { set: !!dc, masked: maskToken(dc) },
             },
-            skills,
         }) + '\n');
         return;
     }
-    const fmtSkill = (s) => {
-        const set = SKILL_SCOPES.filter(k => s[k]);
-        return set.length ? `installed (${set.join(' + ')})` : 'not installed';
-    };
     process.stdout.write(`metro ${pkg.version}\n\n` +
         `config:  ${CONFIG_ENV_FILE}${existsSync(CONFIG_ENV_FILE) ? '' : ' (not yet written)'}\n\n` +
         `  TELEGRAM_BOT_TOKEN  ${tg ? `set (${maskToken(tg)})` : 'not set'}\n` +
-        `  DISCORD_BOT_TOKEN   ${dc ? `set (${maskToken(dc)})` : 'not set'}\n\n` +
-        'Skills:\n' +
-        `  claude-code  ${fmtSkill(skills['claude-code'])}\n` +
-        `  codex        ${fmtSkill(skills.codex)}\n\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 setup skill                # auto-onboard your agent (writes to both runtimes)\n' +
-            '  3. metro doctor                     # verify everything works\n' +
-            '  4. metro                            # start the inbound stream\n');
-    }
-    else if (!anySkill) {
-        process.stdout.write('Next: `metro setup skill` to auto-onboard your agent. Then `metro doctor`, then `metro`.\n');
+            '  2. metro doctor                    # verify\n' +
+            '  3. metro                           # run the orchestrator\n');
     }
     else {
-        process.stdout.write('Run `metro` to start the inbound stream, or `metro doctor` to verify.\n');
+        process.stdout.write('Run `metro` to start the orchestrator, or `metro doctor` to verify.\n');
     }
 }
-async function cmdSetupSkill(flags) {
-    const scope = flags.project ? 'project' : 'user';
-    if (flags.clear) {
-        const removed = [];
-        for (const runtime of SKILL_RUNTIMES) {
-            const dir = skillDir(runtime, scope);
-            if (existsSync(dir)) {
-                rmSync(dir, { recursive: true, force: true });
-                removed.push(dir);
-            }
-        }
-        emitResult(flags, removed.length ? `removed:\n  ${removed.join('\n  ')}` : '(no skills installed at this scope)', { ok: true, cleared: removed });
-        return;
-    }
-    if (!existsSync(BUNDLED_SKILL))
-        throw new Error(`bundled SKILL.md missing at ${BUNDLED_SKILL} (broken install?)`);
-    const written = SKILL_RUNTIMES.map(r => {
-        const dest = skillFile(r, scope);
-        mkdirSync(dirname(dest), { recursive: true });
-        copyFileSync(BUNDLED_SKILL, dest);
-        return dest;
-    });
-    emitResult(flags, `wrote skill (${scope}) to:\n  ${written.join('\n  ')}\n\nThe agent will pick it up on its next session start.`, { ok: true, scope, paths: written });
-}
 async function cmdDoctor(flags) {
     loadMetroEnv();
     const checks = [];
-    // tokens
     const cfg = configuredPlatforms();
     checks.push({
         name: 'tokens',
@@ -316,7 +150,6 @@ async function cmdDoctor(flags) {
             ? `loaded from ${existsSync(CONFIG_ENV_FILE) ? CONFIG_ENV_FILE : 'process env'}`
             : 'no platform configured — run `metro setup telegram|discord <token>`',
     });
-    // gateway / API healthcheck per configured platform
     for (const [platform, getMe] of [['telegram', telegram.getMe], ['discord', discord.getMe]]) {
         if (!cfg[platform]) {
             checks.push({ name: platform, ok: null, detail: 'not configured' });
@@ -330,11 +163,9 @@ async function cmdDoctor(flags) {
             checks.push({ name: platform, ok: false, detail: errMsg(err) });
         }
     }
-    // tail process state. A stale lockfile (process gone) is informational —
-    // the next `metro` start auto-reclaims it, so we don't fail the doctor on it.
     const lockFile = join(STATE_DIR, '.tail-lock');
     if (!existsSync(lockFile)) {
-        checks.push({ name: 'stream', ok: null, detail: 'not running' });
+        checks.push({ name: 'orchestrator', ok: null, detail: 'not running' });
     }
     else {
         try {
@@ -342,26 +173,11 @@ async function cmdDoctor(flags) {
             if (!Number.isInteger(pid) || pid <= 0)
                 throw new Error('invalid pid');
             process.kill(pid, 0);
-            checks.push({ name: 'stream', ok: true, detail: `running (pid ${pid})` });
+            checks.push({ name: 'orchestrator', ok: true, detail: `running (pid ${pid})` });
         }
         catch {
-            checks.push({ name: 'stream', ok: null, detail: 'stale lockfile (will auto-reclaim on next start)' });
-        }
-    }
-    // skill install + freshness vs bundled
-    for (const runtime of SKILL_RUNTIMES) {
-        const present = SKILL_SCOPES.filter(s => existsSync(skillFile(runtime, s)));
-        if (present.length === 0) {
-            checks.push({ name: `skill: ${runtime}`, ok: null, detail: 'not installed — run `metro setup skill` (writes both runtimes)' });
-            continue;
+            checks.push({ name: 'orchestrator', ok: null, detail: 'stale lockfile (will auto-reclaim on next start)' });
         }
-        const bundled = existsSync(BUNDLED_SKILL) ? readFileSync(BUNDLED_SKILL) : null;
-        const stale = bundled
-            ? present.filter(s => !readFileSync(skillFile(runtime, s)).equals(bundled))
-            : [];
-        checks.push(stale.length === 0
-            ? { name: `skill: ${runtime}`, ok: true, detail: present.join(' + ') }
-            : { name: `skill: ${runtime}`, ok: false, detail: `stale at ${stale.join(' + ')} — re-run \`metro setup skill${stale.includes('project') ? ' --project' : ''}\`` });
     }
     if (isJson(flags)) {
         process.stdout.write(JSON.stringify({ checks }) + '\n');
@@ -370,17 +186,14 @@ async function cmdDoctor(flags) {
         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(20)} ${c.detail}\n`);
+            process.stdout.write(`  ${icon} ${c.name.padEnd(15)} ${c.detail}\n`);
         }
         process.stdout.write('\n');
     }
     if (checks.some(c => c.ok === false))
         throw exitErr('one or more checks failed', 3);
 }
-// ---------------- update ---------------------------------------------------
 async function cmdUpdate(flags) {
-    // While metro is in prerelease, the @beta dist-tag is what we publish.
-    // After GA, swap to 'latest' (or auto-pick from current version's prerelease tag).
     const tag = pkg.version.includes('-') ? 'beta' : 'latest';
     const res = await fetch('https://registry.npmjs.org/@stage-labs/metro', { signal: AbortSignal.timeout(15_000) });
     if (!res.ok)
@@ -399,138 +212,22 @@ async function cmdUpdate(flags) {
         : argv1.includes('/pnpm/') || argv1.includes('\\pnpm\\') ? ['pnpm', 'add', '-g', spec]
             : ['npm', 'install', '-g', spec];
     if (isJson(flags)) {
-        process.stdout.write(JSON.stringify({ ok: true, current: pkg.version, latest, command: argv.join(' '), upgraded: 'pending' }) + '\n');
+        process.stdout.write(JSON.stringify({ ok: true, current: pkg.version, latest, command: argv.join(' ') }) + '\n');
     }
     else {
         process.stdout.write(`metro ${pkg.version} → ${latest}\n$ ${argv.join(' ')}\n`);
     }
-    // Snapshot which skill destinations are installed BEFORE the package
-    // manager replaces our binary — after the spawn, BUNDLED_SKILL on disk
-    // points at the new content (npm install -g overwrites in place), so a
-    // fresh copyFileSync picks it up automatically.
-    const refreshTargets = SKILL_RUNTIMES.flatMap(r => SKILL_SCOPES.filter(s => existsSync(skillFile(r, s))).map(s => skillFile(r, s)));
     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 with code ${code}`))));
+        child.on('exit', code => (code === 0 ? resolve() : reject(new Error(`${argv[0]} exited ${code}`))));
         child.on('error', reject);
     });
-    // Refresh installed skills from the (now-updated) bundled SKILL.md.
-    if (existsSync(BUNDLED_SKILL)) {
-        for (const dest of refreshTargets) {
-            mkdirSync(dirname(dest), { recursive: true });
-            copyFileSync(BUNDLED_SKILL, dest);
-        }
-        if (refreshTargets.length > 0 && !isJson(flags)) {
-            process.stdout.write(`\nrefreshed installed skills:\n  ${refreshTargets.join('\n  ')}\n`);
-        }
-    }
-}
-// ---------------- inbound action commands ----------------------------------
-async function cmdSend(flags) {
-    const addr = resolveAddr(flags, false);
-    const text = await resolveText(flags);
-    const sentMessageId = addr.platform === 'telegram'
-        ? String((await tg('sendMessage', buildSendBody(addr.chat, text, readTelegramOpts(flags)))).message_id)
-        : await discord.sendMessage(addr.chat, text);
-    emitResult(flags, 'sent', { ok: true, platform: addr.platform, to: String(flags.to), sent_message_id: sentMessageId });
-}
-async function cmdReply(flags) {
-    const addr = resolveAddr(flags, true);
-    const text = await resolveText(flags);
-    let sentMessageId;
-    if (addr.platform === 'telegram') {
-        const body = buildSendBody(addr.chat, text, readTelegramOpts(flags));
-        body.reply_parameters = { message_id: tgMessageId(addr), allow_sending_without_reply: true };
-        sentMessageId = String((await tg('sendMessage', body)).message_id);
-    }
-    else {
-        sentMessageId = await discord.replyToMessage(addr.chat, addr.messageId, text);
-    }
-    signalReplyComplete(addr.platform, addr.chat);
-    await clearReaction(addr).catch(err => log.warn({ err: errMsg(err) }, 'clear-reaction failed'));
-    emitResult(flags, 'sent', { ok: true, platform: addr.platform, to: String(flags.to), sent_message_id: sentMessageId });
-}
-async function cmdReact(flags) {
-    const addr = resolveAddr(flags, true);
-    const emoji = typeof flags.emoji === 'string' ? flags.emoji : '';
-    if (addr.platform === 'telegram') {
-        await tg('setMessageReaction', { chat_id: addr.chat, message_id: tgMessageId(addr), reaction: emoji ? [{ type: 'emoji', emoji }] : [] });
-    }
-    else {
-        await discord.setReaction(addr.chat, addr.messageId, emoji);
-    }
-    emitResult(flags, emoji ? 'reacted' : 'cleared', { ok: true, to: String(flags.to), emoji, action: emoji ? 'reacted' : 'cleared' });
-}
-async function cmdEdit(flags) {
-    const addr = resolveAddr(flags, true);
-    const text = await resolveText(flags);
-    if (addr.platform === 'telegram') {
-        const body = buildSendBody(addr.chat, text, readTelegramOpts(flags));
-        body.message_id = tgMessageId(addr);
-        await tg('editMessageText', body);
-    }
-    else {
-        await discord.editMessage(addr.chat, addr.messageId, text);
-    }
-    emitResult(flags, 'edited', { ok: true, to: String(flags.to) });
-}
-async function cmdDownload(flags) {
-    const addr = resolveAddr(flags, true);
-    const outDir = typeof flags.out === 'string' ? flags.out : join(STATE_DIR, 'attachments');
-    mkdirSync(outDir, { recursive: true });
-    const images = addr.platform === 'telegram'
-        ? await Promise.all(telegram.getCachedAttachments(addr.chat, tgMessageId(addr)).map(a => telegram.downloadAttachment(a.file_id, a.mime)))
-        : await discord.fetchAttachments(addr.chat, addr.messageId);
-    if (images.length === 0) {
-        if (isJson(flags))
-            process.stdout.write(JSON.stringify({ ok: true, images: [] }) + '\n');
-        else
-            process.stderr.write('no image attachments found\n');
-        return;
-    }
-    const safeChat = addr.chat.replace(/[^\w-]/g, '_');
-    const safeMsg = (addr.messageId ?? '').replace(/[^\w-]/g, '_');
-    const out = images.map((img, i) => {
-        const ext = EXT_FROM_MIME[img.mime] ?? 'bin';
-        const path = join(outDir, `${addr.platform}_${safeChat}_${safeMsg}_${i}.${ext}`);
-        writeFileSync(path, Buffer.from(img.data, 'base64'));
-        return { path, mime: img.mime };
-    });
-    if (isJson(flags))
-        process.stdout.write(JSON.stringify({ ok: true, images: out }) + '\n');
-    else
-        process.stdout.write(out.map(o => o.path).join('\n') + '\n');
-}
-async function cmdFetch(flags) {
-    const addr = resolveAddr(flags, false);
-    if (addr.platform !== 'discord') {
-        throw new Error('metro fetch is Discord-only — Telegram has no recent-messages API for bots');
-    }
-    const limit = Number(flags.limit ?? 10);
-    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
-        throw new Error('--limit must be an integer 1–100');
-    const msgs = await discord.fetchRecentMessages(addr.chat, limit);
-    if (isJson(flags)) {
-        process.stdout.write(JSON.stringify(msgs) + '\n');
-    }
-    else {
-        const text = msgs.map(m => `[message_id=${m.message_id} ${m.timestamp}] ${m.author}: ${m.text}`).join('\n');
-        process.stdout.write((text || '(channel is empty)') + '\n');
-    }
 }
-// ---------------- main dispatcher ------------------------------------------
 const COMMANDS = {
-    setup: (positional, flags) => cmdSetup(positional, flags),
-    doctor: (_, flags) => cmdDoctor(flags),
-    update: (_, flags) => cmdUpdate(flags),
-    reply: (_, flags) => cmdReply(flags),
-    react: (_, flags) => cmdReact(flags),
-    edit: (_, flags) => cmdEdit(flags),
-    send: (_, flags) => cmdSend(flags),
-    download: (_, flags) => cmdDownload(flags),
-    fetch: (_, flags) => cmdFetch(flags),
+    setup: cmdSetup,
+    doctor: (_, f) => cmdDoctor(f),
+    update: (_, f) => cmdUpdate(f),
 };
-const NEEDS_ENV = new Set(['doctor', 'reply', 'react', 'edit', 'send', 'download', 'fetch']);
 async function main() {
     const cmd = process.argv[2];
     if (cmd === '--version' || cmd === '-v') {
@@ -541,11 +238,9 @@ async function main() {
         process.stdout.write(USAGE);
         return;
     }
-    // Bare `metro` runs the inbound stream — the primary action; one-shot
-    // subcommands are the secondary surface (matches claude / redis-server /
-    // nginx convention where the daemon's the default).
+    // Bare `metro` runs the orchestrator (the daemon's the default).
     if (!cmd) {
-        await import('./tail.js');
+        await import('./orchestrator.js');
         return;
     }
     const handler = COMMANDS[cmd];
@@ -554,8 +249,6 @@ async function main() {
         process.exit(1);
     }
     const { positional, flags } = parseArgs(process.argv.slice(3));
-    if (NEEDS_ENV.has(cmd))
-        loadMetroEnv();
     try {
         await handler(positional, flags);
     }

package/dist/lib/scope-cache.js

@@ -0,0 +1,85 @@
+// 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>
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { errMsg, log } from '../log.js';
+import { STATE_DIR } from '../paths.js';
+const cacheFile = join(STATE_DIR, 'scopes.json');
+function read() {
+    if (!existsSync(cacheFile))
+        return {};
+    try {
+        return JSON.parse(readFileSync(cacheFile, 'utf8'));
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err), path: cacheFile }, 'scope cache read failed; treating as empty');
+        return {};
+    }
+}
+function write(cache) {
+    try {
+        writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err), path: cacheFile }, 'scope cache write failed');
+    }
+}
+function ensure(cache, scopeKey) {
+    if (!cache[scopeKey])
+        cache[scopeKey] = { createdAt: new Date().toISOString(), agents: {} };
+    if (!cache[scopeKey].agents)
+        cache[scopeKey].agents = {};
+    return cache[scopeKey];
+}
+export function getAgentThread(scopeKey, kind) {
+    return read()[scopeKey]?.agents?.[kind];
+}
+export function setAgentThread(scopeKey, kind, threadId) {
+    const cache = read();
+    const entry = ensure(cache, scopeKey);
+    entry.agents[kind] = threadId;
+    entry.lastAgent = kind;
+    write(cache);
+}
+export function getLastAgent(scopeKey) {
+    return read()[scopeKey]?.lastAgent;
+}
+export function setLastAgent(scopeKey, kind) {
+    const cache = read();
+    if (!cache[scopeKey])
+        return;
+    cache[scopeKey].lastAgent = kind;
+    write(cache);
+}
+export function setLastSeen(scopeKey, messageId) {
+    const cache = read();
+    if (!cache[scopeKey])
+        return;
+    cache[scopeKey].lastSeenMessageId = messageId;
+    write(cache);
+}
+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'}`;
+}