agent-relay-server 0.119.10 → 0.120.0

package/src/services/task-lifecycle.ts

@@ -30,13 +30,13 @@ import {
   getTaskDetail,
   markTaskAgentReaped,
 } from "../db";
-import { setTaskEntityStage } from "./task-entity";
+import { setTaskEntityStage, setTaskEntityStatus } from "./task-entity";
 import { postTaskMilestoneComment, taskCloseBridge, type TaskCloseBridgeEntry } from "./task-issue-weave";
 import { requestTransientAgentShutdown } from "./transient-agent-reaper";
 import { emitRelayEvent } from "../events";
 import { routeNotification } from "../notification-router";
 import { resolveCoordinatorAgentId } from "../steward-identity";
-import { stageSatisfiesDoneWhen } from "./task-done-when";
+import { isAgentExitDoneWhen, stageSatisfiesDoneWhen } from "./task-done-when";
 import { emitTaskSemanticNotification, type TaskSemanticTransition } from "./task-semantic-events";
 import type { IssueRef, TaskDeliverableStage, TaskGateState, WorkspaceRecord } from "../types";
 import type { IssueTrackerAdapter } from "../issue-tracker";
@@ -253,6 +253,16 @@ function finalizeReap(outcomes: TaskLandOutcome[], reap: ReapResult, log: LogFn)
     if (reap.reaped && reap.agentId) {
       try {
         markTaskAgentReaped(outcome.taskId, { agentId: reap.agentId, reason: "deliverable-landed" });
+        const task = getTaskDetail(outcome.taskId);
+        if (task && task.status !== "done" && isAgentExitDoneWhen(task.doneWhen)) {
+          setTaskEntityStatus(outcome.taskId, {
+            status: "done",
+            note: "doneWhen=agent-exit satisfied by worker reap after land",
+            actor: "task-lifecycle",
+          });
+          outcome.doneWhenSatisfied = true;
+          outcome.statusAdvanced = true;
+        }
       } catch (error) {
         log(`task reap marker failed for task ${outcome.taskId}: ${errMessage(error)}`);
       }

package/src/sse.ts

@@ -11,12 +11,17 @@ interface Connection {
   agentId: string | null;
   controller: ReadableStreamDefaultController<Uint8Array>;
   keepalive: Timer;
+  // Pending cross-tick backpressure re-check (#971 refinement). Set when a stream
+  // dips below the queue floor during a synchronous fanout; cleared on the deferred
+  // tick once we know whether it drained (healthy) or stayed stuck (stale → drop).
+  drainCheck?: Timer;
 }
 
 const connections = new Map<string, Connection>();
 const encoder = new TextEncoder();
 const SSE_KEEPALIVE_MS = 15_000;
 const SSE_RETRY_MS = 5_000;
+const SSE_MAX_QUEUED_CHUNKS = 128;
 
 subscribeRelayEvents((event) => fanout(event));
 
@@ -38,8 +43,9 @@ export function createSSEStream(agentId: string | null): Response {
     start(controller) {
       connId = crypto.randomUUID();
       const keepalive = setInterval(() => {
-        try { controller.enqueue(encoder.encode(": keepalive\n\n")); }
-        catch { removeConnection(connId); }
+        const conn = connections.get(connId);
+        if (!conn) return;
+        sendEncoded(conn, encoder.encode(": keepalive\n\n"));
       }, SSE_KEEPALIVE_MS);
 
       connections.set(connId, { id: connId, agentId, controller, keepalive });
@@ -68,18 +74,57 @@ function removeConnection(id: string) {
   const conn = connections.get(id);
   if (conn) {
     clearInterval(conn.keepalive);
+    if (conn.drainCheck) clearTimeout(conn.drainCheck);
     connections.delete(id);
   }
 }
 
-function send(conn: Connection, event: string, data: unknown) {
+function closeConnection(id: string) {
+  const conn = connections.get(id);
+  removeConnection(id);
+  try { conn?.controller.close(); } catch {}
+}
+
+function sseFrame(event: string, data: unknown): Uint8Array {
+  return encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+}
+
+function isBackpressured(conn: Connection): boolean {
+  return conn.controller.desiredSize !== null && conn.controller.desiredSize < -SSE_MAX_QUEUED_CHUNKS;
+}
+
+function sendEncoded(conn: Connection, chunk: Uint8Array) {
   try {
-    conn.controller.enqueue(encoder.encode(
-      `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
-    ));
+    conn.controller.enqueue(chunk);
   } catch {
+    // Controller already closed/errored — the reader is gone.
     removeConnection(conn.id);
+    return;
   }
+  // #971 — the queue only drains between event-loop ticks, so within a single
+  // synchronous fanout (a batch loop emitting >SSE_MAX_QUEUED_CHUNKS frames)
+  // desiredSize falls on liveness, not staleness. Closing inline here would kill
+  // healthy, actively-read dashboards mid-burst. Instead defer the verdict: mark
+  // the stream and re-check on a later tick, after the runtime has had a chance to
+  // flush to the socket. Recovered → keep it; still stuck across ticks → drop it.
+  if (isBackpressured(conn)) scheduleDrainCheck(conn);
+}
+
+function scheduleDrainCheck(conn: Connection) {
+  if (conn.drainCheck) return; // one deferred verdict per stream is enough
+  conn.drainCheck = setTimeout(() => {
+    conn.drainCheck = undefined;
+    // The connection may already have been removed (cancel/close) between ticks —
+    // closeConnection is idempotent, but bail early so we never touch a stale ref.
+    if (connections.get(conn.id) !== conn) return;
+    // Drained across the tick → genuinely healthy-but-slow. Stayed backpressured →
+    // genuinely stalled/stale; drop it (the original #971 protection).
+    if (isBackpressured(conn)) closeConnection(conn.id);
+  }, 0);
+}
+
+function send(conn: Connection, event: string, data: unknown) {
+  sendEncoded(conn, sseFrame(event, data));
 }
 
 function fanout(event: RelayEvent): void {
@@ -91,8 +136,9 @@ function fanout(event: RelayEvent): void {
     sendTaskChanged(event.data as unknown as Task, event.type);
     return;
   }
+  const chunk = sseFrame(event.type, event.data);
   for (const conn of connections.values()) {
-    send(conn, event.type, event.data);
+    sendEncoded(conn, chunk);
   }
 }
 
@@ -100,14 +146,15 @@ function sendNewMessage(msg: Message): void {
   const scopedBroadcastAgentIds = msg.to === "broadcast"
     ? new Set(matchingDeliveryAgents("broadcast", { from: msg.from, channel: msg.channel }).map((agent) => agent.id))
     : null;
+  const chunk = sseFrame("message.new", msg);
   for (const conn of connections.values()) {
     if (!conn.agentId) {
-      send(conn, "message.new", msg);
+      sendEncoded(conn, chunk);
       continue;
     }
     if (scopedBroadcastAgentIds && !scopedBroadcastAgentIds.has(conn.agentId)) continue;
     if (!messageMatchesAgent(msg, conn.agentId, getAgent(conn.agentId))) continue;
-    send(conn, "message.new", msg);
+    sendEncoded(conn, chunk);
   }
 }
 
@@ -215,9 +262,10 @@ export function emitMessageReactionUpdated(msg: Message) {
 }
 
 function sendTaskChanged(task: Task, eventType = "task.updated"): void {
+  const chunk = sseFrame(eventType, task);
   for (const conn of connections.values()) {
     if (conn.agentId && !targetMatchesAgent(task.target, conn.agentId, getAgent(conn.agentId))) continue;
-    send(conn, eventType, task);
+    sendEncoded(conn, chunk);
   }
 }