agent-relay-server 0.95.0 → 0.95.1

package/docs/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Relay API",
-    "version": "0.95.0",
+    "version": "0.95.1",
     "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.95.0",
+  "version": "0.95.1",
   "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.95.0",
+  "version": "0.95.1",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/agent-busy-health.ts

@@ -3,8 +3,9 @@ import {
   STUCK_BUSY_RECONNECT_MS,
   STUCK_BUSY_SHUTDOWN_MS,
   STUCK_BUSY_STARTUP_MS,
+  STUCK_BUSY_TRANSPORT_STALE_MS,
 } from "./config";
-import { stringValue } from "agent-relay-sdk";
+import { isRecord, stringValue } from "agent-relay-sdk";
 import type { AgentCard } from "./types";
 
 type BusyHealthKind = "provider-turn" | "startup" | "reconnect" | "shutdown";
@@ -27,6 +28,12 @@ export interface AgentBusyHealth {
   activeWorkAgeMs: number;
   lastProviderEventAt?: number;
   lastProviderEventAgeMs?: number;
+  /** Most recent of lastProviderEventAt and any fresh lifecycle/timeline transition (e.g. `compacting`). */
+  lastProgressAt: number;
+  /** Most recent transport liveness signal (server frame / heartbeat ack); undefined when the runner reports no transport. */
+  transportLiveAt?: number;
+  /** Age of the transport liveness signal; +Infinity when transport is unknown (treated as dead). */
+  transportStaleForMs: number;
   staleForMs: number;
 }
 
@@ -45,6 +52,29 @@ function hasLiveToolOrSubprocessWork(works: ActiveWorkLike[]): boolean {
   });
 }
 
+// #713 — most recent transport-liveness timestamp the runner reported on meta.transport
+// (`lastServerFrameAt` / `lastHeartbeatAckAt`). A current value proves the runner→server link is
+// alive, which means the agent is NOT wedged regardless of provider-token silence. Returns undefined
+// when no transport block is present (older runners / pre-transport meta) — the caller treats that as
+// "can't prove alive" so a genuine wedge with no transport still fires.
+function transportLiveAt(agent: AgentCard): number | undefined {
+  const transport = isRecord(agent.meta?.transport) ? agent.meta.transport : undefined;
+  if (!transport) return undefined;
+  const frame = numberValue(transport.lastServerFrameAt);
+  const ack = numberValue(transport.lastHeartbeatAckAt);
+  if (frame === undefined && ack === undefined) return undefined;
+  return Math.max(frame ?? 0, ack ?? 0);
+}
+
+// #713 — timestamp of the latest lifecycle/timeline transition (e.g. Claude `compacting`/`compacted`)
+// the runner published on meta.timelineEvent. These mark active progress through a lifecycle even when
+// no provider tokens flow, so they count as progress against the no-progress threshold.
+function timelineProgressAt(agent: AgentCard): number | undefined {
+  const event = isRecord(agent.meta?.timelineEvent) ? agent.meta.timelineEvent : undefined;
+  if (!event) return undefined;
+  return numberValue(event.timestamp);
+}
+
 function thresholdFor(kind: BusyHealthKind): number {
   if (kind === "startup") return STUCK_BUSY_STARTUP_MS;
   if (kind === "reconnect") return STUCK_BUSY_RECONNECT_MS;
@@ -82,12 +112,21 @@ export function deriveAgentBusyHealth(agent: AgentCard, now: number = Date.now()
   const activeWorkStartedAt = Math.max(0, classified.startedAt);
   const activeWorkAgeMs = Math.max(0, now - activeWorkStartedAt);
   const lastProviderEventAt = numberValue(agent.meta?.lastProviderEventAt);
-  const lastProgressAt = lastProviderEventAt ?? activeWorkStartedAt;
+  // Progress = provider tokens OR any lifecycle/timeline transition (e.g. native compaction). #713: a
+  // fresh `compacting` event means the worker is actively progressing even with zero provider tokens.
+  const lastProgressAt = Math.max(lastProviderEventAt ?? activeWorkStartedAt, timelineProgressAt(agent) ?? 0);
   const staleForMs = Math.max(0, now - lastProgressAt);
+  // #713: transport heartbeat liveness. A current server-frame/heartbeat-ack proves the runner→server
+  // link is alive ⇒ the agent is NOT wedged, no matter how long provider tokens have been silent
+  // (long turns, extended thinking, native compaction). Unknown transport ⇒ +Infinity (can't prove
+  // alive), so a genuine wedge whose runner has stopped reporting still trips.
+  const liveAt = transportLiveAt(agent);
+  const transportStaleForMs = liveAt === undefined ? Number.POSITIVE_INFINITY : Math.max(0, now - liveAt);
   const stuck =
     !hasLiveToolOrSubprocessWork(works) &&
     activeWorkAgeMs >= thresholdMs &&
-    staleForMs >= thresholdMs;
+    staleForMs >= thresholdMs &&
+    transportStaleForMs >= STUCK_BUSY_TRANSPORT_STALE_MS;
   const work = classified.work;
   return {
     status: stuck ? "stuck-busy" : "ok",
@@ -99,6 +138,9 @@ export function deriveAgentBusyHealth(agent: AgentCard, now: number = Date.now()
     activeWorkStartedAt,
     activeWorkAgeMs,
     ...(lastProviderEventAt !== undefined ? { lastProviderEventAt, lastProviderEventAgeMs: Math.max(0, now - lastProviderEventAt) } : {}),
+    lastProgressAt,
+    ...(liveAt !== undefined ? { transportLiveAt: liveAt } : {}),
+    transportStaleForMs,
     staleForMs,
   };
 }

package/src/config.ts

@@ -64,6 +64,13 @@ 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);
+// #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
+// this window. The runner heartbeats every 30s, so 2min (4 missed beats) is a clear "transport gone"
+// signal, well above jitter and far below the 15min provider threshold — a real wedge (transport dead
+// AND provider silent AND no lifecycle progress) still fires. A live heartbeat ⇒ not wedged.
+export const STUCK_BUSY_TRANSPORT_STALE_MS = envPositiveInt("AGENT_RELAY_STUCK_BUSY_TRANSPORT_STALE_MS", 2 * 60_000);
 export const CLAIM_LEASE_MS = envPositiveInt("AGENT_RELAY_CLAIM_LEASE_MS", 1_800_000); // 30min claim lease
 export const POOL_CLAIM_LEASE_MS = envPositiveInt("AGENT_RELAY_POOL_CLAIM_LEASE_MS", STALE_TTL_MS * 3); // pool binding lease
 // Per-repo merge serialization lease — only one base merge may run at a time per

package/src/db/provider-quotas.ts

@@ -370,10 +370,25 @@ function mergeQuotaWindows(existing: StoredQuotaState | undefined, incoming: Quo
     if (!incomingWindow) {
       mergedTimes.set(key, existingUpdatedAt); mergedSources.set(key, existingSource); return window;
     }
-    // Per-window source precedence: higher-priority source keeps value even with newer timestamp (#712)
-    if (quotaSourcePriority(existingSource) > quotaSourcePriority(incoming.source)) {
+    // Per-window source precedence is symmetric in BOTH directions (#712, #716):
+    // - A higher-priority existing value is kept even against a newer lower-priority reading.
+    // - A higher-priority incoming value (e.g. authoritative WHAM `ingest`) overrides the stored
+    //   value outright, bypassing the timestamp + regression guards below. Those guards exist to
+    //   reject a noisy lower-or-equal source's improbable swing (a wedged probe self-report) — they
+    //   must NOT block authoritative data correcting a stale probe that pinned the window high.
+    const existingPriority = quotaSourcePriority(existingSource);
+    const incomingPriority = quotaSourcePriority(incoming.source);
+    if (existingPriority > incomingPriority) {
       mergedTimes.set(key, existingUpdatedAt); mergedSources.set(key, existingSource); return window;
     }
+    if (incomingPriority > existingPriority) {
+      acceptedIncomingWindow = true;
+      updatedAt = Math.max(updatedAt, incoming.updatedAt);
+      source = incoming.source;
+      mergedTimes.set(key, incoming.updatedAt); mergedSources.set(key, incoming.source);
+      return incomingWindow;
+    }
+    // Same-priority sources: prefer the newer reading and guard against an improbable regression.
     if (incoming.updatedAt < existingUpdatedAt) {
       mergedTimes.set(key, existingUpdatedAt); mergedSources.set(key, existingSource); return window;
     }