agent-relay-server 0.120.1 → 0.120.3

package/public/index.html

@@ -12,34 +12,34 @@
   <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='6' fill='%2309090b'/%3E%3Ccircle cx='16' cy='16' r='4.5' fill='%2358a6ff'/%3E%3Ccircle cx='6' cy='8' r='2.5' fill='%233fb950'/%3E%3Ccircle cx='26' cy='8' r='2.5' fill='%233fb950'/%3E%3Ccircle cx='6' cy='24' r='2.5' fill='%233fb950'/%3E%3Ccircle cx='26' cy='24' r='2.5' fill='%233fb950'/%3E%3Cline x1='8' y1='9.5' x2='13' y2='14' stroke='%2330363d' stroke-width='1.5'/%3E%3Cline x1='24' y1='9.5' x2='19' y2='14' stroke='%2330363d' stroke-width='1.5'/%3E%3Cline x1='8' y1='22.5' x2='13' y2='18' stroke='%2330363d' stroke-width='1.5'/%3E%3Cline x1='24' y1='22.5' x2='19' y2='18' stroke='%2330363d' stroke-width='1.5'/%3E%3C/svg%3E">
   <link rel="manifest" href="manifest.webmanifest">
   <link rel="apple-touch-icon" href="icons/agent-relay-192.png">
-  <script type="module" crossorigin src="./assets/index-D_fNJnsI.js"></script>
+  <script type="module" crossorigin src="./assets/index-Ceiwd02X.js"></script>
   <link rel="modulepreload" crossorigin href="./assets/chunk-CilyBKbf.js">
   <link rel="modulepreload" crossorigin href="./assets/preload-helper-C_JMBXql.js">
-  <link rel="modulepreload" crossorigin href="./assets/lucide-react-Dc3ZwCBi.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-ChDX_t12.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-Cs8X0P1d.js">
-  <link rel="modulepreload" crossorigin href="./assets/react-dom-cLkVFBsS.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-CQ0Z-TDi.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-mm7c7nBt.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-CDZZxxJq.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-DV83j9tm.js">
+  <link rel="modulepreload" crossorigin href="./assets/lucide-react-DuhlF2Sj.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-B-T7lg0a.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-BIjlN-xB.js">
+  <link rel="modulepreload" crossorigin href="./assets/react-dom-DWBmcawP.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-B9G83DXv.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-DT-OV6sQ.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-C7aTlosb.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-B3e4B9pg.js">
   <link rel="modulepreload" crossorigin href="./assets/dist-BiLuYU6G.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-DyNJNwpi.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-D2jvo5oA.js">
-  <link rel="modulepreload" crossorigin href="./assets/es2015-VnZ2kVIz.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-CmFeEXMe.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-CBMWGhWc.js">
-  <link rel="modulepreload" crossorigin href="./assets/dist-y03IwOrd.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-BInckSJC.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-DGfp5dLz.js">
+  <link rel="modulepreload" crossorigin href="./assets/es2015-CnKXYKpf.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-BlzVGRhh.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-OUPTEP6q.js">
+  <link rel="modulepreload" crossorigin href="./assets/dist-B6woQ9Tb.js">
   <link rel="modulepreload" crossorigin href="./assets/types-uVOXgvMT.js">
   <link rel="modulepreload" crossorigin href="./assets/display-exQDWum3.js">
-  <link rel="modulepreload" crossorigin href="./assets/store-BuuJUn70.js">
-  <link rel="modulepreload" crossorigin href="./assets/agent-type-icon-BEz393ra.js">
-  <link rel="modulepreload" crossorigin href="./assets/button-C-V4oij1.js">
-  <link rel="modulepreload" crossorigin href="./assets/copy-button-BStzXgtd.js">
-  <link rel="modulepreload" crossorigin href="./assets/formatted-body-Dg9R3RD7.js">
-  <link rel="modulepreload" crossorigin href="./assets/task-chip-kxk4eNm1.js">
-  <link rel="modulepreload" crossorigin href="./assets/badge-BhUZ1cAb.js">
-  <link rel="modulepreload" crossorigin href="./assets/input-CtLT7WXi.js">
+  <link rel="modulepreload" crossorigin href="./assets/store-BM4zM89B.js">
+  <link rel="modulepreload" crossorigin href="./assets/agent-type-icon-CeEoMouY.js">
+  <link rel="modulepreload" crossorigin href="./assets/button-CzdTkRIf.js">
+  <link rel="modulepreload" crossorigin href="./assets/copy-button-B3o1jpLu.js">
+  <link rel="modulepreload" crossorigin href="./assets/formatted-body-q_qzt1L-.js">
+  <link rel="modulepreload" crossorigin href="./assets/task-chip-DXfvXBDx.js">
+  <link rel="modulepreload" crossorigin href="./assets/badge-DCIT3Irj.js">
+  <link rel="modulepreload" crossorigin href="./assets/input-B6Q0NWCS.js">
   <link rel="modulepreload" crossorigin href="./assets/themes-DjSwmAZN.js">
   <link rel="stylesheet" crossorigin href="./assets/index-DcmG5gLR.css">
 </head>

package/runner/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.120.1",
+  "version": "0.120.3",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/automations/reconcile.ts

@@ -1,5 +1,5 @@
 import { createCommand } from "../commands-db";
-import { getAgent, getTask, listOrchestrators, sendMessage, updateTaskStatus } from "../db";
+import { getAgent, getTask, listAgents, listOrchestrators, sendMessage, updateTaskStatus } from "../db";
 import { renderTemplate } from "../prompt-resolver";
 import { CLOSED_TASK_STATUS } from "./constants";
 import {
@@ -11,7 +11,7 @@ import {
   db,
 } from "./storage";
 import type { AutomationReconcileResult } from "./types";
-import type { AutomationRun, AutomationRunStatus, AutomationRuntimeBudget, Command, Message, Task } from "../types";
+import type { AgentCard, AutomationRun, AutomationRunStatus, AutomationRuntimeBudget, Command, Message, Task } from "../types";
 
 export function reconcileAutomationRuns(now = Date.now()): AutomationReconcileResult[] {
   ensureAutomationTables();
@@ -41,6 +41,11 @@ export function reconcileAutomationRuns(now = Date.now()): AutomationReconcileRe
     if (!CLOSED_TASK_STATUS.has(task.status)) {
       const updated = getAutomationRun(run.id);
       if (!updated) continue;
+      const neverReadyOffline = maybeFailNeverReadyOfflineTarget(updated, task, now);
+      if (neverReadyOffline) {
+        results.push(neverReadyOffline);
+        continue;
+      }
       const timedOut = maybeTimeoutRuntimeBudget(updated, task, now);
       if (timedOut) {
         results.push(timedOut);
@@ -68,9 +73,8 @@ export function reconcileAutomationRuns(now = Date.now()): AutomationReconcileRe
 }
 
 function automationRunRuntimeMeta(run: AutomationRun, task: Task): Record<string, unknown> {
-  const agentId = task.claimedBy ?? run.targetAgentId ?? run.spawnedAgentId;
+  const { agentId, agent } = resolveAutomationRunAgent(run, task);
   if (!agentId) return {};
-  const agent = getAgent(agentId);
   const managed = listOrchestrators()
     .flatMap((orchestrator) => orchestrator.managedAgents.map((managedAgent) => ({ orchestrator, managedAgent })))
     .find(({ managedAgent }) => managedAgent.agentId === agentId);
@@ -103,6 +107,23 @@ function hasMetaChanges(current: Record<string, unknown>, patch: Record<string,
   return Object.entries(patch).some(([key, value]) => current[key] !== value);
 }
 
+function resolveAutomationRunAgent(run: AutomationRun, task: Task): { agentId?: string; agent?: AgentCard } {
+  const explicitAgentId = task.claimedBy ?? run.targetAgentId ?? run.spawnedAgentId ?? stringMeta(run.meta, "runtimeAgentId");
+  if (explicitAgentId) return { agentId: explicitAgentId, agent: getAgent(explicitAgentId) ?? undefined };
+
+  const onDemandLabel = stringMeta(run.meta, "onDemandLabel");
+  const agent = listAgents().find((candidate) =>
+    (onDemandLabel !== undefined && candidate.label === onDemandLabel) ||
+    stringMeta(candidate.meta, "automationRunId") === run.id
+  );
+  return agent ? { agentId: agent.id, agent } : {};
+}
+
+function isOnDemandAutomationRun(run: AutomationRun): boolean {
+  if (run.meta.targetMode === "on_demand_agent") return true;
+  return getAutomation(run.automationId)?.targetPolicy.mode === "on_demand_agent";
+}
+
 function runtimeBudgetForRun(run: AutomationRun): AutomationRuntimeBudget | undefined {
   const automation = getAutomation(run.automationId);
   if (!automation || automation.targetPolicy.mode !== "on_demand_agent") return undefined;
@@ -163,6 +184,50 @@ function maybeWarnRuntimeBudget(run: AutomationRun, task: Task, now: number): Me
   return message;
 }
 
+function maybeFailNeverReadyOfflineTarget(run: AutomationRun, task: Task, now: number): AutomationReconcileResult | undefined {
+  if (!isOnDemandAutomationRun(run) || task.claimedBy) return undefined;
+  const { agentId, agent } = resolveAutomationRunAgent(run, task);
+  if (!agentId || !agent || agent.status !== "offline" || agent.ready) return undefined;
+
+  const reason = "Automation target went offline before becoming ready";
+  const taskResult = updateTaskStatus(task.id, {
+    status: "canceled",
+    agentId,
+    result: reason,
+    body: reason,
+    metadata: {
+      automationId: run.automationId,
+      automationRunId: run.id,
+      automationTargetOffline: true,
+      automationTargetNeverReady: true,
+      agentId,
+    },
+  });
+  const updatedTask = taskResult.task ?? getTask(task.id) ?? task;
+  updateRun(run.id, {
+    status: "failed",
+    finishedAt: now,
+    error: reason,
+    result: {
+      taskStatus: updatedTask.status,
+      automationTargetOffline: true,
+      automationTargetNeverReady: true,
+      agentId,
+    },
+    targetAgentId: agentId,
+    spawnedAgentId: run.spawnedAgentId ?? agentId,
+    meta: {
+      ...run.meta,
+      runtimeAgentId: agentId,
+      runtimeAgentStatus: agent.status,
+      runtimeAgentReady: agent.ready,
+      runtimeTargetOfflineAt: now,
+      runtimeTargetNeverReady: true,
+    },
+  }, now);
+  return { run: getAutomationRun(run.id)!, task: getTask(task.id) ?? updatedTask };
+}
+
 function maybeTimeoutRuntimeBudget(run: AutomationRun, task: Task, now: number): AutomationReconcileResult | undefined {
   const budget = runtimeBudgetForRun(run);
   if (!budget) return undefined;

package/src/branch-landed.ts

@@ -8,6 +8,7 @@ import { resolveCoordinatorAgentId } from "./steward-identity";
 import { stewardFallbackTarget } from "./config";
 import { handleLandedIssueLifecycle } from "./services/issue-lifecycle";
 import { handleLandedTaskLifecycle } from "./services/task-lifecycle";
+import { runGit } from "./services/git-process";
 import type { WorkspaceMergePreview, WorkspaceRecord } from "./types";
 
 // #444 — branch.landed is the first rule-driven type: the on-main "merged" fan-out audience comes
@@ -46,7 +47,7 @@ export interface BranchLandedInput {
 }
 
 type BranchLandedLogFn = (message: string) => void;
-type LandedCommitSubjectResolver = (input: BranchLandedInput, log: BranchLandedLogFn) => string[] | undefined;
+type LandedCommitSubjectResolver = (input: BranchLandedInput, log: BranchLandedLogFn) => string[] | undefined | Promise<string[] | undefined>;
 
 let landedCommitSubjectResolverForTests: LandedCommitSubjectResolver | undefined;
 
@@ -59,7 +60,7 @@ function cleanRef(value: string | undefined): string | undefined {
   return cleaned || undefined;
 }
 
-function landedCommitSubjects(input: BranchLandedInput, log: BranchLandedLogFn): string[] | undefined {
+async function landedCommitSubjects(input: BranchLandedInput, log: BranchLandedLogFn): Promise<string[] | undefined> {
   if (landedCommitSubjectResolverForTests) return landedCommitSubjectResolverForTests(input, log);
   if (input.prLand) return undefined;
   const repoRoot = cleanRef(input.workspace.repoRoot);
@@ -67,17 +68,13 @@ function landedCommitSubjects(input: BranchLandedInput, log: BranchLandedLogFn):
   const tipSha = cleanRef(input.mergedSha);
   if (!repoRoot || !baseSha || !tipSha || baseSha === tipSha) return undefined;
   try {
-    const proc = Bun.spawnSync(["git", "-C", repoRoot, "log", "--format=%B%x00", `${baseSha}..${tipSha}`], {
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    if (proc.exitCode !== 0) {
-      const error = Buffer.from(proc.stderr).toString("utf8").trim() || `exit ${proc.exitCode}`;
+    const { stdout, stderr, exitCode, timedOut } = await runGit(["-C", repoRoot, "log", "--format=%B%x00", `${baseSha}..${tipSha}`]);
+    if (exitCode !== 0) {
+      const error = timedOut ? "timed out" : stderr.trim() || `exit ${exitCode}`;
       log(`issue lifecycle commit range scan failed for ${input.workspace.id} (${baseSha.slice(0, 12)}..${tipSha.slice(0, 12)}): ${error}; falling back to tip subject`);
       return undefined;
     }
-    const subjects = Buffer.from(proc.stdout).toString("utf8").split("\x00").map((msg) => msg.trim()).filter(Boolean);
+    const subjects = stdout.split("\x00").map((msg) => msg.trim()).filter(Boolean);
     return subjects.length > 0 ? subjects : undefined;
   } catch (error) {
     log(`issue lifecycle commit range scan failed for ${input.workspace.id} (${baseSha.slice(0, 12)}..${tipSha.slice(0, 12)}): ${errMessage(error)}; falling back to tip subject`);
@@ -94,6 +91,13 @@ function resolveLandedTask(workspace: Pick<WorkspaceRecord, "branch" | "ownerAge
   return task ? { taskId: task.id, taskLabel: task.title } : undefined;
 }
 
+function landedNotificationIdempotencyKey(input: BranchLandedInput, landedTask: { taskId: number } | undefined, base: string): string | undefined {
+  const sha = cleanRef(input.mergedSha);
+  if (sha) return `branch-landed:${sha}`;
+  if (landedTask) return `branch-landed:task:${landedTask.taskId}:${base}`;
+  return undefined;
+}
+
 /**
  * #239 — turn an authoritative land completion into a relay-driven push so the author
  * stops polling to learn it merged. Always emits the durable `branch.landed` event (the
@@ -108,8 +112,8 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
   const landedBranch = workspace.branch;
   const shortSha = input.mergedSha ? input.mergedSha.slice(0, 12) : undefined;
   const lifecycleLog = (message: string) => console.warn(message);
-  const commitSubjects = landedCommitSubjects(input, lifecycleLog);
   const landedTask = resolveLandedTask(workspace);
+  const idempotencyKey = landedNotificationIdempotencyKey(input, landedTask, base);
 
   emitRelayEvent({
     type: "branch.landed",
@@ -151,6 +155,7 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
   // receipt accurate. Both are best-effort + isolated — a throw in either can never fail the merge
   // (it already landed before notifyBranchLanded runs). A non-task branch makes the Task drive a no-op.
   void (async () => {
+    const commitSubjects = await landedCommitSubjects(input, lifecycleLog);
     try {
       await handleLandedIssueLifecycle({ ...input, commitSubjects }, { log: lifecycleLog });
     } catch (error) {
@@ -208,6 +213,7 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
           continueLabel,
         }),
         payload: { ...payload, notification: "landed-success" },
+        idempotencyKey,
         replyExpected: false,
       },
     });
@@ -231,6 +237,7 @@ export function notifyBranchLanded(input: BranchLandedInput): void {
       subject: `Merged to ${base}`,
       body: `🔀 ${branchLabel}${authorLabel} merged to \`${base}\`${shaLabel}${subjectLabel}.${publishLabel}`,
       payload: { ...payload, notification: "landed-success" },
+      idempotencyKey,
       replyExpected: false,
     },
   });

package/src/bus.ts

@@ -31,7 +31,7 @@ import {
 } from "agent-relay-sdk/protocol";
 import { errMessage, isRecord } from "agent-relay-sdk";
 import { getComponentAuth, isComponentAuthorizedFor, isAuthorized, isOriginAllowed, unauthorized } from "./security";
-import type { Command, ComponentToken, ContextState, Message, ProviderCapabilities, QuotaState, RegisterAgentInput, Task } from "./types";
+import type { AgentCard, Command, ComponentToken, ContextState, Message, ProviderCapabilities, QuotaState, RegisterAgentInput, Task } from "./types";
 
 interface BusSocketData {
   kind: "bus";
@@ -503,36 +503,43 @@ function withRegistered(
 }
 
 function broadcastRelayEvent(event: RelayEvent): void {
+  const frame = JSON.stringify({
+    type: "event",
+    payload: {
+      seq: event.seq,
+      eventType: event.type,
+      source: event.source,
+      subject: event.subject,
+      data: event.data,
+      timestamp: event.timestamp,
+    },
+  });
+  const agentCache = new Map<string, AgentCard | null>();
   for (const conn of busConnections.values()) {
-    if (!connectionWantsEvent(conn, event)) continue;
-    send(conn.ws, {
-      type: "event",
-      payload: {
-        seq: event.seq,
-        eventType: event.type,
-        source: event.source,
-        subject: event.subject,
-        data: event.data,
-        timestamp: event.timestamp,
-      },
-    });
+    if (!connectionWantsEvent(conn, event, agentCache)) continue;
+    conn.ws.send(frame);
   }
 }
 
-function connectionWantsEvent(conn: BusConnection, event: RelayEvent): boolean {
+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;
+}
+
+function connectionWantsEvent(conn: BusConnection, event: RelayEvent, agentCache: Map<string, AgentCard | null>): boolean {
   if (!matchesSubscription(conn.subscriptions, event.type)) return false;
+  if (event.type === "agent.status" && conn.agentId) return event.subject === conn.agentId || (typeof event.data.id === "string" && event.data.id === conn.agentId);
   if (event.type === "message.new" && conn.agentId) {
-    return messageMatchesAgent(event.data as unknown as Message, conn.agentId, getAgent(conn.agentId));
+    return messageMatchesAgent(event.data as unknown as Message, conn.agentId, fanoutAgent(conn.agentId, agentCache));
   }
   if (event.type.startsWith("task.") && conn.agentId) {
     const target = typeof event.data.target === "string" ? event.data.target : "";
-    return targetMatchesAgent(target, conn.agentId, getAgent(conn.agentId));
+    return targetMatchesAgent(target, conn.agentId, fanoutAgent(conn.agentId, agentCache));
   }
   if (event.type.startsWith("command.")) {
     const command = isRecord(event.data.command) ? event.data.command : undefined;
     if (!command) return true;
-    const target = typeof command.target === "string" ? command.target : "";
-    const source = typeof command.source === "string" ? command.source : "";
+    const target = typeof command.target === "string" ? command.target : "", source = typeof command.source === "string" ? command.source : "";
     return target === conn.componentId || target === conn.agentId || source === conn.componentId || source === conn.agentId;
   }
   return true;

package/src/db/connection.ts

@@ -1,12 +1,15 @@
 import { Database } from "bun:sqlite";
+import { join } from "node:path";
 import { DB_SLOW_QUERY_MS } from "../config";
 
 // The shared SQLite handle. Set once by initDb() (schema.ts) and read everywhere
 // else through getDb(). Kept module-private so the only mutation path is setDb().
 let db: Database;
+let dbPath: string | undefined;
 
-export function setDb(conn: Database): void {
+export function setDb(conn: Database, path?: string): void {
   db = conn;
+  dbPath = path;
 }
 
 export function getDb(): Database {
@@ -14,6 +17,10 @@ export function getDb(): Database {
   return db;
 }
 
+export function getDbPath(): string | undefined {
+  return dbPath;
+}
+
 // Connection-scoped pragmas. journal_mode and auto_vacuum persist in the file;
 // the rest reset per connection, so they must be re-applied on every open.
 export function applyConnectionPragmas(conn: Database): void {
@@ -67,6 +74,51 @@ export function runDbMaintenance(options: { vacuum?: boolean } = {}): {
   return { analyzed: true, checkpointed: true, vacuumed };
 }
 
+export async function runDbMaintenanceWorker<T>(operation: string, args: string[], signal?: AbortSignal): Promise<T> {
+  if (!dbPath || dbPath === ":memory:") {
+    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], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  let killTimer: Timer | undefined;
+  const abort = () => {
+    proc.kill("SIGTERM");
+    killTimer = setTimeout(() => proc.kill("SIGKILL"), 2_000);
+  };
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+    if (signal?.aborted) throw new Error("database worker aborted");
+    if (exitCode !== 0) {
+      const detail = stderr.trim() || stdout.trim() || `exit ${exitCode}`;
+      throw new Error(`database worker ${operation} failed: ${detail}`);
+    }
+    return JSON.parse(stdout) as T;
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    if (killTimer) clearTimeout(killTimer);
+  }
+}
+
+export async function runDbMaintenanceAsync(options: { vacuum?: boolean; signal?: AbortSignal } = {}): Promise<{
+  analyzed: boolean;
+  checkpointed: boolean;
+  vacuumed: boolean;
+  offThread: boolean;
+}> {
+  if (!dbPath || dbPath === ":memory:") return { ...runDbMaintenance(options), offThread: false };
+  const result = await runDbMaintenanceWorker<{ analyzed: boolean; checkpointed: boolean; vacuumed: boolean }>(
+    "db-maintenance",
+    [options.vacuum ? "vacuum" : "no-vacuum"],
+    options.signal,
+  );
+  return { ...result, offThread: true };
+}
+
 // Shared error types thrown across query domains and unwrapped at call sites.
 // `ValidationError` now lives in the SDK (agent-relay-sdk) as the single canonical
 // home shared with the orchestrator package; re-exported here so the ~120 server

package/src/db/maintenance-worker.ts

@@ -0,0 +1,37 @@
+import { Database } from "bun:sqlite";
+import { applyConnectionPragmas } from "./connection";
+
+const [, , operation, dbPath, arg] = Bun.argv;
+
+if (!operation || !dbPath) {
+  console.error("operation and db path are required");
+  process.exit(2);
+}
+
+const db = new Database(dbPath, { create: true });
+try {
+  applyConnectionPragmas(db);
+  if (operation === "db-maintenance") {
+    db.run("ANALYZE");
+    db.run("PRAGMA optimize");
+    db.run("PRAGMA wal_checkpoint(TRUNCATE)");
+    let vacuumed = false;
+    if (arg === "vacuum") {
+      db.run("VACUUM");
+      vacuumed = true;
+    }
+    console.log(JSON.stringify({ analyzed: true, checkpointed: true, vacuumed }));
+  } else if (operation === "old-message-prune") {
+    const cutoff = Number(arg);
+    if (!Number.isFinite(cutoff)) throw new Error("old-message-prune requires a cutoff timestamp");
+    const prunedMessages = db.transaction(() => {
+      db.query("UPDATE messages SET reply_to = NULL WHERE reply_to IN (SELECT id FROM messages WHERE created_at < ?)").run(cutoff);
+      return db.query("DELETE FROM messages WHERE created_at < ?").run(cutoff).changes;
+    })();
+    console.log(JSON.stringify({ prunedMessages }));
+  } else {
+    throw new Error(`unknown maintenance operation: ${operation}`);
+  }
+} finally {
+  db.close();
+}

package/src/db/message-reads.ts

@@ -15,9 +15,9 @@ import {
 import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
 import { matchAgents } from "../agent-ref";
 import { getAgent } from "./agents.ts";
-import { getMessage, sendMessageWithResult } from "./messages.ts";
+import { sendMessageWithResult } from "./messages.ts";
 import { deleteArtifactLinksForEntity } from "./artifacts.ts";
-import { getDb, timedQuery } from "./connection.ts";
+import { getDb, getDbPath, runDbMaintenanceWorker, timedQuery } from "./connection.ts";
 import { legacyChannelTargets, isChannelAgentId } from "./delivery.ts";
 import { messageTaskClosed } from "./claim-sql.ts";
 import { MSG_SELECT, rowToMessage } from "./mappers.ts";
@@ -393,25 +393,58 @@ function relayConversationId(message: Message): string | undefined {
   return stringField(replyContext?.conversationId) ?? stringField(conversation?.id);
 }
 
-function isCoveredByLaterAgentResponse(message: Message, agentId: string): boolean {
+function messagesCoveredByLaterAgentResponses(messages: Message[], agentId: string): Set<number> {
+  if (messages.length === 0) return new Set();
   // Order by id, not created_at: ids are monotonic insertion order, so this is
   // robust when a reply lands in the same millisecond as the message it covers
   // (created_at > … strictly would miss it, leaving the message wrongly pending).
-  const replies = (getDb().query(`
-    ${MSG_SELECT}
-    WHERE m.from_agent = ?
-      AND m.id > ?
-    ORDER BY m.id ASC
-    LIMIT 200
-  `).all(agentId, message.id) as any[]).map(rowToMessage);
-
-  const conversationId = relayConversationId(message);
-  return replies.some((reply) => {
-    if (reply.replyTo === message.id) return true;
-    if (message.threadId !== undefined && reply.threadId === message.threadId) return true;
-    if (!message.channel || reply.channel !== message.channel || !conversationId) return false;
-    return relayConversationId(reply) === conversationId;
-  });
+  const minMessageId = Math.min(...messages.map((message) => message.id));
+  const replies = getDb().query(`
+    SELECT id, thread_id, channel, reply_to, payload
+    FROM messages INDEXED BY idx_msg_from_id
+    WHERE from_agent = ?
+      AND id > ?
+    ORDER BY id ASC
+  `).all(agentId, minMessageId) as Array<{ id: number; thread_id: number | null; channel: string | null; reply_to: number | null; payload: string }>;
+  if (replies.length === 0) return new Set();
+
+  const covered = new Set<number>();
+  const conversationsById = new Map<number, string | undefined>();
+  for (const message of messages) conversationsById.set(message.id, relayConversationId(message));
+
+  for (const message of messages) {
+    const conversationId = conversationsById.get(message.id);
+    for (const reply of replies) {
+      if (reply.id <= message.id) continue;
+      if (reply.reply_to === message.id) {
+        covered.add(message.id);
+        break;
+      }
+      if (message.threadId !== undefined && reply.thread_id === message.threadId) {
+        covered.add(message.id);
+        break;
+      }
+      if (!message.channel || reply.channel !== message.channel || !conversationId) continue;
+      if (relayConversationId({
+        id: reply.id,
+        from: agentId,
+        to: "",
+        body: "",
+        kind: "chat",
+        channel: reply.channel ?? undefined,
+        replyTo: reply.reply_to ?? undefined,
+        threadId: reply.thread_id ?? undefined,
+        payload: parseJson(reply.payload ?? "{}", {}),
+        meta: {},
+        readBy: [],
+        createdAt: 0,
+      }) === conversationId) {
+        covered.add(message.id);
+        break;
+      }
+    }
+  }
+  return covered;
 }
 
 function replyObligationFromMessage(message: Message, agentId: string): ReplyObligation {
@@ -433,11 +466,20 @@ function replyObligationFromMessage(message: Message, agentId: string): ReplyObl
 export function listPendingReplyObligations(agentId: string, limit = 20): ReplyObligation[] {
   const scanLimit = Math.max(limit * 5, 50);
   const rows = timedQuery("listPendingReplyObligations", () => getDb().query(`
-    ${MSG_SELECT}
-    WHERE EXISTS (
-      SELECT 1 FROM message_reads mr
-      WHERE mr.message_id = m.id AND mr.agent_id = ?
-    )
+    SELECT m.*, (
+      SELECT json_group_array(agent_id) FROM message_reads WHERE message_id = m.id
+    ) AS read_by_agents, (
+      SELECT json_group_array(json_object(
+        'messageId', message_id,
+        'actorId', actor_id,
+        'emoji', emoji,
+        'createdAt', created_at,
+        'updatedAt', updated_at
+      )) FROM message_reactions WHERE message_id = m.id
+    ) AS reactions_json
+    FROM message_reads mr INDEXED BY idx_mr_agent
+    JOIN messages m ON m.id = mr.message_id
+    WHERE mr.agent_id = ?
       AND m.from_agent != ?
       AND NOT EXISTS (
         SELECT 1 FROM messages reply
@@ -447,10 +489,12 @@ export function listPendingReplyObligations(agentId: string, limit = 20): ReplyO
     ORDER BY m.created_at ASC
     LIMIT ?
   `).all(agentId, agentId, agentId, scanLimit) as any[]);
-  return rows
+  const candidates = rows
     .map(rowToMessage)
-    .filter(messageRequiresReply)
-    .filter((message) => !isCoveredByLaterAgentResponse(message, agentId))
+    .filter(messageRequiresReply);
+  const covered = messagesCoveredByLaterAgentResponses(candidates, agentId);
+  return candidates
+    .filter((message) => !covered.has(message.id))
     .slice(0, limit)
     .map((message) => replyObligationFromMessage(message, agentId));
 }
@@ -484,25 +528,6 @@ export function channelObligationAnsweredBy(
   return open.length === 1 ? open[0]!.messageId : null;
 }
 
-/**
- * Spawn report-back linking (#492): a spawned worker's actual task is delivered as the provider
- * prompt, while `seedSpawnReplyObligation` creates a short Stop-hook contract message so the worker
- * cannot go idle without reporting back. Workers commonly send their natural completion report
- * directly to the spawning coordinator; when there is exactly one open spawn obligation from that
- * coordinator, that send is the answer. Link it to the obligation at send time so the Stop hook does
- * not nag the worker into re-sending the same verdict through `/reply`.
- */
-export function spawnObligationAnsweredBy(
-  agentId: string,
-  spawnerAgentId: string,
-): number | null {
-  const open = listPendingReplyObligations(agentId, 50).filter((obligation) => {
-    if (obligation.from !== spawnerAgentId) return false;
-    return getMessage(obligation.messageId)?.payload?.source === "spawn-obligation";
-  });
-  return open.length === 1 ? open[0]!.messageId : null;
-}
-
 /**
  * #573 — spawned children no longer get a report-back reply obligation. Their turn-final
  * response is promoted server-side to the spawn-parent by lineage, so creating a separate
@@ -605,6 +630,10 @@ export function getLatestMessageId(): number {
 
 export function pruneOldMessages(maxAgeMs: number): number {
   const cutoff = Date.now() - maxAgeMs;
+  return pruneOldMessagesBefore(cutoff);
+}
+
+function pruneOldMessagesBefore(cutoff: number): number {
   return getDb().transaction(() => {
     getDb()
       .query("UPDATE messages SET reply_to = NULL WHERE reply_to IN (SELECT id FROM messages WHERE created_at < ?)")
@@ -614,3 +643,15 @@ export function pruneOldMessages(maxAgeMs: number): number {
       .run(cutoff).changes;
   })();
 }
+
+export async function pruneOldMessagesAsync(maxAgeMs: number, options: { signal?: AbortSignal } = {}): Promise<{
+  prunedMessages: number;
+  offThread: boolean;
+}> {
+  const cutoff = Date.now() - maxAgeMs;
+  if (!getDbPath() || getDbPath() === ":memory:") {
+    return { prunedMessages: pruneOldMessagesBefore(cutoff), offThread: false };
+  }
+  const result = await runDbMaintenanceWorker<{ prunedMessages: number }>("old-message-prune", [String(cutoff)], options.signal);
+  return { ...result, offThread: true };
+}

package/src/db/migrations.ts

@@ -411,6 +411,7 @@ export function applyMigrations(): void {
     getDb().run("ALTER TABLE messages ADD COLUMN payload TEXT NOT NULL DEFAULT '{}'");
   }
   getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_kind ON messages(kind)");
+  getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_from_id ON messages(from_agent, id)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_from_kind_id ON messages(from_agent, kind, id)"); getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_analytics_created ON messages(created_at, kind, from_agent, claimable, reply_to)"); getDb().run("CREATE INDEX IF NOT EXISTS idx_msg_session_analytics ON messages(kind, created_at, json_extract(payload, '$.session.type'), json_extract(payload, '$.session.label'), json_extract(payload, '$.session.turnId'))");
   // (from_agent, idempotency_key) powers findMessageByIdempotencyKey — the retry-dedup lookup
   // AND the session-step in-place upsert (Codex tool running→completed / streamed reasoning),