fix(gateway): gate busy run-age ceiling on disconnected transport

yetval · yetval · commit a1af976ae51d · 2026-07-19T00:34:55.000Z
diff --git a/src/gateway/channel-health-policy.test.ts b/src/gateway/channel-health-policy.test.ts
@@ -86,17 +86,42 @@ describe("evaluateChannelHealth", () => {
     expect(evaluation).toEqual({ healthy: false, reason: "stuck" });
   });
 
-  it("flags a hung run as stuck once its start ages past the threshold despite a fresh heartbeat", () => {
+  it("flags a hung run masking a disconnected transport as stuck despite a fresh heartbeat", () => {
     const now = 30 * 60_000;
     const evaluation = evaluateHealth(
       activeRunAccount(now - 1_000, {
+        connected: false,
         activeRunStartedAt: now - 26 * 60_000,
       }),
       { now },
     );
     expect(evaluation).toEqual({ healthy: false, reason: "stuck" });
   });
 
+  it("keeps a connected run healthy past the threshold while its heartbeat stays fresh", () => {
+    const now = 30 * 60_000;
+    const evaluation = evaluateHealth(
+      activeRunAccount(now - 1_000, {
+        connected: true,
+        activeRunStartedAt: now - 26 * 60_000,
+      }),
+      { now },
+    );
+    expect(evaluation).toEqual({ healthy: true, reason: "busy" });
+  });
+
+  it("keeps a run without transport reporting healthy past the threshold while its heartbeat stays fresh", () => {
+    const now = 30 * 60_000;
+    const evaluation = evaluateHealth(
+      activeRunAccount(now - 1_000, {
+        connected: undefined,
+        activeRunStartedAt: now - 26 * 60_000,
+      }),
+      { now },
+    );
+    expect(evaluation).toEqual({ healthy: true, reason: "busy" });
+  });
+
   it("keeps a short-lived run healthy when both start and activity are recent", () => {
     const now = 30 * 60_000;
     const evaluation = evaluateHealth(
diff --git a/src/gateway/channel-health-policy.ts b/src/gateway/channel-health-policy.ts
@@ -101,14 +101,15 @@ export function evaluateChannelHealth(
     if (!busyStateInitializedForLifecycle) {
       // Fall through to normal startup/disconnect checks below.
     } else {
-      const runStartAge =
-        activeRunStartedAt == null ? null : Math.max(0, policy.now - activeRunStartedAt);
       const runActivityAge =
-        lastRunActivityAt == null ? null : Math.max(0, policy.now - lastRunActivityAt);
-      const busyAge =
-        runStartAge == null && runActivityAge == null
+        lastRunActivityAt == null
           ? Number.POSITIVE_INFINITY
-          : Math.max(runStartAge ?? 0, runActivityAge ?? 0);
+          : Math.max(0, policy.now - lastRunActivityAt);
+      const disconnectedRunStartAge =
+        snapshot.connected === false && activeRunStartedAt != null
+          ? Math.max(0, policy.now - activeRunStartedAt)
+          : 0;
+      const busyAge = Math.max(runActivityAge, disconnectedRunStartAge);
       if (busyAge < BUSY_ACTIVITY_STALE_THRESHOLD_MS) {
         return { healthy: true, reason: "busy" };
       }
diff --git a/src/plugin-sdk/channel-lifecycle.queue.test.ts b/src/plugin-sdk/channel-lifecycle.queue.test.ts
@@ -123,6 +123,44 @@ describe("createChannelRunQueue", () => {
     }
   });
 
+  it("advances to the next-oldest run start when the oldest run ends", async () => {
+    vi.useFakeTimers();
+    try {
+      const first = createDeferred();
+      const second = createDeferred();
+      const setStatus = vi.fn();
+      const queue = createChannelRunQueue({ setStatus });
+
+      vi.setSystemTime(1_000);
+      queue.enqueue("first", async () => {
+        await first.promise;
+      });
+      await flushAsyncWork();
+
+      vi.setSystemTime(2_000);
+      queue.enqueue("second", async () => {
+        await second.promise;
+      });
+      await flushAsyncWork();
+
+      first.resolve?.();
+      await first.promise;
+      await flushAsyncWork();
+
+      expect(setStatus.mock.calls.at(-1)?.[0]).toMatchObject({
+        activeRuns: 1,
+        busy: true,
+        activeRunStartedAt: 2_000,
+      });
+
+      queue.deactivate();
+      second.resolve?.();
+      await second.promise;
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it("contains reporting hook errors", async () => {
     const taskError = new Error("boom");
     const onError = vi.fn(() => {
