@stage-labs/metro 0.1.0-beta.10 → 0.1.0-beta.11

package/README.md

@@ -1,8 +1,11 @@
 # Metro
 
-> **A live JSON stream of Telegram, Discord, webhooks, and cross-agent messages for your local Claude Code / Codex session.**
+[![npm](https://img.shields.io/npm/v/@stage-labs/metro/beta?label=npm&color=cb3837)](https://www.npmjs.com/package/@stage-labs/metro)
+[![lines of code](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.codetabs.com%2Fv1%2Floc%2F%3Fgithub%3Dbonustrack%2Fmetro&query=%24%5B0%5D.linesOfCode&label=lines%20of%20TypeScript&color=blue)](https://github.com/bonustrack/metro)
 
-Metro is a small daemon you launch from inside your agent. It connects to Discord, Telegram, and any third-party service that can POST a webhook (GitHub, Intercom, Fireflies, …), emits each inbound as one JSON line on stdout (which Claude Code's `Monitor` consumes natively, and Codex picks up via an app-server WebSocket push), and exposes a tiny CLI — `metro reply`, `metro send`, `metro edit`, `metro react`, `metro download`, `metro fetch` — for posting back. Cross-agent: any agent can ping any other via `metro send metro://claude/<agent-id>/<session-id>` and the daemon re-emits it on the stream.
+> **A live JSON stream of Telegram, Discord, webhooks, and cross-user messages for your local Claude Code / Codex session.**
+
+Metro is a small daemon you launch from inside your session. It connects to Discord, Telegram, and any third-party service that can POST a webhook (GitHub, Intercom, Fireflies, …), emits each inbound as one JSON line on stdout (which Claude Code's `Monitor` consumes natively, and Codex picks up via an app-server WebSocket push), and exposes a tiny CLI — `metro reply`, `metro send`, `metro edit`, `metro react`, `metro download`, `metro fetch` — for posting back. Cross-user: any user can ping any other via `metro send metro://claude/<user-id>/<session-id>` and the daemon re-emits it on the stream.
 
 ```
 [Claude Code session]
@@ -11,7 +14,7 @@ $ metro &                              # backgrounded
 $ Monitor( … metro's stdout … )
 
 >>> {"kind":"inbound","station":"discord","line":"metro://discord/123…","messageId":"9876",
-     "text":"@bot we got a 5xx spike from /v1/sync. Look?",
+     "text":"@metro we got a 5xx spike from /v1/sync. Look?",
      "payload":{"channelId":"123…","guildId":"456…","content":"<@…> we got a 5xx spike…",
                 "mentions":{"users":["<bot-id>"],"roles":[],"everyone":false},…}}
 
@@ -19,7 +22,7 @@ $ Monitor( … metro's stdout … )
   Bash: metro reply metro://discord/123… 9876 "three deploys in the last 24h…"
 ```
 
-The agent owns its own streaming, tool calls, and reply timing. Metro is the wire.
+You own your own streaming, tool calls, and reply timing. Metro is the wire.
 
 ---
 
@@ -34,7 +37,7 @@ metro doctor                             # verify
 metro                                    # run the daemon
 ```
 
-Requires **Node ≥ 22 or Bun ≥ 1.3**. Metro doesn't launch Claude or Codex — you do, and the agent launches metro. See [`docs/agents.md`](docs/agents.md).
+Requires **Node ≥ 22 or Bun ≥ 1.3**. Metro doesn't launch Claude or Codex — you do, and the user launches metro. See [`docs/users.md`](docs/users.md).
 
 In **Discord**: DM the bot, or `@<bot>` in any channel. In **Telegram**: DM, or `@<bot>` in a forum supergroup. Every inbound becomes one JSON line on `metro`'s stdout.
 
@@ -49,16 +52,16 @@ Cloudflare tunnel   ──┤ ── HTTP webhooks (GitHub, Intercom, …)
                       │
                       ├─▶ metro daemon ───▶ stdout (JSON events; Claude Code's Monitor reads here)
                       │                ───▶ codex-rc WebSocket (Codex turn/start; opt-in)
-                      │                ◀── IPC Unix socket  (metro send to agent lines)
+                      │                ◀── IPC Unix socket  (metro send to Claude / Codex lines)
                       │
-agent CLI calls   ────┴── REST → Discord / Telegram   (metro reply / send / edit / react / download / fetch)
+local CLI calls   ────┴── REST → Discord / Telegram   (metro reply / send / edit / react / download / fetch)
 ```
 
-- **Inversion of control.** The agent (Claude Code, Codex) launches `metro`, not the other way around. Metro never spawns an agent process.
+- **Inversion of control.** Claude Code / Codex launches `metro`, not the other way around. Metro never spawns a Claude / Codex process.
 - **Single daemon per machine.** Lockfile at `$METRO_STATE_DIR/.tail-lock` enforces singleton.
 - **Account-tied identity.** `to` on inbound and `from` on outbound resolve to a stable account-scoped URI per runtime: `metro://claude/user/<orgId>` (from `claude auth status --json`) or `metro://codex/user/<accountId>` (from `$CODEX_HOME/auth.json`). Same on any device for the same logged-in account.
 - **Codex push (opt-in).** Set `METRO_CODEX_RC=ws://127.0.0.1:8421` and metro pushes each event via JSON-RPC `turn/start` to the Codex app-server. Codex's TUI must be attached with `--remote` to the same URL.
-- **Cross-agent notification.** `metro send metro://claude/<agent-id>/<session-id>` (or `metro://codex/<agent-id>/<session-id>`) routes through the daemon's IPC socket; the daemon re-emits on its stdout (and pushes to codex-rc), so the peer agent sees it. Discover reachable agents/sessions via `metro stations` or `$METRO_STATE_DIR/agent-registry.json`.
+- **Cross-user notification.** `metro send metro://claude/<user-id>/<session-id>` (or `metro://codex/<user-id>/<session-id>`) routes through the daemon's IPC socket; the daemon re-emits on its stdout (and pushes to codex-rc), so the peer sees it. Discover reachable users/sessions via `metro stations` or `$METRO_STATE_DIR/user-registry.json`.
 - **Webhooks (opt-in).** `metro webhook add <label>` registers an HTTP receive endpoint; the daemon binds `127.0.0.1:8420` (override with `$METRO_WEBHOOK_PORT`). If you've run `metro tunnel setup`, a Cloudflare named tunnel exposes it publicly. Each POST is re-emitted on stdout as an inbound event.
 
 ---
@@ -67,20 +70,20 @@ agent CLI calls   ────┴── REST → Discord / Telegram   (metro rep
 
 Each endpoint is a **station** with declared capabilities:
 
-| Station    | Kind    | Modalities    | Features                                              | Config                                                                                  |
-|------------|---------|---------------|-------------------------------------------------------|-----------------------------------------------------------------------------------------|
-| `discord`  | chat    | text + image  | reply, send, edit, react, download, fetch             | `DISCORD_BOT_TOKEN` + Message Content Intent                                            |
-| `telegram` | chat    | text + image  | reply, send, edit, react, download                    | `TELEGRAM_BOT_TOKEN`                                                                    |
-| `claude`   | agent   | text          | send, notify                                          | auto-detected from `$CLAUDECODE`; identity via `claude auth status --json`              |
-| `codex`    | agent   | text          | send, notify                                          | auto-detected from `$METRO_CODEX_RC` / `$CODEX_HOME`; identity via `$CODEX_HOME/auth.json` |
-| `webhook`  | service | text          | (receive-only; optional HMAC verify)                  | `metro webhook add <label>` + `metro tunnel setup` (Cloudflare named tunnel)            |
+| Station    | Modalities    | Features                                              | Config                                                                                  |
+|------------|---------------|-------------------------------------------------------|-----------------------------------------------------------------------------------------|
+| `discord`  | text + image  | reply, send, edit, react, download, fetch             | `DISCORD_BOT_TOKEN` + Message Content Intent                                            |
+| `telegram` | text + image  | reply, send, edit, react, download                    | `TELEGRAM_BOT_TOKEN`                                                                    |
+| `claude`   | text          | send                                                  | auto-detected from `$CLAUDECODE`; identity via `claude auth status --json`              |
+| `codex`    | text          | send                                                  | auto-detected from `$METRO_CODEX_RC` / `$CODEX_HOME`; identity via `$CODEX_HOME/auth.json` |
+| `webhook`  | text          | (receive-only; optional HMAC verify)                  | `metro webhook add <label>` + `metro tunnel setup` (Cloudflare named tunnel)            |
 
 Run `metro stations` to see live config status (`✓` configured, `✗` not, `·` informational).
 
 Behaviors worth knowing:
-- **No streaming / no edit machinery in metro.** The agent runs the show; metro is one-shot REST.
+- **No streaming / no edit machinery in metro.** The local CLI runs the show; metro is one-shot REST.
 - **No link previews.** Outgoing messages set `link_preview_options.is_disabled` on Telegram and `SUPPRESS_EMBEDS` on Discord.
-- **Image attachments inbound** — `[image]` placeholders surface inline in `text`; the agent calls `metro download` to materialize them. 20 MB cap.
+- **Image attachments inbound** — `[image]` placeholders surface inline in `text`; the user calls `metro download` to materialize them. 20 MB cap.
 - **Rich content outbound.** `metro send` / `reply` accept `--image=<path>` (repeatable: albums of up to 10), `--document=<path>` (repeatable), `--voice=<path>` (single voice message — Telegram renders the voice bubble), and `--buttons='[[{"text":"…","url":"…"}]]'` for inline URL-button keyboards. `metro edit` accepts `--buttons` (pass `'[]'` to clear). 20 MB / file. URL buttons only for now — no callback/interactive components.
 - **Telegram non-forum groups are skipped.** No thread boundary to scope on.
 - **Webhook signature verification.** Pass `--secret=<shared-secret>` to `metro webhook add` and the daemon verifies `X-Hub-Signature-256` (GitHub/Intercom format) on every POST. Mismatches return 401 and never reach the stream.
@@ -115,7 +118,7 @@ Paste the URL into the provider's webhook settings (for GitHub: **Content type m
 | One-time tunnel setup | `metro tunnel setup <tunnel-name> <hostname>` |
 | Tunnel status | `metro tunnel status` |
 
-The tunnel is optional — without it the listener binds `127.0.0.1:8420` only (good for local testing or your own loopback tools). With Cloudflare named tunnels, the URL stays stable across daemon restarts and machines. See [docs/uri-scheme.md](docs/uri-scheme.md) and [docs/agents.md](docs/agents.md) for the full event shape.
+The tunnel is optional — without it the listener binds `127.0.0.1:8420` only (good for local testing or your own loopback tools). With Cloudflare named tunnels, the URL stays stable across daemon restarts and machines. See [docs/uri-scheme.md](docs/uri-scheme.md) and [docs/users.md](docs/users.md) for the full event shape.
 
 ---
 
@@ -127,12 +130,12 @@ Every conversational scope is identified by a **Line** — a URI in the form `me
 metro://discord/1234567890123456789
 metro://telegram/-1001234567890                 # main chat / DM
 metro://telegram/-1001234567890/42              # forum topic 42
-metro://claude/9bfc7af0-…/50b00d11-…            # claude agent session
-metro://codex/8119ecb1-…/01997d4b-…             # codex agent session
+metro://claude/9bfc7af0-…/50b00d11-…            # claude user session
+metro://codex/8119ecb1-…/01997d4b-…             # codex user session
 metro://webhook/fwaCgTKJuLAjS2K0                # HTTP webhook endpoint
 ```
 
-Anyone can post to a line via [`metro send`](#cli) — daemon required only for agent lines. Full grammar in [`docs/uri-scheme.md`](docs/uri-scheme.md).
+Anyone can post to a line via [`metro send`](#cli) — daemon required only for Claude / Codex lines. Full grammar in [`docs/uri-scheme.md`](docs/uri-scheme.md).
 
 ---
 
@@ -167,12 +170,12 @@ metro update                                Upgrade in place.
 All commands accept `--json`. `reply` / `send` / `edit` read multi-line `<text>` from stdin if no positional is given.
 
 **State files** in `$METRO_STATE_DIR` (default `~/.cache/metro`):
-- `AGENTS.md` — agent skill copied from the package on every start (so the path is stable across upgrades)
-- `history.jsonl` — universal message log (one JSON object per line; append-only). Read with `metro history`. Each entry carries `from` and `to` as universal participant URIs (`metro://<station>/user/<id>`, `metro://claude/user/<orgId>`, `metro://codex/user/<accountId>`) plus a `fromName` display field. The dispatcher auto-detects the consuming agent for `to` on inbound (`$CLAUDECODE` → `metro://claude/user/<orgId>` from `claude auth status --json`; `$METRO_CODEX_RC`/`$CODEX_HOME` → `metro://codex/user/<accountId>` from `$CODEX_HOME/auth.json`).
-- `bot-ids.json` — `{discord: "<botUserId>", telegram: "<botUserId>"}` written by the daemon on startup (cached for the few historical lookups that still need a bot identity).
+- `USERS.md` — user skill copied from the package on every start (so the path is stable across upgrades)
+- `history.jsonl` — universal message log (one JSON object per line; append-only). Read with `metro history`. Each entry carries `from` and `to` as universal participant URIs (`metro://<station>/user/<id>`, `metro://claude/user/<orgId>`, `metro://codex/user/<accountId>`) plus a `fromName` display field. The dispatcher auto-detects the local user for `to` on inbound (`$CLAUDECODE` → `metro://claude/user/<orgId>` from `claude auth status --json`; `$METRO_CODEX_RC`/`$CODEX_HOME` → `metro://codex/user/<accountId>` from `$CODEX_HOME/auth.json`).
+- `bot-ids.json` — `{discord: "<botUserId>", telegram: "<botUserId>"}` written by the daemon on startup (cached for the few historical lookups that still need a platform-side bot identity).
 - `lines.json` — line → last-seen / name cache (read by `metro lines`)
-- `agent-registry.json` — every `(station, agent-id, sessions[])` tuple metro has seen; surfaced under each agent row in `metro stations`
-- `stations/codex/session-id` — current codex-rc thread id (daemon writes on handshake; CLI processes read for `metro://codex/<agent-id>/<session>`)
+- `user-registry.json` — every `(station, user-id, sessions[])` tuple metro has seen; surfaced under each Claude / Codex row in `metro stations`
+- `stations/codex/session-id` — current codex-rc thread id (daemon writes on handshake; CLI processes read for `metro://codex/<user-id>/<session>`)
 - `webhooks.json` — registered HTTP receive endpoints (id, label, optional shared secret)
 - `tunnel.json` — Cloudflare named-tunnel config (`{name, hostname}`); when present, the daemon spawns `cloudflared tunnel run`. The token is resolved via `cloudflared tunnel token <name>` and passed through as `TUNNEL_TOKEN`, so the per-tunnel credentials JSON at `~/.cloudflared/<id>.json` is not required (the named-form spawn is the fallback when the token call fails)
 - `.tail-lock` — dispatcher pid
@@ -188,8 +191,8 @@ All commands accept `--json`. `reply` / `send` / `edit` read multi-line `<text>`
 | `TELEGRAM_BOT_TOKEN`, `DISCORD_BOT_TOKEN` | — | Bot tokens. `metro setup` writes them here. |
 | `METRO_CODEX_RC` | — | Codex app-server URL (`ws://…`, `wss://…`, `unix:///…`). When set, the daemon pushes each event via JSON-RPC `turn/start`. |
 | `METRO_WEBHOOK_PORT` | `8420` | Local port the HTTP webhook listener binds to (always `127.0.0.1`; expose publicly via Cloudflare tunnel). |
-| `METRO_AGENT_ID` | — | Override the resolved agent id (orgId / accountId) used in `metro://<station>/user/<id>` and `metro://<station>/<id>/<session>`. Useful for testing. |
-| `METRO_AGENT_SESSION_ID` | — | Override the resolved session id (Claude session / Codex thread). |
+| `METRO_USER_ID` | — | Override the resolved user id (orgId / accountId) used in `metro://<station>/user/<id>` and `metro://<station>/<id>/<session>`. Useful for testing. |
+| `METRO_USER_SESSION_ID` | — | Override the resolved session id (Claude session / Codex thread). |
 | `METRO_FROM` | — | Pin a custom `from` URI for all writes (overrides runtime detection). |
 | `METRO_CONFIG_DIR` | `~/.config/metro` | Where the global `.env` lives. |
 | `METRO_STATE_DIR` | `~/.cache/metro` | Lockfile, line cache, IPC socket, telegram offset, registries, tunnel config. |
@@ -215,15 +218,15 @@ Source map:
 
 - [`src/cli/`](src/cli/) — `metro` binary entry ([`index.ts`](src/cli/index.ts)) + admin commands ([`config.ts`](src/cli/config.ts): setup/doctor/update), action handlers ([`actions.ts`](src/cli/actions.ts): send/reply/edit/react/download/fetch), webhook + tunnel commands ([`webhook.ts`](src/cli/webhook.ts)), and shared CLI primitives ([`util.ts`](src/cli/util.ts)).
 - [`src/dispatcher.ts`](src/dispatcher.ts) — the daemon: starts each station, emits events on stdout, listens on the IPC socket, optionally pushes to codex-rc, supervises the Cloudflare tunnel.
-- [`src/stations/`](src/stations/) — Line URI scheme + ChatStation interface + listing ([`index.ts`](src/stations/index.ts)). Chat impls: [`discord.ts`](src/stations/discord.ts), [`telegram.ts`](src/stations/telegram.ts) (+ [`telegram-md.ts`](src/stations/telegram-md.ts) markdown helper). Agent identity resolvers: [`claude.ts`](src/stations/claude.ts) (orgId via `claude auth status --json`), [`codex.ts`](src/stations/codex.ts) (account_id via `auth.json`). HTTP receive: [`webhook.ts`](src/stations/webhook.ts).
+- [`src/stations/`](src/stations/) — Line URI scheme + ChatStation interface + listing ([`index.ts`](src/stations/index.ts)). Chat impls: [`discord.ts`](src/stations/discord.ts), [`telegram.ts`](src/stations/telegram.ts) (+ [`telegram-md.ts`](src/stations/telegram-md.ts) markdown helper). User identity resolvers: [`claude.ts`](src/stations/claude.ts) (orgId via `claude auth status --json`), [`codex.ts`](src/stations/codex.ts) (account_id via `auth.json`). HTTP receive: [`webhook.ts`](src/stations/webhook.ts).
 - [`src/codex-rc.ts`](src/codex-rc.ts) — Codex app-server WebSocket push client (also exposes the rc thread id used as Codex session-id).
 - [`src/tunnel.ts`](src/tunnel.ts) — Cloudflared named-tunnel supervisor.
 - [`src/webhooks.ts`](src/webhooks.ts) — webhook endpoint store (`webhooks.json` CRUD).
-- [`src/registry.ts`](src/registry.ts) — agent registry: `(station, agent-id, sessions[])` tracking.
-- [`src/history.ts`](src/history.ts) — universal message log + `agentSelf()` / `selfLine()` identity helpers.
+- [`src/registry.ts`](src/registry.ts) — user registry: `(station, user-id, sessions[])` tracking.
+- [`src/history.ts`](src/history.ts) — universal message log + `userSelf()` / `selfLine()` identity helpers.
 - [`src/ipc.ts`](src/ipc.ts) — Unix-socket IPC between the daemon and one-shot CLI commands.
 - [`src/cache.ts`](src/cache.ts) — in-memory line cache with debounced flush to `lines.json`, plus bot-id cache.
-- [`docs/uri-scheme.md`](docs/uri-scheme.md) specs the Line format; [`docs/agents.md`](docs/agents.md) is the in-context skill for agents.
+- [`docs/uri-scheme.md`](docs/uri-scheme.md) specs the Line format; [`docs/users.md`](docs/users.md) is the in-context skill for users.
 
 CI runs typecheck + lint + build on every PR via [`.github/workflows/ci.yml`](.github/workflows/ci.yml).
 

package/dist/cache.js

@@ -3,7 +3,6 @@ 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 { Line } from './stations/index.js';
 const cacheFile = join(STATE_DIR, 'lines.json');
 const FLUSH_DELAY_MS = 5_000;
 let cache = null;
@@ -68,8 +67,3 @@ export function saveBotId(station, id) {
         log.warn({ err: errMsg(err) }, 'bot-ids cache write failed');
     }
 }
-/** Resolve the bot's URI for a station. Returns `metro://<station>/bot/<id>` or the placeholder. */
-export function botLine(station) {
-    const id = readBotIds()[station];
-    return id ? Line.bot(station, id) : `metro://${station}/bot`;
-}

package/dist/cli/actions.js

@@ -6,7 +6,7 @@ import { errMsg } from '../log.js';
 import { DiscordStation } from '../stations/discord.js';
 import { TelegramStation } from '../stations/telegram.js';
 import { ipcCall } from '../ipc.js';
-import { agentSelf, appendHistory, lookupEntry, mintId, resolvePlatformId, } from '../history.js';
+import { userSelf, appendHistory, lookupEntry, mintId, readHistory, resolvePlatformId, } from '../history.js';
 import { asLine, Line } from '../stations/index.js';
 import { loadMetroEnv } from '../paths.js';
 import { emit, flagList, flagOne, isJson, need, resolveText, writeJson, } from './util.js';
@@ -45,13 +45,19 @@ function richOpts(f) {
         opts.buttons = buttons;
     return opts;
 }
-/** Append an outbound action to history.jsonl; `to` = the original sender when replying/reacting. */
+/** Mirror the original entry's destination: group → `line`; DM → the other-party user URI. */
+function destinationFor(orig, line) {
+    if (!orig || !orig.to || orig.to === orig.line)
+        return line;
+    return orig.from;
+}
+/** Append an outbound action to history.jsonl; `to` mirrors the destination per `destinationFor`. */
 function logOutbound(f, e) {
     const id = mintId();
     const fromOverride = flagOne(f, 'from');
     appendHistory({
         id, ts: new Date().toISOString(), station: Line.station(e.line) ?? '?',
-        from: fromOverride ? asLine(fromOverride) : agentSelf(), to: e.to ?? e.line, ...e,
+        from: fromOverride ? asLine(fromOverride) : userSelf(), to: e.to ?? e.line, ...e,
     });
     return id;
 }
@@ -59,7 +65,7 @@ export async function cmdSend(p, f) {
     need(p, 1, 'metro send <line> <text> [--image=<path>]… [--document=<path>]… [--voice=<path>] [--buttons=<json>]');
     loadMetroEnv();
     const text = await resolveText(p, 1), line = asLine(p[0]);
-    if (Line.isAgent(line)) {
+    if (Line.isLocal(line)) {
         const from = flagOne(f, 'from');
         const resp = await ipcCall({ op: 'notify', line, from, text });
         if (!resp.ok)
@@ -67,7 +73,9 @@ export async function cmdSend(p, f) {
         return emit(f, `notified ${line}`, { ok: true, line, id: null, messageId: null });
     }
     const messageId = await chatStationOf(line).send(line, text, richOpts(f));
-    const id = logOutbound(f, { kind: 'outbound', line, text, messageId });
+    /** Inherit destination from the most recent inbound on this line so DM sends address the user. */
+    const to = destinationFor(readHistory({ line, kind: 'inbound', limit: 1 })[0], line);
+    const id = logOutbound(f, { kind: 'outbound', line, text, messageId, to });
     emit(f, `sent ${id} (${messageId}) to ${line}`, { ok: true, line, id, messageId });
 }
 export async function cmdReply(p, f) {
@@ -76,7 +84,7 @@ export async function cmdReply(p, f) {
     const [to, replyToArg] = p, text = await resolveText(p, 2), line = asLine(to);
     const replyTo = resolvePlatformId(replyToArg);
     const messageId = await chatStationOf(line).send(line, text, { ...richOpts(f), replyTo });
-    const id = logOutbound(f, { kind: 'outbound', line, text, messageId, replyTo: replyToArg, to: lookupEntry(replyToArg)?.from });
+    const id = logOutbound(f, { kind: 'outbound', line, text, messageId, replyTo: replyToArg, to: destinationFor(lookupEntry(replyToArg), line) });
     emit(f, `replied ${id} (${messageId}) to ${line}#${replyTo}`, { ok: true, line, id, replyTo: replyToArg, messageId });
 }
 export async function cmdEdit(p, f) {
@@ -96,7 +104,7 @@ export async function cmdReact(p, f) {
     const [to, msgArg, emoji = ''] = p, line = asLine(to);
     const platformId = resolvePlatformId(msgArg);
     await chatStationOf(line).react(line, platformId, emoji);
-    const id = logOutbound(f, { kind: 'react', line, messageId: platformId, emoji, to: lookupEntry(msgArg)?.from });
+    const id = logOutbound(f, { kind: 'react', line, messageId: platformId, emoji, to: destinationFor(lookupEntry(msgArg), line) });
     const human = emoji ? `reacted ${emoji} on ${line}#${platformId}` : `cleared reaction on ${line}#${platformId}`;
     emit(f, human, { ok: true, line, id, messageId: platformId, emoji });
 }

package/dist/cli/index.js

@@ -4,14 +4,14 @@ import pkg from '../../package.json' with { type: 'json' };
 import { errMsg } from '../log.js';
 import { listLines } from '../cache.js';
 import { fmtCapabilities, listStations } from '../stations/index.js';
-import { listAgents } from '../registry.js';
+import { listUsers } from '../registry.js';
 import { loadMetroEnv } from '../paths.js';
 import { readHistory } from '../history.js';
 import { cmdDoctor, cmdSetup, cmdUpdate } from './config.js';
 import { cmdDownload, cmdEdit, cmdFetch, cmdReact, cmdReply, cmdSend, } from './actions.js';
 import { cmdTunnel, cmdWebhook } from './webhook.js';
 import { flagOne, isJson, parseArgs, writeJson, } from './util.js';
-const USAGE = `metro — Telegram + Discord stream for your Claude Code / Codex agent
+const USAGE = `metro — Telegram + Discord stream for your Claude Code / Codex user
 
 Usage:
   metro                                       Run the dispatcher (emits JSON events on stdout).
@@ -47,22 +47,20 @@ Exit codes: 0 success · 1 usage · 2 config · 3 upstream
 async function cmdStations(_, f) {
     loadMetroEnv();
     const rows = listStations();
-    const agentsByStation = {
-        claude: listAgents('claude'),
-        codex: listAgents('codex'),
+    const usersByStation = {
+        claude: listUsers('claude'),
+        codex: listUsers('codex'),
     };
     if (isJson(f))
-        return writeJson({ stations: rows, agents: agentsByStation });
+        return writeJson({ stations: rows, users: usersByStation });
     process.stdout.write('metro stations\n\n');
     for (const s of rows) {
         const mark = s.configured === true ? '✓' : s.configured === false ? '✗' : '·';
-        process.stdout.write(`  ${mark} ${s.name.padEnd(10)} ${s.kind.padEnd(6)} ${fmtCapabilities(s.capabilities)}\n        ${s.detail}\n`);
-        if (s.kind === 'agent') {
-            const seen = agentsByStation[s.name] ?? [];
-            for (const inst of seen) {
-                const sessionsTxt = inst.sessions.length ? ` · sessions: ${inst.sessions.length}` : '';
-                process.stdout.write(`          seen: ${inst.agentId}${sessionsTxt}\n`);
-            }
+        process.stdout.write(`  ${mark} ${s.name.padEnd(10)} ${fmtCapabilities(s.capabilities)}\n        ${s.detail}\n`);
+        const seen = usersByStation[s.name] ?? [];
+        for (const inst of seen) {
+            const sessionsTxt = inst.sessions.length ? ` · sessions: ${inst.sessions.length}` : '';
+            process.stdout.write(`          seen: ${inst.userId}${sessionsTxt}\n`);
         }
     }
     process.stdout.write('\n');
@@ -123,16 +121,14 @@ async function cmdHistory(_, f) {
         process.stdout.write(`${ts}  ${e.id.padEnd(12)}  ${e.kind.padEnd(12)}  ${from} → ${to}  ${text}\n`);
     }
 }
-/** Compact display: fromName if known; else `station:@<id>` (user), `station:bot`, or `station:<id>`. */
+/** Compact display: fromName if known; else `station:@<id>` (user) or `station:<id>`. */
 function fmtActor(uri, name) {
     if (name)
         return name;
-    const m = uri.match(/^metro:\/\/([^/]+)(?:\/(?:(user|bot)\/)?(.*))?$/);
+    const m = uri.match(/^metro:\/\/([^/]+)(?:\/(?:(user)\/)?(.*))?$/);
     if (!m)
         return uri;
     const [, station, kind, rest] = m;
-    if (kind === 'bot')
-        return `${station}:bot`;
     if (kind === 'user')
         return `${station}:@${shortId(rest ?? '')}`;
     return rest ? `${station}:${shortId(rest)}` : station;

package/dist/cli/skill.js

@@ -1,4 +1,4 @@
-/** `metro setup skill` — install the bundled SKILL.md into each detected agent runtime. */
+/** `metro setup skill` — install the bundled SKILL.md into each detected user runtime. */
 import { copyFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
@@ -42,7 +42,7 @@ function install(f) {
         }
     }
     if (!installed.length) {
-        throw exitErr('no agent runtime detected (~/.claude or ~/.codex). Install one and rerun.', 2);
+        throw exitErr('no user runtime detected (~/.claude or ~/.codex). Install one and rerun.', 2);
     }
     emit(f, `installed metro skill → ${installed.join(', ')}`, { ok: true, installed });
 }

package/dist/dispatcher.js

@@ -1,5 +1,5 @@
 /**
- * Daemon: chat inbound → JSON on stdout; optional codex-rc push; cross-agent `notify` over Unix socket.
+ * Daemon: chat inbound → JSON on stdout; optional codex-rc push; cross-user `notify` over Unix socket.
  */
 import { copyFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
@@ -11,12 +11,12 @@ import { WebhookStation } from './stations/webhook.js';
 import { asLine, Line } from './stations/index.js';
 import { CodexRC } from './codex-rc.js';
 import { startIpcServer, stopIpcServer } from './ipc.js';
-import { agentSelf, appendHistory, formatDisplay, mintId, selfLine } from './history.js';
+import { userSelf, appendHistory, formatDisplay, mintId, selfLine } from './history.js';
 import { noteSeen, saveBotId } from './cache.js';
 import { errMsg, log } from './log.js';
 import { acquireLock, configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
 import { setCodexSessionId } from './stations/codex.js';
-import { noteAgentFromLine } from './registry.js';
+import { noteUserFromLine } from './registry.js';
 import { listEndpoints, webhookPort } from './webhooks.js';
 import { loadTunnelConfig, Tunnel } from './tunnel.js';
 loadMetroEnv();
@@ -25,19 +25,19 @@ const endpoints = listEndpoints();
 requireConfiguredPlatform(platforms, endpoints.length > 0);
 acquireLock(join(STATE_DIR, '.tail-lock'));
 // Fail fast if launched from Claude Code without a logged-in account.
-const self = agentSelf();
-log.info({ self, line: selfLine() }, 'agent identity');
+const self = userSelf();
+log.info({ self, line: selfLine() }, 'user identity');
 const seedSelf = () => { const l = selfLine(); if (l)
-    noteAgentFromLine(l); };
+    noteUserFromLine(l); };
 seedSelf();
-const AGENTS_MD = join(STATE_DIR, 'AGENTS.md');
+const USERS_MD = join(STATE_DIR, 'USERS.md');
 try {
-    copyFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'docs', 'agents.md'), AGENTS_MD);
+    copyFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'docs', 'users.md'), USERS_MD);
 }
 catch (err) {
-    log.warn({ err: errMsg(err), path: AGENTS_MD }, 'failed to install agent skill');
+    log.warn({ err: errMsg(err), path: USERS_MD }, 'failed to install user skill');
 }
-/** Suppress EPIPE so the daemon survives the agent (Monitor reader) restarting / dying. */
+/** Suppress EPIPE so the daemon survives the user (Monitor reader) restarting / dying. */
 process.stdout.on('error', err => {
     if (err.code !== 'EPIPE')
         log.warn({ err: errMsg(err) }, 'stdout error');
@@ -51,7 +51,7 @@ const webhook = new WebhookStation();
 const tunnelCfg = loadTunnelConfig();
 const tunnel = tunnelCfg ? new Tunnel(tunnelCfg, webhookPort()) : null;
 function emit(entry) {
-    /** `display` first so it survives Monitor's ~500-char body truncation — the agent must see it to echo it. */
+    /** `display` first so it survives Monitor's ~500-char body truncation — the user must see it to echo it. */
     const enriched = { display: formatDisplay(entry), ...entry };
     const json = JSON.stringify(enriched);
     process.stdout.write(json + '\n');
@@ -59,17 +59,19 @@ function emit(entry) {
     noteSeen(entry.line, entry.lineName);
     for (const l of [entry.line, entry.from, entry.to])
         if (l)
-            noteAgentFromLine(l);
+            noteUserFromLine(l);
     appendHistory(enriched);
 }
-const onInbound = (m) => emit({ ...m, kind: 'inbound', to: agentSelf() });
+const destinationFor = (m) => m.isPrivate ? userSelf() : m.line;
+const onInbound = (m) => emit({ ...m, kind: 'inbound', to: destinationFor(m) });
+const onReaction = (r) => emit({ ...r, kind: 'react', to: destinationFor(r) });
 const ipc = startIpcServer(async (req) => {
     if (req.op === 'notify') {
         const line = asLine(req.line);
         emit({
-            id: mintId(), ts: new Date().toISOString(), kind: 'notification',
+            id: mintId(), ts: new Date().toISOString(), kind: 'inbound',
             station: Line.station(line) ?? '?', line,
-            from: req.from ? asLine(req.from) : agentSelf(), to: line, text: req.text,
+            from: req.from ? asLine(req.from) : userSelf(), to: line, text: req.text,
         });
         return { ok: true };
     }
@@ -84,12 +86,14 @@ const ipc = startIpcServer(async (req) => {
 async function main() {
     if (platforms.discord) {
         discord.onMessage(onInbound);
+        discord.onReaction(onReaction);
         const [, me] = await Promise.all([discord.start(), discord.getMe()]);
         saveBotId('discord', me.id);
         log.info({ bot: me.username }, 'discord ready');
     }
     if (platforms.telegram) {
         telegram.onMessage(onInbound);
+        telegram.onReaction(onReaction);
         const [me] = await Promise.all([telegram.getMe(), telegram.start()]);
         saveBotId('telegram', String(me.id));
         log.info({ bot: `@${me.username}` }, 'telegram ready');

package/dist/history.js

@@ -5,9 +5,9 @@ import { join } from 'node:path';
 import { errMsg, log } from './log.js';
 import { STATE_DIR } from './paths.js';
 import { Line } from './stations/index.js';
-import { claudeAgentId, claudeSessionId } from './stations/claude.js';
-import { codexAgentId, codexSessionId } from './stations/codex.js';
-/** Pre-render a chat-bubble line — the agent echoes `event.display` verbatim instead of composing markdown itself. */
+import { claudeUserId, claudeSessionId } from './stations/claude.js';
+import { codexUserId, codexSessionId } from './stations/codex.js';
+/** Pre-render a chat-bubble line — the user echoes `event.display` verbatim instead of composing markdown itself. */
 export function formatDisplay(e) {
     const headerFor = (icon, parts) => `**${icon} ${parts.filter(Boolean).join(' · ')}**`;
     const body = e.text ?? (e.emoji ? `[react ${e.emoji}]` : '');
@@ -17,11 +17,9 @@ export function formatDisplay(e) {
             ?.headers?.['x-intercom-topic'];
         return `${headerFor('🪝', ['webhook', e.lineName, ev])}\n> ${body}`;
     }
-    if (e.kind === 'inbound') {
-        return `${headerFor('📩', [e.station, e.fromName ?? e.from, e.lineName])}\n> ${body}`;
-    }
-    if (e.kind === 'notification') {
-        return `${headerFor('🔔', ['notification', e.station, e.fromName ?? e.from])}\n> ${body}`;
+    if (e.kind === 'inbound' || (e.kind === 'react' && !Line.isLocal(e.from))) {
+        const reactBody = e.kind === 'react' ? `reacted ${e.emoji ?? ''}`.trim() : body;
+        return `${headerFor('📩', [e.station, e.fromName ?? e.from, e.lineName])}\n> ${reactBody}`;
     }
     return `${headerFor('📤', [e.station, '→', e.fromName ?? e.to])}\n> ${body}`;
 }
@@ -92,26 +90,26 @@ export function resolvePlatformId(id) {
         return hit.messageId;
     throw new Error(`unknown universal id: ${id} (run \`metro history --limit=50\` to see recent ids)`);
 }
-/** The current agent's **participant** URI for `from`/`to`. Precedence: METRO_FROM > runtime env > generic. */
-export function agentSelf() {
+/** The current user's **participant** URI for `from`/`to`. Precedence: METRO_FROM > runtime env > generic. */
+export function userSelf() {
     const explicit = process.env.METRO_FROM;
     if (explicit)
         return explicit;
     if (process.env.CLAUDECODE)
-        return Line.user('claude', claudeAgentId());
+        return Line.user('claude', claudeUserId());
     if (process.env.METRO_CODEX_RC || process.env.CODEX_HOME)
-        return Line.user('codex', codexAgentId());
-    return 'metro://agent';
+        return Line.user('codex', codexUserId());
+    return 'metro://user';
 }
-/** The current agent's **line** URI `<agent-id>/<session>`. Null until session is known (rc thread pending). */
+/** The current user's **line** URI `<user-id>/<session>`. Null until session is known (rc thread pending). */
 export function selfLine() {
     if (process.env.CLAUDECODE) {
         const s = claudeSessionId();
-        return s ? Line.claude(claudeAgentId(), s) : null;
+        return s ? Line.claude(claudeUserId(), s) : null;
     }
     if (process.env.METRO_CODEX_RC || process.env.CODEX_HOME) {
         const s = codexSessionId();
-        return s ? Line.codex(codexAgentId(), s) : null;
+        return s ? Line.codex(codexUserId(), s) : null;
     }
     return null;
 }

package/dist/registry.js

@@ -1,10 +1,10 @@
-/** Append-only registry of `(station, agent-id, sessions[])` tuples metro has seen. */
+/** Append-only registry of `(station, user-id, sessions[])` tuples metro has seen. */
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { STATE_DIR } from './paths.js';
 import { Line } from './stations/index.js';
 import { errMsg, log } from './log.js';
-const REGISTRY_FILE = join(STATE_DIR, 'agent-registry.json');
+const REGISTRY_FILE = join(STATE_DIR, 'user-registry.json');
 function readRegistry() {
     if (!existsSync(REGISTRY_FILE))
         return {};
@@ -12,16 +12,16 @@ function readRegistry() {
         return JSON.parse(readFileSync(REGISTRY_FILE, 'utf8'));
     }
     catch (err) {
-        log.warn({ err: errMsg(err) }, 'agent-registry: malformed, resetting');
+        log.warn({ err: errMsg(err) }, 'user-registry: malformed, resetting');
         return {};
     }
 }
-function record(station, agentId, sessionId) {
+function record(station, userId, sessionId) {
     const reg = readRegistry();
     const rows = (reg[station] ??= []);
-    let row = rows.find(r => r.agentId === agentId);
+    let row = rows.find(r => r.userId === userId);
     if (!row) {
-        row = { agentId, sessions: [], lastSeen: '' };
+        row = { userId, sessions: [], lastSeen: '' };
         rows.push(row);
     }
     if (sessionId && !row.sessions.includes(sessionId))
@@ -31,18 +31,18 @@ function record(station, agentId, sessionId) {
         writeFileSync(REGISTRY_FILE, JSON.stringify(reg, null, 2));
     }
     catch (err) {
-        log.warn({ err: errMsg(err) }, 'agent-registry: write failed');
+        log.warn({ err: errMsg(err) }, 'user-registry: write failed');
     }
 }
-/** Scan a line URI for `(station, agentId, sessionId)` and record it. No-op on non-agent or participant URIs. */
-export function noteAgentFromLine(line) {
+/** Scan a line URI for `(station, userId, sessionId)` and record it. No-op on non-user or participant URIs. */
+export function noteUserFromLine(line) {
     const station = Line.station(line);
     if (station !== 'claude' && station !== 'codex')
         return;
     const p = station === 'claude' ? Line.parseClaude(line) : Line.parseCodex(line);
     if (p)
-        record(station, p.agentId, p.sessionId);
+        record(station, p.userId, p.sessionId);
 }
-export function listAgents(station) {
+export function listUsers(station) {
     return readRegistry()[station] ?? [];
 }

package/dist/stations/claude.js

@@ -1,4 +1,4 @@
-/** Resolve the Claude Code agent identity (account id + session id). */
+/** Resolve the Claude Code user identity (account id + session id). */
 import { execFileSync } from 'node:child_process';
 /** Short TTL so account switches via `claude auth login` propagate to the daemon within seconds. */
 const TTL_MS = 5_000;
@@ -35,11 +35,11 @@ export function tryClaudeAccountId() {
         return null;
     }
 }
-/** Agent-id for the line URI: `METRO_AGENT_ID` override, else the account id. */
-export function claudeAgentId() {
-    return process.env.METRO_AGENT_ID || claudeAccountId();
+/** User-id for the line URI: `METRO_USER_ID` override, else the account id. */
+export function claudeUserId() {
+    return process.env.METRO_USER_ID || claudeAccountId();
 }
-/** Session: `CLAUDE_CODE_SESSION_ID` (stable across `--resume`). Override: `METRO_AGENT_SESSION_ID`. */
+/** Session: `CLAUDE_CODE_SESSION_ID` (stable across `--resume`). Override: `METRO_USER_SESSION_ID`. */
 export function claudeSessionId() {
-    return process.env.METRO_AGENT_SESSION_ID || process.env.CLAUDE_CODE_SESSION_ID || null;
+    return process.env.METRO_USER_SESSION_ID || process.env.CLAUDE_CODE_SESSION_ID || null;
 }

package/dist/stations/codex.js

@@ -1,4 +1,4 @@
-/** Resolve the Codex agent identity (account id + session id). */
+/** Resolve the Codex user identity (account id + session id). */
 import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
@@ -42,15 +42,15 @@ export function tryCodexAccountId() {
         return null;
     }
 }
-/** Agent-id for the line URI: `METRO_AGENT_ID` override, else the account id. */
-export function codexAgentId() {
-    return process.env.METRO_AGENT_ID || codexAccountId();
+/** User-id for the line URI: `METRO_USER_ID` override, else the account id. */
+export function codexUserId() {
+    return process.env.METRO_USER_ID || codexAccountId();
 }
 const SESSION_FILE = join(STATE_DIR, 'stations', 'codex', 'session-id');
-/** Session: codex-rc thread id (daemon persists; CLIs read state file). Override: `METRO_AGENT_SESSION_ID`. */
+/** Session: codex-rc thread id (daemon persists; CLIs read state file). Override: `METRO_USER_SESSION_ID`. */
 export function codexSessionId() {
-    if (process.env.METRO_AGENT_SESSION_ID)
-        return process.env.METRO_AGENT_SESSION_ID;
+    if (process.env.METRO_USER_SESSION_ID)
+        return process.env.METRO_USER_SESSION_ID;
     try {
         return readFileSync(SESSION_FILE, 'utf8').trim() || null;
     }