@@ -75,14 +75,12 @@
     "clearLater": "Clear later loop iterations",
     "clearNote": "Reason for clearing (optional)",
     "clearSelected": "Clear selected executions",
-    "clearTitle": "Clear selected executions",
     "clearWhole": "Clear whole mapped expansions",
+    "empty": "No executions in this run.",
     "iteration": "{{node}} · Iteration {{index}}",
     "mapped_one": "{{task}} ({{count}} mapped task on this page)",
     "mapped_other": "{{task}} ({{count}} mapped tasks on this page)",
-    "nextPage": "Next page",
     "page": "Showing {{start}}–{{end}} of {{total}} executions",
-    "previousPage": "Previous page",
     "runTasks": "Run tasks",
     "select": "Select {{task}}",
     "title": "Execution"
 
@@ -22,14 +22,41 @@ import { afterEach, beforeAll, expect, it, vi } from "vitest";
 
 import { TaskInstanceService } from "openapi/requests";
 
+import {
+  CLEAR_KEEP_TASK_STATE_KEY,
+  CLEAR_PREVENT_RUNNING_TASK_KEY,
+  CLEAR_TASK_INSTANCE_DEFAULT_OPTIONS_KEY,
+} from "src/constants/localStorage";
 import i18n from "src/i18n/config";
 import { Wrapper } from "src/utils/Wrapper";
 
 import dagTranslations from "../../../../public/i18n/locales/en/dag.json";
+import dagsTranslations from "../../../../public/i18n/locales/en/dags.json";
 import { ClearExecutionDialog } from "./ClearExecutionDialog";
 
-beforeAll(() => i18n.addResourceBundle("en", "dag", dagTranslations, true, true));
-afterEach(() => vi.restoreAllMocks());
+beforeAll(() => {
+  i18n.addResourceBundle("en", "dag", dagTranslations, true, true);
+  i18n.addResourceBundle("en", "dags", dagsTranslations, true, true);
+});
+afterEach(() => {
+  vi.restoreAllMocks();
+  localStorage.clear();
+});
+
+const execution = {
+  id: "selected-uuid",
+  map_index: -1,
+  note: "existing note",
+  region_id: "11111111-1111-1111-1111-111111111111",
+  region_index: 1,
+  task_display_name: "work",
+  task_id: "body.work",
+};
+
+const findClearRequest = (clear: { mock: { calls: Array<Array<unknown>> } }) =>
+  (clear.mock.calls as Array<[{ requestBody: { dry_run?: boolean; note?: string | null } }]>)
+    .map(([request]) => request)
+    .find((request) => request.requestBody.dry_run === false);
 
 it("keeps stale UUID scope visible when the clear preview rejects an archived execution", async () => {
   const clear = vi
@@ -136,3 +163,118 @@ it("previews and clears UUID seeds with separate whole-expansion and later-loop
     }),
   );
 });
+
+it("sends the saved clear defaults in the dry run and the real request", async () => {
+  localStorage.setItem(CLEAR_PREVENT_RUNNING_TASK_KEY, JSON.stringify(true));
+  localStorage.setItem(CLEAR_KEEP_TASK_STATE_KEY, JSON.stringify(true));
+  localStorage.setItem(CLEAR_TASK_INSTANCE_DEFAULT_OPTIONS_KEY, JSON.stringify([]));
+  const clear = vi
+    .spyOn(TaskInstanceService, "postClearTaskInstances")
+    .mockResolvedValue({ task_instances: [], total_entries: 1 });
+
+  render(<ClearExecutionDialog dagId="dag" executions={[execution]} onClose={vi.fn()} open runId="run" />, {
+    wrapper: Wrapper,
+  });
+
+  await waitFor(() =>
+    expect(clear.mock.lastCall?.[0].requestBody).toMatchObject({
+      dry_run: true,
+      include_downstream: false,
+      keep_task_state: true,
+      prevent_running_task: true,
+    }),
+  );
+  expect(await screen.findByText("1 execution will be cleared.")).toBeVisible();
+  expect(screen.getByLabelText("Prevent rerun if task is running")).toBeChecked();
+  expect(screen.getByLabelText("Keep task state and resume")).toBeChecked();
+  fireEvent.click(screen.getByLabelText("Keep task state and resume"));
+  fireEvent.click(screen.getByLabelText("Prevent rerun if task is running"));
+  await waitFor(() =>
+    expect(clear.mock.lastCall?.[0].requestBody).toMatchObject({
+      dry_run: true,
+      keep_task_state: false,
+      prevent_running_task: false,
+    }),
+  );
+  await waitFor(() =>
+    expect(screen.getByRole("button", { name: "Clear selected executions" })).toBeEnabled(),
+  );
+  fireEvent.click(screen.getByRole("button", { name: "Clear selected executions" }));
+  await waitFor(() =>
+    expect(findClearRequest(clear)?.requestBody).toMatchObject({
+      keep_task_state: false,
+      prevent_running_task: false,
+    }),
+  );
+});
+
+it("hides the affected count while the dry run is pending", async () => {
+  vi.spyOn(TaskInstanceService, "postClearTaskInstances").mockReturnValue(
+    new Promise(() => undefined) as ReturnType<typeof TaskInstanceService.postClearTaskInstances>,
+  );
+
+  render(<ClearExecutionDialog dagId="dag" executions={[execution]} onClose={vi.fn()} open runId="run" />, {
+    wrapper: Wrapper,
+  });
+
+  expect(await screen.findByLabelText("Clear downstream tasks")).toBeVisible();
+  expect(screen.queryByText(/executions? will be cleared/u)).not.toBeInTheDocument();
+});
+
+it("seeds the note from the execution and only sends it when edited", async () => {
+  const clear = vi
+    .spyOn(TaskInstanceService, "postClearTaskInstances")
+    .mockResolvedValue({ task_instances: [], total_entries: 1 });
+
+  render(<ClearExecutionDialog dagId="dag" executions={[execution]} onClose={vi.fn()} open runId="run" />, {
+    wrapper: Wrapper,
+  });
+
+  const note = await screen.findByLabelText("Reason for clearing (optional)");
+
+  expect(note).toHaveValue("existing note");
+  await waitFor(() =>
+    expect(screen.getByRole("button", { name: "Clear selected executions" })).toBeEnabled(),
+  );
+  fireEvent.click(screen.getByRole("button", { name: "Clear selected executions" }));
+  await waitFor(() => expect(findClearRequest(clear)).toBeDefined());
+  expect(findClearRequest(clear)?.requestBody.note).toBeUndefined();
+});
+
+it("does not send an empty note when the user erases the existing one", async () => {
+  const clear = vi
+    .spyOn(TaskInstanceService, "postClearTaskInstances")
+    .mockResolvedValue({ task_instances: [], total_entries: 1 });
+
+  render(<ClearExecutionDialog dagId="dag" executions={[execution]} onClose={vi.fn()} open runId="run" />, {
+    wrapper: Wrapper,
+  });
+
+  fireEvent.change(await screen.findByLabelText("Reason for clearing (optional)"), { target: { value: "" } });
+  await waitFor(() =>
+    expect(screen.getByRole("button", { name: "Clear selected executions" })).toBeEnabled(),
+  );
+  fireEvent.click(screen.getByRole("button", { name: "Clear selected executions" }));
+  await waitFor(() => expect(findClearRequest(clear)).toBeDefined());
+  expect(findClearRequest(clear)?.requestBody.note).toBeUndefined();
+});
+
+it("resets the dialog state once it closes", async () => {
+  vi.spyOn(TaskInstanceService, "postClearTaskInstances").mockResolvedValue({
+    task_instances: [],
+    total_entries: 1,
+  });
+  const props = { dagId: "dag", executions: [execution], onClose: vi.fn(), runId: "run" };
+  const { rerender } = render(<ClearExecutionDialog {...props} open />, { wrapper: Wrapper });
+
+  fireEvent.click(await screen.findByLabelText("Clear later loop iterations"));
+  fireEvent.change(screen.getByLabelText("Reason for clearing (optional)"), { target: { value: "typed" } });
+  await waitFor(() => expect(screen.getByLabelText("Clear later loop iterations")).not.toBeChecked());
+  await waitFor(() => expect(screen.getByLabelText("Reason for clearing (optional)")).toHaveValue("typed"));
+  rerender(<ClearExecutionDialog {...props} open={false} />);
+  await waitFor(() => expect(screen.queryByLabelText("Clear later loop iterations")).not.toBeInTheDocument());
+  rerender(<ClearExecutionDialog {...props} open />);
+
+  expect(await screen.findByLabelText("Clear later loop iterations")).toBeChecked();
+  expect(screen.getByLabelText("Reason for clearing (optional)")).toHaveValue("existing note");
+});
@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { useState } from "react";
+import { useEffect, useState } from "react";
 
 import { Button, Stack, Text, Textarea } from "@chakra-ui/react";
 import { useTranslation } from "react-i18next";
@@ -27,12 +27,17 @@ import { Checkbox, Modal } from "src/system-components";
 
 import { ErrorAlert } from "src/components/ErrorAlert";
 
+import {
+  useClearKeepTaskStateDefault,
+  useClearPreventRunningTaskDefault,
+  useClearTaskInstanceDefaultOptions,
+} from "src/hooks/useUserSettings";
 import { useClearTaskInstances } from "src/queries/useClearTaskInstances";
 import { useClearTaskInstancesDryRun } from "src/queries/useClearTaskInstancesDryRun";
 
 type SelectedExecution = Pick<
   ExecutionTaskResponse,
-  "id" | "map_index" | "region_id" | "region_index" | "task_display_name" | "task_id"
+  "id" | "map_index" | "note" | "region_id" | "region_index" | "task_display_name" | "task_id"
 >;
 
 export const ClearExecutionDialog = ({
@@ -49,10 +54,28 @@ export const ClearExecutionDialog = ({
   readonly runId: string;
 }) => {
   const { t: translate } = useTranslation("dag");
-  const [downstream, setDownstream] = useState(true);
+  const [defaultOptions] = useClearTaskInstanceDefaultOptions();
+  const [preventRunningDefault] = useClearPreventRunningTaskDefault();
+  const [keepTaskStateDefault] = useClearKeepTaskStateDefault();
+  const initialNote = (executions.length === 1 ? executions[0]?.note : undefined) ?? "";
+  const defaultDownstream = defaultOptions.includes("downstream");
+  const [downstream, setDownstream] = useState(defaultDownstream);
   const [later, setLater] = useState(true);
   const [whole, setWhole] = useState(false);
-  const [note, setNote] = useState<string>();
+  const [preventRunning, setPreventRunning] = useState(preventRunningDefault);
+  const [keepTaskState, setKeepTaskState] = useState(keepTaskStateDefault);
+  const [note, setNote] = useState(initialNote);
+
+  useEffect(() => {
+    if (!open) {
+      setDownstream(defaultDownstream);
+      setLater(true);
+      setWhole(false);
+      setPreventRunning(preventRunningDefault);
+      setKeepTaskState(keepTaskStateDefault);
+      setNote(initialNote);
+    }
+  }, [open, defaultDownstream, preventRunningDefault, keepTaskStateDefault, initialNote]);
   const mappedIds = executions
     .filter(
       (ti) =>
@@ -64,7 +87,9 @@ export const ClearExecutionDialog = ({
     dag_run_id: runId,
     include_downstream: downstream,
     include_later_loop_iterations: later,
+    keep_task_state: keepTaskState,
     only_failed: false,
+    prevent_running_task: preventRunning,
     task_instance_ids: executions.map((ti) => ti.id),
     whole_expansion_ids: whole ? mappedIds : [],
   };
@@ -81,7 +106,16 @@ export const ClearExecutionDialog = ({
         <Button
           disabled={preview.isPending || preview.isError}
           loading={clear.isPending}
-          onClick={() => clear.mutate({ dagId, requestBody: { ...requestBody, dry_run: false, note } })}
+          onClick={() =>
+            clear.mutate({
+              dagId,
+              requestBody: {
+                ...requestBody,
+                dry_run: false,
+                note: note === initialNote ? undefined : note || undefined,
+              },
+            })
+          }
         >
           {translate("execution.clearSelected")}
         </Button>
@@ -92,10 +126,10 @@ export const ClearExecutionDialog = ({
         }
       }}
       open={open}
-      title={translate("execution.clearTitle")}
+      title={translate("execution.clearSelected")}
     >
       <Stack gap={4}>
-        <ErrorAlert error={preview.error ?? clear.error} />
+        <ErrorAlert error={preview.error} />
         <Checkbox checked={downstream} onCheckedChange={(details) => setDownstream(details.checked === true)}>
           {translate("execution.clearDownstream")}
         </Checkbox>
@@ -107,13 +141,27 @@ export const ClearExecutionDialog = ({
             {translate("execution.clearWhole")}
           </Checkbox>
         ) : undefined}
-        <Text>{translate("execution.clearAffected", { count: preview.data?.total_entries ?? 0 })}</Text>
+        <Checkbox
+          checked={preventRunning}
+          onCheckedChange={(details) => setPreventRunning(details.checked === true)}
+        >
+          {translate("dags:runAndTaskActions.options.preventRunningTasks")}
+        </Checkbox>
+        <Checkbox
+          checked={keepTaskState}
+          onCheckedChange={(details) => setKeepTaskState(details.checked === true)}
+        >
+          {translate("dags:runAndTaskActions.options.keepTaskState")}
+        </Checkbox>
+        {preview.data === undefined ? undefined : (
+          <Text>{translate("execution.clearAffected", { count: preview.data.total_entries })}</Text>
+        )}
         <Textarea
           aria-label={translate("execution.clearNote")}
           maxLength={1000}
           onChange={(event) => setNote(event.target.value)}
           placeholder={translate("execution.clearNote")}
-          value={note ?? ""}
+          value={note}
         />
       </Stack>
     </Modal>
 
@@ -17,7 +17,7 @@
  * under the License.
  */
 import "@testing-library/jest-dom";
-import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { fireEvent, render, screen, waitFor, within } from "@testing-library/react";
 import { http, HttpResponse } from "msw";
 import { setupServer, type SetupServer } from "msw/node";
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
@@ -75,6 +75,14 @@ const taskInstance: TaskInstanceResponse = {
 
 const affectedTasks = { task_instances: [taskInstance], total_entries: 1 };
 
+const loopPass = (id: string, regionIndex: number): TaskInstanceResponse => ({
+  ...taskInstance,
+  id,
+  region_id: "11111111-1111-4111-8111-111111111111",
+  region_index: regionIndex,
+  task_id: "body.work",
+});
+
 const mutateMock = vi.fn();
 
 vi.mock("src/queries/useClearTaskInstances", () => ({
@@ -99,6 +107,8 @@ beforeAll(() => {
   server.listen({ onUnhandledRequest: "bypass" });
 });
 afterEach(() => {
+  affectedTasks.task_instances = [taskInstance];
+  mutateMock.mockClear();
   server.resetHandlers();
   localStorage.clear();
 });
@@ -126,4 +136,25 @@ describe("ClearTaskInstanceDialog", () => {
 
     expect(requestBody.keep_task_state).toBe(true);
   });
+
+  it("clears the kept loop passes by execution id when another pass is unticked", async () => {
+    affectedTasks.task_instances = [loopPass("pass-0", 0), loopPass("pass-2", 2)];
+
+    render(<ClearTaskInstanceDialog onClose={vi.fn()} open taskInstance={taskInstance} />, {
+      wrapper: Wrapper,
+    });
+
+    const rows = await screen.findAllByRole("row");
+
+    fireEvent.click(within(rows[1] as HTMLElement).getByRole("checkbox"));
+    fireEvent.click(await screen.findByRole("button", { name: /modal\.confirm/iu }));
+
+    await waitFor(() => expect(mutateMock).toHaveBeenCalledTimes(1));
+    const [{ requestBody }] = mutateMock.mock.calls[0] as [
+      { requestBody: { task_ids?: unknown; task_instance_ids?: Array<string> } },
+    ];
+
+    expect(requestBody.task_instance_ids).toEqual(["pass-2"]);
+    expect(requestBody.task_ids).toBeUndefined();
+  });
 });
@@ -340,16 +340,16 @@ const ClearTaskInstanceDialog = (props: Props) => {
               // instances by run and fire one run-scoped clear each, with the graph-expansion
               // flags off. This honors per-run exclusions (e.g. keep task X in run 1 but drop
               // it from run 2) that a single flat request cannot express.
-              const idsByRun = new Map<string, NonNullable<ClearTaskInstancesBody["task_ids"]>>();
+              const idsByRun = new Map<string, Array<string>>();
 
               for (const ti of keptTaskInstances) {
                 const ids = idsByRun.get(ti.dag_run_id) ?? [];
 
-                ids.push(ti.map_index < 0 ? ti.task_id : [ti.task_id, ti.map_index]);
+                ids.push(ti.id);
                 idsByRun.set(ti.dag_run_id, ids);
               }
 
-              for (const [runId, taskIds] of idsByRun) {
+              for (const [runId, taskInstanceIds] of idsByRun) {
                 mutate({
                   dagId,
                   requestBody: {
@@ -362,7 +362,7 @@ const ClearTaskInstanceDialog = (props: Props) => {
                     note: noteChanged ? note : undefined,
                     only_failed: onlyFailed,
                     run_on_latest_version: runOnLatestVersion,
-                    task_ids: taskIds,
+                    task_instance_ids: taskInstanceIds,
                     ...(keepTaskState ? { keep_task_state: true } : {}),
                     ...(preventRunningTask ? { prevent_running_task: true } : {}),
                   },