"Idle lane" test missing result-status assertion

The second test case only verifies that getReplyFromConfig was called, but never asserts on the return value of runHeartbeatOnce. This means the test would still pass even if the function returned an unexpected status (e.g., "skipped") as long as the reply spy was triggered somewhere in the call chain.

Adding an explicit assertion on result would make the test's intent clearer and guard against future regressions:

This is a comment left during a code review.
Path: src/infra/heartbeat-runner.skips-busy-session-lane.test.ts
Line: 142-151

Comment:
**"Idle lane" test missing result-status assertion**

The second test case only verifies that `getReplyFromConfig` was called, but never asserts on the return value of `runHeartbeatOnce`. This means the test would still pass even if the function returned an unexpected status (e.g., `"skipped"`) as long as the reply spy was triggered somewhere in the call chain.

Adding an explicit assertion on `result` would make the test's intent clearer and guard against future regressions:

```suggestion
    const result = await runHeartbeatOnce({
      cfg,
      deps: { getQueueSize, nowMs: () => Date.now() } as HeartbeatDeps,
    });

    // Should have proceeded past the lane checks and called getReplyFromConfig
    expect(replySpy).toHaveBeenCalled();
    // Confirm the run completed (not skipped due to a lane check)
    expect(result.status).not.toBe("skipped");
```

How can I resolve this? If you propose a fix, please make it concise.

Differentiate session-lane busy from global queue saturation

Returning reason: "requests-in-flight" for a busy session lane conflates two different conditions: global main-lane contention and per-session contention. The scheduler path in startHeartbeatRunner (the run loop in src/infra/heartbeat-runner.ts) treats requests-in-flight as a global backpressure signal and returns early, so in multi-agent setups one busy session can block heartbeat execution for other agents that are otherwise idle. This should use a distinct skip reason (or scoped handling) so only the contended session is retried.

Useful? React with 👍 / 👎.

Return a distinct skip reason for busy session lanes

This new branch reports reason: "requests-in-flight" even when only the resolved session lane is busy, but unscoped scheduling paths interpret that reason as global backpressure: startHeartbeatRunner exits the agent loop on that reason (src/infra/heartbeat-runner.ts:1208) and heartbeat-wake.ts retries it as “main lane busy” (src/infra/heartbeat-wake.ts:157). In multi-agent or multi-session runs, one busy session lane can therefore repeatedly prevent heartbeats for otherwise idle agents/sessions. Please use a separate skip reason (or separate handling) for session-lane contention so retries stay scoped to the contended target.

Useful? React with 👍 / 👎.

Return distinct skip reason for busy session lanes

Using "requests-in-flight" for session-lane contention makes scoped backpressure look like global main-lane saturation, and that changes scheduler behavior: in the unscoped agent loop, startHeartbeatRunner returns early on this reason (src/infra/heartbeat-runner.ts:1208), while heartbeat-wake retries it as a global busy condition (src/infra/heartbeat-wake.ts:156), so one busy session can delay heartbeats for other agents/sessions that are idle. Fresh evidence in this commit is the new session-lane branch now returning this shared reason, which introduces the conflation directly.

Useful? React with 👍 / 👎.

Use distinct skip reason for busy session lanes

Returning reason: "requests-in-flight" for session-lane contention conflates per-session backpressure with global main-lane saturation, and downstream logic treats that reason as global: startHeartbeatRunner exits the unscoped agent loop early on this reason (src/infra/heartbeat-runner.ts:1208) and heartbeat-wake.ts retries it as a main-lane busy condition (src/infra/heartbeat-wake.ts:156). In multi-agent runs, a single busy session can therefore delay heartbeats for unrelated idle agents/sessions. Fresh evidence in this commit is the new session-lane guard now returning this shared reason.

Useful? React with 👍 / 👎.

Use a distinct skip reason for busy session lanes

Returning "requests-in-flight" here makes per-session contention look identical to global main-lane saturation, but downstream scheduling treats that reason as global backpressure: the unscoped runner loop exits early on this reason (startHeartbeatRunner run loop) and heartbeat-wake retries it as a main-lane busy condition. In multi-agent or multi-session usage, one busy session lane can therefore delay heartbeats for unrelated idle sessions until that session drains.

Useful? React with 👍 / 👎.