agent-relay-server 0.94.4 → 0.94.5

package/docs/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Relay API",
-    "version": "0.94.4",
+    "version": "0.94.5",
     "description": "Real-time message bus for inter-agent communication. Agent-first: this spec is designed for machine consumption — agents can self-discover the full API surface via GET /api/spec.",
     "license": {
       "name": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-server",
-  "version": "0.94.4",
+  "version": "0.94.5",
   "description": "Lightweight HTTP message relay for inter-agent communication across machines",
   "module": "src/index.ts",
   "type": "module",

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.94.4",
+  "version": "0.94.5",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/db/delivery.ts

@@ -422,6 +422,23 @@ export function resolveQueuedPolicyMessages(policyName: string, agentId: string)
  * Returns the flushed messages so callers can emit `message.available` / `message.new` /
  * `message.delivery_updated` events.
  */
+/**
+ * Distinct direct (agent) targets that have messages still parked at
+ * `queued` older than `minAgeMs`. Backstop for #706: the primary recovery is
+ * flush-on-availability, but if that event is ever missed a queued message is
+ * invisible (pollMessages excludes `queued`) until it expires. The periodic
+ * resweep uses this to re-resolve such messages once the target is available.
+ */
+export function listStaleQueuedDirectTargets(now: number = Date.now(), minAgeMs = 60_000): string[] {
+  const rows = getDb().query(`
+    SELECT DISTINCT to_target FROM messages
+    WHERE delivery_status = 'queued'
+      AND to_target IS NOT NULL
+      AND COALESCE(queued_at, created_at) <= ?
+  `).all(now - minAgeMs) as Array<{ to_target: string }>;
+  return rows.map((row) => row.to_target);
+}
+
 export function resolveQueuedDirectMessages(agentId: string): Message[] {
   const rows = getDb().query(`
     SELECT m.id
@@ -451,6 +468,21 @@ export function resolveQueuedDirectMessages(agentId: string): Message[] {
   return ids.map((id) => getMessage(id)).filter((message): message is Message => Boolean(message));
 }
 
+/**
+ * Count messages that expired undelivered at max_age within the trailing
+ * `windowMs` (default 24h). Surfaces silent channel data loss (#706) — a queued
+ * 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
+    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;
+}
+
 export function expireQueuedMessages(now: number = Date.now()): Message[] {
   const rows = getDb().query(`
     SELECT id FROM messages

package/src/db/stats.ts

@@ -16,6 +16,7 @@ import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_ME
 import { matchAgents } from "../agent-ref";
 import { listAgents } from "./agents.ts";
 import { listChannels } from "./channels.ts";
+import { countExpiredUndeliveredMessages } from "./delivery.ts";
 import { messageTaskClosed } from "./claim-sql.ts";
 import { getDb } from "./connection.ts";
 import type {
@@ -466,6 +467,37 @@ export function getHealth(now: number = Date.now()): HealthReport {
       : undefined,
   });
 
+  // A channel bridge (e.g. Telegram) that is registered but stale or not-ready
+  // is silently NOT delivering — channel messages queue against it (#706). The
+  // binding-target health above can read "ok" while the bridge itself is wedged,
+  // so check the bridge agent's own liveness to avoid green-washing a down bridge.
+  const channelBridges = listAgents().filter((agent) =>
+    agent.id !== "user" && agent.id !== "system" &&
+    (agent.kind === "channel" || agent.meta?.kind === "channel"));
+  const staleChannelBridges = channelBridges.filter((agent) =>
+    agent.status !== "offline" && agent.lastSeen <= now - STALE_TTL_MS);
+  const notReadyChannelBridges = channelBridges.filter((agent) =>
+    agent.status !== "offline" && !agent.ready && agent.lastSeen > now - STALE_TTL_MS);
+  const unhealthyChannelBridges = [...staleChannelBridges, ...notReadyChannelBridges];
+  checks.push({
+    name: "channel-bridge-liveness",
+    status: staleChannelBridges.length > 0 ? "error" : notReadyChannelBridges.length > 0 ? "warn" : "ok",
+    count: unhealthyChannelBridges.length,
+    detail: unhealthyChannelBridges.length > 0
+      ? `${unhealthyChannelBridges.length} channel bridge(s) not delivering: ${unhealthyChannelBridges.slice(0, 3).map((a) => `${a.id} (status=${a.status}, ready=${a.ready})`).join("; ")}`
+      : undefined,
+  });
+
+  const expiredUndelivered = countExpiredUndeliveredMessages(now);
+  checks.push({
+    name: "expired-undelivered-messages",
+    status: expiredUndelivered > 0 ? "warn" : "ok",
+    count: expiredUndelivered,
+    detail: expiredUndelivered > 0
+      ? `${expiredUndelivered} queued message(s) expired undelivered at max_age in the last 24h (silent data loss)`
+      : undefined,
+  });
+
   const rootTokenRuntimeAgents = listAgents().filter((agent) => {
     if (agent.status === "offline") return false;
     if (agent.id === "user" || agent.id === "system") return false;

package/src/maintenance/jobs.ts

@@ -10,6 +10,7 @@ import {
   expireQueuedMessages,
   getAgent,
   listAgents,
+  listStaleQueuedDirectTargets,
   pruneOrphanedSharedWorkspaces,
   pruneOfflineAgents,
   pruneOldMessages,
@@ -22,6 +23,8 @@ import {
   runDbMaintenance,
   sweepArtifacts,
 } from "../db";
+import { isAgentUnavailable } from "../db/agent-predicates";
+import { flushQueuedDirectMessages } from "../services/managed-running";
 import { notifyAgentOffline } from "../agent-lifecycle-events";
 import { diagnoseAgentDeath } from "../agent-death-diagnosis";
 import { autoMergeCleanFastForwards } from "../workspace-auto-merge";
@@ -193,10 +196,35 @@ export const definitions: MaintenanceJobDefinition[] = [
     runOnStart: true,
     handler() {
       const messages = expireQueuedMessages();
-      for (const message of messages) emitMessageExpired(message);
+      for (const message of messages) {
+        // Silent data loss is the worst failure mode here (#706): a queued
+        // message died without ever reaching its recipient. Surface it loudly.
+        console.warn(`[delivery] message ${message.id} to ${message.to} (kind=${message.kind}) expired undelivered after max_age — silent data loss`);
+        emitMessageExpired(message);
+      }
       return { expiredQueuedMessageIds: messages.map((message) => message.id) };
     },
   },
+  {
+    id: "queued-message-resweep",
+    title: "Queued message re-sweep",
+    description: "Re-resolve long-queued direct messages whose target agent is available again — safety net for a missed flush-on-recovery event (#706).",
+    intervalMs: REAP_INTERVAL_MS,
+    runOnStart: true,
+    handler() {
+      const reswept: Record<string, number> = {};
+      for (const target of listStaleQueuedDirectTargets()) {
+        const agent = getAgent(target);
+        // Only flush to a target that is actually available now; otherwise the
+        // message belongs in the queue (this is hooked to agent availability,
+        // not pool-slot reclaim).
+        if (!agent || isAgentUnavailable(agent)) continue;
+        const flushed = flushQueuedDirectMessages(target);
+        if (flushed.length > 0) reswept[target] = flushed.length;
+      }
+      return { resweptTargets: reswept };
+    },
+  },
   {
     id: "command-expiration",
     title: "Command expiration",

package/src/services/managed-running.ts

@@ -17,7 +17,7 @@ import { getManagedAgentState, updateManagedAgentState } from "../config-store";
 import { emitRelayEvent } from "../events";
 import { emitMessageAvailable, emitMessageDeliveryUpdated, emitNewMessage } from "../sse";
 import type { AuthContext } from "./auth-context";
-import type { ManagedAgentState } from "../types";
+import type { ManagedAgentState, Message } from "../types";
 
 interface ManagedRunningInput {
   policyName?: string;
@@ -135,14 +135,16 @@ function recordManagedTransition(
  * transitions back to available: heartbeat stale→idle, re-registration after restart/compact, or
  * rate-limit resume. Emits the same `message.available` / `message.new` / `message.delivery_updated`
  * events that the policy flush emits so SSE subscribers and the dashboard react identically.
- * No-op when there are no queued direct messages.
+ * No-op when there are no queued direct messages. Returns the flushed messages so
+ * callers (e.g. the resweep safety net, #706) can report how many were recovered.
  */
-export function flushQueuedDirectMessages(agentId: string): void {
+export function flushQueuedDirectMessages(agentId: string): Message[] {
   const available = resolveQueuedDirectMessages(agentId);
-  if (!available.length) return;
+  if (!available.length) return [];
   emitMessageAvailable("direct", agentId, available);
   for (const message of available) {
     emitNewMessage(message);
     emitMessageDeliveryUpdated(message);
   }
+  return available;
 }