agent-relay-server 0.120.5 → 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/commands-db.ts

@@ -38,11 +38,13 @@ const TERMINAL_STATUSES: CommandStatus[] = ["succeeded", "failed", "canceled", "
 // committed to doing the work, not from enqueue.
 const SPAWN_TTL_MS = 180_000;
 const LIFECYCLE_TTL_MS = 30_000;
+const WORKSPACE_COMMAND_TTL_MS = 20 * 60_000;
 const DISPATCH_STATUSES: CommandStatus[] = ["accepted", "running"];
 
 function commandTtlMs(type: string): number | undefined {
   if (type === "agent.spawn") return SPAWN_TTL_MS;
   if (type === "agent.shutdown" || type === "agent.restart" || type === "agent.reconnect" || type === "agent.kill" || type === "agent.compact" || type === "agent.clearContext" || type === "agent.injectContext") return LIFECYCLE_TTL_MS;
+  if (type === "workspace.merge" || type === "workspace.cleanup" || type === "workspace.reconcile" || type === "workspace.idle-refresh") return WORKSPACE_COMMAND_TTL_MS;
   return undefined;
 }
 
@@ -148,6 +150,18 @@ export function findSpawnCommandByRequestId(spawnRequestId: string, statuses?: C
   return rows[0] ? rowToCommand(rows[0]) : null;
 }
 
+export function findLatestCommandByCorrelation(type: string, correlationId: string): Command | null {
+  const row = getDb()
+    .query(`
+      SELECT * FROM commands
+      WHERE type = ? AND correlation_id = ?
+      ORDER BY created_at DESC
+      LIMIT 1
+    `)
+    .get(type, correlationId) as CommandRow | undefined;
+  return row ? rowToCommand(row) : null;
+}
+
 export function countInFlightSpawnCommands(parentId: string): number {
   const row = getDb()
     .query(

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/delivery.ts

@@ -474,13 +474,95 @@ export function resolveQueuedDirectMessages(agentId: string): Message[] {
  * message that died without ever reaching its recipient — as a health signal.
  */
 export function countExpiredUndeliveredMessages(now: number = Date.now(), windowMs = 86_400_000): number {
-  return (getDb().query(`
-    SELECT COUNT(*) as c FROM messages
+  return summarizeExpiredUndeliveredMessages(now, windowMs).unexplainedCount;
+}
+
+interface ExpiredUndeliveredRow {
+  id: number;
+  toTarget: string;
+  kind: string;
+  subject?: string | null;
+  policyValue?: string | null;
+  policyStatus?: string | null;
+  policyAgentId?: string | null;
+  policyLastError?: string | null;
+}
+
+export interface ExpiredUndeliveredMessagesSummary {
+  totalCount: number;
+  unexplainedCount: number;
+  explainedManagedPolicyCount: number;
+  subjects: NonNullable<HealthCheck["subjects"]>;
+}
+
+function managedPolicyExpiryExplanation(row: ExpiredUndeliveredRow): string | undefined {
+  if (!row.toTarget.startsWith("policy:")) return undefined;
+  if (typeof row.policyValue !== "string") return undefined;
+  const policy = parseJson<Record<string, unknown>>(row.policyValue, {});
+  if (policy.enabled === false) return "managed policy is disabled";
+  if (row.policyStatus === "backoff" || row.policyStatus === "failed") {
+    return `managed policy is ${row.policyStatus}${row.policyLastError ? `: ${row.policyLastError}` : ""}`;
+  }
+  return undefined;
+}
+
+/**
+ * Classify queued-message expiries that happened within the trailing window.
+ * Channel/direct/unknown expiries remain a silent-loss health warning. Managed
+ * policy expiries with an explicit unavailable policy state are explained by the
+ * policy health surface instead, so they stay visible without degrading global
+ * health as generic message loss (#998).
+ */
+export function summarizeExpiredUndeliveredMessages(now: number = Date.now(), windowMs = 86_400_000): ExpiredUndeliveredMessagesSummary {
+  const rows = getDb().query(`
+    SELECT
+      m.id,
+      m.to_target AS toTarget,
+      m.kind,
+      m.subject,
+      c.value AS policyValue,
+      s.status AS policyStatus,
+      s.agent_id AS policyAgentId,
+      s.last_error AS policyLastError
+    FROM messages m
+    LEFT JOIN config c
+      ON c.namespace = 'spawn-policy'
+     AND c.key = substr(m.to_target, 8)
+    LEFT JOIN managed_agent_state s
+      ON s.policy_name = substr(m.to_target, 8)
     WHERE delivery_status = 'dead'
       AND delivery_poison_reason = 'queued message expired'
       AND delivery_updated_at IS NOT NULL
       AND delivery_updated_at >= ?
-  `).get(now - windowMs) as { c: number }).c;
+  `).all(now - windowMs) as ExpiredUndeliveredRow[];
+
+  let unexplainedCount = 0;
+  let explainedManagedPolicyCount = 0;
+  const explainedByTarget = new Map<string, { count: number; detail: string }>();
+
+  for (const row of rows) {
+    const explanation = managedPolicyExpiryExplanation(row);
+    if (!explanation) {
+      unexplainedCount += 1;
+      continue;
+    }
+    explainedManagedPolicyCount += 1;
+    const existing = explainedByTarget.get(row.toTarget);
+    if (existing) existing.count += 1;
+    else explainedByTarget.set(row.toTarget, { count: 1, detail: explanation });
+  }
+
+  return {
+    totalCount: rows.length,
+    unexplainedCount,
+    explainedManagedPolicyCount,
+    subjects: [...explainedByTarget.entries()].slice(0, 10).map(([target, item]) => ({
+      id: target,
+      label: target,
+      status: "explained",
+      detail: `${item.count} expired message(s); ${item.detail}`,
+    })),
+  };
 }
 
 export function expireQueuedMessages(now: number = Date.now()): Message[] {

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 (