@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

package/runtime/node_modules/@metro-labs/daemon/src/boot/boot.ts

@@ -0,0 +1,238 @@
+import { join } from 'node:path';
+import { type Server } from 'node:http';
+import { userSelf } from '@metro-labs/core/events';
+import { setTrainCallBackend } from '../stations/train-call.js';
+import { errMsg, log, logFatalSync } from '@metro-labs/core/log';
+import { acquireLock, STATE_DIR, trainsDir } from './paths.js';
+import { installCrashGuard, markDaemonReady } from './crash-guard.js';
+import { METRO_VERSION } from '@metro-labs/core/version';
+import { funnelDriver, Tunnel, tunnelWanted } from '../net/tunnel.js';
+import { webhookPort } from '../files/attach-serve.js';
+import {
+  localConnectHint,
+  publicConnectHint,
+  tunnelPendingHint,
+} from './connect-hint.js';
+import { TrainSupervisor } from '../stations/supervisor.js';
+import {
+  makeEmit,
+  startWebhookServer,
+  trainEventToMetroEvent,
+} from '../routes/http.js';
+import { agentsDir, fileSource } from '../agents/files.js';
+import { syncPluginServers } from '../connectors/plugin-sync.js';
+import { loadConnectorPolicies, readLocalConnectors } from '../connectors/store.js';
+import { ensureMetroPlugin } from '../claude/plugin-install.js';
+import { runningAsRoot } from '../metro-user/privilege.js';
+import { provisionAgentUser } from '../agent-user/provision.js';
+import { applyVault } from '../vault/index.js';
+import { blockImds } from '../metro-user/imds.js';
+import { followRelease } from '../metro-user/root-follow.js';
+import { unwatchSession, watchSession } from '../claude/session.js';
+import { liveEvents, memoryRoutine, tryClaudeSetup } from '../claude/setup.js';
+import { tryMemoryJob } from '../claude/memory-routine.js';
+import { applyLocalOwner } from './local-owner.js';
+import { installBearerSessions } from '../routes/bearer.js';
+import { ensureLocalAgent, localOwner } from '../agents/file-admin.js';
+import { ensureStationDeps } from '../stations/runtime-deps.js';
+import { localSessionApis } from '../routes/local-mode.js';
+import type { SessionApis } from '../routes/session-apis.js';
+import { createMetroMcp } from '../mcp/index.js';
+import { startPromptExpiry } from '../approvals/pending.js';
+import { watchPolicySnapshot } from '../mcp/policy-snapshot.js';
+import { gatherAccountsForAgents } from '../mcp/accounts.js';
+import { stationToolGroups } from '../mcp/tool-catalog.js';
+import {
+  accountStationCapabilities,
+  forgetOrphans,
+  stationByName,
+} from '../stations/registry.js';
+import { prepareAccount } from '../stations/attach.js';
+import { knownAccounts } from '../agents/map.js';
+import { materializeFrom, reloadFrom } from '../stations/materialize.js';
+import type { StationName } from '@metro-labs/core/station-names';
+import { startUploadReaper } from '../files/upload-store.js';
+import { startAttachReaper } from '../files/attach-reaper.js';
+import { startCloudWatchPublisher } from '../server/cloudwatch.js';
+import { watchFallbackUsage } from '../gateway/usage-refresh.js';
+import { isCallEvent, leaveCallsForShutdown, onCallEvent, sweepLeftoverCalls } from '../voice/calls.js';
+
+installCrashGuard();
+acquireLock(join(STATE_DIR, '.tail-lock'));
+
+log.info({ self: userSelf() }, 'user identity');
+
+process.stdout.on('error', (err) => {
+  if ((err as NodeJS.ErrnoException).code !== 'EPIPE')
+    log.warn({ err: errMsg(err) }, 'stdout error');
+});
+
+const supervisor = new TrainSupervisor();
+const emit = makeEmit();
+
+supervisor.onTrainEvent((env, train) => {
+  if (isCallEvent(env)) {
+    onCallEvent(env);
+    return;
+  }
+  const entry = trainEventToMetroEvent(env, train);
+  if (entry) emit(entry);
+});
+
+let webhookServer: Server | null = null;
+const tunnel = tunnelWanted() ? new Tunnel(funnelDriver(webhookPort()), announcePublic) : null;
+
+function announcePublic(url: string): void {
+  process.stderr.write(`\n${publicConnectHint(url, localOwner())}`);
+}
+
+setTrainCallBackend((train, action, args) =>
+  supervisor.call(train, action, args),
+);
+
+function announceLocalEndpoint(): void {
+  process.stderr.write(
+    `\n${tunnel === null ? localConnectHint(webhookPort(), localOwner()) : tunnelPendingHint()}`,
+  );
+}
+
+async function syncStations(station: StationName): Promise<void> {
+  const { removed } = await reloadFrom(fileSource);
+  if (stationByName(station)?.hasTrain === false) return;
+  if (removed.includes(station)) await supervisor.stopTrain(station);
+  else {
+    ensureStationDeps(station);
+    supervisor.requestReload(station);
+  }
+}
+
+function sessionApis(setLiveEvents: (on: boolean) => void, switchModel: (model: string | null) => boolean): SessionApis {
+  return localSessionApis({
+      syncStations,
+      reloadAgents: async () => {
+        await reloadFrom(fileSource);
+      },
+      restart: () => {
+        exitCode = RESTART_EXIT;
+        onShutdown();
+      },
+      stop: () => {
+        exitCode = HOLD_EXIT;
+        onShutdown();
+      },
+      gatherAccounts: gatherAccountsForAgents,
+      capabilities: accountStationCapabilities,
+      toolGroups: stationToolGroups,
+      prepareAccount,
+      liveEvents: setLiveEvents,
+      switchModel,
+    });
+}
+
+
+async function main(): Promise<void> {
+  applyLocalOwner();
+installBearerSessions(agentsDir(), localOwner);
+  watchPolicySnapshot();
+  loadConnectorPolicies().catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'connector policy: loading the policies failed');
+  });
+  log.info({ agent: await ensureLocalAgent() }, 'local daemon: agent');
+  await materializeFrom(fileSource);
+  forgetOrphans(knownAccounts());
+  supervisor.start();
+  sweepLeftoverCalls();
+  const metroMcp = await createMetroMcp({ liveEvents: liveEvents() });
+  webhookServer = await startWebhookServer(
+    emit,
+    sessionApis(metroMcp.setLiveEvents, metroMcp.switchModel),
+    metroMcp.httpHandler,
+    true,
+  );
+  metroMcp.startInbound();
+  startPromptExpiry();
+  syncPluginServers(readLocalConnectors());
+  startUploadReaper();
+  startAttachReaper();
+  startCloudWatchPublisher();
+  watchFallbackUsage();
+  announceLocalEndpoint();
+  tunnel?.start();
+  log.info(
+    { tunnel: !!tunnel, trainsDir: trainsDir(), mcp: '/', version: METRO_VERSION },
+    'dispatcher ready',
+  );
+  markDaemonReady();
+  startClaude().catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'claude: could not start the Claude Code side');
+  });
+}
+
+async function startClaude(): Promise<void> {
+  if (runningAsRoot()) {
+    log.error('claude: Metro runs as root, so Claude Code never starts here; reinstall Metro as the metro user');
+    return;
+  }
+  const agentUser = await provisionAgentUser();
+  if (agentUser !== 'off') log.info({ agentUser }, 'agent-user: Claude Code runs as its own user');
+  if (agentUser === 'failed') return;
+  if (agentUser === 'ready') {
+    blockImds();
+    followRelease();
+    const vault = (await applyVault()).status;
+    if (vault.enabled) log.info({ running: vault.running, problem: vault.problem }, 'vault: the agent reaches the internet through the vault');
+  }
+  ensureMetroPlugin()
+    .then((outcome) => {
+      log.info({ outcome }, 'plugin: metro plugin for Claude Code');
+      if (outcome !== 'skipped') syncPluginServers(readLocalConnectors());
+    })
+    .catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'plugin: could not ensure the Claude Code plugin');
+    });
+  tryClaudeSetup();
+  tryMemoryJob(memoryRoutine());
+  watchSession();
+}
+
+const SHUTDOWN_TIMEOUT_MS = 3_000;
+const RESTART_EXIT = 75;
+const HOLD_EXIT = 76;
+let exitCode = 0;
+let shuttingDown = false;
+async function shutdown(): Promise<void> {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log.info('dispatcher shutting down');
+  const leaving = leaveCallsForShutdown();
+  unwatchSession();
+  tunnel?.stop();
+  if (webhookServer) {
+    const server = webhookServer;
+    await Promise.race([
+      new Promise<void>((r) => {
+        server.close(() => {
+          r();
+        });
+      }),
+      new Promise<void>((r) => {
+        setTimeout(r, SHUTDOWN_TIMEOUT_MS).unref();
+      }),
+    ]);
+  }
+  await leaving;
+  await supervisor.stop();
+  process.exit(exitCode);
+}
+const onShutdown = (): void => {
+  shutdown().catch((err: unknown) => {
+    log.error({ err: errMsg(err) }, 'dispatcher: shutdown failed');
+    process.exit(1);
+  });
+};
+for (const sig of ['SIGINT', 'SIGTERM'] as const) process.on(sig, onShutdown);
+
+await main().catch((err: unknown) => {
+  logFatalSync({ err: errMsg(err) }, 'dispatcher failed to start');
+  process.exit(1);
+});

package/runtime/node_modules/@metro-labs/daemon/src/boot/connect-hint.ts

@@ -0,0 +1,36 @@
+import { hostname } from 'node:os';
+
+const connectLink = (base: string): string => `https://metro.box/#/${new URL(base).host}`;
+
+const ownerLine = (owner: string | null): string =>
+  owner === null
+    ? 'No owner is set, so nobody can sign in. Restart with:  metro serve --owner <organization id>'
+    : `Only members of the organization ${owner} can sign in.`;
+
+export function localConnectHint(port: number, owner: string | null): string {
+  const here = `http://127.0.0.1:${String(port)}`;
+  const forward = `ssh -L ${String(port)}:127.0.0.1:${String(port)} ${hostname()}`;
+  return [
+    'Manage this machine from the web UI:',
+    '',
+    `  ${connectLink(here)}`,
+    '',
+    `From another computer, forward the port first:  ${forward}`,
+    ownerLine(owner),
+    '',
+  ].join('\n');
+}
+
+export function publicConnectHint(url: string, owner: string | null): string {
+  return [
+    'Manage this machine from the web UI, from anywhere:',
+    '',
+    `  ${connectLink(url)}`,
+    '',
+    ownerLine(owner),
+    '',
+  ].join('\n');
+}
+
+export const tunnelPendingHint = (): string =>
+  'Publishing this daemon through Tailscale Funnel… (if Tailscale asks to enable Funnel, its link is in the log)\n';

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/boot}/crash-guard.ts

@@ -1,4 +1,4 @@
-import { errMsg, log, logFatalSync } from './log.js';
+import { errMsg, log, logFatalSync } from '@metro-labs/core/log';
 
 export type CrashKind = 'unhandledRejection' | 'uncaughtException';
 

package/runtime/node_modules/@metro-labs/daemon/src/boot/local-owner.ts

@@ -0,0 +1,21 @@
+import { localOwner, setLocalOwner } from '../agents/file-admin.js';
+import { isOrganizationId } from '@metro-labs/http/workos-token';
+import { log } from '@metro-labs/core/log';
+
+export function applyLocalOwner(): string | null {
+  const wanted = process.env.METRO_OWNER?.trim() ?? '';
+  const stored = localOwner();
+  if (stored !== null) {
+    if (wanted !== '' && wanted !== stored)
+      log.info({ owner: stored, ignored: wanted }, 'local daemon: this machine already belongs to an organization, so --owner is ignored');
+    return stored;
+  }
+  if (isOrganizationId(wanted)) {
+    const owner = setLocalOwner(wanted);
+    log.info({ owner }, 'local daemon: owner set from METRO_OWNER');
+    return owner;
+  }
+  if (wanted !== '') log.info({ ignored: wanted }, 'local daemon: --owner is not an organization id, so it is ignored');
+  log.warn('local daemon: no organization owns this machine, so nobody can sign in; restart with metro serve --owner <organization id>');
+  return null;
+}

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/boot}/paths.ts

@@ -1,8 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import {
   closeSync,
-  existsSync,
-  mkdirSync,
   openSync,
   readFileSync,
   unlinkSync,
@@ -10,45 +8,19 @@ import {
 } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { log } from './log.js';
+import { fileURLToPath } from 'node:url';
+import { log } from '@metro-labs/core/log';
+import { ensureSecureDir } from '@metro-labs/core/secure-fs';
 
 export const STATE_DIR =
   process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
-mkdirSync(STATE_DIR, { recursive: true });
+ensureSecureDir(STATE_DIR);
 
-export const CONFIG_DIR =
-  process.env.METRO_CONFIG_DIR ??
-  join(process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), 'metro');
-export const CONFIG_ENV_FILE = join(CONFIG_DIR, '.env');
 
-export const TRAINS_ENV_FILE = join(homedir(), '.metro', '.env');
-
-export const envSources = (): readonly string[] => [
-  join(process.cwd(), '.env'),
-  TRAINS_ENV_FILE,
-  CONFIG_ENV_FILE,
-];
-
-const LINE_RE = /^\s*([A-Za-z_]\w*)\s*=\s*(.*?)\s*$/;
-const QUOTED_RE = /^(['"])(.*)\1$/;
-
-export function readDotenv(path: string): Record<string, string> {
-  if (!existsSync(path)) return {};
-  const out: Record<string, string> = {};
-  for (const line of readFileSync(path, 'utf8').split('\n')) {
-    const m = LINE_RE.exec(line);
-    if (m?.[1] !== undefined && m[2] !== undefined)
-      out[m[1]] = m[2].replace(QUOTED_RE, '$2');
-  }
-  return out;
-}
-
-export function loadMetroEnv(): void {
-  for (const path of envSources()) {
-    for (const [k, v] of Object.entries(readDotenv(path))) {
-      process.env[k] ??= v;
-    }
-  }
+export function trainsDir(): string {
+  const env = process.env.METRO_TRAINS_DIR?.trim();
+  if (env !== undefined && env !== '') return env;
+  return fileURLToPath(new URL('../../trains', import.meta.url));
 }
 
 function readLockPid(lockFile: string): number {

package/runtime/node_modules/@metro-labs/daemon/src/channels/addressed.ts

@@ -0,0 +1,26 @@
+import { str } from '@metro-labs/core/str';
+
+export type Addressed = 'direct' | 'mention' | 'reply';
+
+interface AddressFacts {
+  isPrivate?: unknown;
+  mentionsSelf?: unknown;
+  replyToSelf?: unknown;
+}
+
+export function addressedBy(facts: AddressFacts, replyTo: string, sent: ReadonlySet<string>): Addressed | undefined {
+  if (facts.isPrivate === true) return 'direct';
+  if (facts.mentionsSelf === true) return 'mention';
+  if (facts.replyToSelf === true || (replyTo !== '' && sent.has(replyTo))) return 'reply';
+  return undefined;
+}
+
+export function replyMeta(ev: Record<string, unknown>, sent: ReadonlySet<string>): Record<string, string> {
+  const replyTo = str(ev.replyTo);
+  const addressed = addressedBy(ev, replyTo, sent);
+  return {
+    ...(replyTo ? { reply_to: replyTo } : {}),
+    ...(addressed === undefined ? {} : { addressed }),
+    ...(typeof ev.senderVerified === 'boolean' ? { sender_verified: String(ev.senderVerified) } : {}),
+  };
+}

package/runtime/node_modules/@metro-labs/{mcp → daemon}/src/channels/inbound.ts

@@ -1,6 +1,5 @@
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { str } from '../mcp/str.js';
-import { dedupeKey } from './dedupe.js';
+import { str } from '@metro-labs/core/str';
 import {
   buildMediaFailureNote,
   buildMediaNote,
@@ -8,6 +7,7 @@ import {
   type SavedMedia,
 } from './media-note.js';
 import { buildWebhookNote } from './webhook-note.js';
+import { replyMeta } from './addressed.js';
 import {
   capSet,
   displayNameMeta,
@@ -18,31 +18,54 @@ import {
   type PendingAtt,
   type PendingMsg,
 } from './pending.js';
+import { agentUser } from '../agent-user/user.js';
+
+const PERMISSION_REPLY_RE = /^\s*(y|yes|n|no)\s+([a-km-z]{5})\s*$/i;
+
+const accountStrippedLine = (line: string): string => {
+  const parts = line.split('/');
+  if (parts.length < 5) return line;
+  return [parts[0], parts[1], parts[2], ...parts.slice(4)].join('/');
+};
+
+const dedupeKey = (station: string, line: string, kind: string, messageId: string): string =>
+  `${station} ${accountStrippedLine(line)} ${kind} ${messageId}`;
+
+const shortId = (id: string): string => (id.length > 10 ? `${id.slice(0, 6)}…` : id);
+
+function reactionEmoji(raw: unknown): string {
+  if (typeof raw === 'string') return raw;
+  const obj = raw as { name?: string; reaction?: string } | undefined;
+  return obj?.name ?? obj?.reaction ?? '';
+}
+
+function reactContent(emoji: string, target: string, removed: boolean): string {
+  const verb = removed ? 'removed from' : 'reacted to';
+  const label = removed ? emoji || 'reaction' : emoji || 'reacted';
+  return `${label} ${verb} message ${shortId(target)}`.trim();
+}
 
 interface InboundDeps {
   mcp: Server;
   log: (...a: unknown[]) => void;
   getStations: () => Set<string>;
-  senderAllowed: (from: string, line: string) => boolean;
+  senderAllowed: (from: string, line: string, verified?: boolean) => boolean;
+  approves?: (station: string) => boolean;
+  answerPermission?: (requestId: string, behavior: 'allow' | 'deny', line: string, from: string) => Promise<boolean>;
 }
 
 const ATTACH_TIMEOUT_MS = 15_000;
 const DEDUPE_TTL_MS = 30_000;
 const DEDUPE_MAX = 2_000;
 const ALLOWED_LINES_MAX = 2_000;
-const PENDING_PERMISSIONS_MAX = 500;
-
-const PERMISSION_REPLY_RE = /^\s*(y|yes|n|no)\s+([a-km-z]{5})\s*$/i;
-
-const shortId = (id: string): string =>
-  id.length > 10 ? `${id.slice(0, 6)}…` : id;
+const SENT_IDS_MAX = 2_000;
 
 export class InboundRelay {
   private readonly deps: InboundDeps;
   private readonly pendingAttachments = new Map<string, PendingMsg>();
   private readonly seenEvents = new Map<string, number>();
   private readonly allowedLines = new Set<string>();
-  private readonly pendingPermissions = new Set<string>();
+  private readonly sentIds = new Set<string>();
   private lastLine: string | undefined;
 
   constructor(deps: InboundDeps) {
@@ -53,9 +76,15 @@ export class InboundRelay {
     return this.lastLine;
   }
 
-  registerPermission(requestId: string): void {
-    this.pendingPermissions.add(requestId);
-    capSet(this.pendingPermissions, PENDING_PERMISSIONS_MAX);
+  dropPending(): void {
+    for (const e of this.pendingAttachments.values()) clearTimeout(e.timer);
+    this.pendingAttachments.clear();
+  }
+
+  noteSent(messageId: string): void {
+    if (!messageId) return;
+    this.sentIds.add(messageId);
+    capSet(this.sentIds, SENT_IDS_MAX);
   }
 
   private notify(method: string, params: Record<string, unknown>): Promise<void> {
@@ -95,6 +124,7 @@ export class InboundRelay {
         from: ctx.from,
         station: ctx.station,
         ...senderMeta(ctx),
+        ...ctx.reply,
         kind: note.kind,
         mime: p.mime ?? '',
         name: note.name,
@@ -104,11 +134,12 @@ export class InboundRelay {
   }
 
   private async surfaceMedia(ctx: MediaCtx, p: SavedMedia): Promise<void> {
-    const note = await buildMediaNote(p, ctx.text ?? '');
+    const ownUser = agentUser() !== null;
+    const note = await buildMediaNote(p, ctx.text ?? '', !ownUser);
     if (!note) return;
     await this.surfaceNote(ctx, p, note, {
       ...(p.url ? { url: p.url } : {}),
-      local_path: note.path,
+      ...(ownUser ? {} : { local_path: note.path }),
     });
   }
 
@@ -140,6 +171,7 @@ export class InboundRelay {
         line_name: e.lineName,
         from_name: e.fromName,
         ...displayNameMeta(e.fromDisplayName),
+        ...e.reply,
       },
     });
   }
@@ -197,6 +229,7 @@ export class InboundRelay {
       lineName: str(ev.lineName),
       fromName: str(ev.fromName),
       fromDisplayName: str(ev.fromDisplayName),
+      reply: replyMeta(ev, this.sentIds),
       attachments: atts.map((a) => ({ kind: a.kind, name: a.name })),
       saved: new Set<number>(),
       timer: setTimeout(() => {
@@ -224,9 +257,7 @@ export class InboundRelay {
     const removed =
       (ev.payload as { removed?: boolean } | undefined)?.removed === true ||
       / \(removed\)\]?$/.test(base.text);
-    const verb = removed ? 'removed from' : 'reacted to';
-    const label = removed ? emoji || 'reaction' : emoji || 'reacted';
-    const content = `${label} ${verb} message ${shortId(target)}`.trim();
+    const content = reactContent(emoji, target, removed);
     await this.notify('notifications/claude/channel', {
       content,
       meta: {
@@ -244,28 +275,33 @@ export class InboundRelay {
     });
   }
 
-  private async handlePermissionReply(text: string): Promise<boolean> {
-    const m = PERMISSION_REPLY_RE.exec(text);
-    if (m?.[1] === undefined || m[2] === undefined || !this.pendingPermissions.size)
-      return false;
-    const id = m[2].toLowerCase();
-    if (!this.pendingPermissions.has(id)) return false;
-    this.pendingPermissions.delete(id);
-    await this.notify('notifications/claude/channel/permission', {
-      request_id: id,
-      behavior: m[1].toLowerCase().startsWith('y') ? 'allow' : 'deny',
-    });
-    return true;
+  private async handlePermissionReply(ev: Record<string, unknown>, base: EventBase): Promise<boolean> {
+    const answer = this.deps.answerPermission;
+    if (answer === undefined || base.evType !== 'msg' || !this.approves(base.station) || ev.senderVerified === false) return false;
+    const m = PERMISSION_REPLY_RE.exec(base.text);
+    if (m?.[1] === undefined || m[2] === undefined) return false;
+    return answer(m[2].toLowerCase(), m[1].toLowerCase().startsWith('y') ? 'allow' : 'deny', base.line, base.from);
+  }
+
+  private approves(station: string): boolean {
+    return this.deps.approves?.(station) !== false;
+  }
+
+  private noteLine(base: EventBase): void {
+    if (base.evType !== 'system' && this.approves(base.station)) this.lastLine = base.line;
+    if (!base.line) return;
+    this.allowedLines.add(base.line);
+    capSet(this.allowedLines, ALLOWED_LINES_MAX);
   }
 
-  private droppedSender(from: string, line: string): boolean {
+  private droppedSender(from: string, line: string, verified: unknown): boolean {
     if (
       from.startsWith('metro://claude') ||
       from === 'metro://user' ||
       !from.startsWith('metro://')
     )
       return true;
-    if (!this.deps.senderAllowed(from, line)) {
+    if (!this.deps.senderAllowed(from, line, typeof verified === 'boolean' ? verified : undefined)) {
       this.deps.log('drop: sender not allowed', from);
       return true;
     }
@@ -284,7 +320,7 @@ export class InboundRelay {
     if (!this.deps.getStations().has(station)) return null;
     const from = str(ev.from);
     const line = str(ev.line);
-    if (this.droppedSender(from, line)) return null;
+    if (this.droppedSender(from, line, ev.senderVerified)) return null;
     const text = str(ev.text);
     if (!replay && this.isDuplicate(station, line, evType, str(ev.messageId))) {
       this.deps.log(
@@ -302,8 +338,11 @@ export class InboundRelay {
     ev: Record<string, unknown>,
     base: EventBase,
   ): Promise<void> {
-    if (base.evType === 'msg' && (await this.handlePermissionReply(base.text)))
+    if (base.evType === 'msg' && base.text.trim() === '') {
+      this.deps.log('drop: empty message', base.station, base.line, str(ev.messageId));
       return;
+    }
+    if (await this.handlePermissionReply(ev, base)) return;
     await this.notify('notifications/claude/channel', {
       content:
         base.evType === 'system'
@@ -318,6 +357,7 @@ export class InboundRelay {
         line_name: str(ev.lineName),
         from_name: str(ev.fromName),
         ...displayNameMeta(ev.fromDisplayName),
+        ...replyMeta(ev, this.sentIds),
       },
     });
   }
@@ -330,11 +370,7 @@ export class InboundRelay {
 
     const base = this.routable(ev, replay);
     if (!base) return;
-    if (base.evType !== 'system') this.lastLine = base.line;
-    if (base.line) {
-      this.allowedLines.add(base.line);
-      capSet(this.allowedLines, ALLOWED_LINES_MAX);
-    }
+    this.noteLine(base);
 
     const atts = (ev.payload as { attachments?: PendingAtt[] } | undefined)
       ?.attachments;
@@ -347,7 +383,6 @@ export class InboundRelay {
       await this.handleReact(ev, base);
       return;
     }
-
     await this.emitMessage(ev, base);
   }
 }
@@ -360,8 +395,3 @@ interface EventBase {
   text: string;
 }
 
-function reactionEmoji(raw: unknown): string {
-  if (typeof raw === 'string') return raw;
-  const obj = raw as { name?: string; reaction?: string } | undefined;
-  return obj?.name ?? obj?.reaction ?? '';
-}