feat(worker): dependsOn via MCP + honest staleness signal in merge preview

Adds a user/MCP-declared task dependency (DependsOnTaskId) distinct from the
planning chain's internal BlockedByTaskId: add_task/update_task can set it,
the queue picker skips a Queued task until the dependency reaches Done, a
Failed/Cancelled dependency leaves the dependent blocked instead of starving
silently, and setting a link rejects self-reference/unknown-id/cycles.
get_task/list_tasks/batch_get_tasks now report blocked/blockedReason, and
wait_for_task_change reports "Blocked" immediately instead of running out its
timeout on a task the picker will never claim.

preview_merge/preview_merge_set gain staleFiles: files a branch touches that
the target branch also changed since the branch's fork point, a more honest
staleness signal than `behind` alone.

tests/ClaudeDo.Worker.Tests/Queue/QueuePickerTests.cs

@@ -49,7 +49,8 @@ public sealed class QueuePickerTests : IDisposable
         string? blockedBy = null,
         bool taskAgentTag = false,
         int? sortOrder = null,
-        bool isManual = false)
+        bool isManual = false,
+        string? dependsOn = null)
     {
         var task = new TaskEntity
         {
@@ -60,6 +61,7 @@ public sealed class QueuePickerTests : IDisposable
             CreatedAt = createdAt ?? DateTime.UtcNow,
             ScheduledFor = scheduledFor,
             BlockedByTaskId = blockedBy,
+            DependsOnTaskId = dependsOn,
             CommitType = "feat",
             IsManual = isManual,
         };
@@ -110,6 +112,49 @@ public sealed class QueuePickerTests : IDisposable
         Assert.Null(second);
     }
 
+    [Fact]
+    public async Task ClaimNextAsync_Skips_TasksWithUnmetDependsOn()
+    {
+        var listId = await CreateListAsync();
+        var dependency = await SeedAsync(listId, status: TaskStatus.Idle);
+        await SeedAsync(listId, dependsOn: dependency.Id);
+
+        // The dependency is only Idle (not Done), so both stay unclaimed: the dependent is
+        // gated on depends_on_task_id, and the dependency itself was never queued.
+        Assert.Null(await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None));
+    }
+
+    [Fact]
+    public async Task ClaimNextAsync_Claims_TaskWhoseDependsOnIsDone()
+    {
+        var listId = await CreateListAsync();
+        var dependency = await SeedAsync(listId, status: TaskStatus.Done);
+        var dependent = await SeedAsync(listId, dependsOn: dependency.Id);
+
+        var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
+
+        Assert.NotNull(picked);
+        Assert.Equal(dependent.Id, picked!.Id);
+    }
+
+    [Fact]
+    public async Task ClaimNextAsync_Skips_TaskWhoseDependsOnFailed_ButKeepsClaimingOthers()
+    {
+        var listId = await CreateListAsync();
+        var dependency = await SeedAsync(listId, status: TaskStatus.Failed);
+        await SeedAsync(listId, dependsOn: dependency.Id);
+        var independent = await SeedAsync(listId, createdAt: DateTime.UtcNow.AddMinutes(1));
+
+        // A Failed dependency does not cascade-cancel or auto-unblock the dependent (unlike the
+        // planning chain's BlockedByTaskId) -- it just stays Queued and skipped forever.
+        var first = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
+        Assert.NotNull(first);
+        Assert.Equal(independent.Id, first!.Id);
+
+        var second = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
+        Assert.Null(second);
+    }
+
     [Fact]
     public async Task ClaimNextAsync_Picks_TasksWithoutAgentTag()
     {