diff --git a/frontend/src/lib/components/VariableEditor.svelte b/frontend/src/lib/components/VariableEditor.svelte
index 1c92f4350d..045778df16 100644
--- a/frontend/src/lib/components/VariableEditor.svelte
+++ b/frontend/src/lib/components/VariableEditor.svelte
@@ -291,6 +291,9 @@
 	const saveInFlight = $derived(
 		dirtyWorkspaces.some((ws) => isDraftSaving('variable', editPath, { workspace: ws }))
 	)
+	// A create has no cell to key that on — its form is the detached handle an empty
+	// path gets — so the one case the shared window cannot see keeps a local flag.
+	let creating = $state(false)
 
 	async function save(): Promise<void> {
 		// Everything the writes need, read before the first await. An inline host can
@@ -326,6 +329,10 @@
 		// is in flight for this cell, so a second editor on it cannot start one —
 		// checked before the first is opened, or this would see its own.
 		if (payloads.some(({ ws }) => isDraftSaving('variable', from, { workspace: ws }))) return
+		if (!from) {
+			if (creating) return
+			creating = true
+		}
 		const closeSettleWindows = from
 			? payloads.map(({ ws }) => beginDraftSettleWindow('variable', from, { workspace: ws }))
 			: []
@@ -373,11 +380,10 @@
 				// to it via `discard` (not `remove` — blanking the cell to `undefined` reads
 				// as dirty) and keeps an edit made mid-request. Each workspace settles
 				// against the path its own write used, not the reported one.
-				// The live cell only while this editor is still on the item it saved: the
-				// drawer is reused, so after a re-point `states` is the next item's, and
-				// reading it here would take that for an edit made over this write —
-				// leaving this item's draft behind. Re-pointed, the cell it released
-				// during the write is what answers.
+				// The live cell only while this editor is still on the item it saved: reused
+				// for the next one, `states` is that one's, and reading it here would take
+				// it for an edit made over this write. Re-pointed, the cell released
+				// during the write answers instead.
 				await settleDraftAfterWrite(
 					'variable',
 					s,
@@ -426,6 +432,7 @@
 			}
 		} finally {
 			for (const close of closeSettleWindows) close()
+			creating = false
 		}
 	}
 </script>
@@ -470,7 +477,12 @@
 	{/if}
 	<Button
 		on:click={save}
-		disabled={saveInFlight || !anyDirty || !dirtyValid || !dirtyCanWrite || pathError != ''}
+		disabled={saveInFlight ||
+			creating ||
+			!anyDirty ||
+			!dirtyValid ||
+			!dirtyCanWrite ||
+			pathError != ''}
 		startIcon={{ icon: Save }}
 		variant="accent"
 		unifiedSize="sm"
diff --git a/frontend/src/lib/components/triggers/schedules/ScheduleEditorInner.svelte b/frontend/src/lib/components/triggers/schedules/ScheduleEditorInner.svelte
index 31a9f5ad96..8688616b7e 100644
--- a/frontend/src/lib/components/triggers/schedules/ScheduleEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/schedules/ScheduleEditorInner.svelte
@@ -855,6 +855,10 @@
 		const previousEnabled = enabled
 		const path = initialPath
 		const ws = wsId
+		// The baseline of the schedule being toggled, read before the request: this
+		// editor is reused for whatever the drawer opens next, and `initialConfig` is
+		// then that one's.
+		const baselineBefore = initialConfig ? ($state.snapshot(initialConfig) as any) : undefined
 		enabled = nEnabled
 		if (!trigger?.draftConfig) {
 			const ok = await withForkConflictRetry(
@@ -866,26 +870,31 @@
 					}),
 				'schedule'
 			)
+			// Nothing read or written below describes the toggled schedule once this
+			// editor has moved on — only the request's own outcome does.
+			const stillHere = initialPath === path && wsId === ws
 			if (!ok) {
-				enabled = previousEnabled
+				if (stillHere) enabled = previousEnabled
 				return
 			}
 			sendUserToast(`${nEnabled ? 'enabled' : 'disabled'} schedule ${path}`)
-			// Deployed state moved, so the baseline the banner compares against does too.
-			deployedEnabled = nEnabled
-			if (initialConfig) {
-				initialConfig.enabled = nEnabled
-				baselineNonce++
+			if (stillHere) {
+				// Deployed state moved, so the baseline the banner compares against does too.
+				deployedEnabled = nEnabled
+				if (initialConfig) {
+					initialConfig.enabled = nEnabled
+					baselineNonce++
+				}
 			}
 
 			// Setting `enabled` above queued a draft against the pre-toggle baseline.
 			// It matches the new one, so nothing would ever show it again — but it is
 			// still a row on the server and a `*` on the list until it is settled away.
-			if (initialConfig)
+			if (baselineBefore)
 				await settleDraftAfterWrite(
 					'trigger_schedule',
-					$state.snapshot(initialConfig),
-					getScheduleCfg(),
+					{ ...baselineBefore, enabled: nEnabled },
+					stillHere ? getScheduleCfg() : undefined,
 					path,
 					path,
 					{ workspace: ws ?? undefined }
@@ -893,7 +902,7 @@
 			// This request carried the enabled flag alone, so anything else the form has
 			// diverged into is the user's — read after the settle, which awaits a request
 			// of its own with the form still editable.
-			onUpdate?.(path, path, ws, !draftValuesEqual(getScheduleCfg(), initialConfig))
+			onUpdate?.(path, path, ws, stillHere && !draftValuesEqual(getScheduleCfg(), initialConfig))
 		}
 	}
 
diff --git a/frontend/src/lib/userDraftSettleAfterWrite.test.ts b/frontend/src/lib/userDraftSettleAfterWrite.test.ts
index b271356975..1e92b67423 100644
--- a/frontend/src/lib/userDraftSettleAfterWrite.test.ts
+++ b/frontend/src/lib/userDraftSettleAfterWrite.test.ts
@@ -42,11 +42,6 @@ beforeEach(() => {
 const OPTS = { workspace: 'ws' }
 const sent = { path: 'u/me/a', value: 'sent' }
 
-/**
- * The forms stay editable while their save is in flight, so the cell can hold a
- * newer edit by the time the write returns. Resetting it unconditionally — what
- * every editor did — swallows that edit with no trace.
- */
 // Duplicate tabs and warm sessions mount several editors over one cell, so what
 // says "a write is in flight for this item" cannot live in any of them. The
 // window each save opens is per key, and every editor's Save reads it.
@@ -70,6 +65,11 @@ describe('isDraftSaving', () => {
 	})
 })
 
+/**
+ * The forms stay editable while their save is in flight, so the cell can hold a
+ * newer edit by the time the write returns. Resetting it unconditionally — what
+ * every editor did — swallows that edit with no trace.
+ */
 describe('settleDraftAfterWrite', () => {
 	it('resets the cell when it still holds what was written', () => {
 		settleDraftAfterWrite('variable', sent, { ...sent }, 'u/me/a', 'u/me/a', OPTS)