fix: prevent parent task from hanging when subtask delegation returns after per-mode API profile switch

**Problem:**
When an orchestrator/parent task delegates to a subtask whose mode is bound to a different API-configuration profile (modeApiConfigs) than the parent, the subtask completes and calls attempt_completion, but control never returns to the parent. The run silently waits for manual click instead of auto-resuming.

**Root cause:**
handleModeSwitch → activateProviderProfile leaves the parent task record as status="active" while awaitingChildId still points at the child. Two guards then reject because they require parent status to be exactly "delegated":

1. reopenParentFromDelegation() had an overly strict guard checking cancelledDelegationChildIds.has(childTaskId). When cancelTask() fails to detach the parent due to a runDelegationTransition race, the child is added to the blacklist. On the second attempt_completion call, the guard blocks reopen permanently.

2. Guard in attempt_completion delegation pre-check only accepts status === "delegated".

**Fix:**
- Remove cancelledDelegationChildIds from reopenParentFromDelegation guard. The cancelledDelegationChildIds blacklist is redundant — cancelTask() already sets parent status to "active" before adding to blacklist. If parent is still "delegated" and awaiting this child, it is safe to reopen.
- Add parentHistory verification before delegation: check parentHistory.status === "delegated" && parentHistory.awaitingChildId === task.taskId before calling delegateToParent.
- Exempt subtask delegation from didToolFailInCurrentTurn guard (&& !task.parentTaskId) — the subtask is legitimately finishing assigned work.

Fixes #457

Author: AGI Developer

src/core/tools/AttemptCompletionTool.ts

@@ -40,8 +40,10 @@ export class AttemptCompletionTool extends BaseTool<"attempt_completion"> {
 		const { result } = params
 		const { handleError, pushToolResult, askFinishSubTaskApproval } = callbacks
 
-		// Prevent attempt_completion if any tool failed in the current turn
-		if (task.didToolFailInCurrentTurn) {
+		// Prevent attempt_completion if any tool failed in the current turn.
+		// Subtask delegation (parentTaskId) is exempt — the subtask is legitimately
+		// finishing its assigned work, not trying to "escape" from a failure.
+		if (task.didToolFailInCurrentTurn && !task.parentTaskId) {
 			const errorMsg = t("common:errors.attempt_completion_tool_failed")
 
 			await task.say("error", errorMsg)
@@ -86,7 +88,6 @@ export class AttemptCompletionTool extends BaseTool<"attempt_completion"> {
 				// to prevent duplicate tool_results when user revisits from history
 				const provider = task.providerRef.deref() as DelegationProvider | undefined
 				if (provider) {
-					let historyLookupTaskId = task.taskId
 					try {
 						const { historyItem } = await provider.getTaskWithId(task.taskId)
 						const status = historyItem?.status
@@ -97,9 +98,10 @@ export class AttemptCompletionTool extends BaseTool<"attempt_completion"> {
 							// This shows the user the completion result and waits for acceptance
 							// without injecting another tool_result to the parent
 						} else if (status === "active") {
-							historyLookupTaskId = task.parentTaskId
+							// Verify parent still awaits this child before asking the user.
+							// If parent detached (cancelled/resumed), skip delegation to avoid
+							// asking the user to return to a task no longer waiting for us.
 							const { historyItem: parentHistory } = await provider.getTaskWithId(task.parentTaskId)
-
 							if (
 								parentHistory?.status === "delegated" &&
 								parentHistory?.awaitingChildId === task.taskId
@@ -116,13 +118,15 @@ export class AttemptCompletionTool extends BaseTool<"attempt_completion"> {
 								}
 								if (delegation !== "continue") return
 							} else {
-								// Parent already detached, such as when the user cancelled this child.
-								// Fall through to the normal completion ask flow.
+								console.warn(
+									`[AttemptCompletionTool] Parent ${task.parentTaskId} no longer awaiting child ${task.taskId} ` +
+										`(status=${parentHistory?.status}, awaitingChildId=${parentHistory?.awaitingChildId}). ` +
+										`Skipping delegation. Task completed but parent NOT resumed.`,
+								)
+								// Fall through to normal completion ask flow
 							}
 						} 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.`,
@@ -132,7 +136,7 @@ export class AttemptCompletionTool extends BaseTool<"attempt_completion"> {
 					} catch (err) {
 						// If we can't get the history, log error and skip delegation
 						console.error(
-							`[AttemptCompletionTool] Failed to get history for task ${historyLookupTaskId}: ${(err as Error)?.message ?? String(err)}. ` +
+							`[AttemptCompletionTool] Failed to get history for task ${task.taskId}: ${(err as Error)?.message ?? String(err)}. ` +
 								`Skipping delegation.`,
 						)
 						// Fall through to normal completion ask flow
@@ -185,6 +189,10 @@ export class AttemptCompletionTool extends BaseTool<"attempt_completion"> {
 		})
 
 		if (didReopen === false) {
+			console.warn(
+				`[AttemptCompletionTool] Parent ${task.parentTaskId} reopen failed for child ${task.taskId}. ` +
+					`Task completed but parent NOT resumed. User can manually resume.`,
+			)
 			return "continue"
 		}
 

src/core/webview/ClineProvider.ts

@@ -3531,11 +3531,13 @@ export class ClineProvider
 			// (setting status → "active", awaitingChildId → undefined) while the user was
 			// approving the subtask finish.  If the parent no longer awaits this child,
 			// routing output back would corrupt an unrelated task.
-			if (
-				this.cancelledDelegationChildIds.has(childTaskId) ||
-				historyItem.status !== "delegated" ||
-				historyItem.awaitingChildId !== childTaskId
-			) {
+			// NOTE: cancelledDelegationChildIds is NOT checked here because
+			// cancelTask() already sets parent status to "active" BEFORE adding
+			// the child to the blacklist. If the parent IS still "delegated" and
+			// awaiting this child, it's safe to reopen — the blacklist only exists
+			// to prevent stale fail-closed children from corrupting unrelated tasks,
+			// and the status+awaitingChildId check below already handles that.
+			if (historyItem.status !== "delegated" || historyItem.awaitingChildId !== childTaskId) {
 				this.log(
 					`[reopenParentFromDelegation] Aborting: parent ${parentTaskId} is no longer delegated to child ${childTaskId} ` +
 						`(status=${historyItem.status}, awaitingChildId=${historyItem.awaitingChildId})`,