@@ -408,6 +408,9 @@ export class ContextProxy {
 	 * pairing a reset cannot tell a settled-but-orphaned write from a live one.
 	 */
 	private readonly pendingSecretWrites = new Map<string, Set<{ settle: Promise<void> }>>()
+	// A reset is in progress: the caches are meaningless mid-reset, and a secret write begun
+	// inside it would commit after the delete pass and survive the erase.
+	private resetting = false
 	/** How many writes of each secret were started. Unlike the owners, it is not cleared when a write is over. */
 	private readonly secretWriteCount = new Map<string, number>()
 
@@ -461,6 +464,13 @@ export class ContextProxy {
 	}
 
 	storeSecret(key: SecretStateKey, value?: string) {
+		if (this.resetting) {
+			// Refused rather than deferred: a deferred secret write would re-store exactly the
+			// value the user asked to erase, and a silently dropped one would lose the save.
+			return Promise.reject(
+				new SettingsWriteError([], [key], new Error("secret writes are refused while state is being reset")),
+			)
+		}
 		// Update cache.
 		const owner = {}
 		this.secretWriteOwner.set(key, owner)
@@ -746,6 +756,7 @@ export class ContextProxy {
 	 * @returns A promise that resolves when all reset operations are complete
 	 */
 	public async resetAllState() {
+		this.resetting = true
 		// A secret write that is in flight at this moment has already committed nothing, but it will
 		// commit as soon as it settles, and the deletes below cannot un-commit a write that lands
 		// after them. Wait for the pending writes first, then end the claims, then delete, so the
@@ -774,6 +785,7 @@ export class ContextProxy {
 		])
 
 		await this.initialize()
+		this.resetting = false
 	}
 
 	private static _instance: ContextProxy | null = null
 
@@ -230,6 +230,56 @@ describe("ContextProxy", () => {
 			expect(await mockSecrets.get("apiKey")).toBe("newer-secret")
 		})
 
+		it("erases a secret whose write begins after the reset has snapshotted the pending writes", async () => {
+			const durable = new Map<string, string | undefined>()
+			let deleteCalls = 0
+			let settleFirstDelete: () => void = () => {}
+			let markDeletePassStarted: () => void = () => {}
+			const deletePassStarted = new Promise<void>((resolve) => {
+				markDeletePassStarted = resolve
+			})
+			mockSecrets.get.mockImplementation(async (key: string) => durable.get(key))
+			mockSecrets.store.mockImplementation(async (key: string, value: string) => {
+				durable.set(key, value)
+			})
+			// Park the reset inside its own delete pass so a write can begin in the window the in-flight
+			// snapshot cannot cover. Only the first delete is held open; the rest settle normally, so
+			// releasing the park lets the reset finish.
+			mockSecrets.delete.mockImplementation((key: string) => {
+				deleteCalls++
+				durable.delete(key)
+				if (deleteCalls === 1) {
+					return new Promise<undefined>((resolve) => {
+						markDeletePassStarted()
+						settleFirstDelete = () => resolve(undefined)
+					})
+				}
+				return Promise.resolve(undefined)
+			})
+
+			const reset = proxy.resetAllState()
+			await deletePassStarted
+
+			// The reset has taken its in-flight snapshot, cleared both caches and dropped both write
+			// claims, and is standing inside the delete pass. This write is invisible to all of it.
+			const late = proxy.storeSecret("apiKey", "late-secret")
+			settleFirstDelete()
+			await reset
+			await late.catch(() => undefined)
+
+			// All three reads matter. Durable storage is what a reset is supposed to empty, the cache is
+			// what this provider instance shows the user, and re-initializing is what a restarted
+			// provider does - which is how a secret that survived the reset reaches the user after the
+			// fact, so the middle read alone would understate the finding.
+			expect(await mockSecrets.get("apiKey")).toBeUndefined()
+			expect(proxy.getSecret("apiKey")).toBeUndefined()
+			await proxy.initialize()
+			expect(proxy.getSecret("apiKey")).toBeUndefined()
+			// The caller is told: a write the reset cannot honour is refused rather than dropped, so
+			// the save surfaces as a failure instead of vanishing.
+			await expect(late).rejects.toThrow()
+		})
+
 		it("should bypass cache for pass-through state keys", async () => {
 			// Setup mock return value
 			mockGlobalState.get.mockReturnValue("pass-through-value")