fix(webapp): validate mollifier snapshot dates before use

`new Date("not-a-date")` returns a truthy Invalid Date object, which would
mis-classify the run as CANCELED in the read-fallback synthesised shape.
Add an `asDate` helper that rejects NaN-valued parses and use it for
`cancelledAt` and `delayUntil`.

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

Author: d-cs

apps/webapp/app/v3/mollifier/readFallback.server.ts

@@ -102,6 +102,13 @@ function asStringArray(value: unknown): string[] {
   return Array.isArray(value) && value.every((v) => typeof v === "string") ? (value as string[]) : [];
 }
 
+function asDate(value: unknown): Date | undefined {
+  const raw = asString(value);
+  if (!raw) return undefined;
+  const parsed = new Date(raw);
+  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+
 export async function findRunByIdWithMollifierFallback(
   input: ReadFallbackInput,
   deps: ReadFallbackDeps = {},
@@ -134,17 +141,15 @@ export async function findRunByIdWithMollifierFallback(
         ? (snapshot.environment as Record<string, unknown>)
         : undefined;
 
-    const cancelledAtRaw = asString(snapshot.cancelledAt);
-    const cancelledAt = cancelledAtRaw ? new Date(cancelledAtRaw) : undefined;
+    const cancelledAt = asDate(snapshot.cancelledAt);
     const cancelReason = asString(snapshot.cancelReason);
     let status: SyntheticRun["status"] = "QUEUED";
     if (cancelledAt) {
       status = "CANCELED";
     } else if (entry.status === "FAILED") {
       status = "FAILED";
     }
-    const delayUntilRaw = asString(snapshot.delayUntil);
-    const delayUntil = delayUntilRaw ? new Date(delayUntilRaw) : undefined;
+    const delayUntil = asDate(snapshot.delayUntil);
 
     return {
       id: RunId.fromFriendlyId(entry.runId),

apps/webapp/test/mollifierReadFallback.test.ts

@@ -257,6 +257,58 @@ describe("findRunByIdWithMollifierFallback", () => {
     expect(result!.runTags).toEqual(["t1", "t2"]);
   });
 
+  it("treats invalid date strings as undefined and does not mis-classify status as CANCELED", async () => {
+    const entry: BufferEntry = {
+      runId: "run_1",
+      envId: "env_a",
+      orgId: "org_1",
+      payload: JSON.stringify({
+        taskIdentifier: "t",
+        cancelledAt: "not-a-date",
+        cancelReason: "user requested",
+        delayUntil: "also-not-a-date",
+      }),
+      status: "QUEUED",
+      attempts: 0,
+      createdAt: NOW,
+    };
+    const result = await findRunByIdWithMollifierFallback(
+      { runId: "run_1", environmentId: "env_a", organizationId: "org_1" },
+      { getBuffer: () => fakeBuffer(entry) },
+    );
+    expect(result).not.toBeNull();
+    expect(result!.status).toBe("QUEUED");
+    expect(result!.cancelledAt).toBeUndefined();
+    expect(result!.delayUntil).toBeUndefined();
+  });
+
+  it("parses valid ISO date strings on cancelledAt and delayUntil", async () => {
+    const cancelledAtIso = "2026-05-11T13:00:00.000Z";
+    const delayUntilIso = "2026-05-11T14:00:00.000Z";
+    const entry: BufferEntry = {
+      runId: "run_1",
+      envId: "env_a",
+      orgId: "org_1",
+      payload: JSON.stringify({
+        taskIdentifier: "t",
+        cancelledAt: cancelledAtIso,
+        cancelReason: "user requested",
+        delayUntil: delayUntilIso,
+      }),
+      status: "QUEUED",
+      attempts: 0,
+      createdAt: NOW,
+    };
+    const result = await findRunByIdWithMollifierFallback(
+      { runId: "run_1", environmentId: "env_a", organizationId: "org_1" },
+      { getBuffer: () => fakeBuffer(entry) },
+    );
+    expect(result!.status).toBe("CANCELED");
+    expect(result!.cancelledAt).toEqual(new Date(cancelledAtIso));
+    expect(result!.cancelReason).toBe("user requested");
+    expect(result!.delayUntil).toEqual(new Date(delayUntilIso));
+  });
+
   it("falls back to entry.envId for runtimeEnvironmentId when snapshot lacks environment.id", async () => {
     const entry: BufferEntry = {
       runId: "run_1",