fix(tools): process queued messages when terminal command finishes

packages/types/src/task.ts

@@ -127,7 +127,7 @@ export interface TaskLike {
 
 	approveAsk(options?: { text?: string; images?: string[] }): void
 	denyAsk(options?: { text?: string; images?: string[] }): void
-	submitUserMessage(text: string, images?: string[], mode?: string, providerProfile?: string): Promise<void>
+	submitUserMessage(text: string, images?: string[], mode?: string, providerProfile?: string): Promise<boolean>
 	abortTask(): Promise<void>
 }
 

src/core/message-queue/MessageQueueService.ts

@@ -73,18 +73,18 @@ export class MessageQueueService extends EventEmitter<QueueEvents> {
 		return true
 	}
 
-	public dequeueMessage(): QueuedMessage | undefined {
-		const index = this._messages.findIndex((message) => !this.claimedMessageIds.has(message.id))
-		if (index === -1) {
-			return undefined
-		}
-		const [message] = this._messages.splice(index, 1)
-		this.emit("stateChanged", this._messages)
-		return message
-	}
-
-	public claimNextMessage(): QueuedMessage | undefined {
-		const message = this._messages.find((candidate) => !this.claimedMessageIds.has(candidate.id))
+	/**
+	 * Claims the first message that is neither already claimed nor listed in
+	 * `excludeIds`.
+	 *
+	 * `excludeIds` lets a consumer that must not take certain messages skip them
+	 * without removing them: an execution-gating ask passes the IDs a drain has
+	 * already submitted so stale feedback can never stand in for an approval.
+	 */
+	public claimNextMessage(excludeIds?: ReadonlySet<string>): QueuedMessage | undefined {
+		const message = this._messages.find(
+			(candidate) => !this.claimedMessageIds.has(candidate.id) && !excludeIds?.has(candidate.id),
+		)
 		if (message) {
 			this.claimedMessageIds.add(message.id)
 		}
@@ -115,9 +115,13 @@ export class MessageQueueService extends EventEmitter<QueueEvents> {
 	 * report a non-empty queue. Consumers that are about to take a message need
 	 * this instead: it answers "is there anything I may take", which is false
 	 * when every remaining message is already spoken for.
+	 *
+	 * `excludeIds` mirrors `claimNextMessage`: a message the caller may not take
+	 * is not available, so an execution-gating ask does not report availability
+	 * for a message only a conversational ask may consume.
 	 */
-	public hasUnclaimed(): boolean {
-		return this._messages.some((message) => !this.claimedMessageIds.has(message.id))
+	public hasUnclaimed(excludeIds?: ReadonlySet<string>): boolean {
+		return this._messages.some((message) => !this.claimedMessageIds.has(message.id) && !excludeIds?.has(message.id))
 	}
 
 	public dispose(): void {

src/core/message-queue/__tests__/MessageQueueService.spec.ts

@@ -8,7 +8,7 @@ describe("MessageQueueService claims", () => {
 
 		expect(queue.claimNextMessage()).toEqual(first)
 		expect(queue.claimNextMessage()).toEqual(second)
-		expect(queue.dequeueMessage()).toBeUndefined()
+		expect(queue.claimNextMessage()).toBeUndefined()
 		expect(queue.messages).toEqual([first, second])
 	})
 
@@ -67,4 +67,32 @@ describe("MessageQueueService claims", () => {
 		queue.releaseMessage(message.id)
 		expect(queue.hasUnclaimed()).toBe(true)
 	})
+
+	it("skips excluded messages without claiming or removing them", () => {
+		const queue = new MessageQueueService()
+		const retained = queue.addMessage("retained by a drain")!
+		const fresh = queue.addMessage("fresh")!
+		const excluded = new Set([retained.id])
+
+		// Availability must agree with the claim: the excluded message is not
+		// available to this consumer even though the queue holds it.
+		expect(queue.hasUnclaimed(excluded)).toBe(true)
+		expect(queue.claimNextMessage(excluded)).toEqual(fresh)
+
+		// The excluded message stays queued and unclaimed, so a consumer allowed
+		// to take it (a conversational ask) still can.
+		expect(queue.messages).toEqual([retained, fresh])
+		expect(queue.hasUnclaimed(excluded)).toBe(false)
+		expect(queue.claimNextMessage()).toEqual(retained)
+	})
+
+	it("reports no availability when every message is excluded", () => {
+		const queue = new MessageQueueService()
+		const only = queue.addMessage("only")!
+		const excluded = new Set([only.id])
+
+		expect(queue.hasUnclaimed(excluded)).toBe(false)
+		expect(queue.claimNextMessage(excluded)).toBeUndefined()
+		expect(queue.messages).toEqual([only])
+	})
 })