@stage-labs/metro 0.1.0-beta.4 → 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

@@ -1,8 +1,9 @@
-/** Per-machine scope→{thread ids,last-used} cache. Keys: `discord:<id>` / `telegram:<chat>:<topic>`. */
+/** 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))
@@ -23,43 +24,44 @@ function write(cache) {
         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];
+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 function getAgentThread(scopeKey, kind) {
-    return read()[scopeKey]?.agents?.[kind];
-}
-export function setAgentThread(scopeKey, kind, threadId) {
+export const getAgentThread = (line, kind) => read()[line]?.agents?.[kind];
+export function setAgentThread(line, kind, threadId) {
     const cache = read();
-    const entry = ensure(cache, scopeKey);
+    const entry = ensure(cache, line);
     entry.agents[kind] = threadId;
     entry.lastAgent = kind;
     write(cache);
 }
-export function getLastAgent(scopeKey) {
-    return read()[scopeKey]?.lastAgent;
-}
-export function setLastAgent(scopeKey, kind) {
+export const getLastAgent = (line) => read()[line]?.lastAgent;
+export function setLastAgent(line, kind) {
     const cache = read();
-    if (!cache[scopeKey])
+    if (!cache[line])
         return;
-    cache[scopeKey].lastAgent = kind;
+    cache[line].lastAgent = kind;
     write(cache);
 }
-export function setLastSeen(scopeKey, messageId) {
+export function setLastSeen(line, messageId) {
     const cache = read();
-    if (!cache[scopeKey])
+    if (!cache[line])
         return;
-    cache[scopeKey].lastSeenMessageId = messageId;
+    cache[line].lastSeenMessageId = messageId;
+    cache[line].lastSeenAt = new Date().toISOString();
     write(cache);
 }
-export function listScopes() {
-    return Object.entries(read()).map(([scopeKey, entry]) => ({ scopeKey, entry }));
+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 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'}`;
+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

@@ -39,17 +39,16 @@ export class StreamScheduler {
 }
 /** Break embedded triple backticks so they can't close our fenced block early. */
 const escapeFence = (s) => s.replace(/```/g, '`​`​`');
-/** Cap output by lines + chars; return `body` to embed and a `_(N more …)_` overflow note (or ''). */
+/** 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 droppedLines = Math.max(0, lines.length - MAX_RESULT_LINES);
+    const dropped = Math.max(0, lines.length - MAX_RESULT_LINES);
     if (body.length > MAX_RESULT_CHARS)
         body = body.slice(0, MAX_RESULT_CHARS) + '…';
-    if (droppedLines === 0 && body === s)
+    if (dropped === 0 && body === s)
         return { body: s, overflow: '' };
-    const noun = droppedLines > 0 ? `${droppedLines} more line${droppedLines === 1 ? '' : 's'}` : 'output truncated';
-    return { body, overflow: `_(${noun})_` };
+    return { body, overflow: `_(${dropped > 0 ? `${dropped} more line${dropped === 1 ? '' : 's'}` : 'output truncated'})_` };
 }
 export class StreamingMessage {
     adapter;
@@ -60,6 +59,8 @@ export class StreamingMessage {
     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;
@@ -74,10 +75,19 @@ export class StreamingMessage {
             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;
+        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. */
@@ -96,11 +106,12 @@ export class StreamingMessage {
             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}` });
+        this.blocks.push({ kind: 'text', text: message === 'Interrupted' ? '_**Interrupted**_' : `⚠️ ${message}` });
         this.scheduler.request(this);
     }
     async finalize() {
@@ -116,7 +127,7 @@ export class StreamingMessage {
     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 fence is fully visible (no collapse). */
+    /** Plain header + fenced input block + fenced output block (each fully visible — no collapse). */
     renderToolBlock(b) {
         const parts = [`🛠 **${b.name}**`];
         if (b.detail)
@@ -131,14 +142,12 @@ export class StreamingMessage {
     }
     /** Redistribute the rendered body across segments, keeping existing segment ids stable. */
     redistribute() {
-        const fullBody = this.renderBody();
-        const chunks = this.chunkify(fullBody, MAX_BODY_LEN - STATUS_RESERVE);
+        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) {
+            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;
@@ -149,10 +158,8 @@ export class StreamingMessage {
         if (s.length <= cap)
             return [s];
         const out = [];
-        for (let r = s; r.length > 0;) {
-            const take = r.length > cap ? this.sliceAtBoundary(r, cap) : r;
-            out.push(take);
-            r = r.slice(take.length);
+        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;
     }
@@ -180,14 +187,17 @@ export class StreamingMessage {
                 this.redistribute();
                 for (let i = 0; i < this.segments.length; i++) {
                     const s = this.segments[i];
-                    const body = this.render(s, i === this.segments.length - 1);
+                    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);
+                            s.id = await this.adapter.send(body, stopId);
                         else if (s.dirty)
-                            await this.adapter.edit(s.id, body);
+                            await this.adapter.edit(s.id, body, stopId);
                         s.dirty = false;
                     }
                     catch (err) {

package/dist/helpers/turn.js

@@ -1,40 +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';
-const inFlight = new Set();
-const queued = new Map();
-export async function runTurn(agent, threadId, text, adapter, scheduler) {
-    const dispatch = (t) => runTurn(agent, threadId, t, adapter, scheduler);
-    if (inFlight.has(threadId)) {
-        const q = queued.get(threadId);
-        if (q)
-            q.texts.push(text);
-        else
-            queued.set(threadId, { texts: [text], dispatch });
+/** 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.add(threadId);
+    inFlight.set(threadId, { texts: [], dispatch });
     const stream = new StreamingMessage(adapter, scheduler);
-    const finishAndDrain = async () => {
+    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);
-        const q = queued.get(threadId);
-        if (!q?.texts.length)
-            return;
-        queued.delete(threadId);
-        await q.dispatch(q.texts.join('\n\n')).catch(err => log.warn({ err: errMsg(err) }, 'queued turn failed'));
-    };
-    const callbacks = {
-        onDelta: d => stream.appendDelta(d),
-        onToolStart: a => a.transient ? stream.setStatus(a.name) : stream.appendToolCall(a.id, a.name, a.detail),
-        onToolEnd: (id, result) => { if (result)
-            stream.appendToolResult(id, result); stream.setStatus(null); },
-        onComplete: () => { void finishAndDrain(); },
-        onError: err => {
-            log.warn({ err: errMsg(err) }, 'agent turn failed');
-            stream.appendError(errMsg(err) || 'agent turn failed');
-            void finishAndDrain();
-        },
-    };
-    await agent.sendTurn(threadId, text, callbacks);
+        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,6 +1,11 @@
-/** Pino → stderr. Stdout reserved for command output / --json. */
+/** 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;