@@ -448,6 +448,13 @@ export type ExtensionState = Pick<
 	 * (captured during async getStateToPostToWebview) from overwriting newer messages.
 	 */
 	clineMessagesSeq?: number
+
+	/**
+	 * Monotonically increasing sequence number for every state snapshot, assigned before the
+	 * snapshot is read. Snapshots are built asynchronously and can be posted out of order, so the
+	 * frontend applies `language` only from a snapshot newer than the last one it applied.
+	 */
+	stateSeq?: number
 }
 
 export interface Command {
 
@@ -350,6 +350,12 @@ export class ClineProvider
 	 */
 	private clineMessagesSeq = 0
 
+	/**
+	 * Monotonically increasing sequence number for every state snapshot.
+	 * Used by the frontend to ignore the language from snapshots that arrive out-of-order.
+	 */
+	private stateSeq = 0
+
 	public isViewLaunched = false
 	public settingsImportedAt?: number
 	public readonly latestAnnouncementId = "oct-2026-v3.94.0-models-oauth-chat" // v3.94.0 model support, MCP OAuth, and chat reliability
@@ -2793,6 +2799,8 @@ export class ClineProvider
 	}
 
 	async getStateToPostToWebview({ includeTaskHistory = true }: GetStateOptions = {}): Promise<ExtensionState> {
+		// Assign the sequence before the first await so it orders snapshots by when they were read.
+		const stateSeq = ++this.stateSeq
 		// Ensure the store is initialized before reading task history
 		await this.taskHistoryStore.initialized
 
@@ -3034,6 +3042,7 @@ export class ClineProvider
 			showRooIgnoredFiles: showRooIgnoredFiles ?? false,
 			enableSubfolderRules: enableSubfolderRules ?? false,
 			language: language ?? formatLanguage(vscode.env.language),
+			stateSeq,
 			renderContext: this.renderContext,
 			maxImageFileSize: maxImageFileSize ?? 5,
 			maxTotalImageSize: maxTotalImageSize ?? 20,
 
@@ -1465,6 +1465,42 @@ describe("ClineProvider", () => {
 		expect(postMessageSpy.mock.calls.map(([message]) => message.state?.clineMessagesSeq)).toEqual([2, 1])
 	})
 
+	test.each([
+		["postStateToWebview", (currentProvider: ClineProvider) => currentProvider.postStateToWebview()],
+		[
+			"postStateToWebviewWithoutTaskHistory",
+			(currentProvider: ClineProvider) => currentProvider.postStateToWebviewWithoutTaskHistory(),
+		],
+		[
+			"postStateToWebviewWithoutClineMessages",
+			(currentProvider: ClineProvider) => currentProvider.postStateToWebviewWithoutClineMessages(),
+		],
+	])("%s orders snapshots by when they were read, not when they were posted", async (_methodName, postState) => {
+		const baseState = await provider.getState({ includeTaskHistory: false })
+		let releaseOlderRead!: () => void
+		const olderRead = new Promise<void>((resolve) => {
+			releaseOlderRead = resolve
+		})
+		vi.spyOn(provider, "getState")
+			.mockImplementationOnce(async () => {
+				await olderRead
+				return { ...baseState, language: "en" }
+			})
+			.mockResolvedValueOnce({ ...baseState, language: "es" })
+		const postMessageSpy = vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined)
+
+		const olderPost = postState(provider)
+		await Promise.resolve()
+		await postState(provider)
+		releaseOlderRead()
+		await olderPost
+
+		const posted = postMessageSpy.mock.calls.map(([message]) => message.state)
+		expect(posted.map((state) => state?.language)).toEqual(["es", "en"])
+		const [newer, older] = posted.map((state) => state?.stateSeq ?? 0)
+		expect(older).toBeLessThan(newer)
+	})
+
 	test.each([
 		[
 			"postStateToWebviewWithoutTaskHistory",
 
@@ -167,6 +167,9 @@ const messagesAreStale = (incoming: Partial<ExtensionState>, currentSequence: nu
 	currentSequence !== undefined &&
 	incoming.clineMessagesSeq <= currentSequence
 
+const snapshotIsStale = (incoming: Partial<ExtensionState>, currentSequence: number | undefined): boolean =>
+	incoming.stateSeq !== undefined && currentSequence !== undefined && incoming.stateSeq <= currentSequence
+
 function internMessages(messages: ClineMessage[], previousMessages: ClineMessage[], cache: StringCache): void {
 	const previousByTimestamp = new Map(previousMessages.map((item) => [item.ts, item]))
 	for (const message of messages) {
@@ -222,6 +225,13 @@ export const mergeExtensionState = (prevState: ExtensionState, newState: Partial
 		rest.currentTaskId = newState.currentTaskId
 	}
 
+	// Snapshots are read asynchronously, so an older one can arrive after a newer one. Keep the
+	// language from the newest snapshot instead of reverting to the one the stale snapshot read.
+	if (snapshotIsStale(newState, prevState.stateSeq)) {
+		rest.language = prevState.language
+		rest.stateSeq = prevState.stateSeq
+	}
+
 	// Note that we completely replace the previous apiConfiguration and customSupportPrompts objects
 	// with new ones since the state that is broadcast is the entire objects so merging is not necessary.
 	return {
@@ -328,6 +338,7 @@ export const ExtensionStateContextProvider: React.FC<{
 	const messagesRef = useRef(initialState?.clineMessages ?? [])
 	const currentTaskIdRef = useRef(initialState?.currentTaskId)
 	const clineMessagesSeqRef = useRef(initialState?.clineMessagesSeq)
+	const stateSeqRef = useRef(initialState?.stateSeq)
 
 	const [state, setState] = useState<ExtensionState>(() => {
 		const mergedState = mergeExtensionState(createInitialExtensionState(), initialState ?? {})
@@ -424,7 +435,10 @@ export const ExtensionStateContextProvider: React.FC<{
 					if (newState.currentTaskItem) {
 						historyCache.intern(newState.currentTaskItem)
 					}
-					applyLanguage(i18next, newState.language)
+					if (!snapshotIsStale(newState, stateSeqRef.current)) {
+						applyLanguage(i18next, newState.language)
+						stateSeqRef.current = newState.stateSeq ?? stateSeqRef.current
+					}
 					setState((prevState) => mergeExtensionState(prevState, newState))
 					setShowWelcome(!checkExistKey(newState.apiConfiguration, newState.zooCodeIsAuthenticated))
 					setDidHydrateState(true)
 
@@ -1111,4 +1111,37 @@ describe("mergeExtensionState", () => {
 			expect(result.clineMessagesSeq).toBe(1)
 		})
 	})
+
+	describe("stateSeq protection", () => {
+		const prevState: ExtensionState = { ...createInitialExtensionState(), language: "es", stateSeq: 5 }
+
+		it.each([
+			["older", 4],
+			["equal", 5],
+		])("keeps the language when the snapshot seq is %s", (_label, stateSeq) => {
+			const result = mergeExtensionState(prevState, { language: "en", stateSeq, soundEnabled: true })
+
+			expect(result.language).toBe("es")
+			expect(result.stateSeq).toBe(5)
+			// Only the language is protected; the rest of the snapshot still applies.
+			expect(result.soundEnabled).toBe(true)
+		})
+
+		it.each<[string, Partial<ExtensionState>, number]>([
+			["newer", { language: "en", stateSeq: 6 }, 6],
+			["unsequenced", { language: "en" }, 5],
+		])("applies the language from an %s snapshot", (_label, newState, expectedSeq) => {
+			const result = mergeExtensionState(prevState, newState)
+
+			expect(result.language).toBe("en")
+			expect(result.stateSeq).toBe(expectedSeq)
+		})
+
+		it("applies the language from the first sequenced snapshot", () => {
+			const result = mergeExtensionState(createInitialExtensionState(), { language: "es", stateSeq: 1 })
+
+			expect(result.language).toBe("es")
+			expect(result.stateSeq).toBe(1)
+		})
+	})
 })
@@ -48,6 +48,33 @@ describe("hydrated language", () => {
 	})
 })
 
+describe("out-of-order state pushes", () => {
+	beforeEach(async () => {
+		await i18next.changeLanguage("en")
+	})
+
+	const LanguageProbe = () => <span data-testid="language">{useExtensionState().language}</span>
+
+	it("keeps the newer language when an older snapshot arrives later", async () => {
+		render(
+			<ExtensionStateContextProvider>
+				<LanguageProbe />
+			</ExtensionStateContextProvider>,
+		)
+
+		await postState({ language: "es", stateSeq: 2 })
+		await postState({ language: "en", stateSeq: 1 })
+
+		expect(i18next.language).toBe("es")
+		expect(screen.getByTestId("language")).toHaveTextContent("es")
+
+		await postState({ language: "en", stateSeq: 3 })
+
+		expect(i18next.language).toBe("en")
+		expect(screen.getByTestId("language")).toHaveTextContent("en")
+	})
+})
+
 describe("applyLanguage", () => {
 	beforeEach(async () => {
 		await i18next.changeLanguage("en")
@@ -58,6 +85,13 @@ describe("applyLanguage", () => {
 		expect(i18next.language).toBe("es")
 	})
 
+	it("keeps the language from the latest of consecutive pushes", () => {
+		applyLanguage(i18next, "es")
+		applyLanguage(i18next, "en")
+		expect(i18next.language).toBe("en")
+		expect(i18next.t("history:recentTasks")).toBe("Recent Tasks")
+	})
+
 	it("does not re-emit languageChanged for the active language or a missing one", () => {
 		const onChanged = vi.fn()
 		i18next.on("languageChanged", onChanged)