fix exact Gateway approval waiter settlement (#2681)

* fix interrupt pending group approvals

* docs link interrupt approval fix to PR

* fix interrupt approval generation isolation

* fix exact gateway approval waiter settlement

* docs link gateway waiter fix PR

---------

Co-authored-by: Lux <wangw9475@agent.qq.com>

Author: wtj-0527

docs/chat-chain-changes/2026-08-22-issue-2676-interrupt-pending-approval.md

@@ -0,0 +1,9 @@
+---
+date: 2026-08-22
+pr: 2677
+feature: Group Agent interrupt approval settlement
+impact: Interrupting an exact Group Agent run generation now denies its pending approvals in both the runtime and browser while leaving other runs untouched.
+---
+
+Approval cancellation is idempotent and uses deny-only test commands so interrupted work cannot be approved accidentally.
+Approval routes and Agent Bridge waiters are bound to the exact Session + run generation; legacy or malformed empty generations are never claimed by an interrupt, and a later run in the same Session remains isolated.

docs/chat-chain-changes/2026-08-22-issue-2680-exact-gateway-approval-waiter.md

@@ -0,0 +1,8 @@
+---
+date: 2026-08-22
+pr: 2681
+feature: Exact Gateway approval waiter settlement
+impact: Interrupting a Group Agent run now denies its exact Hermes Gateway waiter by Runtime request ID without consuming another generation's waiter from the same Session.
+---
+
+Gateway approval notifications retain the Runtime `request_id` beside their exact Session and run generation. Interrupt and user-response paths pass that identity back to Hermes Agent, while missing request IDs fail closed instead of falling back to Session FIFO.

packages/server/src/services/hermes/agent-bridge/python/bridge_pool.py

@@ -185,7 +185,8 @@ def __init__(self) -> None:
         self._lock = threading.RLock()
         self._db = SessionDbHolder()
         self._approval_requests: dict[str, queue.Queue[str]] = {}
-        self._gateway_approval_requests: dict[str, str] = {}
+        self._approval_request_generations: dict[str, tuple[str, str]] = {}
+        self._gateway_approval_requests: dict[str, tuple[str, str, str]] = {}
         self._gateway_approval_pattern_keys: dict[str, list[str]] = {}
         self._compression_requests: dict[str, queue.Queue[dict[str, Any]]] = {}
         self._background_notification_claims: dict[tuple[str, str], dict[str, Any]] = {}
@@ -1371,10 +1372,13 @@ def callback(command: str, description: str, *, allow_permanent: bool = True) ->
             approval_id = uuid.uuid4().hex
             response_queue: queue.Queue[str] = queue.Queue(maxsize=1)
             with self._lock:
+                run_id = str(self._sessions.get(session_id).current_run_id or "") if self._sessions.get(session_id) else ""
                 self._approval_requests[approval_id] = response_queue
+                self._approval_request_generations[approval_id] = (session_id, run_id)
             choices = ["once", "session", "always", "deny"] if allow_permanent else ["once", "session", "deny"]
             self._append_event(session_id, {
                 "event": "approval.requested",
+                "run_id": run_id,
                 "approval_id": approval_id,
                 "command": str(command or ""),
                 "description": str(description or ""),
@@ -1389,8 +1393,10 @@ def callback(command: str, description: str, *, allow_permanent: bool = True) ->
             finally:
                 with self._lock:
                     self._approval_requests.pop(approval_id, None)
+                    self._approval_request_generations.pop(approval_id, None)
             self._append_event(session_id, {
                 "event": "approval.resolved",
+                "run_id": run_id,
                 "approval_id": approval_id,
                 "choice": choice,
             })
@@ -1467,11 +1473,14 @@ def callback(approval_data: dict[str, Any]) -> None:
             approval_id = uuid.uuid4().hex
             choices = ["once", "session", "always", "deny"]
             pattern_keys = _approval_pattern_keys(approval_data)
+            request_id = str(approval_data.get("request_id") or "").strip()
             with self._lock:
-                self._gateway_approval_requests[approval_id] = session_id
+                run_id = str(self._sessions.get(session_id).current_run_id or "") if self._sessions.get(session_id) else ""
+                self._gateway_approval_requests[approval_id] = (session_id, run_id, request_id)
                 self._gateway_approval_pattern_keys[approval_id] = pattern_keys
             self._append_event(session_id, {
                 "event": "approval.requested",
+                "run_id": run_id,
                 "approval_id": approval_id,
                 "command": str(approval_data.get("command") or ""),
                 "description": str(approval_data.get("description") or ""),
@@ -2039,6 +2048,7 @@ def interrupt(self, session_id: str, message: str | None = None) -> dict[str, An
             raise KeyError(f"unknown session: {session_id}")
         with session.lock:
             self._cancel_boundary_run(session)
+            interrupted_run_id = str(session.current_run_id or "")
         background_delegation_ids = self._background_delegation_ids_for_session(session_id)
         with self._lock:
             self._suppressed_background_delegations.update(background_delegation_ids)
@@ -2050,6 +2060,7 @@ def interrupt(self, session_id: str, message: str | None = None) -> dict[str, An
         if not hasattr(session.agent, "interrupt"):
             raise RuntimeError("agent does not support interrupt")
         session.agent.interrupt(message)
+        self._cancel_pending_approvals_for_generation(session_id, interrupted_run_id)
         deadline = time.time() + 10.0
         synced = False
         while time.time() < deadline:
@@ -2066,6 +2077,50 @@ def interrupt(self, session_id: str, message: str | None = None) -> dict[str, An
             "background_delegation_ids": background_delegation_ids,
         }
 
+    def _cancel_pending_approvals_for_generation(self, session_id: str, run_id: str) -> int:
+        if not session_id or not run_id:
+            return 0
+        terminal_queues: list[queue.Queue[str]] = []
+        gateway_approvals: list[tuple[str, str, list[str]]] = []
+        with self._lock:
+            for approval_id, approval_generation in list(self._approval_request_generations.items()):
+                if approval_generation != (session_id, run_id):
+                    continue
+                response_queue = self._approval_requests.pop(approval_id, None)
+                self._approval_request_generations.pop(approval_id, None)
+                if response_queue is not None:
+                    terminal_queues.append(response_queue)
+            for approval_id, approval_generation in list(self._gateway_approval_requests.items()):
+                if approval_generation[:2] != (session_id, run_id):
+                    continue
+                self._gateway_approval_requests.pop(approval_id, None)
+                gateway_approvals.append((
+                    approval_id,
+                    approval_generation[2],
+                    self._gateway_approval_pattern_keys.pop(approval_id, []),
+                ))
+        for response_queue in terminal_queues:
+            try:
+                response_queue.put_nowait("deny")
+            except queue.Full:
+                pass
+        for approval_id, request_id, _pattern_keys in gateway_approvals:
+            try:
+                from tools.approval import resolve_gateway_approval
+
+                if request_id:
+                    resolve_gateway_approval(session_id, "deny", request_id=request_id)
+            except Exception:
+                pass
+            self._append_event(session_id, {
+                "event": "approval.resolved",
+                "run_id": run_id,
+                "approval_id": approval_id,
+                "choice": "deny",
+                "reason": "Session interrupted",
+            })
+        return len(terminal_queues) + len(gateway_approvals)
+
     def request_boundary_interrupt(
         self,
         session_id: str,
@@ -2165,31 +2220,39 @@ def respond_approval(self, approval_id: str, choice: str) -> dict[str, Any]:
         if cleaned not in {"once", "session", "always", "deny"}:
             cleaned = "deny"
         with self._lock:
-            response_queue = self._approval_requests.get(approval_id)
+            response_queue = self._approval_requests.pop(approval_id, None)
+            if response_queue is not None:
+                self._approval_request_generations.pop(approval_id, None)
+                try:
+                    response_queue.put_nowait(cleaned)
+                except queue.Full:
+                    pass
         if response_queue is None:
             with self._lock:
-                gateway_session_id = self._gateway_approval_requests.pop(approval_id, None)
+                gateway_generation = self._gateway_approval_requests.pop(approval_id, None)
                 pattern_keys = self._gateway_approval_pattern_keys.pop(approval_id, [])
-            if gateway_session_id is None:
+            if gateway_generation is None:
                 return {"approval_id": approval_id, "resolved": False, "choice": cleaned}
+            gateway_session_id, gateway_run_id, gateway_request_id = gateway_generation
             try:
                 from tools.approval import resolve_gateway_approval
 
-                resolved = resolve_gateway_approval(gateway_session_id, cleaned) > 0
+                resolved = bool(gateway_request_id) and resolve_gateway_approval(
+                    gateway_session_id,
+                    cleaned,
+                    request_id=gateway_request_id,
+                ) > 0
             except Exception:
                 resolved = False
             if resolved:
                 _persist_execute_code_approval_choice(gateway_session_id, pattern_keys, cleaned)
             self._append_event(gateway_session_id, {
                 "event": "approval.resolved",
+                "run_id": gateway_run_id,
                 "approval_id": approval_id,
                 "choice": cleaned,
             })
             return {"approval_id": approval_id, "resolved": resolved, "choice": cleaned}
-        try:
-            response_queue.put_nowait(cleaned)
-        except queue.Full:
-            pass
         return {"approval_id": approval_id, "resolved": True, "choice": cleaned}
 
     def respond_clarify(self, clarify_id: str, response: str) -> dict[str, Any]:

packages/server/src/services/hermes/group-chat/agent-clients.ts

@@ -1158,7 +1158,12 @@ export class AgentClient implements GroupAgentExecutor {
                     } else if (event === 'tool.completed' || event === 'tool.failed') {
                         queueToolEventWrite(() => this.recordToolCompleted(roomId, sessionId, { ...payload, event }).then(() => undefined))
                     } else if (event === 'approval.requested') {
-                        this.emitApprovalRequested(roomId, { ...payload, agentSessionId: sessionId })
+                        const { run_id: _runtimeRunId, runId: _runtimeCamelRunId, ...approvalPayload } = payload
+                        this.emitApprovalRequested(roomId, {
+                            ...approvalPayload,
+                            agentSessionId: sessionId,
+                            runId: responseRunId,
+                        })
                     } else if (event === 'approval.resolved') {
                         this.emitApprovalResolved(roomId, { ...payload, agentSessionId: sessionId })
                     } else if (event === 'clarify.requested') {
@@ -1569,6 +1574,7 @@ export class AgentClient implements GroupAgentExecutor {
                 this.emitApprovalRequested(roomId, {
                     event: 'approval.requested',
                     agentSessionId: sessionId,
+                    runId: responseRunId,
                     approval_id: (ev as any).approval_id,
                     command: (ev as any).command,
                     description: (ev as any).description,

packages/server/src/services/hermes/group-chat/index.ts

@@ -94,6 +94,7 @@ interface PendingGroupApprovalRoute {
     agentName: string
     ownerMemberId: string
     agentSessionId: string
+    runId: string
     approvalId: string
     command: string
     description: string
@@ -3917,7 +3918,7 @@ export class GroupChatServer {
         socket.on('cancel_execution_queue_item', (data: { roomId?: string; queueId?: string; executionQueueCapability?: string }, ack?: (response?: unknown) => void) => this.handleCancelExecutionQueueItem(socket, data, ack))
         socket.on('interrupt_agent', (data: { roomId?: string; agentName?: string }, ack?: (response?: unknown) => void) => this.handleInterruptAgent(socket, data, ack))
         socket.on('remove_agent', (data: { roomId?: string; agentId?: string }, ack?: (response?: unknown) => void) => this.handleRemoveAgent(socket, data, ack))
-        socket.on('approval.requested', (data: { roomId?: string; agentName?: string; approval_id?: string; command?: string; description?: string; choices?: string[]; allow_permanent?: boolean; timeout_ms?: number; agentSessionId?: string }) => this.handleApprovalRequested(socket, data))
+        socket.on('approval.requested', (data: { roomId?: string; agentName?: string; approval_id?: string; command?: string; description?: string; choices?: string[]; allow_permanent?: boolean; timeout_ms?: number; agentSessionId?: string; runId?: string }) => this.handleApprovalRequested(socket, data))
         socket.on('approval.resolved', (data: { roomId?: string; agentName?: string; approval_id?: string; choice?: string; agentSessionId?: string }) => this.handleApprovalResolved(socket, data))
         socket.on('approval.respond', (data: { roomId?: string; approval_id?: string; choice?: string }, ack?: (response?: unknown) => void) => this.handleApprovalRespond(socket, data, ack))
         socket.on('clarify.requested', (data: { roomId?: string; agentName?: string; clarify_id?: string; question?: string; choices?: string[] | null; initial_response?: string; response_mode?: string; timeout_ms?: number; agentSessionId?: string; runId?: string; runtimeRunId?: string }) => this.handleClarifyRequested(socket, data))
@@ -4876,6 +4877,12 @@ export class GroupChatServer {
             return
         }
         const activeGeneration = this.contextStatusState.get(roomId)?.get(agentName)
+        const interruptedApprovals = this.takePendingApprovalsForGeneration(
+            roomId,
+            agentName,
+            activeGeneration?.agentSessionId || '',
+            activeGeneration?.runId || '',
+        )
         const interruptedClarifications = this.takePendingEkkoClarificationsForGeneration(
             roomId,
             agentName,
@@ -4884,7 +4891,10 @@ export class GroupChatServer {
         )
         try {
             await this.agentClients.interruptAgent(roomId, agentName)
-            await this.settleInterruptedEkkoClarifications(interruptedClarifications)
+            await Promise.all([
+                this.settleInterruptedApprovals(interruptedApprovals),
+                this.settleInterruptedEkkoClarifications(interruptedClarifications),
+            ])
             const roomStatuses = this.contextStatusState.get(roomId)
             roomStatuses?.delete(agentName)
             if (roomStatuses?.size === 0) this.contextStatusState.delete(roomId)
@@ -4895,7 +4905,10 @@ export class GroupChatServer {
             this.nsp.to(roomId).emit('context_status', { roomId, agentName, status: 'ready' })
             ack?.({ ok: true })
         } catch (err: any) {
-            await this.settleInterruptedEkkoClarifications(interruptedClarifications)
+            await Promise.all([
+                this.settleInterruptedApprovals(interruptedApprovals),
+                this.settleInterruptedEkkoClarifications(interruptedClarifications),
+            ])
             logger.warn(`[GroupChat] failed to interrupt agent ${agentName} in room ${roomId}: ${err.message}`)
             ack?.({ error: err.message || 'interrupt failed' })
         }
@@ -4996,7 +5009,7 @@ export class GroupChatServer {
         })
     }
 
-    private handleApprovalRequested(socket: Socket, data: { roomId?: string; agentName?: string; approval_id?: string; command?: string; description?: string; choices?: string[]; allow_permanent?: boolean; timeout_ms?: number; agentSessionId?: string }): void {
+    private handleApprovalRequested(socket: Socket, data: { roomId?: string; agentName?: string; approval_id?: string; command?: string; description?: string; choices?: string[]; allow_permanent?: boolean; timeout_ms?: number; agentSessionId?: string; runId?: string }): void {
         const roomId = data.roomId
         const agentName = data.agentName || ''
         if (!roomId || !data.approval_id || !this.getCurrentAgentEventMember(socket, roomId, agentName, data.agentSessionId)) return
@@ -5008,6 +5021,7 @@ export class GroupChatServer {
             agentName,
             ownerMemberId: this.groupAgentOwnerMemberId(roomId, agentName),
             agentSessionId: String(data.agentSessionId || '').trim(),
+            runId: String(data.runId || '').trim(),
             approvalId: data.approval_id,
             command: data.command || '',
             description: data.description || '',
@@ -5034,6 +5048,56 @@ export class GroupChatServer {
         })
     }
 
+    private takePendingApprovalsForGeneration(
+        roomId: string,
+        agentName: string,
+        agentSessionId: string,
+        runId: string,
+    ): PendingGroupApprovalRoute[] {
+        if (!agentSessionId || !runId || !(this.pendingApprovalRoutes instanceof Map)) return []
+        const routes: PendingGroupApprovalRoute[] = []
+        for (const [routeKey, route] of this.pendingApprovalRoutes) {
+            if (route.roomId !== roomId
+                || route.agentName !== agentName
+                || route.agentSessionId !== agentSessionId
+                || !route.runId
+                || route.runId !== runId) {
+                continue
+            }
+            const claimed = this.takePendingApprovalRoute(routeKey)
+            if (claimed) routes.push(claimed)
+        }
+        return routes
+    }
+
+    private async settleInterruptedApprovals(routes: PendingGroupApprovalRoute[]): Promise<void> {
+        for (const route of routes) {
+            let resolved = false
+            const executor = this.agentClients.getAgents(route.roomId).find(agent =>
+                agent.name === route.agentName && typeof agent.respondApproval === 'function'
+            )
+            try {
+                resolved = Boolean(await executor?.respondApproval?.(route.approvalId, 'deny'))
+                if (!resolved) {
+                    resolved = Boolean((await new AgentBridgeClient().approvalRespond(route.approvalId, 'deny') as any)?.resolved)
+                }
+            } catch (err: any) {
+                if (!isExpiredInteractionError(err?.message || err)) {
+                    logger.warn(`[GroupChat] failed to cancel interrupted approval ${route.approvalId}: ${err?.message || err}`)
+                }
+            }
+            this.emitToAgentApprovalOwner(route, 'approval.resolved', {
+                event: 'approval.resolved',
+                roomId: route.roomId,
+                agentName: route.agentName,
+                approval_id: route.approvalId,
+                choice: 'deny',
+                reason: 'Agent run interrupted',
+                resolved,
+            })
+        }
+    }
+
     private handleApprovalResolved(socket: Socket, data: { roomId?: string; agentName?: string; approval_id?: string; choice?: string; agentSessionId?: string }): void {
         const roomId = data.roomId
         const agentName = data.agentName || ''