fix: address async mode initialization concerns

- Add taskModeReady promise to ensure async initialization completes
- Add waitForModeInitialization() method for external callers
- Improve error handling to use provider.log() instead of console.error
- Add JSDoc documentation for taskMode property
- Update tests to use waitForModeInitialization() instead of setTimeout

Author: hannesrudolph

src/core/task/Task.ts

@@ -137,7 +137,16 @@ export class Task extends EventEmitter<ClineEvents> {
 	readonly parentTask: Task | undefined = undefined
 	readonly taskNumber: number
 	readonly workspacePath: string
+	/**
+	 * The mode associated with this task. Persisted across sessions
+	 * to maintain user context when reopening tasks from history.
+	 */
 	taskMode: string
+	/**
+	 * Promise that resolves when the task mode has been initialized.
+	 * This ensures async mode initialization completes before the task is used.
+	 */
+	private taskModeReady: Promise<void>
 
 	providerRef: WeakRef<ClineProvider>
 	private readonly globalStoragePath: string
@@ -279,22 +288,13 @@ export class Task extends EventEmitter<ClineEvents> {
 			TelemetryService.instance.captureTaskCreated(this.taskId)
 		}
 
-		// If no historyItem, get the current mode from provider
-		if (!historyItem && provider.getState) {
-			const statePromise = provider.getState()
-			// Check if getState() returns a Promise
-			if (statePromise && typeof statePromise.then === "function") {
-				statePromise
-					.then((state) => {
-						if (state?.mode) {
-							this.taskMode = state.mode
-						}
-					})
-					.catch((error) => {
-						// If there's an error getting state, keep the default mode
-						console.error("Failed to get mode from provider state:", error)
-					})
-			}
+		// Initialize the task mode ready promise
+		if (!historyItem) {
+			// For new tasks, initialize mode asynchronously
+			this.taskModeReady = this.initializeTaskMode(provider)
+		} else {
+			// For history items, mode is already set
+			this.taskModeReady = Promise.resolve()
 		}
 
 		// Only set up diff strategy if diff is enabled
@@ -330,6 +330,32 @@ export class Task extends EventEmitter<ClineEvents> {
 		}
 	}
 
+	/**
+	 * Initialize the task mode from the provider state.
+	 * This method handles async initialization with proper error handling.
+	 */
+	private async initializeTaskMode(provider: ClineProvider): Promise<void> {
+		try {
+			const state = await provider.getState()
+			if (state?.mode) {
+				this.taskMode = state.mode
+			}
+		} catch (error) {
+			// If there's an error getting state, keep the default mode
+			// Use the provider's log method for better error visibility
+			const errorMessage = `Failed to initialize task mode: ${error instanceof Error ? error.message : String(error)}`
+			provider.log(errorMessage)
+		}
+	}
+
+	/**
+	 * Wait for the task mode to be initialized.
+	 * This should be called before any operations that depend on the correct mode being set.
+	 */
+	public async waitForModeInitialization(): Promise<void> {
+		return this.taskModeReady
+	}
+
 	static create(options: TaskOptions): [Task, Promise<void>] {
 		const instance = new Task({ ...options, startTask: false })
 		const { images, task, historyItem } = options

src/core/task/__tests__/Task.sticky-mode.spec.ts

@@ -283,8 +283,8 @@ describe("Task - Sticky Mode", () => {
 				startTask: false,
 			})
 
-			// Wait for async mode initialization
-			await new Promise((resolve) => setTimeout(resolve, 10))
+			// Wait for async mode initialization using the new method
+			await task.waitForModeInitialization()
 
 			// Import taskMetadata mock
 			const { taskMetadata } = await import("../../task-persistence")
@@ -313,8 +313,8 @@ describe("Task - Sticky Mode", () => {
 				startTask: false,
 			})
 
-			// Wait for async mode initialization
-			await new Promise((resolve) => setTimeout(resolve, 10))
+			// Wait for async mode initialization using the new method
+			await task.waitForModeInitialization()
 
 			const { taskMetadata } = await import("../../task-persistence")
 			vi.mocked(taskMetadata).mockClear()
@@ -385,8 +385,8 @@ describe("Task - Sticky Mode", () => {
 				startTask: false,
 			})
 
-			// Wait for async mode initialization
-			await new Promise((resolve) => setTimeout(resolve, 10))
+			// Wait for async mode initialization using the new method
+			await parentTask.waitForModeInitialization()
 
 			// Change provider mode to code
 			mockProvider.getState.mockResolvedValue({
@@ -403,8 +403,8 @@ describe("Task - Sticky Mode", () => {
 				startTask: false,
 			})
 
-			// Wait for async mode initialization
-			await new Promise((resolve) => setTimeout(resolve, 10))
+			// Wait for async mode initialization using the new method
+			await childTask.waitForModeInitialization()
 
 			const { taskMetadata } = await import("../../task-persistence")
 			vi.mocked(taskMetadata).mockClear()
@@ -447,8 +447,8 @@ describe("Task - Sticky Mode", () => {
 				startTask: false,
 			})
 
-			// Wait for async mode initialization
-			await new Promise((resolve) => setTimeout(resolve, 10))
+			// Wait for async mode initialization using the new method
+			await task.waitForModeInitialization()
 
 			// Task should use defaultModeSlug when provider returns no mode
 			expect((task as any).taskMode).toBe("architect")
@@ -475,6 +475,7 @@ describe("Task - Sticky Mode", () => {
 			const errorProvider = {
 				...mockProvider,
 				getState: vi.fn().mockRejectedValue(new Error("Provider error")),
+				log: vi.fn(), // Add the log method to the mock
 			}
 
 			const task = new Task({
@@ -484,8 +485,8 @@ describe("Task - Sticky Mode", () => {
 				startTask: false,
 			})
 
-			// Wait a bit for the promise rejection to settle
-			await new Promise((resolve) => setTimeout(resolve, 20))
+			// Wait for the promise rejection to settle using the new method
+			await task.waitForModeInitialization()
 
 			// Task should still be created without throwing
 			expect(task).toBeDefined()