Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@api/v1/api.yaml`:
- Around line 2247-2250: The dagRunId property currently references the reusable
DAGRunId schema which permits the special alias "latest" (causing ambiguity for
a newly-created retry run); change dagRunId to use a concrete schema that
disallows the "latest" alias (either by referencing a new schema like
DAGRunCreateId or replacing the allOf with an inline string schema/pattern that
excludes "latest"). Update the OpenAPI definition where dagRunId appears so the
new retry-run contract accepts only explicit IDs (no "latest") and add/adjust
the new schema definition (e.g., DAGRunCreateId) to mirror DAGRunId format but
without the "latest" alternative.

In `@internal/intg/edit_retry_api_test.go`:
- Around line 49-57: The test uses new(sourceRunID) and new(retryRunID)
incorrectly (new expects a type); update the request bodies so DagRunId receives
pointers to the string variables by replacing new(sourceRunID) with &sourceRunID
and new(retryRunID) with &retryRunID where
api.ExecuteDAGJSONRequestBody{DagRunId: ...} is constructed (refer to the
sourceRunID and retryRunID variables and the DagRunId field).

In `@internal/service/frontend/api/v1/dagruns_edit_retry.go`:
- Around line 538-589: seedEditRetryAttempt creates an attempt via
dagRunStore.CreateAttempt but never rolls it back on later errors, leaving
orphaned attempts; update seedEditRetryAttempt to introduce a committed bool
after CreateAttempt, add a deferred closure that calls
a.dagRunStore.RollbackAttempt(ctx, attempt) when committed is false (logging any
rollback error), and set committed = true only after successful attempt.Open and
attempt.Write complete so failures before commit release the run ID; reference
CreateAttempt, RollbackAttempt, seedEditRetryAttempt, attempt.Open, and
attempt.Write when making the change.
- Around line 717-726: The function editRetryWarnings currently emits "no
previously successful steps are eligible to skip" whenever skipped is empty;
change it to only emit that message when skipped is empty AND there was actually
something to skip or the caller explicitly requested skipping — e.g., add a
boolean parameter skipRequested (or an int successfulSourceCount) to
editRetryWarnings and update all callers, then change the condition to: if
len(skipped) == 0 && (skipRequested || len(ineligible) > 0) { append the "no
previously successful steps are eligible to skip" warning }; keep the existing
ineligible branch unchanged so "some previously successful steps cannot be
skipped..." still appears when applicable.
- Around line 144-153: The code currently calls a.dagStore.UpdateSpec (guarded
by opts.persistSpec) before launching the retry, which can mutate stored DAGs
even if launchEditRetryDAGRun fails; move the persistence so it runs only after
a successful launch: call a.launchEditRetryDAGRun(ctx, plan) first, check err
(and queued if needed), then if opts.persistSpec call a.dagStore.UpdateSpec(ctx,
request.Name, []byte(opts.specContent)) and handle any UpdateSpec error (return
or wrap as appropriate). Use the existing symbols (opts.persistSpec,
a.dagStore.UpdateSpec, a.launchEditRetryDAGRun, queued) to locate and reorder
the operations.
- Around line 247-259: The current buildEditRetryPlan calls
validateDAGRunID(opts.newDAGRunID) even when opts.newDAGRunID is empty (preview
path) which is redundant; update buildEditRetryPlan to skip calling
validateDAGRunID when opts.newDAGRunID == "" (only perform the validation when a
non-empty newDAGRunID is provided), leaving the execute-path logic that
regenerates and revalidates the ID (the block that handles empty newDAGRunID
later) unchanged; reference validateDAGRunID, buildEditRetryPlan, and
opts.newDAGRunID to locate the change.

In `@ui/src/features/dag-runs/components/common/DAGRunActions.tsx`:
- Around line 737-750: The DAG Name Override input (controlled by
dagNameOverride and setDagNameOverride) must be disabled and cleared when
editRetryPersistSpec is true to avoid backend 400s; update the Input with
disabled={editRetryPersistSpec} and onChange behavior so toggling
editRetryPersistSpec to true calls setDagNameOverride('') to clear it, and
ensure the request-building code that sends the preview / edit-retry payload
(where dagNameOverride is included) omits dagName when editRetryPersistSpec ===
true (i.e., only include dagName in the body if !editRetryPersistSpec &&
dagNameOverride is non-empty).
- Around line 132-229: Both previewEditRetrySpec and loadEditRetrySpec currently
use try/finally but lack a catch block, so thrown rejections from
client.POST/GET become unhandled; add a catch in each function around the await
client calls that calls showError with a helpful message (e.g., include
error.message or a default) and then rethrows or returns as appropriate, keeping
the existing finally block to ensure setEditRetryLoading(false) still runs;
update previewEditRetrySpec and loadEditRetrySpec to handle network/abort
exceptions via try/catch/finally so errors surface to the user.

---

Nitpick comments:
In `@internal/intg/edit_retry_api_test.go`:
- Around line 108-114: The test may race because calling ProcessQueuedInlineRun
once then polling waitForEditRetryStoredStatus(retryRunID, core.Succeeded) can
observe the retry while it's still in-flight on slow CI; update the test around
ProcessQueuedInlineRun and waitForEditRetryStoredStatus to first poll for a
terminal state using waitForEditRetryStoredStatus(...,
status.Status.IsTerminal()) or assert status.Status.IsTerminal() before
asserting specific terminal value, or instead drain the queue processor
repeatedly like the helper in internal/test/reschedule_inline_helpers.go so the
retry dispatch completes deterministically; adjust assertions on
retryStatus.Nodes (e.g., Nodes[0].Status, Nodes[0].SkippedByRetry,
Nodes[1].Status, Nodes[2].Status) after confirming terminal state.

In `@internal/service/frontend/api/v1/dagruns_edit_retry.go`:
- Around line 450-465: The function missingEditedRetryOutputReason currently
treats any non-string stored in node.OutputVariables as ineligible; instead,
accept non-string values by coercing them to string for downstream consumers.
Replace the type assertion branch that returns "previous output %q is not a
string" with logic that treats a loaded raw value as available (e.g., use
fmt.Sprint(raw) when the caller needs a string) so
OutputVariables.Load(editedStep.Output) no longer causes a rejection for
non-string types; update the function to only return an error when the key is
missing or OutputVariables is nil, and remove the strict raw.(string) assertion.

In `@ui/src/features/dag-runs/components/common/DAGRunActions.tsx`:
- Around line 604-619: When enabling the "reschedule" Checkbox (the
onCheckedChange handler for id "reschedule" in DAGRunActions), you currently set
setRetryAsNew(true) and setEditRetry(false) but leave stale edit-retry state in
memory; update that handler to also clear the edit-retry state by setting
editRetrySpec, editRetryPreview, editRetrySkipSteps, and editRetryPersistSpec to
their initial/empty values (same cleanup performed in the edit-retry checkbox's
else branch) so toggling into reschedule fully resets the edit-retry state.
- Around line 770-780: Replace the plain Textarea used for edited DAG spec with
the Monaco YAML editor component used elsewhere: locate the block rendering the
Textarea with id "edit-retry-spec" and state variables editRetrySpec and
setEditRetrySpec, remove the <Textarea> and swap in the project's Monaco wrapper
(e.g., MonacoEditor or YamlMonacoEditor) configured for language="yaml",
value={editRetrySpec} and onChange to call setEditRetrySpec(newValue); preserve
existing props like id and className (min-h-56, resize-y, font-mono, text-xs)
and ensure the Monaco component exposes onChange that supplies the new string so
validation/highlighting behaves the same as the other DAG editing flow.