fix(webapp): mutations-layer Devin follow-ups

- metadata route was routing rootOperations to bufferedEntry.parentTaskRunId
  with a comment claiming PG's nil-coalesce defaults to parent. PG actually
  defaults to taskRun.id (self), so a buffered grandchild metadata.root.set()
  was silently mutating the child's metadata instead of the root's.
  SyntheticRun already carries rootTaskRunFriendlyId from the snapshot —
  use it, falling back to the run itself (matching PG) when absent.

- reschedule route's PG path delegates to RescheduleTaskRunService which
  enforces `status !== "DELAYED"` and 422s otherwise. The buffer path had
  no equivalent guard, so a customer could inject delayUntil into the
  snapshot of an undelayed buffered run and the drainer would materialise
  it with an unintended delay. Added a pre-fetch through
  findRunByIdWithMollifierFallback and 422 when the buffered run has no
  delayUntil. SyntheticRun doesn't carry a "DELAYED" status enum
  (only QUEUED|FAILED|CANCELED) so the gate reads the snapshot's
  delayUntil field directly.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: d-cs

apps/webapp/app/routes/api.v1.runs.$runId.metadata.ts

@@ -159,11 +159,19 @@ const { action } = createActionApiRoute(
     if (bufferedEntry) {
       await Promise.all([
         routeOperationsToRun(bufferedEntry.parentTaskRunId, body.parentOperations, env),
-        // The snapshot doesn't carry rootTaskRunId; fall back to parent
-        // as a rough proxy (matches the existing service's nil-coalesce
-        // behaviour where rootTaskRun defaults to the parent). Phase D
-        // / future work could thread rootTaskRunId through the snapshot.
-        routeOperationsToRun(bufferedEntry.parentTaskRunId, body.rootOperations, env),
+        // The PG service routes rootOperations to
+        // `taskRun.rootTaskRun?.id ?? taskRun.id` — the actual root, not
+        // the parent. The snapshot carries the root's *friendlyId*
+        // (parentTaskRunId is an internal id; root is friendlyId because
+        // it's what the engine passes through). Use it; if absent,
+        // route to the run itself (matches PG's self-fallback) rather
+        // than misrouting to the parent for grandchild → child → root
+        // hierarchies.
+        routeOperationsToRun(
+          bufferedEntry.rootTaskRunFriendlyId ?? runId,
+          body.rootOperations,
+          env,
+        ),
       ]);
     }
 

apps/webapp/app/routes/api.v1.runs.$runParam.reschedule.ts

@@ -10,6 +10,7 @@ import { logger } from "~/services/logger.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { RescheduleTaskRunService } from "~/v3/services/rescheduleTaskRun.server";
 import { mutateWithFallback } from "~/v3/mollifier/mutateWithFallback.server";
+import { findRunByIdWithMollifierFallback } from "~/v3/mollifier/readFallback.server";
 import { parseDelay } from "~/utils/delays";
 
 const ParamsSchema = z.object({
@@ -49,6 +50,29 @@ export async function action({ request, params }: ActionFunctionArgs) {
   }
 
   try {
+    // PG-side `RescheduleTaskRunService.call` enforces
+    // `taskRun.status !== "DELAYED"` and 422s otherwise — without an
+    // equivalent guard the buffer path would happily inject a
+    // `delayUntil` into the snapshot of a non-delayed buffered run, and
+    // the drainer would materialise it with an unintended delay. The
+    // SyntheticRun type doesn't carry a "DELAYED" enum value because
+    // it's not a terminal status the trace API needs to express; the
+    // buffered analogue is `delayUntil` set in the snapshot. Gate on
+    // that. Race window between read and write is bounded: if the
+    // drainer materialises mid-call, mutateWithFallback falls through
+    // to the PG mutation which has its own DELAYED check.
+    const buffered = await findRunByIdWithMollifierFallback({
+      runId: parsed.data.runParam,
+      environmentId: env.id,
+      organizationId: env.organizationId,
+    });
+    if (buffered && !buffered.delayUntil) {
+      return json(
+        { error: "Cannot reschedule a run that is not delayed" },
+        { status: 422 },
+      );
+    }
+
     const outcome = await mutateWithFallback<Response>({
       runId: parsed.data.runParam,
       environmentId: env.id,