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

package/README.md

@@ -1,6 +1,6 @@
 # Metro
 
-Run a long-lived daemon that bridges Discord and Telegram to your Codex + Claude Code agents. Each chat thread/topic gets its own agent session with streaming responses and live tool-call status. Both agents run side-by-side — pick per-message with a `with claude` / `with codex` suffix.
+Run a long-lived daemon that bridges Discord and Telegram to your Codex + Claude Code agents. Each chat thread/topic gets its own agent session with streaming responses and inline, persistent tool-call traces. Both agents run side-by-side — pick per-message with a `with claude` / `with codex` suffix.
 
 ## Prereqs
 
@@ -38,14 +38,14 @@ How would Codex have done this? with codex
 @-mention the bot in any channel:
 1. Metro creates a thread anchored on your message (named after the message).
 2. Spins up an agent session for that thread.
-3. Streams the agent's reply with tool-call status (`Running: <command>`, `Editing 3 files`, `Thinking…`).
+3. Streams the agent's reply with each tool call as its own block: plain header `🛠 **Read**` followed by two fenced code blocks — input (`src/foo.ts`) above, output (file contents) below. Outputs are capped at 50 lines / 1500 chars per tool with a `_(N more lines)_` note if truncated. `Thinking…` shows as a transient status that vanishes once real content arrives.
 
 Follow-ups in the thread route automatically — no @-mention needed.
 
 ### Telegram
 
 - **DM the bot** — every message is implicitly addressed to it; one scope per chat.
-- **@-mention the bot in a forum supergroup's General topic** — metro auto-creates a new topic for the conversation (Discord-style "thread from message"). Subsequent messages in that topic route automatically.
+- **@-mention the bot in a forum supergroup's General topic** — metro auto-creates a new topic for the conversation (Discord-style "thread from message") and posts a deep link back in General so the new topic is one tap away. Subsequent messages in that topic route automatically.
 - **Inside an existing custom topic** — routes to that topic's scope on every message.
 
 Regular (non-forum) groups are not routed — they have no thread boundary.
@@ -62,7 +62,10 @@ Telegram poller ──┘                       └─▶ claude -p ...      (pe
 
 - **One metro = one daemon.** Lockfile at `$METRO_STATE_DIR/.tail-lock` keeps things singleton.
 - **Both agents side-by-side.** A scope can have up to one session per agent — independent histories. Routing is per-message: explicit `with claude` / `with codex` suffix, otherwise the scope's last-used agent, otherwise Claude.
-- **Streaming.** Replies edit one message every ~1500 ms while deltas stream in (leading-edge first flush for fast initial feedback). Tool calls show as a status line; long replies split past ~1900 chars onto a follow-up message.
+- **Streaming.** Replies edit one message every ~1500 ms while deltas stream in (leading-edge first flush for fast initial feedback). Long replies split past ~1900 chars onto a follow-up message.
+- **Tool-call visibility.** Each tool call is rendered as a plain `🛠 **<tool>**` header plus two fenced code blocks — input then output — paired by tool id so parallel calls don't collide. Both blocks are fully visible (no collapse). Outputs are capped at 50 lines / 1500 chars per tool.
+- **Telegram formatting.** Agent markdown (`**bold**`, `*italic*`, `` `code` ``, fenced blocks, `[link](url)`, blockquotes) is converted to Telegram's HTML parse mode on the way out, so it renders as formatted text instead of literal characters.
+- **No link previews.** Outgoing messages set `link_preview_options.is_disabled` on Telegram and the `SUPPRESS_EMBEDS` flag on Discord, so URLs in agent replies don't unfurl into giant auto-embeds.
 - **Queueing.** Messages that arrive while a turn is running are buffered per-scope and answered together in the next reply.
 - **Catchup-on-restart.** Discord uses a per-scope `lastSeenMessageId` watermark and REST-fetches anything newer when metro comes back up. Telegram leans on its own update-id queue (persisted offset in `telegram-offset.json`).
 

package/dist/agents/claude.js

@@ -1,23 +1,10 @@
-// Claude Code agent adapter. Spawns `claude -p --output-format stream-json
-// --include-partial-messages --verbose` per turn, parses the line-delimited
-// JSON event stream, and exposes the same `Agent` surface as codex.ts.
-//
-// Unlike codex (long-running app-server daemon), Claude Code has no daemon
-// mode — each turn is a fresh subprocess. Session continuity is achieved
-// by passing the same uuid via `--session-id` for the first turn and
-// `--resume` for every subsequent turn.
+/** Claude Code adapter: per-turn `claude -p` subprocess; --session-id then --resume (persisted across restarts). */
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { errMsg, log } from '../log.js';
 import { STATE_DIR } from '../paths.js';
-// Persisted across metro restarts. Without this, the first message after
-// a restart would call `claude -p --session-id <uuid>` on an existing
-// session, which fails silently (no result event) and leaves the user
-// staring at "Thinking…" forever. Codex doesn't have this problem
-// because codex app-server is the state authority and reads its on-disk
-// thread store on spawn.
 const STARTED_FILE = join(STATE_DIR, 'claude-sessions.json');
 function loadStarted() {
     if (!existsSync(STARTED_FILE))
@@ -26,13 +13,11 @@ function loadStarted() {
         return new Set(JSON.parse(readFileSync(STARTED_FILE, 'utf8')));
     }
     catch (err) {
-        log.warn({ err: errMsg(err), path: STARTED_FILE }, 'claude agent: started cache read failed; treating as empty');
+        log.warn({ err: errMsg(err), path: STARTED_FILE }, 'claude: started cache read failed');
         return new Set();
     }
 }
 export class ClaudeAgent {
-    // Threads that have had at least one turn run (so `--session-id` was
-    // already consumed and subsequent turns must use `--resume`).
     started = loadStarted();
     children = new Set();
     persistStarted() {
@@ -40,12 +25,10 @@ export class ClaudeAgent {
             writeFileSync(STARTED_FILE, JSON.stringify([...this.started]));
         }
         catch (err) {
-            log.warn({ err: errMsg(err), path: STARTED_FILE }, 'claude agent: started cache write failed');
+            log.warn({ err: errMsg(err), path: STARTED_FILE }, 'claude: started cache write failed');
         }
     }
     async start() {
-        // No daemon to bring up — sanity-check that `claude` is on PATH so we
-        // fail loud at boot rather than on the first inbound message.
         await new Promise((resolve, reject) => {
             const c = spawn('claude', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
             let out = '';
@@ -71,28 +54,16 @@ export class ClaudeAgent {
         this.children.clear();
     }
     async createThread() {
-        // Pre-allocate a uuid so the Discord thread can be named with it before
-        // the first turn runs. Claude Code accepts any valid uuid via
-        // `--session-id` and persists the session under that id.
         const id = randomUUID();
         log.info({ thread: id }, 'claude agent: thread allocated');
         return id;
     }
     async sendTurn(threadId, text, callbacks) {
-        const args = [
-            '-p',
-            '--output-format', 'stream-json',
-            '--include-partial-messages',
-            '--verbose',
-        ];
-        if (this.started.has(threadId))
-            args.push('--resume', threadId);
-        else
-            args.push('--session-id', threadId);
-        args.push(text);
+        const args = ['-p', '--output-format', 'stream-json', '--include-partial-messages', '--verbose'];
+        args.push(this.started.has(threadId) ? '--resume' : '--session-id', threadId, text);
         const child = spawn('claude', args, { stdio: ['ignore', 'pipe', 'pipe'] });
         this.children.add(child);
-        log.debug({ thread: threadId, args: args.slice(0, -1) }, 'claude agent: turn started');
+        log.debug({ thread: threadId }, 'claude agent: turn started');
         const session = new TurnSession(callbacks);
         let buffer = '';
         child.stdout?.on('data', d => {
@@ -118,8 +89,6 @@ export class ClaudeAgent {
                 this.started.add(threadId);
                 this.persistStarted();
             }
-            // If the subprocess exits without a `result` event (crash, OOM, kill),
-            // surface that as an error so the orchestrator unsticks the thread.
             if (!session.done) {
                 if (code === 0)
                     session.fireComplete();
@@ -127,50 +96,28 @@ export class ClaudeAgent {
                     session.fireError(new Error(`claude exited with code ${code}`));
             }
         });
-        child.on('error', err => {
-            this.children.delete(child);
-            if (!session.done)
-                session.fireError(err);
-        });
+        child.on('error', err => { this.children.delete(child); if (!session.done)
+            session.fireError(err); });
     }
 }
-// Owns the once-only firing of onComplete/onError and the per-index tool
-// tracking so block_stop events can fire onToolEnd correctly.
 class TurnSession {
     cb;
     done = false;
-    // Show "Thinking…" until the first real text/tool event lands. Claude
-    // Code doesn't emit a separate reasoning event the way codex does, so
-    // without this the user sees nothing while the agent is still on its
-    // initial API call — feels like the bot's frozen.
     thinking = true;
-    // Track which content-block indexes belong to tool_use vs text so
-    // block_stop fires onToolEnd only for tool blocks.
-    tools = new Map();
+    /** tool_use_id → kind; survives until the matching tool_result lands. */
+    byUseId = new Map();
+    /** Pending tool_use blocks: input JSON streams in over multiple `input_json_delta` events before the input is complete. */
+    pendingTools = new Map();
     constructor(cb) {
         this.cb = cb;
-        cb.onToolStart('thinking', 'Thinking…');
-    }
-    fireComplete() {
-        if (this.done)
-            return;
-        this.done = true;
-        this.clearThinking();
-        this.cb.onComplete();
-    }
-    fireError(err) {
-        if (this.done)
-            return;
-        this.done = true;
-        this.clearThinking();
-        this.cb.onError(err);
-    }
-    clearThinking() {
-        if (!this.thinking)
-            return;
-        this.thinking = false;
-        this.cb.onToolEnd('thinking');
+        cb.onToolStart({ id: 'thinking', kind: 'thinking', name: 'Thinking…', transient: true });
     }
+    fireComplete() { if (this.done)
+        return; this.done = true; this.clearThinking(); this.cb.onComplete(); }
+    fireError(err) { if (this.done)
+        return; this.done = true; this.clearThinking(); this.cb.onError(err); }
+    clearThinking() { if (!this.thinking)
+        return; this.thinking = false; this.cb.onToolEnd('thinking'); }
     handle(ev) {
         if (ev.type === 'result') {
             if (ev.is_error)
@@ -179,51 +126,82 @@ class TurnSession {
                 this.fireComplete();
             return;
         }
+        if (ev.type === 'user') {
+            this.handleToolResults(ev);
+            return;
+        }
         if (ev.type !== 'stream_event' || !ev.event)
             return;
         const e = ev.event;
         if (e.type === 'content_block_start' && e.content_block?.type === 'tool_use') {
             this.clearThinking();
-            this.tools.set(e.index ?? -1, e.content_block.name ?? 'tool');
-            this.cb.onToolStart(e.content_block.name ?? 'tool', summarizeTool(e.content_block.name, e.content_block.input));
+            const idx = e.index ?? -1;
+            const kind = e.content_block.name ?? 'tool';
+            const id = e.content_block.id ?? `${kind}:${idx}`;
+            this.byUseId.set(id, kind);
+            this.pendingTools.set(idx, { id, kind, toolName: e.content_block.name, inputJson: '' });
+        }
+        else if (e.type === 'content_block_delta' && e.delta?.type === 'input_json_delta') {
+            const tool = this.pendingTools.get(e.index ?? -1);
+            if (tool)
+                tool.inputJson += e.delta.partial_json ?? '';
         }
         else if (e.type === 'content_block_delta' && e.delta?.type === 'text_delta') {
             this.clearThinking();
             this.cb.onDelta(e.delta.text ?? '');
         }
         else if (e.type === 'content_block_stop') {
-            const kind = this.tools.get(e.index ?? -1);
-            if (kind !== undefined) {
-                this.tools.delete(e.index ?? -1);
-                this.cb.onToolEnd(kind);
+            const tool = this.pendingTools.get(e.index ?? -1);
+            if (!tool)
+                return;
+            this.pendingTools.delete(e.index ?? -1);
+            let input;
+            try {
+                input = tool.inputJson ? JSON.parse(tool.inputJson) : undefined;
             }
+            catch { /* malformed mid-stream — show name only */ }
+            const { name, detail } = summarizeTool(tool.toolName, input);
+            this.cb.onToolStart({ id: tool.id, kind: tool.kind, name, detail });
+        }
+    }
+    /** Claude emits `tool_result` blocks inside a follow-up `user` message after the tool runs. */
+    handleToolResults(ev) {
+        for (const block of ev.message?.content ?? []) {
+            if (block.type !== 'tool_result' || !block.tool_use_id)
+                continue;
+            if (!this.byUseId.has(block.tool_use_id))
+                continue;
+            this.byUseId.delete(block.tool_use_id);
+            this.cb.onToolEnd(block.tool_use_id, extractResultText(block.content));
         }
     }
 }
+function extractResultText(content) {
+    if (typeof content === 'string')
+        return content.trim() || undefined;
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content.filter(b => b?.type === 'text').map(b => b.text ?? '').join('\n').trim();
+    return text || undefined;
+}
 function summarizeTool(name, input) {
-    const n = (name ?? 'Tool')[0].toUpperCase() + (name ?? 'Tool').slice(1);
+    const display = (name ?? 'Tool')[0].toUpperCase() + (name ?? 'Tool').slice(1);
     if (!input)
-        return n;
+        return { name: display };
     const path = (input.file_path ?? input.path);
     const cmd = input.command;
     const pattern = input.pattern;
-    const url = input.url;
     switch (name) {
-        case 'Bash': return cmd ? `Running: ${truncate(cmd, 60)}` : n;
+        case 'Bash': return { name: 'Bash', detail: cmd };
         case 'Edit':
         case 'Write':
-        case 'NotebookEdit':
-            return path ? `Editing ${path}` : n;
-        case 'Read': return path ? `Reading ${path}` : n;
+        case 'NotebookEdit': return { name: display, detail: path };
+        case 'Read': return { name: 'Read', detail: path };
         case 'Grep':
-        case 'Glob':
-            return pattern ? `Searching: ${truncate(pattern, 60)}` : n;
-        case 'WebFetch': return url ? `Fetching ${url}` : n;
-        case 'WebSearch': return 'Searching the web';
-        case 'Task': return 'Spawning subagent';
-        default: return n;
+        case 'Glob': return { name: display, detail: pattern };
+        case 'WebFetch': return { name: 'WebFetch', detail: input.url };
+        case 'WebSearch': return { name: 'WebSearch', detail: input.query };
+        case 'Task': return { name: 'Task', detail: (input.description ?? input.subagent_type) };
+        default: return { name: display };
     }
 }
-function truncate(s, n) {
-    return s.length > n ? s.slice(0, n - 1) + '…' : s;
-}

package/dist/agents/codex.js

@@ -1,10 +1,4 @@
-// Codex agent adapter. Spawns `codex app-server --listen unix://…` as a
-// child process, talks to it over WebSocket-over-UDS, manages one codex
-// thread per scope, and streams per-turn events back to the orchestrator
-// (text deltas, tool-call lifecycle, completion).
-//
-// The orchestrator never speaks codex directly — it asks this adapter to
-// `ensureThread(scopeKey)` and `sendTurn(threadId, text, callbacks)`.
+/** Codex adapter: spawns `codex app-server` over UDS WebSocket; one thread/scope, streams turn events. */
 import { spawn } from 'node:child_process';
 import { existsSync, unlinkSync } from 'node:fs';
 import { createConnection } from 'node:net';
@@ -21,49 +15,29 @@ export class CodexAgent {
     daemon = null;
     nextId = 1;
     pending = new Map();
-    turnCallbacks = new Map(); // keyed by thread_id
+    turnCallbacks = new Map();
     constructor(clientVersion) {
         this.clientVersion = clientVersion;
     }
     async start() {
-        // Fail loud at boot if codex isn't installed, rather than 15s later
-        // via a "socket didn't appear" timeout.
         await this.checkCodexInstalled();
-        // Stale socket file from a previous run would let us connect to nothing
-        // (no listener) — wipe before spawning so codex binds fresh.
         try {
             unlinkSync(SOCKET_PATH);
         }
         catch { /* missing is fine */ }
         log.info({ socket: SOCKET_PATH }, 'codex agent: starting app-server');
-        // Spawn the daemon listening on our UDS. Inherits CODEX_HOME so it picks
-        // up the user's auth, settings, MCPs, etc.
-        this.daemon = spawn('codex', ['app-server', '--listen', `unix://${SOCKET_PATH}`], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        // Capture daemon stderr so a startup failure surfaces with the actual
-        // error message, not just a generic timeout. Once the daemon is ready,
-        // stderr goes back to trace (its own tracing is noisy).
+        this.daemon = spawn('codex', ['app-server', '--listen', `unix://${SOCKET_PATH}`], { stdio: ['ignore', 'pipe', 'pipe'] });
         let bootStderr = '';
         let daemonExited = false;
         let daemonExitCode = null;
-        const onBootStderr = (d) => {
-            bootStderr += String(d);
-            log.trace({ src: 'codex-stderr' }, String(d).trim());
-        };
         this.daemon.stdout?.on('data', d => log.trace({ src: 'codex-stdout' }, String(d).trim()));
-        this.daemon.stderr?.on('data', onBootStderr);
-        this.daemon.on('exit', code => {
-            daemonExited = true;
-            daemonExitCode = code;
-            log.warn({ code }, 'codex daemon exited');
-        });
+        this.daemon.stderr?.on('data', (d) => { bootStderr += String(d); log.trace({ src: 'codex-stderr' }, String(d).trim()); });
+        this.daemon.on('exit', code => { daemonExited = true; daemonExitCode = code; log.warn({ code }, 'codex daemon exited'); });
         try {
             await this.waitForSocket(() => daemonExited, () => bootStderr.trim() || `exit code ${daemonExitCode}`);
             await this.connect();
         }
         catch (err) {
-            // Make the failure self-explanatory in the orchestrator's catch log.
             const detail = bootStderr.trim() ? ` (codex stderr: ${bootStderr.trim().slice(0, 200)})` : '';
             throw new Error(`${errMsg(err)}${detail}`);
         }
@@ -75,9 +49,7 @@ export class CodexAgent {
             let stderr = '';
             c.stderr?.on('data', d => { stderr += String(d); });
             c.on('error', err => reject(new Error(`codex CLI not found on PATH: ${errMsg(err)}`)));
-            c.on('exit', code => code === 0
-                ? resolve()
-                : reject(new Error(`codex --version exited ${code}: ${stderr.trim()}`)));
+            c.on('exit', code => code === 0 ? resolve() : reject(new Error(`codex --version exited ${code}: ${stderr.trim()}`)));
         });
     }
     async stop() {
@@ -86,39 +58,22 @@ export class CodexAgent {
         this.daemon?.kill('SIGTERM');
         this.daemon = null;
     }
-    /**
-     * Create a new codex thread and return its id. The caller is responsible
-     * for caching the mapping `scopeKey → threadId` and only calling this
-     * once per scope (subsequent inbounds reuse the thread via `sendTurn`).
-     */
     async createThread() {
         const result = await this.call('thread/start', {});
         log.info({ thread: result.thread.id }, 'codex agent: thread created');
         return result.thread.id;
     }
-    /**
-     * Send a user message to a thread and stream the agent's response via
-     * the provided callbacks. Resolves immediately after `turn/start`
-     * acknowledges; callbacks fire as notifications arrive and conclude
-     * with `onComplete` or `onError`.
-     */
     async sendTurn(threadId, text, callbacks) {
         this.turnCallbacks.set(threadId, callbacks);
         try {
-            // Wire format per codex's generated TS bindings: `text_elements`
-            // (snake_case), not camelCase. Sending camelCase silently degrades
-            // — accepted by the server but doesn't echo back in items.
-            await this.call('turn/start', {
-                threadId,
-                input: [{ type: 'text', text, text_elements: [] }],
-            });
+            /** `text_elements` is snake_case per codex's generated bindings. */
+            await this.call('turn/start', { threadId, input: [{ type: 'text', text, text_elements: [] }] });
         }
         catch (err) {
             this.turnCallbacks.delete(threadId);
             callbacks.onError(err instanceof Error ? err : new Error(String(err)));
         }
     }
-    // --- transport ---
     async waitForSocket(exited, exitReason) {
         const deadline = Date.now() + READY_TIMEOUT_MS;
         while (Date.now() < deadline) {
@@ -130,40 +85,22 @@ export class CodexAgent {
         }
         throw new Error(`codex app-server didn't appear at ${SOCKET_PATH} within ${READY_TIMEOUT_MS}ms`);
     }
+    /** perMessageDeflate disabled: codex 0.130 closes connections offering it. */
     async connect() {
-        // perMessageDeflate disabled: codex 0.130's WS upgrade handler closes
-        // the connection if a client offers `Sec-WebSocket-Extensions:
-        // permessage-deflate` (the `ws` library's default). Disabling it makes
-        // the upgrade succeed cleanly. Compression is irrelevant over a UDS.
         const ws = new WebSocket('ws://localhost/', {
             perMessageDeflate: false,
             createConnection: () => {
                 const sock = createConnection({ path: SOCKET_PATH });
-                // Swallow socket-level errors so a transport hiccup during the HTTP
-                // upgrade doesn't surface as an uncaught error on the http_client
-                // request (Node's http.ClientRequest re-emits this).
                 sock.on('error', err => log.warn({ err: errMsg(err) }, 'codex agent: socket error'));
                 return sock;
             },
         });
         this.ws = ws;
         ws.on('error', err => log.warn({ err: errMsg(err) }, 'codex agent: websocket error'));
-        await new Promise((resolve, reject) => {
-            ws.once('open', () => resolve());
-            ws.once('error', err => reject(err));
-        });
+        await new Promise((resolve, reject) => { ws.once('open', () => resolve()); ws.once('error', reject); });
         ws.on('message', data => this.onMessage(data));
-        ws.on('close', () => {
-            log.warn('codex agent: websocket closed');
-            this.ws = null;
-            // Drain stranded turns + RPC promises so the orchestrator can
-            // release its in-flight gate and the user sees an error rather
-            // than a permanent "Thinking…".
-            this.drainPending('codex websocket closed');
-        });
-        await this.call('initialize', {
-            clientInfo: { name: 'metro', version: this.clientVersion, title: null },
-        });
+        ws.on('close', () => { log.warn('codex agent: websocket closed'); this.ws = null; this.drainPending('codex websocket closed'); });
+        await this.call('initialize', { clientInfo: { name: 'metro', version: this.clientVersion, title: null } });
     }
     onMessage(raw) {
         let msg;
@@ -174,7 +111,6 @@ export class CodexAgent {
             log.warn({ err: errMsg(err) }, 'codex agent: malformed message');
             return;
         }
-        // RPC response
         if (msg.id !== undefined && this.pending.has(msg.id)) {
             const p = this.pending.get(msg.id);
             this.pending.delete(msg.id);
@@ -184,56 +120,47 @@ export class CodexAgent {
                 p.resolve(msg.result);
             return;
         }
-        // Notifications.
         if (!msg.method)
             return;
         log.trace({ method: msg.method }, 'codex agent: notification');
-        const params = msg.params;
-        const threadId = params?.threadId;
+        const threadId = msg.params?.threadId;
         if (!threadId)
             return;
         const cb = this.turnCallbacks.get(threadId);
         if (!cb)
-            return; // no active turn for this thread (yet or anymore)
+            return;
         if (msg.method === 'item/agentMessage/delta') {
-            const p = msg.params;
-            cb.onDelta(p.delta);
+            cb.onDelta(msg.params.delta);
         }
         else if (msg.method === 'item/started') {
-            const p = msg.params;
-            const summary = summarizeItem(p.item);
-            if (summary && p.item.type !== 'agentMessage' && p.item.type !== 'userMessage') {
-                cb.onToolStart(p.item.type, summary);
-            }
+            const a = summarizeItem(msg.params.item);
+            if (a)
+                cb.onToolStart(a);
         }
         else if (msg.method === 'item/completed') {
-            const p = msg.params;
-            if (p.item.type !== 'agentMessage' && p.item.type !== 'userMessage')
-                cb.onToolEnd(p.item.type);
+            const item = msg.params.item;
+            if (item.type !== 'agentMessage' && item.type !== 'userMessage')
+                cb.onToolEnd(item.id, itemOutput(item));
         }
         else if (msg.method === 'thread/status/changed') {
-            // Codex 0.130 doesn't reliably emit `turn/completed` — `thread/status`
-            // returning to `idle` is the dependable completion signal. The same
-            // notification fires on `active` when a turn starts; ignore those.
-            const p = msg.params;
-            if (p.status?.type === 'idle') {
+            /** codex 0.130: `thread/status=idle` is the dependable completion signal. */
+            const status = msg.params.status?.type;
+            if (status === 'idle') {
                 this.turnCallbacks.delete(threadId);
                 cb.onComplete();
             }
-            else if (p.status?.type === 'systemError') {
+            else if (status === 'systemError') {
                 this.turnCallbacks.delete(threadId);
                 cb.onError(new Error('codex thread entered systemError'));
             }
         }
         else if (msg.method === 'turn/completed') {
-            // Belt-and-braces: if codex does emit it, take it.
             this.turnCallbacks.delete(threadId);
             cb.onComplete();
         }
         else if (msg.method === 'error') {
-            const p = msg.params;
             this.turnCallbacks.delete(threadId);
-            cb.onError(new Error(p.error?.message ?? 'codex error notification'));
+            cb.onError(new Error(msg.params.error?.message ?? 'codex error notification'));
         }
     }
     call(method, params) {
@@ -246,7 +173,6 @@ export class CodexAgent {
             ws.send(JSON.stringify({ jsonrpc: '2.0', id, method, params }));
         });
     }
-    /** Fail every in-flight turn + RPC. Used when the transport dies. */
     drainPending(reason) {
         const err = new Error(reason);
         for (const cb of this.turnCallbacks.values()) {
@@ -264,19 +190,18 @@ export class CodexAgent {
     }
 }
 function summarizeItem(item) {
+    const id = item.id;
     if (item.type === 'commandExecution' && 'command' in item) {
-        return `Running: ${truncate(item.command ?? '', 60)}`;
+        return { id, kind: 'commandExecution', name: 'Bash', detail: item.command || undefined };
     }
     if (item.type === 'fileChange' && 'changes' in item) {
-        const n = item.changes?.length ?? 0;
-        return n > 0 ? `Editing ${n} file${n === 1 ? '' : 's'}` : 'Editing files';
+        const paths = (item.changes ?? []).map(c => c.path).filter((p) => !!p);
+        return { id, kind: 'fileChange', name: 'Edit', detail: paths.length === 1 ? paths[0] : paths.length ? `${paths.length} files` : undefined };
     }
     if (item.type === 'reasoning')
-        return 'Thinking…';
-    if (item.type === 'agentMessage')
-        return ''; // text deltas handled separately
-    return item.type;
-}
-function truncate(s, n) {
-    return s.length > n ? s.slice(0, n - 1) + '…' : s;
+        return { id, kind: 'reasoning', name: 'Thinking…', transient: true };
+    if (item.type === 'agentMessage' || item.type === 'userMessage')
+        return null;
+    return { id, kind: item.type, name: item.type };
 }
+const itemOutput = (item) => item.type === 'commandExecution' && 'output' in item ? item.output?.trim() || undefined : undefined;

package/dist/agents/types.js

@@ -1,3 +1,2 @@
-// Shared interface so the orchestrator can talk to either Codex or Claude
-// Code (or future agents) through the same surface.
+/** Shared interface across agent backends (Codex, Claude Code). */
 export {};