fix(workflow): bound cancel/reclaim timeouts to prevent indefinite hangs

- Add RECLAIM_WORKTREE_TIMEOUT_MS (10s) to worktree.remove during reclaim
- Add RECLAIM_ACTOR_TIMEOUT_MS (5s) to actor.cancel during reclaim
- Add FIBER_INTERRUPT_TIMEOUT_MS (5s) to Fiber.interrupt in cancelEntry

These timeouts prevent cancel from hanging indefinitely when:
1. git worktree remove --force blocks on processes using the worktree
2. A child actor is stuck in an uninterruptible operation
3. Fiber.interrupt stalls on a hung LLM fetch

The specific fix addresses the 30s timeout in:
'WorkflowRuntime worktree isolation > cancel removes worktrees of in-flight isolated agents'

Root cause: PR #1709 added Instance.disposeDirectory calls in worktree.remove
which increased the time for cancel cleanup. Combined with git worktree remove
--force potentially blocking, the cancel operation could exceed the test timeout.

Author: wqymi

packages/opencode/src/workflow/runtime.ts

@@ -436,19 +436,39 @@ export const layer = Layer.effect(
     // worktree the run still owns, then clear the set. NEVER throws — a reclaim
     // failure must not mask the original terminal cause. NOT called on success:
     // kept (success+changed) worktrees are the deliverable and must survive.
+    // Worktree removal is bounded by RECLAIM_WORKTREE_TIMEOUT_MS so a hung
+    // git worktree remove (e.g. processes using the worktree) cannot block
+    // cancel indefinitely. Actor cancel is bounded by RECLAIM_ACTOR_TIMEOUT_MS
+    // so a hung child actor cannot block reclaim indefinitely.
+    const RECLAIM_WORKTREE_TIMEOUT_MS = 10_000
+    const RECLAIM_ACTOR_TIMEOUT_MS = 5_000
     const reclaim = (entry: RunEntry) =>
       Effect.gen(function* () {
         const actor = spawnRef.current
         if (actor) {
           yield* Effect.forEach(
             [...entry.childActorIDs],
-            (childID) => actor.cancel(entry.sessionID, childID, "graceful").pipe(Effect.ignore),
+            (childID) =>
+              actor.cancel(entry.sessionID, childID, "graceful").pipe(
+                Effect.timeout(RECLAIM_ACTOR_TIMEOUT_MS),
+                Effect.catchTag("TimeoutError", () =>
+                  Effect.sync(() => log.warn("actor cancel timed out during reclaim", { childID })),
+                ),
+                Effect.ignore,
+              ),
             { concurrency: "unbounded", discard: true },
           )
         }
         yield* Effect.forEach(
           [...entry.worktrees],
-          (directory) => worktree.remove({ directory }).pipe(Effect.ignore),
+          (directory) =>
+            worktree.remove({ directory }).pipe(
+              Effect.timeout(RECLAIM_WORKTREE_TIMEOUT_MS),
+              Effect.catchTag("TimeoutError", () =>
+                Effect.sync(() => log.warn("worktree remove timed out during reclaim", { directory })),
+              ),
+              Effect.ignore,
+            ),
           { concurrency: "unbounded", discard: true },
         )
         entry.worktrees.clear()
@@ -472,13 +492,22 @@ export const layer = Layer.effect(
         )
       })
 
+    // Bounded interrupt: Fiber.interrupt can stall on a hung LLM fetch or an
+    // uninterruptible operation. Bounding it so cancel completes in finite time.
+    const FIBER_INTERRUPT_TIMEOUT_MS = 5_000
     const cancelEntry = (entry: RunEntry): Effect.Effect<void> =>
       Effect.gen(function* () {
         if (entry.status !== "running") return
         yield* reclaim(entry)
         yield* flushNow(entry)
         yield* WorkflowPersistence.recordTerminal({ runID: entry.runID, status: "cancelled" }).pipe(Effect.ignore)
-        if (entry.fiber) yield* Fiber.interrupt(entry.fiber)
+        if (entry.fiber)
+          yield* Fiber.interrupt(entry.fiber).pipe(
+            Effect.timeout(FIBER_INTERRUPT_TIMEOUT_MS),
+            Effect.catchTag("TimeoutError", () =>
+              Effect.sync(() => log.warn("fiber interrupt timed out during cancel", { runID: entry.runID })),
+            ),
+          )
         entry.status = "cancelled"
         yield* Deferred.succeed(entry.deferred, { status: "cancelled" })
         yield* bus.publish(WorkflowFinished, { sessionID: entry.sessionID, runID: entry.runID, status: "cancelled" })