fix: atomic initialStatus for child tasks to prevent race conditions

- Add initialStatus option to CreateTaskOptions to set status at historyItem creation
- Child tasks now created with initialStatus: 'active' to ensure status exists before attempt_completion
- AttemptCompletionTool requires explicit 'active' status for delegation (prevents undefined/corrupted states)
- Reorder child→completed status update before parent metadata update in reopenParentFromDelegation
- ChatView shows 'Start New Task' for completed subtasks instead of misleading 'Resume'
- Remove unused 'aborted' status from history enum

Author: hannesrudolph

packages/types/src/history.ts

@@ -19,7 +19,7 @@ export const historyItemSchema = z.object({
 	size: z.number().optional(),
 	workspace: z.string().optional(),
 	mode: z.string().optional(),
-	status: z.enum(["active", "completed", "aborted", "delegated"]).optional(),
+	status: z.enum(["active", "completed", "delegated"]).optional(),
 	delegatedToId: z.string().optional(), // Last child this parent delegated to
 	childIds: z.array(z.string()).optional(), // All children spawned by this task
 	awaitingChildId: z.string().optional(), // Child currently awaited (set when delegated)

packages/types/src/task.ts

@@ -95,6 +95,8 @@ export interface CreateTaskOptions {
 	consecutiveMistakeLimit?: number
 	experiments?: Record<string, boolean>
 	initialTodos?: TodoItem[]
+	/** Initial status for the task's history item (e.g., "active" for child tasks) */
+	initialStatus?: "active" | "delegated" | "completed"
 }
 
 export enum TaskStatus {

src/__tests__/nested-delegation-resume.spec.ts

@@ -72,6 +72,7 @@ describe("Nested delegation resume (A → B → C)", () => {
 				delegatedToId: "B",
 				awaitingChildId: "B",
 				childIds: ["B"],
+				parentTaskId: undefined,
 				ts: 1,
 				task: "Task A",
 				tokensIn: 0,
@@ -86,6 +87,7 @@ describe("Nested delegation resume (A → B → C)", () => {
 				delegatedToId: "C",
 				awaitingChildId: "C",
 				childIds: ["C"],
+				parentTaskId: "A",
 				ts: 2,
 				task: "Task B",
 				tokensIn: 0,
@@ -94,6 +96,18 @@ describe("Nested delegation resume (A → B → C)", () => {
 				mode: "code",
 				workspace: "/tmp",
 			},
+			C: {
+				id: "C",
+				status: "active",
+				parentTaskId: "B",
+				ts: 3,
+				task: "Task C",
+				tokensIn: 0,
+				tokensOut: 0,
+				totalCost: 0,
+				mode: "code",
+				workspace: "/tmp",
+			},
 		}
 
 		const emitSpy = vi.fn()

src/__tests__/provider-delegation.spec.ts

@@ -13,15 +13,29 @@ describe("ClineProvider.delegateParentAndOpenChild()", () => {
 		const removeClineFromStack = vi.fn().mockResolvedValue(undefined)
 		const createTask = vi.fn().mockResolvedValue({ taskId: "child-1" })
 		const handleModeSwitch = vi.fn().mockResolvedValue(undefined)
-		const getTaskWithId = vi.fn().mockResolvedValue({
-			historyItem: {
-				id: "parent-1",
-				task: "Parent",
-				tokensIn: 0,
-				tokensOut: 0,
-				totalCost: 0,
-				childIds: [],
-			},
+		const getTaskWithId = vi.fn().mockImplementation(async (id: string) => {
+			if (id === "parent-1") {
+				return {
+					historyItem: {
+						id: "parent-1",
+						task: "Parent",
+						tokensIn: 0,
+						tokensOut: 0,
+						totalCost: 0,
+						childIds: [],
+					},
+				}
+			}
+			// child-1
+			return {
+				historyItem: {
+					id: "child-1",
+					task: "Do something",
+					tokensIn: 0,
+					tokensOut: 0,
+					totalCost: 0,
+				},
+			}
 		})
 
 		const provider = {
@@ -48,12 +62,18 @@ describe("ClineProvider.delegateParentAndOpenChild()", () => {
 
 		// Invariant: parent closed before child creation
 		expect(removeClineFromStack).toHaveBeenCalledTimes(1)
-		expect(createTask).toHaveBeenCalledWith("Do something", undefined, parentTask, { initialTodos: [] })
+		// Child task is created with initialStatus: "active" to avoid race conditions
+		expect(createTask).toHaveBeenCalledWith("Do something", undefined, parentTask, {
+			initialTodos: [],
+			initialStatus: "active",
+		})
 
-		// Metadata persistence
+		// Metadata persistence - parent gets "delegated" status (child status is set at creation via initialStatus)
 		expect(updateTaskHistory).toHaveBeenCalledTimes(1)
-		const saved = updateTaskHistory.mock.calls[0][0]
-		expect(saved).toEqual(
+
+		// Parent set to "delegated"
+		const parentSaved = updateTaskHistory.mock.calls[0][0]
+		expect(parentSaved).toEqual(
 			expect.objectContaining({
 				id: "parent-1",
 				status: "delegated",

src/core/task-persistence/taskMetadata.ts

@@ -21,6 +21,8 @@ export type TaskMetadataOptions = {
 	globalStoragePath: string
 	workspace: string
 	mode?: string
+	/** Initial status for the task (e.g., "active" for child tasks) */
+	initialStatus?: "active" | "delegated" | "completed"
 }
 
 export async function taskMetadata({
@@ -32,6 +34,7 @@ export async function taskMetadata({
 	globalStoragePath,
 	workspace,
 	mode,
+	initialStatus,
 }: TaskMetadataOptions) {
 	const taskDir = await getTaskDirectoryPath(globalStoragePath, id)
 
@@ -84,6 +87,9 @@ export async function taskMetadata({
 	}
 
 	// Create historyItem once with pre-calculated values.
+	// initialStatus is included when provided (e.g., "active" for child tasks)
+	// to ensure the status is set from the very first save, avoiding race conditions
+	// where attempt_completion might run before a separate status update.
 	const historyItem: HistoryItem = {
 		id,
 		rootTaskId,
@@ -101,6 +107,7 @@ export async function taskMetadata({
 		size: taskDirSize,
 		workspace,
 		mode,
+		...(initialStatus && { status: initialStatus }),
 	}
 
 	return { historyItem, tokenUsage }

src/core/task/Task.ts

@@ -150,6 +150,8 @@ export interface TaskOptions extends CreateTaskOptions {
 	onCreated?: (task: Task) => void
 	initialTodos?: TodoItem[]
 	workspacePath?: string
+	/** Initial status for the task's history item (e.g., "active" for child tasks) */
+	initialStatus?: "active" | "delegated" | "completed"
 }
 
 export class Task extends EventEmitter<TaskEvents> implements TaskLike {
@@ -321,6 +323,9 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 	// Cloud Sync Tracking
 	private cloudSyncedMessageTimestamps: Set<number> = new Set()
 
+	// Initial status for the task's history item (set at creation time to avoid race conditions)
+	private readonly initialStatus?: "active" | "delegated" | "completed"
+
 	constructor({
 		provider,
 		apiConfiguration,
@@ -341,6 +346,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		onCreated,
 		initialTodos,
 		workspacePath,
+		initialStatus,
 	}: TaskOptions) {
 		super()
 
@@ -427,6 +433,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 
 		this.parentTask = parentTask
 		this.taskNumber = taskNumber
+		this.initialStatus = initialStatus
 
 		// Store the task's mode when it's created.
 		// For history items, use the stored mode; for new tasks, we'll set it
@@ -868,6 +875,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 				globalStoragePath: this.globalStoragePath,
 				workspace: this.cwd,
 				mode: this._taskMode || defaultModeSlug, // Use the task's own mode, not the current provider mode.
+				initialStatus: this.initialStatus,
 			})
 
 			if (hasTokenUsageChanged(tokenUsage, this.tokenUsageSnapshot)) {

src/core/tools/AttemptCompletionTool.ts

@@ -96,12 +96,14 @@ export class AttemptCompletionTool extends BaseTool<"attempt_completion"> {
 				if (provider) {
 					try {
 						const { historyItem } = await provider.getTaskWithId(task.taskId)
-						if (historyItem?.status === "completed") {
+						const status = historyItem?.status
+
+						if (status === "completed") {
 							// Subtask already completed - skip delegation flow entirely
 							// Fall through to normal completion ask flow below (outside this if block)
 							// This shows the user the completion result and waits for acceptance
 							// without injecting another tool_result to the parent
-						} else {
+						} else if (status === "active") {
 							// Normal subtask completion - do delegation
 							const delegated = await this.delegateToParent(
 								task,
@@ -111,17 +113,23 @@ export class AttemptCompletionTool extends BaseTool<"attempt_completion"> {
 								pushToolResult,
 							)
 							if (delegated) return
+						} else {
+							// Unexpected status (undefined or "delegated") - log error and skip delegation
+							// undefined indicates a bug in status persistence during child creation
+							// "delegated" would mean this child has its own grandchild pending (shouldn't reach attempt_completion)
+							console.error(
+								`[AttemptCompletionTool] Unexpected child task status "${status}" for task ${task.taskId}. ` +
+									`Expected "active" or "completed". Skipping delegation to prevent data corruption.`,
+							)
+							// Fall through to normal completion ask flow
 						}
-					} catch {
-						// If we can't get the history, proceed with normal delegation flow
-						const delegated = await this.delegateToParent(
-							task,
-							result,
-							provider,
-							askFinishSubTaskApproval,
-							pushToolResult,
+					} catch (err) {
+						// If we can't get the history, log error and skip delegation
+						console.error(
+							`[AttemptCompletionTool] Failed to get history for task ${task.taskId}: ${(err as Error)?.message ?? String(err)}. ` +
+								`Skipping delegation.`,
 						)
-						if (delegated) return
+						// Fall through to normal completion ask flow
 					}
 				}
 			}

src/core/webview/ClineProvider.ts

@@ -933,6 +933,8 @@ export class ClineProvider
 			onCreated: this.taskCreationCallback,
 			startTask: options?.startTask ?? true,
 			enableBridge: BridgeOrchestrator.isEnabled(cloudUserInfo, taskSyncEnabled),
+			// Preserve the status from the history item to avoid overwriting it when the task saves messages
+			initialStatus: historyItem.status,
 		})
 
 		if (isRehydratingCurrentTask) {
@@ -3017,9 +3019,15 @@ export class ClineProvider
 		}
 
 		// 4) Create child as sole active (parent reference preserved for lineage)
-		const child = await this.createTask(message, undefined, parent as any, { initialTodos })
+		// Pass initialStatus: "active" to ensure the child task's historyItem is created
+		// with status from the start, avoiding race conditions where the task might
+		// call attempt_completion before status is persisted separately.
+		const child = await this.createTask(message, undefined, parent as any, {
+			initialTodos,
+			initialStatus: "active",
+		})
 
-		// 4) Persist parent delegation metadata
+		// 5) Persist parent delegation metadata
 		try {
 			const { historyItem } = await this.getTaskWithId(parentTaskId)
 			const childIds = Array.from(new Set([...(historyItem.childIds ?? []), child.taskId]))
@@ -3039,7 +3047,7 @@ export class ClineProvider
 			)
 		}
 
-		// 5) Emit TaskDelegated (provider-level)
+		// 6) Emit TaskDelegated (provider-level)
 		try {
 			this.emit(RooCodeEventName.TaskDelegated, parentTaskId, child.taskId)
 		} catch {
@@ -3164,7 +3172,22 @@ export class ClineProvider
 
 		await saveApiMessages({ messages: parentApiMessages as any, taskId: parentTaskId, globalStoragePath })
 
-		// 3) Update parent metadata and persist BEFORE emitting completion event
+		// 3) Update child metadata to "completed" status
+		try {
+			const { historyItem: childHistory } = await this.getTaskWithId(childTaskId)
+			await this.updateTaskHistory({
+				...childHistory,
+				status: "completed",
+			})
+		} catch (err) {
+			this.log(
+				`[reopenParentFromDelegation] Failed to persist child completed status for ${childTaskId}: ${
+					(err as Error)?.message ?? String(err)
+				}`,
+			)
+		}
+
+		// 4) Update parent metadata and persist BEFORE emitting completion event
 		const childIds = Array.from(new Set([...(historyItem.childIds ?? []), childTaskId]))
 		const updatedHistory: typeof historyItem = {
 			...historyItem,
@@ -3176,35 +3199,24 @@ export class ClineProvider
 		}
 		await this.updateTaskHistory(updatedHistory)
 
-		// 4) Emit TaskDelegationCompleted (provider-level)
+		// 5) Emit TaskDelegationCompleted (provider-level)
 		try {
 			this.emit(RooCodeEventName.TaskDelegationCompleted, parentTaskId, childTaskId, completionResultSummary)
 		} catch {
 			// non-fatal
 		}
 
-		// 5) Close child instance if still open (single-open-task invariant)
+		// 6) Close child instance if still open (single-open-task invariant)
 		const current = this.getCurrentTask()
 		if (current?.taskId === childTaskId) {
 			await this.removeClineFromStack()
 		}
 
-		// 5b) Mark child subtask as "completed" to prevent duplicate tool_result on revisit
-		try {
-			const { historyItem: childHistory } = await this.getTaskWithId(childTaskId)
-			await this.updateTaskHistory({
-				...childHistory,
-				status: "completed",
-			})
-		} catch {
-			// non-fatal: child history may not exist for some edge cases
-		}
-
-		// 6) Reopen the parent from history as the sole active task (restores saved mode)
+		// 7) Reopen the parent from history as the sole active task (restores saved mode)
 		//    IMPORTANT: startTask=false to suppress resume-from-history ask scheduling
 		const parentInstance = await this.createTaskWithHistoryItem(updatedHistory, { startTask: false })
 
-		// 7) Inject restored histories into the in-memory instance before resuming
+		// 8) Inject restored histories into the in-memory instance before resuming
 		if (parentInstance) {
 			try {
 				await parentInstance.overwriteClineMessages(parentClineMessages)
@@ -3221,7 +3233,7 @@ export class ClineProvider
 			await parentInstance.resumeAfterDelegation()
 		}
 
-		// 8) Emit TaskDelegationResumed (provider-level)
+		// 9) Emit TaskDelegationResumed (provider-level)
 		try {
 			this.emit(RooCodeEventName.TaskDelegationResumed, parentTaskId, childTaskId)
 		} catch {