fix(coding-agent): stop general clears from reclaiming handed-off actions

Restores the pre-handoff clear boundary for general queue operations while preserving targeted accepted-agent cancellation with abort-backed late-event capture.

Author: snimu

packages/coding-agent/src/core/agent-session.ts

@@ -1564,17 +1564,18 @@ export class AgentSession {
 	private _cancelSessionActions(
 		predicate: (action: QueuedSessionAction) => boolean,
 		error: Error,
+		candidates = this._actionStore.clearableActions(),
 	): QueuedSessionAction[] {
-		const clearable = this._actionStore.clearableActions().filter(predicate);
-		const previousStates = new Map(clearable.map((action) => [action.id, action.lifecycle.state]));
+		const matching = candidates.filter(predicate);
+		const previousStates = new Map(matching.map((action) => [action.id, action.lifecycle.state]));
 		const preparing = this._actionStore
 			.activeActions()
 			.filter(
 				(action): action is SessionAction<PreparedTurnPayload> =>
 					action.payload.kind === "turn" && action.lifecycle.state === "preparing",
 			);
 		const previousAnchor = preparing.at(-1);
-		const actions = this._actionStore.remove(predicate);
+		const actions = this._actionStore.remove(predicate, candidates);
 		const removed = new Set(actions);
 		if (previousAnchor && removed.has(previousAnchor)) {
 			for (const action of preparing) {
@@ -5644,10 +5645,16 @@ export class AgentSession {
 
 	clearQueuedUserMessagesMatching(predicate: (text: string) => boolean): { steering: string[]; followUp: string[] } {
 		const matching = this._actionStore
-			.clearableActions()
+			.ownedActions()
 			.filter(
 				(action) =>
-					action.payload.kind === "turn" && action.agentMessageId !== undefined && predicate(action.payload.text),
+					action.payload.kind === "turn" &&
+					action.agentMessageId !== undefined &&
+					predicate(action.payload.text) &&
+					(action.lifecycle.state === "queued" ||
+						action.lifecycle.state === "selected" ||
+						action.lifecycle.state === "preparing" ||
+						(action.lifecycle.state === "committing" && !primaryDeliveryRecord(action).started)),
 			);
 		if (matching.length === 0) return { steering: [], followUp: [] };
 		const removedTexts = (delivery: DeliveryPolicy) =>
@@ -5673,7 +5680,7 @@ export class AgentSession {
 					.filter((action) => action.payload.kind === "turn" && action.payload.acceptedAgentMessage === accepted)
 					.map((action) => action.id),
 			);
-			if (ids.size > 0) this._cancelSessionActions((action) => ids.has(action.id), error);
+			if (ids.size > 0) this._cancelSessionActions((action) => ids.has(action.id), error, matching);
 		}
 		if (
 			matching.some(

packages/coding-agent/src/core/session-action-store.ts

@@ -63,8 +63,7 @@ const ACTIVE_STATES = new Set<ActionLifecycle["state"]>(["selected", "preparing"
 const CLEARABLE_STATES = new Set<ActionLifecycle["state"]>(["queued", "selected", "preparing"]);
 
 function isClearable(action: SessionAction): boolean {
-	if (CLEARABLE_STATES.has(action.lifecycle.state)) return true;
-	return action.lifecycle.state === "committing" && primaryRecords(action).every((record) => !record.started);
+	return CLEARABLE_STATES.has(action.lifecycle.state);
 }
 
 const LEGAL_TRANSITIONS: Readonly<Record<ActionLifecycle["state"], ReadonlySet<ActionLifecycle["state"]>>> = {
@@ -210,8 +209,8 @@ export class ActionStore<TAction extends SessionAction = SessionAction> {
 		return action;
 	}
 
-	remove(predicate: (action: TAction) => boolean): TAction[] {
-		const removed = this.clearableActions().filter(predicate);
+	remove(predicate: (action: TAction) => boolean, candidates = this.clearableActions()): TAction[] {
+		const removed = candidates.filter(predicate);
 		for (const action of removed) transitionSessionAction(action, { state: "cancelled" });
 		return removed;
 	}

packages/coding-agent/test/suite/agent-session-queue.test.ts

@@ -1415,6 +1415,33 @@ describe("AgentSession queue characterization", () => {
 		expect(getUserTexts(harness)).toEqual(["first heartbeat", "second heartbeat"]);
 	});
 
+	it("does not reclaim a handed-off action before its delivery event", async () => {
+		const harness = await createHarness();
+		harnesses.push(harness);
+		harness.setResponses([fauxAssistantMessage("delivered")]);
+		const dispatchGate = createDeferred();
+		const promptCalled = createDeferred();
+		const originalPrompt = harness.session.agent.prompt.bind(harness.session.agent);
+		const promptSpy = vi
+			.spyOn(harness.session.agent, "prompt")
+			.mockImplementation(async (messages: Parameters<typeof originalPrompt>[0]) => {
+				promptSpy.mockRestore();
+				promptCalled.resolve();
+				await dispatchGate.promise;
+				return originalPrompt(messages);
+			});
+		const pause = harness.session.acquireQueuedWorkPause();
+		await harness.session.followUp("handed off", undefined, { resumeIfIdle: true });
+		pause.release();
+		await promptCalled.promise;
+
+		expect(harness.session.clearQueue()).toEqual({ steering: [], followUp: [] });
+		dispatchGate.resolve();
+		await harness.session.waitForIdle();
+		expect(getUserTexts(harness)).toEqual(["handed off"]);
+		expect(getAssistantTexts(harness)).toEqual(["delivered"]);
+	});
+
 	it("keeps cleared prompts out of the handoff snapshot during the refine wait", async () => {
 		let sessionInternals: { _refineInFlight?: Promise<void> };
 		let clearDuringRefineWait: (() => void) | undefined;