Preserve artifact deletion regression coverage

Author: RhysSullivan

e2e/scenarios/artifacts.test.ts

@@ -606,8 +606,10 @@ scenario(
     const suffix = uniqueSuffix();
     const originalTitle = `Draft Dashboard ${suffix}`;
     const renamedTitle = `Quarterly Dashboard ${suffix}`;
+    const listDeleteTitle = `List Card ${suffix}`;
 
     let artifactId: ArtifactId | undefined;
+    let listArtifactId: ArtifactId | undefined;
 
     yield* Effect.gen(function* () {
       const rendered = yield* session.call("create-artifact", {
@@ -657,39 +659,111 @@ scenario(
         originalTitle,
       );
 
+      // A second artifact for the gallery card's own delete path: the detail
+      // page steps below consume the renamed one, and the card's hover →
+      // Delete affordance is a separate surface the console must keep working.
+      const listed = yield* session.call("create-artifact", {
+        code: artifactSource(`list-delete-${suffix}`),
+        title: listDeleteTitle,
+        description: "A dashboard the user will delete from the gallery",
+      });
+      expect(listed.ok, `create-artifact succeeded: ${listed.text}`).toBe(true);
+      listArtifactId = structuredOf(listed).artifactId as ArtifactId;
+      expect(listArtifactId, "the second artifact was persisted").toBeTruthy();
+
       yield* browser.session(identity, async ({ page, step }) => {
-        await step("Delete the artifact from the list", async () => {
+        await step("Delete the artifact from its gallery card", async () => {
           await visit(page, "/artifacts");
+          // Card actions reveal on hover; the card is the link's enclosing tile.
           const card = page.locator('[data-slot="artifact-card"]').filter({
-            hasText: renamedTitle,
+            hasText: listDeleteTitle,
           });
           await card.waitFor({ timeout: 20_000 });
           await card.hover();
           await card.getByRole("button", { name: "Delete" }).click();
 
           const confirm = page.getByRole("alertdialog");
-          await confirm.getByRole("heading", { name: `Delete ${renamedTitle}?` }).waitFor();
+          await confirm.getByRole("heading", { name: `Delete ${listDeleteTitle}?` }).waitFor();
           await confirm.getByRole("button", { name: "Delete Artifact" }).click();
           await confirm.waitFor({ state: "hidden", timeout: 20_000 });
+          await page
+            .getByRole("link", { name: `Open artifact ${listDeleteTitle}` })
+            .waitFor({ state: "detached", timeout: 20_000 });
         });
 
-        await step("The artifact is gone from the list", async () => {
-          await page
+        let releaseListRefresh = () => {};
+        let markListRefreshStarted = () => {};
+        const listRefreshGate = new Promise<void>((resolve) => {
+          releaseListRefresh = resolve;
+        });
+        const listRefreshStarted = new Promise<void>((resolve) => {
+          markListRefreshStarted = resolve;
+        });
+
+        await step("Open the artifact and delete it from its detail page", async () => {
+          await visit(page, "/artifacts");
+          await page.getByRole("link", { name: `Open artifact ${renamedTitle}` }).click();
+          await page.getByRole("heading", { name: renamedTitle }).waitFor({ timeout: 20_000 });
+
+          // Hold the post-delete list refresh open. The redirected gallery must
+          // carry the optimistic removal across the route handoff rather than
+          // relying on a fast canonical response to hide a stale-cache flash.
+          await page.route("**/artifacts", async (route) => {
+            if (route.request().method() !== "GET") {
+              await route.continue();
+              return;
+            }
+            markListRefreshStarted();
+            await listRefreshGate;
+            await route.continue();
+          });
+
+          await page.getByRole("button", { name: "Delete" }).click();
+          const confirm = page.getByRole("alertdialog");
+          await confirm.getByRole("heading", { name: `Delete ${renamedTitle}?` }).waitFor();
+          await confirm.getByRole("button", { name: "Delete Artifact" }).click();
+        });
+
+        await step("The redirected gallery already omits the deleted artifact", async () => {
+          await page.waitForURL((url) => /\/artifacts\/?$/.test(url.pathname), {
+            timeout: 20_000,
+          });
+          await page.getByRole("heading", { name: "Saved artifacts" }).waitFor({ timeout: 20_000 });
+          await listRefreshStarted;
+
+          const deletedCardCount = await page
             .getByRole("link", { name: `Open artifact ${renamedTitle}` })
-            .waitFor({ state: "detached", timeout: 20_000 });
+            .count();
+          releaseListRefresh();
+          await page.unrouteAll({ behavior: "wait" });
+
+          expect(
+            deletedCardCount,
+            "the optimistic delete survives navigation while the list refresh is pending",
+          ).toBe(0);
         });
       });
 
       const afterDelete = yield* session.call("list-artifacts", {});
       expect(afterDelete.text, "the agent no longer offers the deleted artifact").not.toContain(
         renamedTitle,
       );
+      expect(afterDelete.text, "nor the artifact deleted from its gallery card").not.toContain(
+        listDeleteTitle,
+      );
 
       const missing = yield* session.call("show-artifact", { id: artifactId });
       expect(missing.ok, "fetching a deleted artifact is an error, not an empty render").toBe(
         false,
       );
     }).pipe(
+      Effect.ensuring(
+        Effect.suspend(() =>
+          listArtifactId === undefined
+            ? Effect.void
+            : client.artifacts.remove({ params: { artifactId: listArtifactId } }),
+        ).pipe(Effect.ignore),
+      ),
       Effect.ensuring(
         Effect.suspend(() =>
           artifactId === undefined