Fix: Ensure correct mode is persisted for resumed tasks

Introduces a `modeIsFrozen` flag in the Task class. This flag is
set to `true` when a task completes or a completed task is resumed.

When `modeIsFrozen` is true, the task's `currentModeSlug` is
prevented from being updated if the user only changes the mode in
the UI without sending a new message. This avoids saving accidental
mode changes during history browsing.

If a new message is sent to continue a task that was frozen:
1. `modeIsFrozen` is reset to `false`.
2. The task's `currentModeSlug` is updated to match the actual
   mode selected in the UI (obtained from `ClineProvider.getState()`).
3. This updated `currentModeSlug` is then used when saving task
   messages and metadata, ensuring the persisted history accurately
   reflects the mode in which the interaction occurred.

This resolves a bug where re-opening a completed task, changing the
mode, and then sending a message would result in the original (stale)
mode being persisted in the task history, instead of the new mode
used for the interaction.

Author: axmo

src/core/task/Task.ts

@@ -125,7 +125,7 @@ export class Task extends EventEmitter<ClineEvents> {
 	readonly taskNumber: number
 	readonly workspacePath: string
 	currentModeSlug: string
-
+	modeIsFrozen: boolean = false
 	providerRef: WeakRef<ClineProvider>
 	private readonly globalStoragePath: string
 	abort: boolean = false
@@ -299,12 +299,16 @@ export class Task extends EventEmitter<ClineEvents> {
 	}
 
 	public async updateCurrentModeSlug(newModeSlug: string) {
-		this.currentModeSlug = newModeSlug
-		// NOTE: Consider if a mode switch should immediately trigger a save of task metadata.
-		// For now, the updated currentModeSlug will be saved with the next natural
-		// save operation (e.g., when a new message is added).
+		if (this.modeIsFrozen) {
+			// If the mode is frozen, ignore any attempts to change it.
+			return // Crucial: Exit without updating the mode
+		}
+		// Only update if the new mode is actually different to avoid unnecessary assignments
+		if (this.currentModeSlug !== newModeSlug) {
+			this.currentModeSlug = newModeSlug
+		}
 	}
-	
+
 	async overwriteApiConversationHistory(newHistory: ApiMessage[]) {
 		this.apiConversationHistory = newHistory
 		await this.saveApiConversationHistory()
@@ -484,6 +488,14 @@ export class Task extends EventEmitter<ClineEvents> {
 			await this.addToClineMessages({ ts: askTs, type: "ask", ask: type, text })
 		}
 
+		// Set modeIsFrozen if the task just completed
+		if (
+			(type === "completion_result" || type === "resume_completed_task") &&
+			(partial === false || partial === undefined)
+		) {
+			this.modeIsFrozen = true
+		}
+
 		await pWaitFor(() => this.askResponse !== undefined || this.lastMessageTs !== askTs, { interval: 100 })
 
 		if (this.lastMessageTs !== askTs) {
@@ -1081,6 +1093,20 @@ export class Task extends EventEmitter<ClineEvents> {
 			throw new Error(`[RooCode#recursivelyMakeRooRequests] task ${this.taskId}.${this.instanceId} aborted`)
 		}
 
+		// Reset modeIsFrozen when a new message is sent
+		if (this.modeIsFrozen) {
+			this.modeIsFrozen = false
+			// Get the actual current mode from the provider and update the task's mode
+			const provider = this.providerRef.deref()
+			if (provider) {
+				const providerState = await provider.getState()
+				if (providerState.mode !== this.currentModeSlug) {
+					this.currentModeSlug = providerState.mode
+				}
+			}
+			await this.saveClineMessages() // Save messages now reflects the unfreezing and potential mode update
+		}
+
 		if (this.consecutiveMistakeCount >= this.consecutiveMistakeLimit) {
 			const { response, text, images } = await this.ask(
 				"mistake_limit_reached",