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

package/dist/dispatcher.js

@@ -0,0 +1,203 @@
+/** Dispatcher: owns chat stations + agent stations; routes inbounds (suffix "with X" overrides line default). */
+import { copyFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import pkg from '../package.json' with { type: 'json' };
+import { ClaudeStation } from './stations/claude/index.js';
+import { CodexStation } from './stations/codex/index.js';
+import { DiscordStation } from './stations/discord/index.js';
+import { GitHubStation } from './stations/github/index.js';
+import { TelegramStation } from './stations/telegram/index.js';
+import { getAgentThread, getLastAgent, linesForStation, setAgentThread, setLastAgent, setLastSeen, setName, } from './helpers/scope-cache.js';
+import { StreamScheduler } from './helpers/streaming.js';
+import { runTurn, triggerStop } from './helpers/turn.js';
+import { errMsg, log } from './log.js';
+import { acquireLock, configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
+loadMetroEnv();
+const platforms = configuredPlatforms();
+requireConfiguredPlatform(platforms);
+acquireLock(join(STATE_DIR, '.tail-lock'));
+/** Install AGENTS.md skill into state dir so the agent has a stable path to consult. Refreshed every start so upgrades land. */
+const AGENTS_MD = join(STATE_DIR, 'AGENTS.md');
+try {
+    copyFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'docs', 'agents.md'), AGENTS_MD);
+}
+catch (err) {
+    log.warn({ err: errMsg(err) }, 'failed to install agent skill');
+}
+const bootstrapped = new Set();
+const codex = new CodexStation(pkg.version);
+const claude = new ClaudeStation();
+const discord = new DiscordStation();
+const telegram = new TelegramStation();
+const github = new GitHubStation();
+const available = {};
+const scheduler = new StreamScheduler();
+async function startAgents() {
+    await Promise.allSettled([
+        codex.start().then(() => { available.codex = codex; }).catch(err => log.warn({ err: errMsg(err) }, 'codex unavailable')),
+        claude.start().then(() => { available.claude = claude; }).catch(err => log.warn({ err: errMsg(err) }, 'claude unavailable')),
+    ]);
+    if (!Object.keys(available).length) {
+        log.fatal('no agents available');
+        process.exit(2);
+    }
+    log.info({ agents: Object.keys(available) }, 'agents ready');
+}
+const SUFFIX_RE = /(?:^|\s)with\s+(claude|codex)\s*$/i;
+function parseAgentSuffix(text) {
+    const t = text.trimEnd();
+    const m = SUFFIX_RE.exec(t);
+    return m ? { kind: m[1].toLowerCase(), cleanText: t.slice(0, m.index).trimEnd() } : { kind: null, cleanText: text };
+}
+function pickAgent(line, req) {
+    if (req)
+        return available[req] ? { kind: req } : { error: `${req} is not available on this metro instance` };
+    const last = line ? getLastAgent(line) : undefined;
+    if (last && available[last])
+        return { kind: last };
+    if (available.claude)
+        return { kind: 'claude' };
+    if (available.codex)
+        return { kind: 'codex' };
+    return { error: 'no agents available' };
+}
+/** Resolve agent session for `line`, allocating if new, then run the turn. */
+async function dispatch(line, text, attachments, kind, messageId, adapter, lineName) {
+    setLastSeen(line, messageId);
+    let threadId = getAgentThread(line, kind);
+    if (threadId)
+        setLastAgent(line, kind);
+    else {
+        threadId = await available[kind].createThread();
+        setAgentThread(line, kind, threadId);
+        log.info({ line, agent: kind, thread: threadId }, 'allocated agent session');
+    }
+    if (lineName)
+        setName(line, lineName);
+    await runTurn(available[kind], threadId, withContext(line, text), attachments, adapter, scheduler);
+}
+/** Tell the agent its line + the one rule: write normally to reply here, only use `metro send` for OTHER lines. */
+const withContext = (line, text) => `[metro: this turn is on ${line}. To reply HERE just write text — metro streams it back automatically; do NOT use \`metro send\` for this line. Use \`metro send <other-line> <text>\` only to post to a DIFFERENT conversation (list with \`metro lines\`). Full guide: ${AGENTS_MD}]\n\n${text}`;
+const adapterFor = (station, line) => ({
+    send: (t, stopId) => station.send(line, t, { stopId }),
+    edit: async (id, t, stopId) => { await station.edit(line, id, t, { stopId }); },
+});
+/** Dispatch into an existing agent on `m.line`, or (on `@`-mention) allocate a new session, optionally via station-specific bootstrap. */
+async function routeInbound(m, station, bootstrap) {
+    const hasAgent = !!(getAgentThread(m.line, 'codex') ?? getAgentThread(m.line, 'claude'));
+    const { kind: req, cleanText } = parseAgentSuffix(m.text);
+    const postErr = (msg) => station.send(m.line, `⚠️ ${msg}`).then(() => { }).catch(err => log.warn({ err: errMsg(err), station: station.name }, 'error post failed'));
+    if (hasAgent) {
+        const c = pickAgent(m.line, req);
+        return 'error' in c ? postErr(c.error) : dispatch(m.line, cleanText, m.attachments, c.kind, m.messageId, adapterFor(station, m.line), m.lineName);
+    }
+    if (!m.mentionsBot || bootstrapped.has(m.messageId))
+        return;
+    bootstrapped.add(m.messageId);
+    const choice = pickAgent(null, req);
+    if ('error' in choice)
+        return postErr(choice.error);
+    /** Bootstrap creates a new chat-side scope (Discord thread / Telegram topic) — we know its name from `cleanText`. */
+    const line = bootstrap ? await bootstrap(m, cleanText).catch(err => { log.warn({ err: errMsg(err), station: station.name }, 'bootstrap failed'); return null; }) : m.line;
+    if (!line)
+        return;
+    await dispatch(line, cleanText, m.attachments, choice.kind, m.messageId, adapterFor(station, line), bootstrap ? makeThreadName(cleanText) : m.lineName);
+}
+const onDiscordInbound = (m) => {
+    /** DM: the channel IS the conversation, no thread to create. Guild: bootstrap a thread on @-mention. */
+    if (!m.meta.inGuild)
+        return routeInbound(m, discord, null);
+    return routeInbound(m, discord, (m, cleanText) => discord.createThreadFromMessage(m.line, m.messageId, makeThreadName(cleanText)));
+};
+const onTelegramInbound = (m) => {
+    if (!m.meta.isPrivate && !m.meta.inForum)
+        return Promise.resolve();
+    /** Forum General → bootstrap a new topic; private/topic → route into `m.line`. */
+    if (m.meta.inForum && !m.meta.isForumTopic)
+        return routeInbound(m, telegram, telegramTopicBootstrap);
+    return routeInbound(m, telegram, null);
+};
+const telegramTopicBootstrap = async (m, cleanText) => {
+    const topicName = makeThreadName(cleanText);
+    let topicLine;
+    try {
+        topicLine = await telegram.createForumTopic(m.line, topicName);
+    }
+    catch (err) {
+        await telegram.send(m.line, `⚠️ couldn't create topic — bot needs Manage Topics admin permission. (${errMsg(err)})`).catch(() => { });
+        return null;
+    }
+    /** Post a deep link back in General as a reply to the @-mention so it threads visually. */
+    const link = telegram.topicLink(topicLine);
+    if (link)
+        await telegram.send(m.line, `→ [${topicName}](${link})`, { replyTo: m.messageId }).catch(err => log.warn({ err: errMsg(err) }, 'telegram: failed to post topic link in General'));
+    return topicLine;
+};
+const onGithubInbound = (m) => {
+    /** Prepend issue/PR context so the agent has it without us bridging to a different chat. */
+    const header = `**@${m.meta.authorUsername}** on GitHub ${m.meta.isPR ? 'PR' : 'issue'} ${m.meta.repoFullName}#${m.meta.issueNumber} (<${m.meta.url}>):`;
+    return routeInbound({ ...m, text: `${header}\n\n${m.text}` }, github, null);
+};
+/** Strip mention syntax + normalize whitespace; cap at 100 chars (Discord limit). */
+function makeThreadName(rawText) {
+    const cleaned = rawText.replace(/<@!?\d+>|<@&\d+>|<#\d+>|<a?:[^:]+:\d+>|@\w+/g, '').replace(/\s+/g, ' ').trim() || 'metro';
+    return cleaned.length <= 100 ? cleaned : cleaned.slice(0, 99) + '…';
+}
+async function catchupDiscord() {
+    for (const { line, entry } of linesForStation('discord')) {
+        if (!entry.lastSeenMessageId)
+            continue;
+        try {
+            const missed = (await discord.fetchMessagesSince(line, entry.lastSeenMessageId)).filter(m => !m.authorIsBot && m.text);
+            if (!missed.length)
+                continue;
+            log.info({ line, count: missed.length }, 'discord catchup');
+            for (const m of missed)
+                await onDiscordInbound({ station: 'discord', line, messageId: m.messageId, text: m.text, attachments: [], mentionsBot: false, meta: { inGuild: true } });
+        }
+        catch (err) {
+            log.warn({ err: errMsg(err), line }, 'discord catchup skipped');
+        }
+    }
+}
+async function main() {
+    await startAgents();
+    if (platforms.discord) {
+        await discord.start();
+        log.info({ bot: (await discord.getMe()).username }, 'discord ready');
+        discord.onMessage(m => void onDiscordInbound(m).catch(err => log.warn({ err: errMsg(err) }, 'discord inbound failed')));
+        discord.onStop(triggerStop);
+        void catchupDiscord().catch(err => log.warn({ err: errMsg(err) }, 'discord catchup failed'));
+    }
+    if (platforms.telegram) {
+        log.info({ bot: `@${(await telegram.getMe()).username}` }, 'telegram ready');
+        telegram.onMessage(m => void onTelegramInbound(m).catch(err => log.warn({ err: errMsg(err) }, 'telegram inbound failed')));
+        telegram.onStop(triggerStop);
+        await telegram.start();
+    }
+    if (github.isConfigured()) {
+        await github.start();
+        github.onMessage(m => void onGithubInbound(m).catch(err => log.warn({ err: errMsg(err) }, 'github inbound failed')));
+    }
+    log.info('dispatcher ready');
+}
+let shuttingDown = false;
+async function shutdown() {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    log.info('dispatcher shutting down');
+    await Promise.allSettled([available.codex?.stop(), available.claude?.stop()]);
+    if (platforms.discord)
+        await discord.stop().catch(() => { });
+    if (platforms.telegram)
+        await telegram.stop().catch(() => { });
+    await github.stop().catch(() => { });
+    process.exit(0);
+}
+process.stdin.on('end', shutdown);
+process.stdin.on('close', shutdown);
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+await main();

package/dist/helpers/async-queue.js

@@ -0,0 +1,41 @@
+/** Bridge a push-based event source (callbacks) into a pull-based AsyncIterable. */
+export class AsyncQueue {
+    queue = [];
+    resolveNext = null;
+    done = false;
+    error = null;
+    push(item) {
+        if (this.done)
+            return;
+        this.queue.push(item);
+        this.flush();
+    }
+    finish() {
+        if (this.done)
+            return;
+        this.done = true;
+        this.flush();
+    }
+    fail(err) {
+        if (this.done)
+            return;
+        this.error = err;
+        this.done = true;
+        this.flush();
+    }
+    flush() { const r = this.resolveNext; this.resolveNext = null; r?.(); }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.queue.length) {
+                yield this.queue.shift();
+                continue;
+            }
+            if (this.done) {
+                if (this.error)
+                    throw this.error;
+                return;
+            }
+            await new Promise(r => { this.resolveNext = r; });
+        }
+    }
+}

package/dist/helpers/scope-cache.js

@@ -0,0 +1,67 @@
+/** Per-machine Line → {agent threads, last-used} cache. Keys are URI lines (see docs/uri-scheme.md). */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { errMsg, log } from '../log.js';
+import { STATE_DIR } from '../paths.js';
+import { station as stationOf } from '../stations/line.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, line) {
+    if (!cache[line])
+        cache[line] = { createdAt: new Date().toISOString(), agents: {} };
+    if (!cache[line].agents)
+        cache[line].agents = {};
+    return cache[line];
+}
+export const getAgentThread = (line, kind) => read()[line]?.agents?.[kind];
+export function setAgentThread(line, kind, threadId) {
+    const cache = read();
+    const entry = ensure(cache, line);
+    entry.agents[kind] = threadId;
+    entry.lastAgent = kind;
+    write(cache);
+}
+export const getLastAgent = (line) => read()[line]?.lastAgent;
+export function setLastAgent(line, kind) {
+    const cache = read();
+    if (!cache[line])
+        return;
+    cache[line].lastAgent = kind;
+    write(cache);
+}
+export function setLastSeen(line, messageId) {
+    const cache = read();
+    if (!cache[line])
+        return;
+    cache[line].lastSeenMessageId = messageId;
+    cache[line].lastSeenAt = new Date().toISOString();
+    write(cache);
+}
+export function setName(line, name) {
+    const cache = read();
+    const entry = ensure(cache, line);
+    if (entry.name === name)
+        return;
+    entry.name = name;
+    write(cache);
+}
+export const listLines = () => Object.entries(read()).map(([line, entry]) => ({ line: line, entry }));
+export const linesForStation = (name) => listLines().filter(({ line }) => stationOf(line) === name);

package/dist/helpers/streaming.js

@@ -0,0 +1,219 @@
+/** Streams agent deltas + tool calls to chat via debounced edits; splits past MAX_BODY_LEN. */
+import { errMsg, log } from '../log.js';
+/** 1500ms keeps us under Discord's ~5/5s per-channel edit cap; leading-edge 500ms for first delta. */
+const DEFAULT_DEBOUNCE_MS = 1500;
+const LEADING_MS = 500;
+/** Discord cap is 2000; 1900 leaves headroom for status suffix. */
+const MAX_BODY_LEN = 1900;
+const STATUS_RESERVE = 80;
+/** Cap result so a 1000-line file dump doesn't blow the per-message char budget. */
+const MAX_RESULT_LINES = 50;
+const MAX_RESULT_CHARS = 1500;
+/** One per bot. Coalesces edits so concurrent threads don't compound rate limits. */
+export class StreamScheduler {
+    debounceMs;
+    leadingMs;
+    dirty = new Set();
+    timer = null;
+    lastFlushAt = 0;
+    constructor(debounceMs = DEFAULT_DEBOUNCE_MS, leadingMs = LEADING_MS) {
+        this.debounceMs = debounceMs;
+        this.leadingMs = leadingMs;
+    }
+    request(stream) {
+        this.dirty.add(stream);
+        if (this.timer)
+            return;
+        const sinceLast = Date.now() - this.lastFlushAt;
+        const delay = sinceLast >= this.debounceMs ? this.leadingMs : this.debounceMs - sinceLast;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.lastFlushAt = Date.now();
+            const batch = [...this.dirty];
+            this.dirty.clear();
+            for (const s of batch)
+                void s._flushFromScheduler();
+        }, delay);
+    }
+    forget(stream) { this.dirty.delete(stream); }
+}
+/** Break embedded triple backticks so they can't close our fenced block early. */
+const escapeFence = (s) => s.replace(/```/g, '`​`​`');
+/** Cap output by lines + chars; returns the truncated body and an `_(N more …)_` overflow note (or ''). */
+function truncateResult(s) {
+    const lines = s.split('\n');
+    let body = lines.slice(0, MAX_RESULT_LINES).join('\n');
+    const dropped = Math.max(0, lines.length - MAX_RESULT_LINES);
+    if (body.length > MAX_RESULT_CHARS)
+        body = body.slice(0, MAX_RESULT_CHARS) + '…';
+    if (dropped === 0 && body === s)
+        return { body: s, overflow: '' };
+    return { body, overflow: `_(${dropped > 0 ? `${dropped} more line${dropped === 1 ? '' : 's'}` : 'output truncated'})_` };
+}
+export class StreamingMessage {
+    adapter;
+    scheduler;
+    blocks = [];
+    segments = [{ id: null, text: '', dirty: false }];
+    statusLine = null;
+    flushing = false;
+    flushAgain = false;
+    finalized = false;
+    /** Non-null while a stop button should be shown on the last segment. */
+    stopId = null;
+    constructor(adapter, scheduler) {
+        this.adapter = adapter;
+        this.scheduler = scheduler;
+    }
+    appendDelta(delta) {
+        if (this.finalized || !delta)
+            return;
+        const last = this.blocks.at(-1);
+        if (last?.kind === 'text')
+            last.text += delta;
+        else
+            this.blocks.push({ kind: 'text', text: delta });
+        this.scheduler.request(this);
+    }
+    /** Transient status (Thinking…, Reasoning…). Italic+bold so it reads as ambient, not a header. */
+    setStatus(status) {
+        if (this.finalized)
+            return;
+        this.statusLine = status ? `_**${status}**_` : null;
+        this.scheduler.request(this);
+    }
+    /** Set/clear the stop-button id rendered on the last segment by the adapter. */
+    setStopId(id) {
+        if (this.finalized || this.stopId === id)
+            return;
+        this.stopId = id;
+        this.segments[this.segments.length - 1].dirty = true;
+        this.scheduler.request(this);
+    }
+    /** Add a tool block keyed by `id`; rendered immediately as a header, output filled in via appendToolResult. */
+    appendToolCall(id, name, detail) {
+        if (this.finalized)
+            return;
+        this.blocks.push({ kind: 'tool', id, name, detail });
+        this.scheduler.request(this);
+    }
+    /** Set the matching tool block's result; renders truncated output under the header. */
+    appendToolResult(id, result) {
+        if (this.finalized || !result)
+            return;
+        const tool = this.blocks.find((b) => b.kind === 'tool' && b.id === id);
+        if (tool)
+            tool.result = result;
+        this.scheduler.request(this);
+    }
+    /** "Interrupted" is a user-triggered stop — render as a calm italic+bold notice, not a `⚠️` crash. */
+    appendError(message) {
+        if (this.finalized)
+            return;
+        this.statusLine = null;
+        this.blocks.push({ kind: 'text', text: message === 'Interrupted' ? '_**Interrupted**_' : `⚠️ ${message}` });
+        this.scheduler.request(this);
+    }
+    async finalize() {
+        if (this.finalized)
+            return;
+        this.finalized = true;
+        this.scheduler.forget(this);
+        this.statusLine = null;
+        await this.flush();
+    }
+    async _flushFromScheduler() { await this.flush(); }
+    /** Render the block list into a single markdown body. */
+    renderBody() {
+        return this.blocks.map(b => b.kind === 'text' ? b.text : this.renderToolBlock(b)).join('\n\n').trim();
+    }
+    /** Plain header + fenced input block + fenced output block (each fully visible — no collapse). */
+    renderToolBlock(b) {
+        const parts = [`🛠 **${b.name}**`];
+        if (b.detail)
+            parts.push('```\n' + escapeFence(b.detail) + '\n```');
+        if (b.result) {
+            const { body, overflow } = truncateResult(b.result);
+            parts.push('```\n' + escapeFence(body) + '\n```');
+            if (overflow)
+                parts.push(overflow);
+        }
+        return parts.join('\n');
+    }
+    /** Redistribute the rendered body across segments, keeping existing segment ids stable. */
+    redistribute() {
+        const chunks = this.chunkify(this.renderBody(), MAX_BODY_LEN - STATUS_RESERVE);
+        if (!chunks.length)
+            chunks.push('');
+        for (let i = 0; i < chunks.length; i++) {
+            if (i >= this.segments.length)
+                this.segments.push({ id: null, text: chunks[i], dirty: true });
+            else if (this.segments[i].text !== chunks[i]) {
+                this.segments[i].text = chunks[i];
+                this.segments[i].dirty = true;
+            }
+        }
+    }
+    chunkify(s, cap) {
+        if (s.length <= cap)
+            return [s];
+        const out = [];
+        for (let r = s; r.length > 0; r = r.slice(out.at(-1).length)) {
+            out.push(r.length > cap ? this.sliceAtBoundary(r, cap) : r);
+        }
+        return out;
+    }
+    /** Split at the last paragraph/line/sentence/word break in range; hard slice otherwise. */
+    sliceAtBoundary(s, room) {
+        if (s.length <= room)
+            return s;
+        const candidate = s.slice(0, room);
+        for (const b of ['\n\n', '\n', '. ', ' ']) {
+            const i = candidate.lastIndexOf(b);
+            if (i > room * 0.5)
+                return candidate.slice(0, i + b.length);
+        }
+        return candidate;
+    }
+    async flush() {
+        if (this.flushing) {
+            this.flushAgain = true;
+            return;
+        }
+        this.flushing = true;
+        try {
+            do {
+                this.flushAgain = false;
+                this.redistribute();
+                for (let i = 0; i < this.segments.length; i++) {
+                    const s = this.segments[i];
+                    const isLast = i === this.segments.length - 1;
+                    const body = this.render(s, isLast);
+                    if (!body)
+                        continue;
+                    /** Stop button only lives on the final segment; frozen segments never carry it. */
+                    const stopId = isLast ? this.stopId : null;
+                    try {
+                        if (s.id === null)
+                            s.id = await this.adapter.send(body, stopId);
+                        else if (s.dirty)
+                            await this.adapter.edit(s.id, body, stopId);
+                        s.dirty = false;
+                    }
+                    catch (err) {
+                        log.warn({ err: errMsg(err) }, 'streaming edit failed');
+                    }
+                }
+            } while (this.flushAgain);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    render(s, isLast) {
+        const showStatus = isLast && !!this.statusLine;
+        if (!s.text)
+            return showStatus ? this.statusLine : '';
+        return showStatus ? `${s.text}\n\n${this.statusLine}` : s.text;
+    }
+}

package/dist/helpers/turn.js

@@ -0,0 +1,62 @@
+/** Run a turn; stream response via adapter. In-flight follow-ups queue and drain as one combined turn. */
+import { randomUUID } from 'node:crypto';
+import { errMsg, log } from '../log.js';
+import { StreamingMessage } from './streaming.js';
+/** Per-threadId active-turn state. Presence in the map means a turn is running; `texts` are queued follow-ups. */
+const inFlight = new Map();
+/** stopId → AbortController. Populated at turn start; fired by `triggerStop` on platform button clicks. */
+const stoppers = new Map();
+/** Invoked by chat stations when a stop button is pressed. Returns true if a turn was actually cancelled. */
+export async function triggerStop(stopId) {
+    const ctrl = stoppers.get(stopId);
+    if (!ctrl)
+        return false;
+    stoppers.delete(stopId);
+    ctrl.abort();
+    return true;
+}
+export async function runTurn(agent, threadId, text, attachments, adapter, scheduler) {
+    /** Queued follow-ups carry only text (next turn re-fetches its own attachments). */
+    const dispatch = (t) => runTurn(agent, threadId, t, [], adapter, scheduler);
+    const existing = inFlight.get(threadId);
+    if (existing) {
+        existing.texts.push(text);
+        return;
+    }
+    inFlight.set(threadId, { texts: [], dispatch });
+    const stream = new StreamingMessage(adapter, scheduler);
+    const stopId = `stop-${randomUUID()}`;
+    const controller = new AbortController();
+    stoppers.set(stopId, controller);
+    stream.setStopId(stopId);
+    try {
+        for await (const ev of agent.sendTurn({ threadId, text, attachments, signal: controller.signal })) {
+            if (ev.type === 'delta')
+                stream.appendDelta(ev.text);
+            else if (ev.type === 'tool-start') {
+                if (ev.activity.transient)
+                    stream.setStatus(ev.activity.name);
+                else
+                    stream.appendToolCall(ev.activity.id, ev.activity.name, ev.activity.detail);
+            }
+            else if (ev.type === 'tool-end') {
+                if (ev.result)
+                    stream.appendToolResult(ev.id, ev.result);
+                stream.setStatus(null);
+            }
+        }
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err) }, 'agent turn failed');
+        stream.appendError(errMsg(err) || 'agent turn failed');
+    }
+    finally {
+        stoppers.delete(stopId);
+        stream.setStopId(null);
+        await stream.finalize();
+        const entry = inFlight.get(threadId);
+        inFlight.delete(threadId);
+        if (entry?.texts.length)
+            await entry.dispatch(entry.texts.join('\n\n')).catch(err => log.warn({ err: errMsg(err) }, 'queued turn failed'));
+    }
+}

package/dist/log.js

@@ -1,8 +1,11 @@
-// Pino → stderr. Stdout is reserved for command output (`metro`'s inbound
-// JSON lines, subcommand results, --json) — any stray write there breaks
-// parsing. Override level with METRO_LOG_LEVEL.
+/** Pino → stderr. TTY → pino-pretty (colorized, hostname/pid stripped); else JSON. */
 import pino from 'pino';
-export const log = pino({ name: 'metro', level: process.env.METRO_LOG_LEVEL || 'info' }, pino.destination(2));
+import pinoPretty from 'pino-pretty';
+const stream = process.stderr.isTTY
+    ? pinoPretty({ colorize: true, translateTime: 'HH:MM:ss', ignore: 'pid,hostname,name', destination: 2 })
+    : pino.destination(2);
+/** `base: { name }` strips pino's default pid+hostname from JSON output too (not just from the TTY pretty stream). */
+export const log = pino({ base: { name: 'metro' }, level: process.env.METRO_LOG_LEVEL || 'info' }, stream);
 export const errMsg = (err) => {
     if (err instanceof Error)
         return err.message;