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.

src/ClaudeDo.Worker/State/Interfaces/ITaskStateService.cs

@@ -25,6 +25,10 @@ public interface ITaskStateService
     Task<TransitionResult> BlockOnAsync(string taskId, string predecessorTaskId, CancellationToken ct);
     Task<TransitionResult> UnblockAsync(string taskId, CancellationToken ct);
 
+    // dependsOnTaskId null clears the dependency. Rejects self-reference, an unknown dependency
+    // id, and a link that would create a cycle -- see TaskStateService for the walk.
+    Task<TransitionResult> SetDependsOnAsync(string taskId, string? dependsOnTaskId, CancellationToken ct);
+
     // Surfaces a WaitingForChildren parent for review once all its children are terminal.
     // Best-effort (swallows and logs failures) — safe to call after any child mutation,
     // e.g. deleting the last non-terminal child (no terminal transition fires for a delete).

src/ClaudeDo.Worker/State/TaskStateService.cs

@@ -427,6 +427,50 @@ public sealed class TaskStateService : ITaskStateService
         return new TransitionResult(true, null);
     }
 
+    public async Task<TransitionResult> SetDependsOnAsync(string taskId, string? dependsOnTaskId, CancellationToken ct)
+    {
+        await using var ctx = await _dbFactory.CreateDbContextAsync(ct);
+
+        if (dependsOnTaskId is not null)
+        {
+            if (dependsOnTaskId == taskId)
+                return new TransitionResult(false, "A task cannot depend on itself.");
+
+            if (!await ctx.Tasks.AsNoTracking().AnyAsync(t => t.Id == dependsOnTaskId, ct))
+                return new TransitionResult(false, $"Dependency task {dependsOnTaskId} not found.");
+
+            // Walk the proposed predecessor's own chain of dependencies; if it leads back to
+            // taskId, linking here would create a cycle that starves both tasks forever (the
+            // picker never claims either). `visited` also stops us looping forever on
+            // pre-existing bad data unrelated to this write.
+            var current = dependsOnTaskId;
+            var visited = new HashSet<string>();
+            while (current is not null)
+            {
+                if (current == taskId)
+                    return new TransitionResult(false, "Setting this dependency would create a cycle.");
+                if (!visited.Add(current))
+                    break;
+                current = await ctx.Tasks.AsNoTracking()
+                    .Where(t => t.Id == current)
+                    .Select(t => t.DependsOnTaskId)
+                    .FirstOrDefaultAsync(ct);
+            }
+        }
+
+        var affected = await ctx.Tasks
+            .Where(t => t.Id == taskId)
+            .ExecuteUpdateAsync(s => s.SetProperty(t => t.DependsOnTaskId, dependsOnTaskId), ct);
+
+        if (affected == 0)
+            return new TransitionResult(false, "Task not found.");
+
+        // Clearing a dependency may free up a Queued task the picker was skipping.
+        if (dependsOnTaskId is null) _waker.Wake();
+        await _broadcaster.TaskUpdated(taskId);
+        return new TransitionResult(true, null);
+    }
+
     public async Task<int> RecoverStaleRunningAsync(string reason, CancellationToken ct)
     {
         var resultText = "[stale] " + reason;