@wildo-ai/saas-frontend-lib 1.1.9 → 1.1.11

package/dist/esm/core/flows-actors/FlowsActorsContext.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useState, useMemo, useEffect, useCallback, useRef } from 'react';
-import { MAIN_API_BASE_PATH, MANUAL_CONTROLLER_ROUTES_URLS, ManualControllerRouteKey, CoreWebSocketEvent, WS_FlowsActorsApprovalAnnouncementDataSchema, FlowsActors_ExecutionErrorCode, canonicalizeFlowsActorsContextRef, } from '@wildo-ai/saas-models';
+import { MAIN_API_BASE_PATH, ManualControllerRouteKey, CoreWebSocketEvent, WS_FlowsActorsApprovalAnnouncementDataSchema, FlowsActors_ExecutionErrorCode, FlowsActors_Status, canonicalizeFlowsActorsContextRef, AskPersonOptionRef, buildManualControllerRoutePath, } from '@wildo-ai/saas-models';
 import { LoggerFrontendService } from '../../core/monitoring/logger.frontend.service.js';
 import { errorManagement } from '../../core/errors/error-management.frontend.service.js';
 import { useApplication } from '../../core/runtime/useApplication.js';
@@ -46,7 +46,12 @@ function mergeStreamedMessage(existing, incoming, isFinal) {
     return appendMessages(existing, incoming);
 }
 /**
- * FlowsActors Execution Status
+ * How a turn stands in THIS CLIENT — its view of a turn, which is not the server's run status.
+ *
+ * Kept distinct on purpose (#2524): the client knows states the server never holds — STARTING (the start is sent and
+ * not yet acknowledged), and an ERROR it detects itself when the socket drops — and the server knows states the
+ * client never shows (READY, ABORTED). The WIRE speaks the server's vocabulary (`FlowsActors_Status` on
+ * `FLOWS_ACTORS_COMPLETED`), and {@link turnStatusFromServer} is the ONE place that reads it into this one.
  */
 export var FlowsActorsExecutionStatus;
 (function (FlowsActorsExecutionStatus) {
@@ -55,8 +60,29 @@ export var FlowsActorsExecutionStatus;
     FlowsActorsExecutionStatus["RUNNING"] = "running";
     FlowsActorsExecutionStatus["AWAITING_APPROVAL"] = "awaiting_approval";
     FlowsActorsExecutionStatus["COMPLETED"] = "completed";
+    /** The person stopped the turn (#2524). Not an error: nothing failed, and the turn's thread continues. */
+    FlowsActorsExecutionStatus["CANCELLED"] = "cancelled";
     FlowsActorsExecutionStatus["ERROR"] = "error";
 })(FlowsActorsExecutionStatus || (FlowsActorsExecutionStatus = {}));
+/**
+ * The client's turn status for a status the server ENDED a turn with (`FLOWS_ACTORS_COMPLETED.status`). Total over the
+ * server vocabulary, so a status added to it is a compile error here rather than a turn the client never settles.
+ */
+const TURN_STATUS_FROM_SERVER = {
+    [FlowsActors_Status.COMPLETED]: FlowsActorsExecutionStatus.COMPLETED,
+    [FlowsActors_Status.CANCELLED]: FlowsActorsExecutionStatus.CANCELLED,
+    [FlowsActors_Status.AWAITING_APPROVAL]: FlowsActorsExecutionStatus.AWAITING_APPROVAL,
+    [FlowsActors_Status.PROCESSING]: FlowsActorsExecutionStatus.RUNNING,
+    [FlowsActors_Status.PENDING]: FlowsActorsExecutionStatus.STARTING,
+    [FlowsActors_Status.READY]: FlowsActorsExecutionStatus.STARTING,
+    // A run the server ended without completing it, whatever the reason, is an error to the person watching it.
+    [FlowsActors_Status.FAILED]: FlowsActorsExecutionStatus.ERROR,
+    [FlowsActors_Status.ABORTED]: FlowsActorsExecutionStatus.ERROR,
+};
+/** Read a server run status into the client's turn status — the one mapping (#2524). */
+export function turnStatusFromServer(status) {
+    return TURN_STATUS_FROM_SERVER[status] ?? FlowsActorsExecutionStatus.ERROR;
+}
 /**
  * The one mapping from a server approval announcement to the client's pending decision — shared by the
  * live socket handler and the history seeding (#1601), so a decision reached either way renders and
@@ -66,10 +92,11 @@ export var FlowsActorsExecutionStatus;
  * never composed here from `toolName`: that would invent display text no i18n tree owns.
  */
 function pendingApprovalFromAnnouncement(announcement, actionDescription) {
-    const { approvalId, decisionRef, routeKind, toolName, toolArgs, toolInputSchema, requestedAt, expiresAt, reasonCodes } = announcement;
+    const { approvalId, decisionRef, routeKind, toolName, toolArgs, toolInputSchema, requestedAt, expiresAt, reasonCodes, riskLevel, question, presentation, presentationId } = announcement;
     return {
         approvalId,
         actionDescription,
+        ...(riskLevel ? { riskLevel } : {}),
         toolName,
         toolArgs,
         // A descriptor the transport does not re-validate (#587) — typed here for the editor, which falls
@@ -80,6 +107,9 @@ function pendingApprovalFromAnnouncement(announcement, actionDescription) {
         decisionRef,
         routeKind,
         ...(reasonCodes && reasonCodes.length > 0 ? { reasonCodes } : {}),
+        ...(question ? { question } : {}),
+        ...(presentation ? { presentation } : {}),
+        ...(presentationId ? { presentationId } : {}),
     };
 }
 /**
@@ -104,6 +134,8 @@ export const FlowsActorsProvider = ({ children }) => {
     const hasConfiguredFlowsActorsViews = (frontendConfiguration?.flowsActorsViews?.length ?? 0) > 0;
     const [systems, setSystems] = useState([]);
     const [autonomousAgents, setAutonomousAgents] = useState([]);
+    const [chatAgents, setChatAgents] = useState([]);
+    const [chatConnectionRefs, setChatConnectionRefs] = useState([]);
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
     const [executions, setExecutions] = useState(new Map());
@@ -148,9 +180,11 @@ export const FlowsActorsProvider = ({ children }) => {
             // Use httpClient which handles authentication automatically. The path is
             // built from the shared route registry (same source the backend controller
             // registers with) so both sides stay in lockstep under MAIN_API_BASE_PATH.
-            const data = await httpClient.get(`${MAIN_API_BASE_PATH}${MANUAL_CONTROLLER_ROUTES_URLS[ManualControllerRouteKey.FLOWS_ACTORS_FRONTEND_INFO]}`);
+            const data = await httpClient.get(`${MAIN_API_BASE_PATH}${buildManualControllerRoutePath(ManualControllerRouteKey.FLOWS_ACTORS_FRONTEND_INFO)}`);
             setSystems(data.systems);
             setAutonomousAgents(data.autonomousAgents);
+            setChatAgents(data.chatAgents);
+            setChatConnectionRefs(data.chatConnectionRefs);
             setHasCompletedFetch(true);
             logDebug('Systems refreshed', { count: data.systems.length });
         }
@@ -159,6 +193,8 @@ export const FlowsActorsProvider = ({ children }) => {
                 logDebug('FlowsActors backend support not available - skipping systems bootstrap');
                 setSystems([]);
                 setAutonomousAgents([]);
+                setChatAgents([]);
+                setChatConnectionRefs([]);
                 setError(null);
                 setHasCompletedFetch(true);
                 return;
@@ -177,20 +213,21 @@ export const FlowsActorsProvider = ({ children }) => {
      * owner filter restricts rows to the caller's threads. A missing backend
      * surface (feature absent) resolves to `[]`, never an error.
      */
-    const fetchConversationHistory = useCallback(async (systemRef, contextResourceIdentifiers) => {
+    const fetchConversationHistory = useCallback(async (systemRef, contextResourceIdentifiers, page) => {
         if (!httpClient) {
             logDebug('Cannot fetch conversation history - httpClient not available');
-            return [];
+            return undefined;
         }
         try {
-            const basePath = `${MAIN_API_BASE_PATH}${MANUAL_CONTROLLER_ROUTES_URLS[ManualControllerRouteKey.FLOWS_ACTORS_HISTORY]}`;
+            const basePath = `${MAIN_API_BASE_PATH}${buildManualControllerRoutePath(ManualControllerRouteKey.FLOWS_ACTORS_HISTORY)}`;
             const contextRef = contextResourceIdentifiers === undefined
                 ? undefined
                 : canonicalizeFlowsActorsContextRef({
                     ...(appScope?.currentOrganizationId ? { organizationId: appScope.currentOrganizationId } : {}),
                     ...contextResourceIdentifiers,
                 });
-            const query = `?systemRef=${encodeURIComponent(systemRef)}${contextRef === undefined ? '' : `&contextRef=${encodeURIComponent(contextRef)}`}`;
+            const query = `?systemRef=${encodeURIComponent(systemRef)}${contextRef === undefined ? '' : `&contextRef=${encodeURIComponent(contextRef)}`}`
+                + (page?.before ? `&before=${encodeURIComponent(page.before)}` : '');
             const data = await httpClient.get(`${basePath}${query}`);
             logDebug('Conversation history fetched', { systemRef, count: data.executions.length });
             /*
@@ -201,14 +238,26 @@ export const FlowsActorsProvider = ({ children }) => {
              * returns the same announcement the socket carried, and it is folded through the same mapping.
              *
              * A live entry is never replaced: the socket is the fresher source for a turn this page is
-             * watching, and a seeded copy could revive a decision this client just answered.
+             * watching, and a seeded copy could revive a decision this client just answered. Except one: an
+             * entry in ERROR with DECISION_PENDING, which says only "the thread waits for a decision this
+             * page does not hold", so the stored decision is the fresher of the two. It arrives two ways: a
+             * message this page sent was refused (#2721 review F-2), or a turn this page was watching ended
+             * because another turn's decision now holds the thread (#2721 re-review N-1), including the turn
+             * this page resumed by answering. That last case cannot revive the answered decision: the event
+             * names the decision that waits (`waitingDecisionRef`), the error arm records the entry only when
+             * it is NOT the decision the page holds (re-review R-2), and the row history returns holds that
+             * waiting decision, not the answered one.
              */
             const paused = data.executions.filter((row) => row.pendingApproval !== undefined);
             if (paused.length > 0) {
                 setExecutions((prev) => {
                     let next;
                     for (const row of paused) {
-                        if (prev.has(row.executionId) || row.pendingApproval === undefined)
+                        const live = prev.get(row.executionId);
+                        // #2903: an answer refused as stale leaves the decision waiting as it is NOW, which only the stored row says.
+                        const refusedForAnUnheldDecision = live?.status === FlowsActorsExecutionStatus.ERROR
+                            && (live.errorCode === FlowsActors_ExecutionErrorCode.DECISION_PENDING || live.errorCode === FlowsActors_ExecutionErrorCode.DECISION_PRESENTATION_STALE);
+                        if ((live && !refusedForAnUnheldDecision) || row.pendingApproval === undefined)
                             continue;
                         next ??= new Map(prev);
                         next.set(row.executionId, {
@@ -222,15 +271,16 @@ export const FlowsActorsProvider = ({ children }) => {
                     return next ?? prev;
                 });
             }
-            return data.executions;
+            return { executions: data.executions, hasOlder: data.hasOlder === true };
         }
         catch (err) {
             if (errorManagement.isNotFoundError(err)) {
                 logDebug('FlowsActors history surface not available - returning empty history', { systemRef });
-                return [];
+                return { executions: [], hasOlder: false };
             }
-            logDebug('Failed to fetch conversation history', { systemRef, error: err instanceof Error ? err.message : 'unknown' });
-            return [];
+            // A failed read is not an empty history: the host keeps what it last read (#2525 review M4).
+            logger.warn('Failed to fetch conversation history', { systemRef, error: err instanceof Error ? err.message : 'unknown' });
+            return undefined;
         }
     }, [httpClient, appScope?.currentOrganizationId]);
     /**
@@ -242,7 +292,7 @@ export const FlowsActorsProvider = ({ children }) => {
             logDebug('Cannot delete conversation - httpClient not available');
             return;
         }
-        const basePath = `${MAIN_API_BASE_PATH}${MANUAL_CONTROLLER_ROUTES_URLS[ManualControllerRouteKey.FLOWS_ACTORS_HISTORY]}`;
+        const basePath = `${MAIN_API_BASE_PATH}${buildManualControllerRoutePath(ManualControllerRouteKey.FLOWS_ACTORS_HISTORY)}`;
         await httpClient.delete(`${basePath}?executionId=${encodeURIComponent(executionId)}`);
         logDebug('Conversation deleted', { executionId });
     }, [httpClient]);
@@ -290,12 +340,14 @@ export const FlowsActorsProvider = ({ children }) => {
             contextResourceIdentifiers,
             initialInput,
             ...(options?.caseRef ? { caseRef: options.caseRef } : {}),
+            ...(options?.messageId ? { messageId: options.messageId } : {}),
         });
         return executionId;
     }, [isConnected, emit, appScope?.currentOrganizationId]);
     /**
      * Respond to an approval request via WebSocket (fire-and-forget).
-     * Backend confirms via FLOWS_ACTORS_STATUS_UPDATE / FLOWS_ACTORS_ERROR events.
+     * The resumed turn sends no FLOWS_ACTORS_STARTED: it continues the paused turn, streams to the conversation's
+     * owner, and ends on FLOWS_ACTORS_COMPLETED (completed, cancelled) or FLOWS_ACTORS_ERROR.
      */
     const respondToApproval = useCallback((executionId, approvalId, approved, comment, modifiedToolArgs, reasonCode) => {
         const execution = executionsRef.current.get(executionId);
@@ -320,6 +372,8 @@ export const FlowsActorsProvider = ({ children }) => {
              * conversation, and a reviewer answering someone else's decision reaches it.
              */
             ...(execution.pendingApproval?.decisionRef ? { decisionRef: execution.pendingApproval.decisionRef } : {}),
+            // #2903: the presentation this answer was given on. The server refuses an answer naming none, or a stale one.
+            ...(execution.pendingApproval?.presentationId ? { presentationId: execution.pendingApproval.presentationId } : {}),
             /*
              * The arguments the approver AUTHORED (#566), when they edited the proposed call.
              *
@@ -335,6 +389,9 @@ export const FlowsActorsProvider = ({ children }) => {
         updateExecution(executionId, exec => ({
             ...exec,
             status: approved ? FlowsActorsExecutionStatus.RUNNING : exec.status,
+            // The refusal an earlier answer met is answered by this one: a later pause must not inherit its code (#2525).
+            errorCode: undefined,
+            recoverable: undefined,
             pendingApproval: undefined,
             // Kept until the server reacts: a REFUSED modification leaves the pause standing, and this is
             // what the error handler restores — with the arguments the approver submitted (#587).
@@ -343,6 +400,37 @@ export const FlowsActorsProvider = ({ children }) => {
                 : undefined,
         }));
     }, [isConnected, emit, updateExecution]);
+    const answerQuestion = useCallback((executionId, optionRef, values, comment) => {
+        const execution = executionsRef.current.get(executionId);
+        const pending = execution?.pendingApproval;
+        if (!execution || !pending?.question || !pending.decisionRef || !isConnected) {
+            logDebug('Cannot answer a question — no paused question, or the WebSocket is not connected', { executionId });
+            return;
+        }
+        const sendsAnswers = optionRef === AskPersonOptionRef.ANSWER;
+        emit(CoreWebSocketEvent.FLOWS_ACTORS_APPROVAL_RESPONSE, {
+            systemRef: execution.systemRef,
+            executionId,
+            approvalId: pending.approvalId,
+            decisionRef: pending.decisionRef,
+            // #2903: the presentation this answer was given on.
+            ...(pending.presentationId ? { presentationId: pending.presentationId } : {}),
+            // Not read for a question: the answer below is what settles it. Sent because the payload requires a verdict.
+            approved: sendsAnswers,
+            answer: { decisionId: pending.decisionRef, optionRef, values: [...values] },
+            // A note in the person's own words travels with the answer, or with the decline, to the agent.
+            ...(comment ? { comment } : {}),
+        });
+        updateExecution(executionId, exec => ({
+            ...exec,
+            status: FlowsActorsExecutionStatus.RUNNING,
+            errorCode: undefined,
+            recoverable: undefined,
+            pendingApproval: undefined,
+            // Kept until the server reacts: an answer its form refuses leaves the question pending, and this restores it.
+            answeredApproval: exec.pendingApproval ? { approval: exec.pendingApproval } : undefined,
+        }));
+    }, [isConnected, emit, updateExecution]);
     /**
      * Get execution by ID
      */
@@ -355,6 +443,12 @@ export const FlowsActorsProvider = ({ children }) => {
     const getSystem = useCallback((systemRef) => {
         return systems.find(s => s.ref === systemRef);
     }, [systems]);
+    const cancelExecution = useCallback((executionId) => {
+        const execution = executionsRef.current.get(executionId);
+        if (!execution || !isConnected)
+            return;
+        emit(CoreWebSocketEvent.FLOWS_ACTORS_CANCEL, { systemRef: execution.systemRef, executionId });
+    }, [isConnected, emit]);
     const clearExecution = useCallback((executionId) => {
         setExecutions(prev => {
             if (!prev.has(executionId))
@@ -374,10 +468,12 @@ export const FlowsActorsProvider = ({ children }) => {
         hasInitializedRef.current = false;
         setSystems([]);
         setAutonomousAgents([]);
+        setChatAgents([]);
+        setChatConnectionRefs([]);
         setError(null);
         setExecutions(new Map());
     }, [userOrgs]);
-    const requestAutonomousAgents = useCallback(() => {
+    const requestAgentDeclarations = useCallback(() => {
         if (hasInitializedRef.current
             || !appConfig?.runtime?.endPoints?.main_backend_api
             || !httpClient
@@ -450,30 +546,18 @@ export const FlowsActorsProvider = ({ children }) => {
             return;
         }
         const unsubStarted = on(CoreWebSocketEvent.FLOWS_ACTORS_STARTED, (payload) => {
-            logDebug('Execution started', { executionId: payload.executionId, success: payload.success });
-            if (payload.success) {
-                updateExecution(payload.executionId, exec => ({
-                    ...exec,
-                    status: FlowsActorsExecutionStatus.RUNNING,
-                }));
-            }
-            else {
-                updateExecution(payload.executionId, exec => ({
-                    ...exec,
-                    status: FlowsActorsExecutionStatus.ERROR,
-                    messages: appendMessages(exec.messages, {
-                        type: 'text',
-                        content: payload.error ?? 'Execution failed to start',
-                        timestamp: new Date(),
-                    }),
-                }));
-            }
+            logDebug('Execution started', { executionId: payload.executionId });
+            // Only ever a success: a turn that could not start reports on FLOWS_ACTORS_ERROR (#2524).
+            updateExecution(payload.executionId, exec => ({
+                ...exec,
+                status: FlowsActorsExecutionStatus.RUNNING,
+            }));
         });
         const unsubMessage = on(CoreWebSocketEvent.FLOWS_ACTORS_MESSAGE, (payload) => {
             logDebug('Execution message', { executionId: payload.executionId, type: payload.messageType, messageId: payload.messageId, isFinal: payload.isFinal });
             /*
-             * A pause is announced HERE, inside a PROGRESS message's `data` bag — not on
-             * `FLOWS_ACTORS_APPROVAL_REQUEST`, which nothing emits. Parsed rather than key-picked, so
+             * A pause is announced HERE, inside a PROGRESS message's `data` bag — never on a separate
+             * approval-request event, which nothing emitted and #2524 removed. Parsed rather than key-picked, so
              * the browser and the producer share one named contract; a bag that is not an announcement
              * simply fails the parse and the message is stored like any other (#528).
              */
@@ -502,58 +586,16 @@ export const FlowsActorsProvider = ({ children }) => {
                 }, payload.isFinal === true),
             }));
         });
-        /*
-         * UNREACHABLE TODAY, and kept deliberately rather than deleted.
-         *
-         * No code anywhere emits `FLOWS_ACTORS_APPROVAL_REQUEST` — the string occurs once in the whole
-         * tree, in its own enum declaration — so this handler has never run. The live announcement is
-         * parsed in the FLOWS_ACTORS_MESSAGE handler above. Whether the richer payload
-         * (`actionDescription`, `riskLevel`, `requiredRoles`) should be populated by the server or
-         * withdrawn is a decision recorded on #528, not something to settle by deleting the listener:
-         * if it is ever emitted, an approval must still be observable here.
-         *
-         * Note it carries no `decisionRef`, so a decision answered from this path is resolved by the
-         * server from `executionId` + `approvalId`.
-         */
-        const unsubApproval = on(CoreWebSocketEvent.FLOWS_ACTORS_APPROVAL_REQUEST, (payload) => {
-            logDebug('Approval requested', { executionId: payload.executionId, approvalId: payload.approvalId, riskLevel: payload.riskLevel });
-            updateExecution(payload.executionId, exec => ({
-                ...exec,
-                status: FlowsActorsExecutionStatus.AWAITING_APPROVAL,
-                pendingApproval: {
-                    approvalId: payload.approvalId,
-                    actionDescription: payload.actionDescription,
-                    riskLevel: payload.riskLevel,
-                    expiresAt: payload.expiresAt instanceof Date ? payload.expiresAt : (payload.expiresAt ? new Date(payload.expiresAt) : undefined),
-                    requiredRoles: payload.requiredRoles,
-                },
-            }));
-        });
-        const unsubStatus = on(CoreWebSocketEvent.FLOWS_ACTORS_STATUS_UPDATE, (payload) => {
-            logDebug('Status update', { executionId: payload.executionId, status: payload.status, progress: payload.progress });
-            updateExecution(payload.executionId, exec => ({
-                ...exec,
-                status: FlowsActorsExecutionStatus.RUNNING,
-                progress: payload.progress,
-                currentStep: payload.currentStep ?? payload.status,
-            }));
-        });
         const unsubCompleted = on(CoreWebSocketEvent.FLOWS_ACTORS_COMPLETED, (payload) => {
-            logDebug('Execution completed', { executionId: payload.executionId, success: payload.success, duration: payload.duration });
+            logDebug('Execution completed', { executionId: payload.executionId, status: payload.status, duration: payload.duration });
+            // The server's run status, read through the one mapping (#2524): COMPLETED, or CANCELLED when the person
+            // stopped it. A failure never arrives here — it reports on FLOWS_ACTORS_ERROR with its reason.
             updateExecution(payload.executionId, exec => ({
                 ...exec,
-                status: payload.success ? FlowsActorsExecutionStatus.COMPLETED : FlowsActorsExecutionStatus.ERROR,
-                progress: payload.success ? 100 : exec.progress,
+                status: turnStatusFromServer(payload.status),
                 pendingApproval: undefined,
-                result: payload.result,
                 duration: payload.duration,
-                messages: payload.success
-                    ? exec.messages
-                    : appendMessages(exec.messages, {
-                        type: 'text',
-                        content: 'Execution completed with errors',
-                        timestamp: new Date(),
-                    }),
+                ...(payload.usage ? { usage: payload.usage } : {}),
             }));
         });
         const unsubError = on(CoreWebSocketEvent.FLOWS_ACTORS_ERROR, (payload) => {
@@ -608,8 +650,10 @@ export const FlowsActorsProvider = ({ children }) => {
                 /*
                  * A decision refused by the application's consent requirement is not a failed turn either (#534). The
                  * server checks the requirement BEFORE it releases the pause, so the approval still stands and can be
-                 * answered once the person has recorded their consent: it goes back on screen, and the reason joins the
-                 * conversation rather than masquerading as an argument-edit error.
+                 * answered once the person has recorded their consent: it goes back on screen with its `errorCode`, which
+                 * the conversation thread words (`consentRequired`) above the decision rather than as an argument-edit error.
+                 * The server's English `errorMessage` is not appended to the turn: it is no reply, and no translator reaches
+                 * it (#2525).
                  */
                 if (payload.recoverable
                     && payload.errorCode === FlowsActors_ExecutionErrorCode.SERVICE_CONSENT_REQUIRED
@@ -628,13 +672,25 @@ export const FlowsActorsProvider = ({ children }) => {
                             reasonCodeRefused: undefined,
                         },
                         answeredApproval: undefined,
-                        messages: appendMessages(exec.messages, {
-                            type: 'text',
-                            content: payload.errorMessage,
-                            timestamp: new Date(),
-                        }),
                     };
                 }
+                /*
+                 * DECISION_PENDING is not this tab's failure either (#2721 review F-2). It arrives for a message refused
+                 * because the thread waits for a decision, and as the END of a turn whose own end was not written because
+                 * another turn's decision now holds the thread (#2721 re-review N-1). It reaches every tab of the owner's
+                 * room, so a tab that holds THAT decision — asked, or answered and awaiting the server — keeps it exactly as
+                 * it is: the decision is the thread's state, and clearing it here took the card away from the one tab that
+                 * could act on it. Any other tab records it as ERROR, worded by `decisionPending`, and its history reload
+                 * restores the waiting decision over it (`fetchConversationHistory`). That includes a tab holding a
+                 * DIFFERENT decision (#2721 re-review R-2): the tab that answered D1 while another door's turn paused the
+                 * thread on D2, or a second tab still showing the settled D1. Kept, either stayed RUNNING or on a dead card,
+                 * and history could not help, since it never replaces an entry it does not see as refused.
+                 */
+                const heldDecisionRef = exec.pendingApproval?.decisionRef ?? exec.answeredApproval?.approval.decisionRef;
+                if (payload.errorCode === FlowsActors_ExecutionErrorCode.DECISION_PENDING
+                    && heldDecisionRef !== undefined && heldDecisionRef === payload.waitingDecisionRef) {
+                    return exec;
+                }
                 return {
                     ...exec,
                     status: FlowsActorsExecutionStatus.ERROR,
@@ -642,19 +698,12 @@ export const FlowsActorsProvider = ({ children }) => {
                     errorCode: payload.errorCode,
                     pendingApproval: undefined,
                     answeredApproval: undefined,
-                    messages: appendMessages(exec.messages, {
-                        type: 'text',
-                        content: payload.errorMessage,
-                        timestamp: new Date(),
-                    }),
                 };
             });
         });
         return () => {
             unsubStarted();
             unsubMessage();
-            unsubApproval();
-            unsubStatus();
             unsubCompleted();
             unsubError();
         };
@@ -662,19 +711,23 @@ export const FlowsActorsProvider = ({ children }) => {
     const contextValue = useMemo(() => ({
         systems,
         autonomousAgents,
-        requestAutonomousAgents,
+        chatAgents,
+        chatConnectionRefs,
+        requestAgentDeclarations,
         isLoading,
         error,
         executions,
         startExecution,
         respondToApproval,
+        answerQuestion,
+        cancelExecution,
         clearExecution,
         getExecution,
         getSystem,
         refreshSystems,
         fetchConversationHistory,
         deleteConversation,
-    }), [systems, autonomousAgents, requestAutonomousAgents, isLoading, error, executions, startExecution, respondToApproval, clearExecution, getExecution, getSystem, refreshSystems, fetchConversationHistory, deleteConversation]);
+    }), [systems, autonomousAgents, chatAgents, chatConnectionRefs, requestAgentDeclarations, isLoading, error, executions, startExecution, respondToApproval, answerQuestion, cancelExecution, clearExecution, getExecution, getSystem, refreshSystems, fetchConversationHistory, deleteConversation]);
     return (_jsx(FlowsActorsContext.Provider, { value: contextValue, children: children }));
 };
 //# sourceMappingURL=FlowsActorsContext.js.map