fix(loop): work queued behind a human was reported as a failed run

The other half of the idle deadlock, found by the end-to-end sweep that was
meant to prove the first half fixed.

Only `done` satisfies a dependency, so a task sitting in ready_to_dev whose
dependency was parked in to_scope by the attempt ceiling can never become
executable. AgentWorkRemaining counts ready_to_dev, so it short-circuited the
human-backlog branch directly below it: the loop found nothing schedulable,
found nothing to reclaim, and then spent 31 idle rounds before returning
ErrIdleTimeout — reporting a board that was simply owed to a human as a run that
gave up.

Measured on a live greenfield Go build: T1 and T3 parked by the ceiling, T4 and
T5 queued behind them, and the verdict read "gave up before the board was
finished: idle while agent work still in progress (rounds=31, tasks still
open=2)". The human-backlog path already existed one branch below and already
returns cleanly with an announcement rather than a failure; it was simply
unreachable.

Agent work waiting behind a human is not agent work in progress, so the idle
branch now defers to it. Reclaim still runs first — an orphan left mid-flight by
a finished wave is a different condition and is still re-queued.

Author: piotrlaczkowski

pkg/loop/reclaim_test.go

@@ -107,3 +107,44 @@ func TestReclaimIsNilSafe(t *testing.T) {
 		t.Fatalf("reclaimed %d from a nil board", moved)
 	}
 }
+
+// Agent work waiting BEHIND A HUMAN is not agent work in progress.
+//
+// Only `done` satisfies a dependency, so a task in ready_to_dev whose
+// dependency is parked in to_scope can never become executable. But
+// AgentWorkRemaining counts ready_to_dev, so it short-circuited the
+// human-backlog branch and the loop idled 31 rounds before reporting a
+// hand-back as ErrIdleTimeout — a failure.
+//
+// Measured on a live greenfield build: T1 and T3 parked by the attempt ceiling,
+// T4 and T5 queued behind them, and the run reported
+// "gave up ... idle while agent work still in progress" over a board that was
+// simply owed to a human.
+func TestWorkQueuedBehindAHumanIsNotAgentProgress(t *testing.T) {
+	b := &plan.Board{Tasks: []plan.Task{
+		{ID: "T1", Role: plan.RoleWorker, Column: plan.ColToScope, Title: "parked by the ceiling"},
+		{ID: "T3", Role: plan.RoleWorker, Column: plan.ColToScope, Title: "also parked"},
+		{ID: "T4", Role: plan.RoleWorker, Column: plan.ColReadyToDev, DependsOn: []string{"T3"}},
+		{ID: "T5", Role: plan.RoleTester, Column: plan.ColReadyToDev, DependsOn: []string{"T1", "T3", "T4"}},
+	}}
+	for i := range b.Tasks {
+		b.Tasks[i].Normalize()
+	}
+
+	// The shape: nothing executable, yet the board claims work remains.
+	if len(b.ReadyTasks()) != 0 {
+		t.Fatal("fixture is wrong: something is executable")
+	}
+	if !b.AgentWorkRemaining() {
+		t.Fatal("fixture is wrong: ready_to_dev must make this look like agent work")
+	}
+	// Reclaim cannot help — nothing is mid-flight.
+	if moved := (&Runner{}).reclaimOrphaned(b); moved != 0 {
+		t.Fatalf("reclaimed %d, want 0 — nothing is in_progress/in_review", moved)
+	}
+	// So the honest reading is the human backlog, which the loop now checks
+	// before spending 31 idle rounds on a failure verdict.
+	if !b.HumanBacklogRemaining() {
+		t.Fatal("the parked tasks must register as human backlog")
+	}
+}

pkg/loop/runner.go

@@ -401,16 +401,27 @@ func (r *Runner) RunBoard(ctx context.Context, board *plan.Board) error {
 
 		ready := scheduleReady(board.ReadyTasks())
 		if len(ready) == 0 {
-			if board.AgentWorkRemaining() {
-				// Nothing is executable, yet the board says work is in
-				// progress. runWave is synchronous, so nothing actually is:
-				// whatever sits in in_progress/in_review was abandoned by a
-				// wave that already returned, and no code path re-dispatches
-				// those columns. Re-queue them and schedule again rather than
-				// idling 31 rounds waiting on an agent that exited.
-				if r.reclaimOrphaned(board) > 0 {
-					continue
-				}
+			// Nothing is executable, yet the board says work is in progress.
+			// runWave is synchronous, so nothing actually is: whatever sits in
+			// in_progress/in_review was abandoned by a wave that already
+			// returned, and no code path re-dispatches those columns. Re-queue
+			// them and schedule again rather than idling 31 rounds waiting on
+			// an agent that exited.
+			if board.AgentWorkRemaining() && r.reclaimOrphaned(board) > 0 {
+				continue
+			}
+			// Agent work that is waiting BEHIND A HUMAN is not agent work in
+			// progress. A task in ready_to_dev whose dependency is parked in
+			// to_scope can never become executable — only `done` satisfies a
+			// dependency — but AgentWorkRemaining counts ready_to_dev, so it
+			// short-circuited the human-backlog branch below and the loop idled
+			// 31 rounds before reporting a hand-back as a FAILURE.
+			//
+			// Measured: T1 and T3 parked by the attempt ceiling, T4 and T5
+			// queued behind them, the run reported as "gave up ... idle while
+			// agent work still in progress" with the board simply owed to a
+			// human.
+			if board.AgentWorkRemaining() && !board.HumanBacklogRemaining() {
 				idleRounds++
 				if idleRounds > 30 {
 					return r.giveUp(board, ErrIdleTimeout, idleRounds)