@@ -1786,39 +1786,56 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 	 * to replace the stored messages outright.
 	 */
 	private async saveClineMessages(merge = true): Promise<boolean> {
-		// One save at a time per task, from the message write to the task-history write: callers that do not wait for it
-		// (the fire-and-forget ones) would otherwise let an older save's metadata land after a newer save's and replace
-		// it, an explicit clear of the usage breakdown included. A save that fails does not hold up the next one.
-		const run = this.saveClineMessagesQueue.then(
-			() => this.persistClineMessages(merge),
-			() => this.persistClineMessages(merge),
+		// Two queues. The message writes go one at a time, and a write never waits for the metadata of the save before
+		// it: the messages are what must reach the disk, so a slow history write cannot delay them. The metadata stage
+		// (the history entry, derived from the messages that save persisted) also goes one at a time, in the order the
+		// message writes finished, which is the order the saves were asked for: callers that do not wait for a save (the
+		// fire-and-forget ones) would otherwise let an older save's metadata land after a newer save's and replace it,
+		// an explicit clear of the usage breakdown included. A save that fails does not hold up the next one.
+		const written = this.saveClineMessagesQueue.then(
+			() => this.writeClineMessages(merge),
+			() => this.writeClineMessages(merge),
 		)
-		this.saveClineMessagesQueue = run.then(
+		this.saveClineMessagesQueue = written.then(
 			() => undefined,
 			() => undefined,
 		)
-		return run
+
+		return written.then(async (result) => {
+			if (!result.saved) return false
+			const metadata = this.saveTaskMetadataQueue.then(() => this.writeTaskMetadata(result.persistedMessages))
+			this.saveTaskMetadataQueue = metadata
+			await metadata
+			return true
+		})
 	}
 
 	private saveClineMessagesQueue: Promise<void> = Promise.resolve()
+	private saveTaskMetadataQueue: Promise<void> = Promise.resolve()
 
-	private async persistClineMessages(merge: boolean): Promise<boolean> {
+	/** The message write: `saved` is whether it reached the disk, and `persistedMessages` what was actually stored. */
+	private async writeClineMessages(
+		merge: boolean,
+	): Promise<{ saved: false } | { saved: true; persistedMessages: ClineMessage[] | undefined }> {
 		// What was actually persisted: with `merge`, newer messages another host wrote are folded in. The metadata
 		// (including the usage breakdown) is computed from it, so a stale local snapshot cannot clear usage that
 		// the stored messages still contain.
-		let persistedMessages: ClineMessage[] | undefined
 		try {
-			persistedMessages = await saveTaskMessages({
+			const persistedMessages = await saveTaskMessages({
 				messages: structuredClone(this.clineMessages),
 				taskId: this.taskId,
 				globalStoragePath: this.globalStoragePath,
 				merge,
 			})
+			return { saved: true, persistedMessages }
 		} catch (error) {
 			console.error("Failed to save Roo messages:", error)
-			return false
+			return { saved: false }
 		}
+	}
 
+	/** The metadata stage of a save: it never fails the save, whose messages are already persisted. */
+	private async writeTaskMetadata(persistedMessages: ClineMessage[] | undefined): Promise<void> {
 		try {
 			if (this._taskApiConfigName === undefined) {
 				await this.taskApiConfigReady
@@ -1853,8 +1870,6 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			// recomputes and re-emits the metadata update.
 			console.error("Failed to save task metadata:", error)
 		}
-
-		return true
 	}
 
 	private findMessageByTimestamp(ts: number): ClineMessage | undefined {
 
@@ -1117,7 +1117,7 @@ describe("Task persistence", () => {
 			tokenUsage: { totalTokensIn: 0, totalTokensOut: 0, totalCost: 0, contextTokens: 0 },
 		})
 
-		it("does not start a save before the previous save has written its task-history entry", async () => {
+		it("does not let the metadata of an older save land after the metadata of a newer one, whatever the timing", async () => {
 			const events: string[] = []
 			const firstMetadata = createDeferred<ReturnType<typeof metadataFor>>()
 			const firstHistoryWrite = createDeferred<undefined>()
@@ -1150,20 +1150,42 @@ describe("Task persistence", () => {
 			const newer = save()
 			await vi.waitFor(() => expect(mockTaskMetadata).toHaveBeenCalledTimes(1))
 
-			// The older save is between its two writes; the newer one has not written anything yet.
-			expect(events).toEqual(["messages"])
+			// The older save is in its metadata stage; the newer one has written its messages but not its metadata.
+			expect(events).toEqual(["messages", "messages"])
 
 			firstMetadata.resolve(metadataFor(false))
 			await vi.waitFor(() => expect(updateTaskHistory).toHaveBeenCalledTimes(1))
-			expect(events).toEqual(["messages"])
+			expect(events).toEqual(["messages", "messages"]) // the newer metadata waits for the older one
 			firstHistoryWrite.resolve(undefined)
 			await Promise.all([older, newer])
 
 			// The newer save's entry is the last one written, whatever the timing of the older one.
-			expect(events).toEqual(["messages", "history 1", "messages", "history 2"])
+			expect(events).toEqual(["messages", "messages", "history 1", "history 2"])
 			expect(updateTaskHistory.mock.calls.map(([item]) => item.usage)).toEqual([false, true])
 		})
 
+		it("does not make a message write wait for the metadata stage of the save before it", async () => {
+			const slowMetadata = createDeferred<ReturnType<typeof metadataFor>>()
+			mockSaveTaskMessages.mockResolvedValue([])
+			mockTaskMetadata.mockImplementationOnce(() => slowMetadata.promise)
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+			const save = () => getTaskPersistenceAccess(task).saveClineMessages()
+
+			const first = save()
+			await vi.waitFor(() => expect(mockTaskMetadata).toHaveBeenCalledTimes(1)) // the first is in its metadata stage
+			const second = save()
+
+			// The second message write reaches the disk while the first metadata is still pending.
+			await vi.waitFor(() => expect(mockSaveTaskMessages).toHaveBeenCalledTimes(2))
+			slowMetadata.resolve(metadataFor(false))
+			await Promise.all([first, second])
+		})
+
 		it("runs the next save even when the one before it failed", async () => {
 			mockSaveTaskMessages.mockRejectedValueOnce(new Error("write error")).mockResolvedValueOnce([])
 			const task = new Task({
 
@@ -1338,17 +1338,20 @@ describe("loadProfiles", () => {
 		beforeEach(() => vi.useFakeTimers())
 		afterEach(() => vi.useRealTimers())
 
-		/** Counts the abort listeners that are added and not removed. */
+		/** The abort listeners that were added and not removed: a removal counts only for the function that was added. */
 		const trackListeners = (signal: AbortSignal) => {
-			let live = 0
+			const live = new Set<EventListenerOrEventListenerObject>()
 			const add = signal.addEventListener.bind(signal)
 			const remove = signal.removeEventListener.bind(signal)
-			signal.addEventListener = ((...args: Parameters<typeof add>) => (live++, add(...args))) as typeof add
-			signal.removeEventListener = ((...args: Parameters<typeof remove>) => (
-				live--,
-				remove(...args)
-			)) as typeof remove
-			return () => live
+			signal.addEventListener = ((...args: Parameters<typeof add>) => {
+				if (args[1]) live.add(args[1])
+				return add(...args)
+			}) as typeof add
+			signal.removeEventListener = ((...args: Parameters<typeof remove>) => {
+				if (args[1]) live.delete(args[1])
+				return remove(...args)
+			}) as typeof remove
+			return () => live.size
 		}
 
 		it("rejects at once while the list is pending, and leaves no timer or listener behind", async () => {