agent-relay-server 0.120.6 → 0.121.0

package/src/agent-card-projection.ts

@@ -1,19 +1,30 @@
-// The ONE projection applied to an AgentCard before it leaves the relay over SSE or REST:
+// The ONE projection source for agent cards before they leave the relay:
 // branch-state badge fields (#236) + the resolved `issueRepo` for chat #NNN linkify (#533).
 //
 // Every `agent.status` emitter MUST route through this — the direct dashboard emitter
-// (sse.ts) AND the bus lifecycle emitter (bus.ts). The dashboard's agent.status handler
-// FULL-REPLACES its cached agent card with whatever arrives, so a single emitter sending a
-// raw (un-enriched) card silently blanks these derived fields until the next REST poll —
-// which made #NNN links and branch badges flicker on/off every few seconds (#560). Keeping
-// one projection here is the structural guarantee that projection == reality on every
-// surface; a new emitter can't reintroduce the drift without going around this function.
+// (sse.ts) AND the bus lifecycle emitter (bus.ts). The dashboard merges the slim status
+// projection into its cached card, so a raw (un-enriched) status tick would still blank
+// derived fields on fresh/new cards until the next REST poll (#560).
 
+import { isRecord } from "agent-relay-sdk";
 import { attachBranchState } from "./agent-branch-state";
 import { deriveAgentBusyHealth } from "./agent-busy-health";
 import { attachIssueRepo } from "./agent-issue-repo";
 import type { AgentCard } from "./types";
 
+const OMITTED_STATUS_META_KEYS = new Set([
+  "agentProfile",
+  "auth",
+  "providerCapabilities",
+  "lifecycleCapabilities",
+]);
+
+const OMITTED_STATUS_WORKSPACE_KEYS = new Set([
+  "deps",
+  "probe",
+  "symlinks",
+]);
+
 /** Enrich an AgentCard with the derived fields the dashboard expects on every surface. */
 export function projectAgentCard(agent: AgentCard): AgentCard {
   const projected = attachIssueRepo(attachBranchState(agent));
@@ -21,11 +32,30 @@ export function projectAgentCard(agent: AgentCard): AgentCard {
   return busyHealth ? { ...projected, meta: { ...(projected.meta ?? {}), busyHealth } } : projected;
 }
 
+function projectStatusMeta(meta: AgentCard["meta"]): AgentCard["meta"] | undefined {
+  if (!meta) return undefined;
+  const projected: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(meta)) {
+    if (OMITTED_STATUS_META_KEYS.has(key)) continue;
+    if (key === "workspace" && isRecord(value)) {
+      projected.workspace = Object.fromEntries(Object.entries(value).filter(([workspaceKey]) => !OMITTED_STATUS_WORKSPACE_KEYS.has(workspaceKey)));
+      continue;
+    }
+    projected[key] = value;
+  }
+  return projected;
+}
+
 /** The `agent.status` SSE payload: the enriched card when the agent is known, else the
- *  minimal offline stub the dashboard treats as "agent gone". Shared by both emitters. */
+ *  minimal offline stub the dashboard treats as "agent gone". Shared by both emitters.
+ *  Runtime status stays live, while bulky static/secret launch projection fields stay
+ *  behind GET /api/agents/:id and the normal dashboard polling path. */
 export function projectAgentStatusData(
   agentId: string,
   agent: AgentCard | null | undefined,
 ): AgentCard | { id: string; status: string } {
-  return agent ? projectAgentCard(agent) : { id: agentId, status: "offline" };
+  if (!agent) return { id: agentId, status: "offline" };
+  const projected = projectAgentCard(agent);
+  const meta = projectStatusMeta(projected.meta);
+  return meta ? { ...projected, meta } : { ...projected, meta: undefined };
 }

package/src/bus-outbox.ts

@@ -20,6 +20,23 @@ interface OutboxRow {
 
 export function appendEvent(type: string, source: string, data: unknown, subject?: string): number {
   const timestamp = Date.now();
+  if (type === "message.batch") {
+    const messages = batchMessages(data);
+    if (messages.length > 0) {
+      return getDb().transaction(() => {
+        let firstSeq = 0;
+        const insert = getDb().query(`
+          INSERT INTO bus_outbox (event_type, source, subject, data, timestamp)
+          VALUES (?, ?, ?, ?, ?)
+        `);
+        for (const message of messages) {
+          const result = insert.run("message.new", message.from, String(message.id), JSON.stringify(message), timestamp);
+          if (firstSeq === 0) firstSeq = Number(result.lastInsertRowid);
+        }
+        return firstSeq;
+      })();
+    }
+  }
   const result = getDb().query(`
     INSERT INTO bus_outbox (event_type, source, subject, data, timestamp)
     VALUES (?, ?, ?, ?, ?)
@@ -73,3 +90,16 @@ function parseData(raw: string): Record<string, unknown> {
     return {};
   }
 }
+
+function batchMessages(data: unknown): Array<{ id: number; from: string } & Record<string, unknown>> {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+  const messages = (data as { messages?: unknown }).messages;
+  if (!Array.isArray(messages)) return [];
+  return messages.filter((message): message is { id: number; from: string } & Record<string, unknown> =>
+    Boolean(message) &&
+    typeof message === "object" &&
+    !Array.isArray(message) &&
+    typeof (message as { id?: unknown }).id === "number" &&
+    typeof (message as { from?: unknown }).from === "string"
+  );
+}

package/src/bus.ts

@@ -471,7 +471,7 @@ function handleResume(ws: BusWebSocket, frameId: string, since: number): void {
     sendError(ws, frameId, "REPLAY_GAP", "requested cursor is older than retained bus outbox events");
     return;
   }
-  const events = replayEvents(since).map(outboxToPayload);
+  const events = replayEvents(since).flatMap(outboxToPayloads);
   send(ws, {
     type: "resumed",
     payload: {
@@ -503,6 +503,10 @@ function withRegistered(
 }
 
 function broadcastRelayEvent(event: RelayEvent): void {
+  if (event.type === "message.batch") {
+    broadcastMessageBatch(event);
+    return;
+  }
   const frame = JSON.stringify({
     type: "event",
     payload: {
@@ -521,6 +525,41 @@ function broadcastRelayEvent(event: RelayEvent): void {
   }
 }
 
+function broadcastMessageBatch(event: RelayEvent): void {
+  const messages = batchMessages(event.data);
+  const messageEvents = messages.map((message, index) => {
+    const messageEvent: RelayEvent = {
+      ...event,
+      seq: event.seq + index,
+      type: "message.new",
+      source: message.from,
+      subject: String(message.id),
+      data: message as unknown as Record<string, unknown>,
+    };
+    return {
+      event: messageEvent,
+      frame: JSON.stringify({
+        type: "event",
+        payload: {
+          seq: messageEvent.seq,
+          eventType: "message.new",
+          source: message.from,
+          subject: String(message.id),
+          data: message,
+          timestamp: event.timestamp,
+        },
+      }),
+    };
+  });
+  const agentCache = new Map<string, AgentCard | null>();
+  for (const conn of busConnections.values()) {
+    for (const { event: messageEvent, frame } of messageEvents) {
+      if (!connectionWantsEvent(conn, messageEvent, agentCache)) continue;
+      conn.ws.send(frame);
+    }
+  }
+}
+
 function fanoutAgent(agentId: string, cache: Map<string, AgentCard | null>): AgentCard | null {
   if (!cache.has(agentId)) cache.set(agentId, getAgent(agentId));
   return cache.get(agentId) ?? null;
@@ -565,6 +604,23 @@ function outboxToPayload(event: BusEvent) {
   };
 }
 
+function outboxToPayloads(event: BusEvent) {
+  if (event.eventType !== "message.batch") return [outboxToPayload(event)];
+  return batchMessages(event.data).map((message, index) => ({
+    seq: event.seq + index,
+    eventType: "message.new",
+    source: message.from,
+    subject: String(message.id),
+    data: message as unknown as Record<string, unknown>,
+    timestamp: event.timestamp,
+  }));
+}
+
+function batchMessages(data: Record<string, unknown>): Message[] {
+  const messages = (data as { messages?: unknown }).messages;
+  return Array.isArray(messages) ? messages as Message[] : [];
+}
+
 function emitAgentStatusEvent(agentId: string): void {
   const agent = getAgent(agentId);
   // Same enriched projection as sse.ts's emitAgentStatus — without this the bus lifecycle

package/src/config-store.ts

@@ -9,6 +9,7 @@ import {
   validateNotificationsConfig,
 } from "./notification-settings";
 import { DEFAULT_SELF_RESUME_CONFIG, validateSelfResumeConfig } from "./self-resume-config";
+import { RETENTION_NAMESPACE, validateRetentionConfig } from "./retention-config";
 import { TEAM_TEMPLATE_NAMESPACE, validateTeamTemplate } from "./team-template-config";
 import { PROJECT_INSTRUCTION_POLICY_NAMES } from "./project-instructions";
 import { renderTemplate } from "./prompt-resolver";
@@ -674,6 +675,7 @@ function normalizeValue(namespace: string, key: string, value: unknown): unknown
   if (namespace === SELF_RESUME_NAMESPACE) return validateSelfResumeConfig(value);
   if (namespace === WORKSPACE_NAMESPACE) return validateWorkspaceConfig(value);
   if (namespace === LANDING_NAMESPACE) return validateLandingConfig(value);
+  if (namespace === RETENTION_NAMESPACE) return validateRetentionConfig(value);
   if (namespace === TEAM_TEMPLATE_NAMESPACE) return validateTeamTemplate(key, value);
   if (JSON.stringify(value) === undefined) throw new ValidationError("value must be valid JSON");
   return value;

package/src/config.ts

@@ -64,6 +64,10 @@ export const STUCK_BUSY_PROVIDER_TURN_MS = envPositiveInt("AGENT_RELAY_STUCK_BUS
 export const STUCK_BUSY_STARTUP_MS = envPositiveInt("AGENT_RELAY_STUCK_BUSY_STARTUP_MS", STUCK_BUSY_THRESHOLD_MS);
 export const STUCK_BUSY_RECONNECT_MS = envPositiveInt("AGENT_RELAY_STUCK_BUSY_RECONNECT_MS", STUCK_BUSY_THRESHOLD_MS);
 export const STUCK_BUSY_SHUTDOWN_MS = envPositiveInt("AGENT_RELAY_STUCK_BUSY_SHUTDOWN_MS", STUCK_BUSY_THRESHOLD_MS);
+export const EVENT_LOOP_LAG_SAMPLE_MS = envPositiveInt("AGENT_RELAY_EVENT_LOOP_LAG_SAMPLE_MS", 1_000);
+export const EVENT_LOOP_LAG_WINDOW_SAMPLES = envPositiveInt("AGENT_RELAY_EVENT_LOOP_LAG_WINDOW_SAMPLES", 60);
+export const EVENT_LOOP_LAG_WARN_MS = envNonNegativeNumber("AGENT_RELAY_EVENT_LOOP_LAG_WARN_MS", 250);
+export const EVENT_LOOP_LAG_LOG_MS = envNonNegativeNumber("AGENT_RELAY_EVENT_LOOP_LAG_LOG_MS", EVENT_LOOP_LAG_WARN_MS);
 // #713 — provider-token silence ALONE is not a wedge signal for Claude (long turns, extended
 // thinking, and native compaction all go token-silent while healthy). Before declaring stuck we
 // ALSO require the transport heartbeat to be genuinely dead: no server frame / heartbeat-ack within

package/src/db/connection.ts

@@ -1,4 +1,5 @@
 import { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { DB_SLOW_QUERY_MS } from "../config";
 
@@ -79,7 +80,8 @@ export async function runDbMaintenanceWorker<T>(operation: string, args: string[
     throw new Error("database worker requires a file-backed database");
   }
   if (signal?.aborted) throw new Error("database worker aborted");
-  const proc = Bun.spawn([process.execPath, join(import.meta.dir, "maintenance-worker.ts"), operation, dbPath, ...args], {
+  const bunPath = existsSync(process.execPath) ? process.execPath : (Bun.which("bun") ?? process.execPath);
+  const proc = Bun.spawn([bunPath, join(import.meta.dir, "maintenance-worker.ts"), operation, dbPath, ...args], {
     stdin: "ignore",
     stdout: "pipe",
     stderr: "pipe",

package/src/db/index.ts

@@ -33,6 +33,7 @@ export * from "./continuations.ts";
 export * from "./continuation-archives.ts";
 export * from "./crash-reports.ts";
 export * from "./terminal-events.ts";
+export * from "./retention.ts";
 export * from "./plans.ts";
 export * from "./teams.ts";
 export * from "./blackboard.ts";

package/src/db/maintenance-worker.ts

@@ -29,6 +29,97 @@ try {
       return db.query("DELETE FROM messages WHERE created_at < ?").run(cutoff).changes;
     })();
     console.log(JSON.stringify({ prunedMessages }));
+  } else if (operation === "retention-prune") {
+    if (!arg) throw new Error("retention-prune requires options JSON");
+    const opts = JSON.parse(arg) as {
+      messageCutoff: number;
+      activityCutoff: number;
+      activityMaxRows: number;
+      spawnCommandCutoff: number;
+      batchSize: number;
+    };
+    const batchSize = Math.min(Math.max(Math.trunc(opts.batchSize), 1), 50_000);
+    const result = db.transaction(() => {
+      db.query(`
+        UPDATE messages
+        SET reply_to = NULL
+        WHERE reply_to IN (
+          SELECT id FROM messages
+          WHERE created_at < ?
+          ORDER BY created_at ASC, id ASC
+          LIMIT ?
+        )
+      `).run(opts.messageCutoff, batchSize);
+      const prunedMessages = db.query(`
+        DELETE FROM messages
+        WHERE id IN (
+          SELECT id FROM messages
+          WHERE created_at < ?
+          ORDER BY created_at ASC, id ASC
+          LIMIT ?
+        )
+      `).run(opts.messageCutoff, batchSize).changes;
+      const prunedActivityEvents = db.query(`
+        DELETE FROM activity_events
+        WHERE id IN (
+          SELECT ae.id
+          FROM activity_events ae
+          WHERE (
+              ae.created_at < ?
+              OR ae.id NOT IN (
+                SELECT id
+                FROM activity_events
+                ORDER BY created_at DESC, id DESC
+                LIMIT ?
+              )
+            )
+            AND NOT (
+              ae.kind = 'state'
+              AND ae.title = 'Agent registered'
+              AND EXISTS (
+                SELECT 1
+                FROM commands c
+                WHERE c.type = 'agent.spawn'
+                  AND c.status = 'succeeded'
+                  AND coalesce(json_extract(c.params, '$.registrationConfirmed'), 0) != 1
+                  AND (
+                    c.correlation_id = json_extract(ae.metadata, '$.spawnRequestId')
+                    OR json_extract(c.params, '$.spawnRequestId') = json_extract(ae.metadata, '$.spawnRequestId')
+                  )
+              )
+            )
+          ORDER BY ae.created_at ASC, ae.id ASC
+          LIMIT ?
+        )
+      `).run(opts.activityCutoff, opts.activityMaxRows, batchSize).changes;
+      const prunedSpawnCommands = db.query(`
+        DELETE FROM commands
+        WHERE id IN (
+          SELECT c.id
+          FROM commands c
+          WHERE c.type = 'agent.spawn'
+            AND c.status IN ('succeeded', 'failed', 'canceled', 'timed_out')
+            AND c.updated_at < ?
+            AND NOT (
+              c.status = 'succeeded'
+              AND coalesce(json_extract(c.params, '$.registrationConfirmed'), 0) != 1
+            )
+            AND NOT EXISTS (
+              SELECT 1
+              FROM managed_agent_state mas
+              WHERE mas.spawn_request_id IS NOT NULL
+                AND (
+                  mas.spawn_request_id = c.correlation_id
+                  OR mas.spawn_request_id = json_extract(c.params, '$.spawnRequestId')
+                )
+            )
+          ORDER BY c.updated_at ASC, c.created_at ASC
+          LIMIT ?
+        )
+      `).run(opts.spawnCommandCutoff, batchSize).changes;
+      return { prunedMessages, prunedActivityEvents, prunedSpawnCommands };
+    })();
+    console.log(JSON.stringify(result));
   } else {
     throw new Error(`unknown maintenance operation: ${operation}`);
   }

package/src/db/messages.ts

@@ -402,7 +402,21 @@ function sanitizeOccurredAt(occurredAt: number | undefined, receivedAt: number):
   return Math.floor(occurredAt);
 }
 
-export function sendMessageWithResult(input: SendMessageInput): { message: Message; created: boolean; updated?: boolean } {
+export interface SendMessageResult {
+  message: Message;
+  created: boolean;
+  updated?: boolean;
+}
+
+export function sendMessageWithResult(input: SendMessageInput): SendMessageResult {
+  return sendMessageWithResultInternal(input, true);
+}
+
+export function sendMessagesBatchWithResult(inputs: SendMessageInput[]): SendMessageResult[] {
+  return getDb().transaction(() => inputs.map((input) => sendMessageWithResultInternal(input, false)))();
+}
+
+function sendMessageWithResultInternal(input: SendMessageInput, wrapTransaction: boolean): SendMessageResult {
   const now = Date.now();
   const payload = input.payload ?? {};
   const attachmentRefs = cleanAttachmentRefs(payload);
@@ -495,7 +509,7 @@ export function sendMessageWithResult(input: SendMessageInput): { message: Messa
     maxAgeSeconds = DEFAULT_FANOUT_TTL_SECONDS;
   }
 
-  const id = getDb().transaction(() => {
+  const insertMessage = () => {
     const result = insert.run({
       $from: input.from,
       $to: input.to,
@@ -528,7 +542,8 @@ export function sendMessageWithResult(input: SendMessageInput): { message: Messa
       else enforceQueueLimit(input.to);
     }
     return newId;
-  })();
+  };
+  const id = wrapTransaction ? getDb().transaction(insertMessage)() : insertMessage();
 
   return { message: getMessage(id)!, created: true };
 }
@@ -543,7 +558,7 @@ export function getThread(messageId: number): Message[] {
   const threadId = msg.threadId ?? msg.id;
   return (
     getDb()
-      .query(`${MSG_SELECT} WHERE m.thread_id = ? ORDER BY m.created_at ASC`)
+      .query(`${MSG_SELECT} WHERE m.thread_id = ? ORDER BY m.created_at ASC, m.id ASC`)
       .all(threadId) as any[]
   ).map(rowToMessage);
 }

package/src/db/migrations.ts

@@ -706,6 +706,7 @@ export function applyMigrations(): void {
     getDb().run("ALTER TABLE agents ADD COLUMN team_id TEXT");
   }
   getDb().run("CREATE INDEX IF NOT EXISTS idx_agents_team ON agents(team_id)");
+  getDb().run("CREATE INDEX IF NOT EXISTS idx_agents_spawn_request ON agents(json_extract(meta, '$.spawnRequestId'))");
   getDb().run(`
     CREATE TABLE IF NOT EXISTS notification_subscriptions (
       id TEXT PRIMARY KEY,
@@ -913,6 +914,12 @@ export function applyMigrations(): void {
   getDb().run("CREATE INDEX IF NOT EXISTS idx_agent_active_memories_agent ON agent_active_memories(agent_id)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_agents_label ON agents(label)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_agents_kind ON agents(kind)");
+  getDb().run(`
+    CREATE INDEX IF NOT EXISTS idx_activity_registered_spawn_request
+    ON activity_events(json_extract(metadata, '$.spawnRequestId'))
+    WHERE kind = 'state' AND title = 'Agent registered'
+  `);
+  getDb().run("CREATE INDEX IF NOT EXISTS idx_commands_spawn_watchdog ON commands(type, status, updated_at)");
 
   getDb().run(`
     CREATE TABLE IF NOT EXISTS integration_registry (

package/src/db/retention.ts

@@ -0,0 +1,130 @@
+import { getDb, getDbPath, runDbMaintenanceWorker } from "./connection.ts";
+
+interface RetentionPruneInput {
+  messageCutoff: number;
+  activityCutoff: number;
+  activityMaxRows: number;
+  spawnCommandCutoff: number;
+  batchSize: number;
+}
+
+interface RetentionPruneResult {
+  prunedMessages: number;
+  prunedActivityEvents: number;
+  prunedSpawnCommands: number;
+  offThread: boolean;
+}
+
+function boundedBatchSize(batchSize: number): number {
+  return Math.min(Math.max(Math.trunc(batchSize), 1), 50_000);
+}
+
+function pruneMessagesBefore(cutoff: number, batchSize: number): number {
+  return getDb().transaction(() => {
+    getDb().query(`
+      UPDATE messages
+      SET reply_to = NULL
+      WHERE reply_to IN (
+        SELECT id FROM messages
+        WHERE created_at < ?
+        ORDER BY created_at ASC, id ASC
+        LIMIT ?
+      )
+    `).run(cutoff, batchSize);
+    return getDb().query(`
+      DELETE FROM messages
+      WHERE id IN (
+        SELECT id FROM messages
+        WHERE created_at < ?
+        ORDER BY created_at ASC, id ASC
+        LIMIT ?
+      )
+    `).run(cutoff, batchSize).changes;
+  })();
+}
+
+function pruneActivityEvents(input: RetentionPruneInput): number {
+  return getDb().query(`
+    DELETE FROM activity_events
+    WHERE id IN (
+      SELECT ae.id
+      FROM activity_events ae
+      WHERE (
+          ae.created_at < ?
+          OR ae.id NOT IN (
+            SELECT id
+            FROM activity_events
+            ORDER BY created_at DESC, id DESC
+            LIMIT ?
+          )
+        )
+        AND NOT (
+          ae.kind = 'state'
+          AND ae.title = 'Agent registered'
+          AND EXISTS (
+            SELECT 1
+            FROM commands c
+            WHERE c.type = 'agent.spawn'
+              AND c.status = 'succeeded'
+              AND coalesce(json_extract(c.params, '$.registrationConfirmed'), 0) != 1
+              AND (
+                c.correlation_id = json_extract(ae.metadata, '$.spawnRequestId')
+                OR json_extract(c.params, '$.spawnRequestId') = json_extract(ae.metadata, '$.spawnRequestId')
+              )
+          )
+        )
+      ORDER BY ae.created_at ASC, ae.id ASC
+      LIMIT ?
+    )
+  `).run(input.activityCutoff, input.activityMaxRows, input.batchSize).changes;
+}
+
+function pruneTerminalSpawnCommands(cutoff: number, batchSize: number): number {
+  return getDb().query(`
+    DELETE FROM commands
+    WHERE id IN (
+      SELECT c.id
+      FROM commands c
+      WHERE c.type = 'agent.spawn'
+        AND c.status IN ('succeeded', 'failed', 'canceled', 'timed_out')
+        AND c.updated_at < ?
+        AND NOT (
+          c.status = 'succeeded'
+          AND coalesce(json_extract(c.params, '$.registrationConfirmed'), 0) != 1
+        )
+        AND NOT EXISTS (
+          SELECT 1
+          FROM managed_agent_state mas
+          WHERE mas.spawn_request_id IS NOT NULL
+            AND (
+              mas.spawn_request_id = c.correlation_id
+              OR mas.spawn_request_id = json_extract(c.params, '$.spawnRequestId')
+            )
+        )
+      ORDER BY c.updated_at ASC, c.created_at ASC
+      LIMIT ?
+    )
+  `).run(cutoff, batchSize).changes;
+}
+
+export function pruneRetentionBatch(input: RetentionPruneInput): Omit<RetentionPruneResult, "offThread"> {
+  const batchSize = boundedBatchSize(input.batchSize);
+  return getDb().transaction(() => ({
+    prunedMessages: pruneMessagesBefore(input.messageCutoff, batchSize),
+    prunedActivityEvents: pruneActivityEvents({ ...input, batchSize }),
+    prunedSpawnCommands: pruneTerminalSpawnCommands(input.spawnCommandCutoff, batchSize),
+  }))();
+}
+
+export async function pruneRetentionBatchAsync(input: RetentionPruneInput, options: { signal?: AbortSignal } = {}): Promise<RetentionPruneResult> {
+  const normalized = { ...input, batchSize: boundedBatchSize(input.batchSize) };
+  if (!getDbPath() || getDbPath() === ":memory:") {
+    return { ...pruneRetentionBatch(normalized), offThread: false };
+  }
+  const result = await runDbMaintenanceWorker<Omit<RetentionPruneResult, "offThread">>(
+    "retention-prune",
+    [JSON.stringify(normalized)],
+    options.signal,
+  );
+  return { ...result, offThread: true };
+}

package/src/db/schema.ts

@@ -114,6 +114,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
       last_seen INTEGER NOT NULL,
       created_at INTEGER NOT NULL
     );
+    CREATE INDEX IF NOT EXISTS idx_agents_spawn_request ON agents(json_extract(meta, '$.spawnRequestId'));
     CREATE TABLE IF NOT EXISTS notification_subscriptions (
       id TEXT PRIMARY KEY,
       agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
@@ -865,6 +866,9 @@ export function initDb(path: string = "agent-relay.db"): Database {
     CREATE INDEX IF NOT EXISTS idx_activity_operator ON activity_events(operator_id, created_at);
     CREATE INDEX IF NOT EXISTS idx_activity_created ON activity_events(created_at);
     CREATE INDEX IF NOT EXISTS idx_activity_agent ON activity_events(agent_id, created_at); CREATE INDEX IF NOT EXISTS idx_activity_policy_created ON activity_events(json_extract(metadata, '$.policyName'), created_at DESC, id DESC);
+    CREATE INDEX IF NOT EXISTS idx_activity_registered_spawn_request
+      ON activity_events(json_extract(metadata, '$.spawnRequestId'))
+      WHERE kind = 'state' AND title = 'Agent registered';
     -- issue_ref_id/issue_action indexes are created in applyMigrations() AFTER the ALTER — never inline here (#483: inline index over a not-yet-migrated column crashes initDb on existing DBs).
 
     CREATE TABLE IF NOT EXISTS channels (
@@ -942,6 +946,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
     CREATE INDEX IF NOT EXISTS idx_commands_status ON commands(status);
     CREATE INDEX IF NOT EXISTS idx_commands_created ON commands(created_at);
     CREATE INDEX IF NOT EXISTS idx_commands_correlation ON commands(correlation_id);
+    CREATE INDEX IF NOT EXISTS idx_commands_spawn_watchdog ON commands(type, status, updated_at);
 
     CREATE TABLE IF NOT EXISTS recipe_instances (
       id TEXT PRIMARY KEY,

package/src/db/stats.ts

@@ -20,6 +20,7 @@ import { summarizeExpiredUndeliveredMessages } from "./delivery.ts";
 import { messageTaskClosed } from "./claim-sql.ts";
 import { claimTaskWhere } from "./task-core.ts";
 import { getDb } from "./connection.ts";
+import { getEventLoopLagSnapshot } from "../event-loop-lag";
 import type {
   AgentCard,
   ActivityEvent,
@@ -408,6 +409,27 @@ export function getHealth(now: number = Date.now()): HealthReport {
     checks.push({ name: "database", status: "error", detail: e instanceof Error ? e.message : "database check failed" });
   }
 
+  const eventLoopLag = getEventLoopLagSnapshot();
+  const eventLoopLagHealthMaxMs = Math.max(eventLoopLag.maxMs, eventLoopLag.maxSinceLastReadMs);
+  const eventLoopLagWarn = eventLoopLag.warnThresholdMs > 0 && eventLoopLag.sampleCount > 0 && eventLoopLagHealthMaxMs >= eventLoopLag.warnThresholdMs;
+  checks.push({
+    name: "event-loop-lag",
+    status: eventLoopLagWarn ? "warn" : "ok",
+    detail: eventLoopLagWarn
+      ? `event loop lag max ${Math.round(eventLoopLagHealthMaxMs)}ms over ${eventLoopLag.sampleCount}/${eventLoopLag.windowSamples} sample(s)`
+      : undefined,
+    metrics: {
+      currentMs: eventLoopLag.currentMs,
+      maxMs: eventLoopLag.maxMs,
+      maxSinceLastReadMs: eventLoopLag.maxSinceLastReadMs,
+      sampleCount: eventLoopLag.sampleCount,
+      windowSamples: eventLoopLag.windowSamples,
+      sampleIntervalMs: eventLoopLag.sampleIntervalMs,
+      warnThresholdMs: eventLoopLag.warnThresholdMs,
+      ...(eventLoopLag.lastSampleAt === undefined ? {} : { lastSampleAt: eventLoopLag.lastSampleAt }),
+    },
+  });
+
   const staleLiveAgents = (getDb()
     .query("SELECT COUNT(*) as c FROM agents WHERE status != 'offline' AND last_seen <= ? AND id NOT IN ('user', 'system')")
     .get(now - STALE_TTL_MS) as any).c as number;