fix(webapp): allow cancelling runs in DEQUEUED status from the runs list (#3421)

The cancel button was missing from the runs list for runs in `DEQUEUED`
status. The runs list gates the button on `run.isCancellable`, which
goes through `isCancellableRunStatus` -> `CANCELLABLE_RUN_STATUSES` =
`NON_FINAL_RUN_STATUSES`. `DEQUEUED` was never added to that list when
it was introduced in the run engine.

The single run page uses a separate check (`!run.isFinished`, i.e. the
inverse of `FINAL_RUN_STATUSES`), so cancellation already worked there -
only the list was affected.

Adding `DEQUEUED` to `NON_FINAL_RUN_STATUSES` also flips
`isCrashableRunStatus` and `isFailableRunStatus`, but:

- The crash path is the right behaviour - a `DEQUEUED` run (worker has
claimed but not yet executing) can legitimately crash before
`EXECUTING`, same as `PENDING`/`DELAYED` already do.
- The fail path (`failedTaskRun.server.ts`) is only reached from V1 code
paths (marqs consumers, v1 heartbeat handler). `DEQUEUED` is a
V2-engine-only status, so V1 consumers never see it.

When cancelling a `DEQUEUED` run the execution snapshot goes to
`PENDING_CANCEL` (worker must ack) but `TaskRun.status` flips to
`CANCELED` immediately - the UI reflects cancellation without waiting
for the worker. Added an integration test in
`run-engine/src/engine/tests/cancelling.test.ts` covering the full
trigger -> dequeue -> cancel -> worker-ack flow.

## Stall safety

The stall recovery path (PENDING_EXECUTING heartbeat miss ->
nack-and-requeue -> back to QUEUED) lives entirely inside
`@internal/run-engine` and never touches the webapp's `taskStatus.ts`
helpers - the engine has zero imports from `~/v3/taskStatus` and doesn't
know `CrashTaskRunService` / `FailedTaskRunService` exist. A stalled
DEQUEUED run still goes back to the queue for retry; this change cannot
cause stalls to crash or fail.

The only realistic impact is the intended UI fix - the theoretical V1
crash/fail branches for DEQUEUED are unreachable in practice because V1
runs never have DEQUEUED status.

Author: nicktrn

.server-changes/cancel-dequeued-runs.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Show the cancel button in the runs list for runs in `DEQUEUED` status. `DEQUEUED` was missing from `NON_FINAL_RUN_STATUSES` so the list hid the button even though the single run page allowed it.

apps/webapp/app/v3/taskStatus.ts

@@ -18,6 +18,7 @@ export const NON_FINAL_RUN_STATUSES = [
   "PENDING",
   "PENDING_VERSION",
   "WAITING_FOR_DEPLOY",
+  "DEQUEUED",
   "EXECUTING",
   "WAITING_TO_RESUME",
   "RETRYING_AFTER_FAILURE",

internal-packages/run-engine/src/engine/tests/cancelling.test.ts

@@ -322,5 +322,132 @@ describe("RunEngine cancelling", () => {
     }
   });
 
+  containerTest("Cancelling a run (dequeued)", async ({ prisma, redisOptions }) => {
+    //create environment
+    const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+    const engine = new RunEngine({
+      prisma,
+      worker: {
+        redis: redisOptions,
+        workers: 1,
+        tasksPerWorker: 10,
+        pollIntervalMs: 100,
+      },
+      queue: {
+        redis: redisOptions,
+        masterQueueConsumersDisabled: true,
+        processWorkerQueueDebounceMs: 50,
+      },
+      runLock: {
+        redis: redisOptions,
+      },
+      machines: {
+        defaultMachine: "small-1x",
+        machines: {
+          "small-1x": {
+            name: "small-1x" as const,
+            cpu: 0.5,
+            memory: 0.5,
+            centsPerMs: 0.0001,
+          },
+        },
+        baseCostInCents: 0.0001,
+      },
+      tracer: trace.getTracer("test", "0.0.0"),
+    });
+
+    try {
+      const parentTask = "parent-task";
+
+      //create background worker
+      await setupBackgroundWorker(engine, authenticatedEnvironment, [parentTask]);
+
+      //trigger the run
+      const parentRun = await engine.trigger(
+        {
+          number: 1,
+          friendlyId: "run_p1234",
+          environment: authenticatedEnvironment,
+          taskIdentifier: parentTask,
+          payload: "{}",
+          payloadType: "application/json",
+          context: {},
+          traceContext: {},
+          traceId: "t12345",
+          spanId: "s12345",
+          workerQueue: "main",
+          queue: `task/${parentTask}`,
+          isTest: false,
+          tags: [],
+        },
+        prisma
+      );
+
+      //dequeue the run, but don't start an attempt — this leaves TaskRun.status = DEQUEUED
+      //and execution snapshot = PENDING_EXECUTING (a worker has claimed the run)
+      await setTimeout(500);
+      const dequeued = await engine.dequeueFromWorkerQueue({
+        consumerId: "test_12345",
+        workerQueue: "main",
+      });
+      expect(dequeued.length).toBe(1);
+
+      const dequeuedRun = await prisma.taskRun.findFirstOrThrow({
+        where: { id: parentRun.id },
+      });
+      expect(dequeuedRun.status).toBe("DEQUEUED");
+
+      //cancel the dequeued run — a worker has already claimed it, so the snapshot goes to
+      //PENDING_CANCEL pending the worker ack. TaskRun.status flips to CANCELED immediately
+      //so the UI reflects cancellation without waiting.
+      const result = await engine.cancelRun({
+        runId: parentRun.id,
+        completedAt: new Date(),
+        reason: "Cancelled by the user",
+      });
+      expect(result.snapshot.executionStatus).toBe("PENDING_CANCEL");
+
+      const pendingCancel = await engine.getRunExecutionData({ runId: parentRun.id });
+      expect(pendingCancel?.snapshot.executionStatus).toBe("PENDING_CANCEL");
+      expect(pendingCancel?.run.status).toBe("CANCELED");
+
+      let cancelledEventData: EventBusEventArgs<"runCancelled">[0][] = [];
+      engine.eventBus.on("runCancelled", (result) => {
+        cancelledEventData.push(result);
+      });
+
+      //simulate worker acknowledging the cancellation
+      const completeResult = await engine.completeRunAttempt({
+        runId: parentRun.id,
+        snapshotId: pendingCancel!.snapshot.id,
+        completion: {
+          ok: false,
+          id: parentRun.id,
+          error: {
+            type: "INTERNAL_ERROR" as const,
+            code: "TASK_RUN_CANCELLED" as const,
+          },
+        },
+      });
+      expect(completeResult.snapshot.executionStatus).toBe("FINISHED");
+      expect(completeResult.run.status).toBe("CANCELED");
+
+      //check emitted event after worker ack
+      expect(cancelledEventData.length).toBe(1);
+      const parentEvent = cancelledEventData.find((r) => r.run.id === parentRun.id);
+      assertNonNullable(parentEvent);
+      expect(parentEvent.run.spanId).toBe(parentRun.spanId);
+
+      //concurrency should have been released
+      const envConcurrencyCompleted = await engine.runQueue.currentConcurrencyOfEnvironment(
+        authenticatedEnvironment
+      );
+      expect(envConcurrencyCompleted).toBe(0);
+    } finally {
+      await engine.quit();
+    }
+  });
+
   //todo bulk cancelling runs
 });