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

package/dist/esm/components/flows-actors/approval.js

@@ -1,11 +1,11 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 import * as React from "react";
-import { AI_ApprovalRequest, AI_ApprovalQueue, AI_DecisionRequest, AI_HumanInputRequest, } from "../../components/ai-elements/decision/approval.js";
-import { AGENT_WORK_REASON_CODE_VOCABULARY, ApplicationConfigVocabulary, HumanDecision_Act, HumanDecision_ActOutcomeKind, HumanDecision_Plane, HumanDecision_RefusalReason, HumanDecision_RouteKind, HumanDecision_ToolApprovalOption, ReviewDeadlineKind, ServiceProviderExpertApprovalOption, } from "@wildo-ai/saas-models";
-import { usePendingDecisions } from "../../core/flows-actors/usePendingDecisions.js";
+import { AI_ApprovalRequest, AI_ApprovalQueue, } from "../../components/ai-elements/decision/approval.js";
+import { AGENT_WORK_REASON_CODE_VOCABULARY, ApplicationConfigVocabulary, FlowsActorsToolLabelSlot, flowsActorsToolLabelKey, flowsActorsToolLabelScope, HumanDecision_Act, HumanDecision_ActOutcomeKind, HumanDecision_Plane, HumanDecision_RefusalReason, HumanDecision_RequesterKind, HumanDecision_RouteKind, HumanDecisionPhraseKind, HUMAN_DECISION_VERDICT_OPTIONS_BY_PLANE, ReviewDeadlineKind, describeHumanDecisionCard, humanDecisionAsksItsOwnQuestion, humanDecisionOptionPhrase, } from "@wildo-ai/saas-models";
+import { PendingDecisionsReadState, usePendingDecisions } from "../../core/flows-actors/usePendingDecisions.js";
 import { useFlowsActors } from "../../core/flows-actors/useFlowsActors.js";
-import { FrontendComponentType, LabellingTypes } from "@wildo-ai/presets-components-models";
+import { FrontendComponentType, LabellingTypes, ResourceOperationTextSlot } from "@wildo-ai/presets-components-models";
 import { useI18n } from "../../core/i18n/useI18n.js";
 import { describeApprovalModificationRefusal } from "../../components/flows-actors/approval-modification-refusal.utils.js";
 //===============================================================
@@ -16,9 +16,12 @@ import { describeApprovalModificationRefusal } from "../../components/flows-acto
 //  - FlowsActors_ApprovalRequest answers a decision IN its conversation, over the socket the turn runs on.
 //  - FlowsActors_ApprovalQueue is the person's INBOX: every decision they may act on, read from the server
 //    (#1594 D6), answered and moved over REST.
-//  - FlowsActors_DecisionRequest / FlowsActors_HumanInputRequest answer in the one answer shape,
-//    `HumanDecision_Answer` (#1594 D12). They used to send a comment prefixed `[DECISION]` / `[INPUT]` as a
-//    tool DENIAL, which nothing on the server read: the choice was dropped and the call refused.
+//
+//  A decision with options of its OWN — an actor system's question, with its fields — is answered in the inbox too
+//  (#2526): its card carries the request, and the inbox draws its options in place of Approve and Deny and sends the
+//  chosen one, with the field values, in the one answer shape. Two standalone wrappers that answered such a decision
+//  outside any list (FlowsActors_DecisionRequest, FlowsActors_HumanInputRequest) had no consumer and were folded into
+//  this one path; since #2539 an application raises those decisions on its own actor plane.
 //===============================================================
 /**
  * What an act came to, in the approval's own labels. Total over the outcome vocabulary, so an outcome added
@@ -28,13 +31,19 @@ function noticeOfOutcome(outcome, t) {
     const byKind = {
         [HumanDecision_ActOutcomeKind.APPLIED]: undefined,
         // An admitted person's refused clock act names why (#1628); anything else stays one undisclosing notice.
-        [HumanDecision_ActOutcomeKind.NOT_ACTIONABLE]: outcome.reason === HumanDecision_RefusalReason.CLOCK_ALREADY_PAUSED ? t("noticeClockAlreadyPaused")
-            : outcome.reason === HumanDecision_RefusalReason.CLOCK_NOT_PAUSED ? t("noticeClockNotPaused")
-                : outcome.reason === HumanDecision_RefusalReason.PAUSE_STATE_NOT_DECLARED ? t("noticePauseStateNotDeclared")
-                    : t("noticeNotActionable"),
+        // #2903: the request changed since it was read; the list just re-read shows it as it is now.
+        [HumanDecision_ActOutcomeKind.NOT_ACTIONABLE]: outcome.reason === HumanDecision_RefusalReason.PRESENTATION_STALE ? t("noticePresentationStale")
+            : outcome.reason === HumanDecision_RefusalReason.CLOCK_ALREADY_PAUSED ? t("noticeClockAlreadyPaused")
+                : outcome.reason === HumanDecision_RefusalReason.CLOCK_NOT_PAUSED ? t("noticeClockNotPaused")
+                    : outcome.reason === HumanDecision_RefusalReason.PAUSE_STATE_NOT_DECLARED ? t("noticePauseStateNotDeclared")
+                        : t("noticeNotActionable"),
         [HumanDecision_ActOutcomeKind.LAPSED]: t("noticeLapsed"),
         [HumanDecision_ActOutcomeKind.REQUESTER_AUTHORITY_LAPSED]: t("noticeRequesterAuthorityLapsed"),
-        [HumanDecision_ActOutcomeKind.MODIFICATION_REJECTED]: t("noticeModificationRejected"),
+        // An edit pointing the call at a record the answerer may not reach says so (#2734): the inbox gets no error payload,
+        // only the outcome, so its reason is what tells a representative to put the arguments back.
+        [HumanDecision_ActOutcomeKind.MODIFICATION_REJECTED]: outcome.reason === HumanDecision_RefusalReason.EDITED_CALL_NOT_REACHABLE
+            ? t("noticeEditedCallNotReachable")
+            : t("noticeModificationRejected"),
         [HumanDecision_ActOutcomeKind.REASON_CODE_REJECTED]: t("noticeReasonCodeRejected"),
         [HumanDecision_ActOutcomeKind.CONSENT_REQUIRED]: t("noticeConsentRequired"),
         [HumanDecision_ActOutcomeKind.TARGET_REFUSED]: outcome.reason === HumanDecision_RefusalReason.NO_TARGET ? t("noticeNoEscalationTarget") : t("noticeTargetRefused"),
@@ -42,6 +51,14 @@ function noticeOfOutcome(outcome, t) {
     };
     return byKind[outcome.kind];
 }
+/**
+ * The presentation a card was read on (#2903), echoed on its answer: the server rebuilds the decision's presentation and
+ * refuses an answer naming none, or one that is no longer current, so what is sealed is what this reviewer read.
+ */
+function presentationEchoOf(decisions, decisionRef) {
+    const presentationId = decisions.find((card) => card.decisionRef === decisionRef)?.presentationId;
+    return presentationId ? { presentationId } : {};
+}
 /**
  * The reason picker's options (#1921): each declared code with its word from `system_enums.AgentWorkReasonCode.<code>`.
  *
@@ -64,10 +81,14 @@ export function describeReasonCodeOptions(reasonCodes, tSystemEnum) {
 export function describePauseState(pauseState, tSystemEnum) {
     return tSystemEnum(ApplicationConfigVocabulary.HUMAN_DECISION_PAUSE_STATE, pauseState);
 }
-/** The label namespaces the approval wrappers read beyond their own component: the reason codes' (#1921) and pause states' (#1864) words. */
-const APPROVAL_LABEL_NAMESPACES = [LabellingTypes.SYSTEM_ENUMS];
+/**
+ * The label namespaces the approval wrappers read beyond their own component: the reason codes' (#1921) and pause
+ * states' (#1864) words, and the roles' (#2526 review F3) — the holder line names a role, and `roles` is not an eager
+ * section, so without it every ROLE card named the role by its key.
+ */
+const APPROVAL_LABEL_NAMESPACES = [LabellingTypes.SYSTEM_ENUMS, LabellingTypes.ROLES];
 export function FlowsActors_ApprovalRequest({ executionId, ...props }) {
-    const { executions, respondToApproval } = useFlowsActors();
+    const { executions, respondToApproval, answerQuestion } = useFlowsActors();
     const { tComponent, tSystemEnum } = useI18n({ component: FrontendComponentType.LOW_LEVEL_AI_APPROVAL, keys: APPROVAL_LABEL_NAMESPACES });
     const [processingId, setProcessingId] = React.useState(null);
     const execution = executions.get(executionId);
@@ -87,6 +108,12 @@ export function FlowsActors_ApprovalRequest({ executionId, ...props }) {
         else
             respondToApproval(executionId, id, false, comment);
     }, [executionId, respondToApproval]);
+    // #2720: the agent's QUESTION is answered with the person's values, or declined — never approved.
+    const handleAnswer = React.useCallback((id, optionRef, values, comment) => {
+        setProcessingId(id);
+        answerQuestion(executionId, optionRef, values, comment);
+    }, [executionId, answerQuestion]);
+    const approvalWord = React.useCallback((labelRef) => tComponent(FrontendComponentType.LOW_LEVEL_AI_APPROVAL, labelRef), [tComponent]);
     // A decision answered and then handed BACK arrives as a new pending approval — a refused edit (#587), or a
     // decision the consent requirement refused (#534). Whatever this component recorded as in flight has been
     // answered, so the decision is answerable again instead of staying disabled until the view remounts.
@@ -95,7 +122,7 @@ export function FlowsActors_ApprovalRequest({ executionId, ...props }) {
     }, [pendingApproval]);
     if (!execution || !pendingApproval)
         return null;
-    const { approvalId, actionDescription, riskLevel, expiresAt, requiredRoles, toolName, toolArgs, toolInputSchema, modificationRefusal, rejectedToolArgs, routeKind, reasonCodes, reasonCodeRefused, } = pendingApproval;
+    const { approvalId, actionDescription, riskLevel, expiresAt, toolName, toolArgs, toolInputSchema, modificationRefusal, rejectedToolArgs, routeKind, reasonCodes, reasonCodeRefused, question, } = pendingApproval;
     /*
      * Only an OWNER-routed decision is answered here. One routed to an assignee or a role is answered by a
      * reviewer from their inbox, and the person whose conversation this is may not answer it (separation of
@@ -105,7 +132,11 @@ export function FlowsActors_ApprovalRequest({ executionId, ...props }) {
      * and escalated nothing; an OWNER route cannot be escalated at all, and a reviewer escalates from the inbox.
      */
     const answerable = routeKind === undefined || routeKind === HumanDecision_RouteKind.OWNER;
-    return (_jsx(AI_ApprovalRequest, { approvalId: approvalId, actionDescription: actionDescription, riskLevel: riskLevel, executionId: executionId, systemRef: execution.systemRef, expiresAt: expiresAt, requiredRoles: requiredRoles, answerable: answerable, 
+    if (question) {
+        // #2720: the agent asks its person. Its questions, through their form, in place of the call and its arguments.
+        return (_jsx(AI_ApprovalRequest, { approvalId: approvalId, actionDescription: question.title, executionId: executionId, systemRef: execution.systemRef, expiresAt: expiresAt, answerable: answerable, question: humanDecisionQuestionOf(question, approvalWord), onAnswer: handleAnswer, isProcessing: processingId === approvalId, ...props }));
+    }
+    return (_jsx(AI_ApprovalRequest, { approvalId: approvalId, actionDescription: actionDescription, riskLevel: riskLevel, executionId: executionId, systemRef: execution.systemRef, expiresAt: expiresAt, answerable: answerable, 
         // A refused reason code leaves the approval standing (#1921): it is back on screen, and says why in its own labels.
         actionNotice: !answerable
             ? tComponent(FrontendComponentType.LOW_LEVEL_AI_APPROVAL, "awaitingReview")
@@ -121,7 +152,9 @@ export function FlowsActors_ApprovalRequest({ executionId, ...props }) {
          * records that the decider changed them. So the editor is offered here, where the decision is
          * answered — never where it is only shown.
          */
-        allowArgumentModification: answerable, toolName: toolName, executionContext: toolArgs, argumentsSchema: toolInputSchema, 
+        allowArgumentModification: answerable, toolName: toolName, executionContext: toolArgs, 
+        // #2903: the arguments as the server presented them, rendered verbatim: what the person reads is what is sealed.
+        presentedArguments: pendingApproval.presentation?.fields, argumentsSchema: toolInputSchema, 
         // The refusal in the approval's own labels, naming the tool and the offending arguments (#1186).
         argumentModificationError: modificationRefusal
             ? describeApprovalModificationRefusal(modificationRefusal, (labelRef, params) => tComponent(FrontendComponentType.LOW_LEVEL_AI_APPROVAL, labelRef, params))
@@ -137,38 +170,137 @@ export function FlowsActors_ApprovalRequest({ executionId, ...props }) {
 //  The person's inbox: every decision they may act on, from the server.
 //===============================================================
 /**
- * What one inbox card SAYS, per plane. A tool approval names the tool (an identifier, travelling as a parameter)
- * and shows its proposed arguments; an expert admission (#1612) says which firm asks to admit which person, in the
- * approval's own words, and shows no argument table — there is no tool, and the client's own data is not on the card.
+ * Who holds a listed decision now, in the approval's own words (#2526). Total over the route vocabulary.
+ *
+ * The inbox lists only decisions the viewer may ANSWER (#1594 I3), so an ASSIGNEE card is always assigned to the
+ * viewer: "you claimed it" when they took it from a role, "assigned to you" when a resolver, a reassignment or an
+ * escalation put it there. A decision a colleague claimed is not in the viewer's list at all. A ROLE card names the role
+ * in the roles tree's words, never its key. Exported for the pin that holds it.
  */
-function describeInboxCard(card, t, roleLabel = (roleKey) => roleKey) {
-    const admission = card.plane === HumanDecision_Plane.SERVICE_PROVIDER_EXPERT_ADMISSION ? card.serviceProviderExpertAdmission : undefined;
-    if (admission) {
-        // Names and email are DATA the firm and its expert supplied; the firm's id and the expert's id stand in when unreadable.
-        // The role and the scope are what the approver is granting, so the line names both (#1612 review L3). The role is
-        // worded by the roles label tree (`tRole`), never shown as its identifier; the scope by its own label.
-        const unitCount = admission.organizationUnitIds?.length ?? 0;
-        return {
-            actionDescription: t("inboxExpertAdmission", {
-                firm: admission.providerOrganizationName ?? admission.providerOrganizationId,
-                expert: admission.expertName ?? admission.expertEmail ?? admission.expertUserId,
-                email: admission.expertEmail ?? admission.expertUserId,
-                role: roleLabel(admission.role),
-                scope: unitCount > 0 ? t("inboxExpertAdmissionScopeUnits", { count: String(unitCount) }) : t("inboxExpertAdmissionScopeOrganization"),
-            }),
-        };
+export function describeDecisionHolder(route, t, roleLabel, formatDateTime) {
+    const byKind = {
+        [HumanDecision_RouteKind.OWNER]: () => t("holderOwner"),
+        [HumanDecision_RouteKind.ASSIGNEE]: () => (route.claimedAt ? t("holderClaimedByYou", { when: formatDateTime(route.claimedAt) }) : t("holderAssignedToYou")),
+        // A ROLE route always names its role (a gate without one stops the application at startup); none means no line.
+        [HumanDecision_RouteKind.ROLE]: () => (route.eligibleRole ? t("holderRole", { role: roleLabel(route.eligibleRole) }) : undefined),
+    };
+    return byKind[route.kind]();
+}
+/**
+ * Who raised a listed decision, when that is worth saying (#2526). Total over the requester vocabulary.
+ *
+ * A person's own request needs no line: the holder line already says whose conversation it is when it is the viewer's,
+ * and naming another person by id would show an identifier (naming people is #1852). What a reviewer must not miss is
+ * a request with NO person behind it — an autonomous agent, raised by a machine — or one raised through an application a
+ * person connected, which resumes only while that delegation holds.
+ */
+const REQUESTER_LABEL = {
+    [HumanDecision_RequesterKind.USER]: undefined,
+    [HumanDecision_RequesterKind.MACHINE]: "requesterAutonomousAgent",
+    [HumanDecision_RequesterKind.DELEGATED_CLIENT]: "requesterConnectedApplication",
+};
+export function describeDecisionRequester(requesterKind, t) {
+    const labelRef = REQUESTER_LABEL[requesterKind];
+    return labelRef ? t(labelRef) : undefined;
+}
+/**
+ * A phrase of the shared wording (`describeHumanDecisionCard`), in this inbox's words: an approval label through `t`, a
+ * role through the roles label tree, a tool through its title in the tool label tree (#2551), a resource operation
+ * through its title in the resource label tree (#2288), a host's own words as written.
+ */
+function wordHumanDecisionPhrase(phrase, t, roleLabel, toolLabel, 
+// With no wording function, the operation's label key: a missing label looks missing.
+operationLabel = (resourceType, operationIdentifier) => `${LabellingTypes.RESOURCES}.${resourceType}.operations.${operationIdentifier}.${ResourceOperationTextSlot.TITLE}`) {
+    switch (phrase.kind) {
+        case HumanDecisionPhraseKind.LABEL:
+            return phrase.params
+                ? t(phrase.labelRef, Object.fromEntries(Object.entries(phrase.params).map(([key, value]) => [key, typeof value === 'object' ? wordHumanDecisionPhrase(value, t, roleLabel, toolLabel, operationLabel) : String(value)])))
+                : t(phrase.labelRef);
+        case HumanDecisionPhraseKind.ROLE:
+            return roleLabel(phrase.roleKey);
+        case HumanDecisionPhraseKind.TOOL:
+            return toolLabel(phrase.toolName);
+        case HumanDecisionPhraseKind.RESOURCE_OPERATION:
+            return operationLabel(phrase.resourceType, phrase.operationIdentifier);
+        case HumanDecisionPhraseKind.TEXT:
+            return phrase.text;
+        default: {
+            const unhandled = phrase;
+            return unhandled;
+        }
     }
+}
+/**
+ * What one inbox card SAYS, from the wording every decision surface shares (`describeHumanDecisionCard`): the same
+ * line a chat card posted for this decision carries. A tool approval also shows the tool and its proposed arguments;
+ * a representative admission (#1612) and a card asking its own question show none — there is no tool call.
+ */
+function describeInboxCard(card, t, roleLabel = (roleKey) => roleKey, toolLabel = (toolName) => toolName, operationLabel) {
+    // #2903: the values as the server presented them, rendered verbatim, so what the reviewer reads is what is sealed.
+    const presented = card.presentation ? { presentedArguments: card.presentation.fields } : {};
+    const actionDescription = wordHumanDecisionPhrase(card.presentation?.title ?? describeHumanDecisionCard(card).title, t, roleLabel, toolLabel, operationLabel);
+    // #2288: an operation approval shows the values the requester sent, as a tool approval shows its arguments.
+    if (card.plane === HumanDecision_Plane.OPERATION_APPROVAL && card.operationApproval) {
+        return { actionDescription, executionContext: card.operationApproval.requestedValues, ...presented };
+    }
+    const isRepresentativeAdmission = card.plane === HumanDecision_Plane.REPRESENTATIVE_ADMISSION && !!card.representativeAdmission;
+    if (isRepresentativeAdmission || humanDecisionAsksItsOwnQuestion(card))
+        return { actionDescription };
+    return { actionDescription, toolName: card.toolName, executionContext: card.toolArgs, ...presented };
+}
+/**
+ * A request as the card asks it: its reason, its options and its fields with their form. An option the engine wrote is
+ * worded by the approval label it names (`labelRef`, #2754), through `word` in this reader's language; any other option
+ * carries the words its host wrote. The decision is the shared wording's (`humanDecisionOptionPhrase`), so the chat card,
+ * the inbox and a notice cannot word one option two ways.
+ */
+export function humanDecisionQuestionOf(request, word) {
     return {
-        // The words are the approval's own label; the tool name is an identifier and travels as a parameter.
-        actionDescription: t("inboxToolCall", { toolName: card.toolName }),
-        toolName: card.toolName,
-        executionContext: card.toolArgs,
+        description: request.description,
+        options: request.options.map((option) => ({
+            ref: option.ref,
+            // An option phrase is a label or text: no role and no tool to word, so both pass through.
+            label: wordHumanDecisionPhrase(humanDecisionOptionPhrase(option), word, (roleKey) => roleKey, (toolName) => toolName),
+            intent: option.intent,
+            ...(option.description ? { description: option.description } : {}),
+        })),
+        fields: request.fields,
+        ...(request.form ? { form: request.form } : {}),
     };
 }
+/**
+ * A card's own question, when it asks one (#2526): the request it carries, on a plane whose options are not the inbox's
+ * Approve and Deny — or, on a plane that has those, a request that asks FIELDS, which only an agent's question to its
+ * person does (#2720). `undefined` for a request the inbox words itself.
+ */
+export function decisionQuestionOf(card, word) {
+    if (!card.request)
+        return undefined;
+    if (!humanDecisionAsksItsOwnQuestion(card))
+        return undefined;
+    // An option is worded by the label it names, on any plane (#2754): an agent's question and a flow's person step name
+    // theirs. A host that named its own options keeps its words, whatever refs it chose (#2720 review L6).
+    return humanDecisionQuestionOf(card.request, word);
+}
 export function FlowsActors_ApprovalQueue(props) {
-    const { decisions, act, candidates } = usePendingDecisions();
-    const { tComponent, tRole, tSystemEnum, formatDateTime } = useI18n({ component: FrontendComponentType.LOW_LEVEL_AI_APPROVAL, keys: APPROVAL_LABEL_NAMESPACES });
+    const { decisions, readState, refresh, act, candidates } = usePendingDecisions();
+    // The words of every tool a listed decision would run (#2551), loaded with the inbox's own.
+    const toolNames = React.useMemo(() => [...new Set(decisions.map((card) => card.toolName).filter((name) => !!name))].sort(), [decisions]);
+    // #2288: the resources whose held operations are listed, so each operation is named by its title.
+    const operationResources = React.useMemo(() => [...new Set(decisions.map((card) => card.operationApproval?.resourceType).filter((type) => !!type))].sort(), [decisions]);
+    const labelKeys = React.useMemo(() => [...APPROVAL_LABEL_NAMESPACES, ...toolNames.map(flowsActorsToolLabelScope), ...operationResources.map((type) => `${LabellingTypes.RESOURCES}.${type}`)], [toolNames, operationResources]);
+    const { t: tKey, tComponent, tRole, tSystemEnum, tResourceOperation, formatDateTime } = useI18n({ component: FrontendComponentType.LOW_LEVEL_AI_APPROVAL, keys: labelKeys });
     const t = React.useCallback((labelRef, params) => tComponent(FrontendComponentType.LOW_LEVEL_AI_APPROVAL, labelRef, params), [tComponent]);
+    // A role is worded by the roles label tree, never shown as its identifier.
+    const roleLabel = React.useCallback((roleKey) => (tRole ? tRole(roleKey, 'label') : roleKey), [tRole]);
+    // A tool by its title, as the conversation names the same call; a tool with no words yet by its name.
+    const toolLabel = React.useCallback((toolName) => {
+        const key = flowsActorsToolLabelKey(toolName, FlowsActorsToolLabelSlot.TITLE);
+        const resolved = tKey(key);
+        return resolved === key || resolved.length === 0 ? toolName : resolved;
+    }, [tKey]);
+    // An operation by its title, as the application names it everywhere; with no title generated, its key (missing looks missing).
+    const operationLabel = React.useCallback((resourceType, operationIdentifier) => tResourceOperation(resourceType, operationIdentifier, ResourceOperationTextSlot.TITLE), [tResourceOperation]);
     // Keyed by decisionRef: a decision is in flight from the act until its outcome returns.
     const [processing, setProcessing] = React.useState(() => new Set());
     const [notices, setNotices] = React.useState(() => new Map());
@@ -203,7 +335,14 @@ export function FlowsActors_ApprovalQueue(props) {
         approvalId: card.decisionRef,
         executionId: card.executionId,
         systemRef: card.systemRef,
-        ...describeInboxCard(card, t, (roleKey) => (tRole ? tRole(roleKey, 'label') : roleKey)),
+        // #2526: the assistant by its own name, never its identifier; the risk the call's GATE declares, absent when none.
+        systemName: card.systemDisplayName,
+        riskLevel: card.riskLevel,
+        // #2526: a decision asking its own question is answered by its own options.
+        question: decisionQuestionOf(card, t),
+        holderNotice: describeDecisionHolder(card.route, t, roleLabel, formatDateTime),
+        requesterNotice: describeDecisionRequester(card.requesterKind, t),
+        ...describeInboxCard(card, t, roleLabel, toolLabel, operationLabel),
         expiresAt: card.expiresAt ? new Date(card.expiresAt) : undefined,
         createdAt: new Date(card.requestedAt),
         // Only the acts the server says this person may perform — computed with the rule every act is checked by.
@@ -226,29 +365,35 @@ export function FlowsActors_ApprovalQueue(props) {
         clockPausedNotice: card.clockPause ? t("clockPausedIn", { pauseState: describePauseState(card.clockPause.pauseStateRef, tSystemEnum) }) : undefined,
         // #1921 — the reviewer may give a reason from the application's vocabulary when correcting the agent, and may
         // CORRECT it by editing the call: the act request carries `modifiedToolArgs`, which the server re-validates against
-        // the tool's own schema. Only on a tool approval — an expert admission has no call to edit and no agent to correct.
+        // the tool's own schema. Only on a tool approval — a representative admission has no call to edit and no agent to correct.
         reasonCodeOptions: describeReasonCodeOptions(card.reasonCodes, tSystemEnum),
         allowArgumentModification: card.plane === HumanDecision_Plane.CONVERSATIONAL,
         argumentsSchema: card.toolInputSchema,
-    })), [decisions, reassignCandidates, notices, t, tRole, tSystemEnum, formatDateTime]);
+    })), [decisions, reassignCandidates, notices, t, roleLabel, toolLabel, operationLabel, tSystemEnum, formatDateTime]);
     /**
      * An answer in the one answer shape: the option chosen, and no values. Which option refs "approve" and "deny" mean
-     * depends on the decision's plane — a tool approval's, or an expert admission's (#1612) — so the card decides.
+     * depends on the decision's plane — a tool approval's, or a representative admission's (#1612) — so the card decides.
      */
     const answer = React.useCallback((decisionRef, approve, comment, modifiedToolArgs, reasonCode) => {
         const plane = decisions.find((card) => card.decisionRef === decisionRef)?.plane;
-        const optionRef = plane === HumanDecision_Plane.SERVICE_PROVIDER_EXPERT_ADMISSION
-            ? (approve ? ServiceProviderExpertApprovalOption.APPROVE : ServiceProviderExpertApprovalOption.REJECT)
-            : (approve ? HumanDecision_ToolApprovalOption.APPROVE : HumanDecision_ToolApprovalOption.DENY);
+        const options = plane ? HUMAN_DECISION_VERDICT_OPTIONS_BY_PLANE[plane] : undefined;
+        if (!options) {
+            // A plane whose options this inbox does not offer: say it cannot be answered here, and send nothing.
+            setNotices((previous) => new Map(previous).set(decisionRef, t("noticeNotActionable")));
+            return;
+        }
+        const optionRef = approve ? options.approve : options.deny;
         void run(decisionRef, HumanDecision_Act.ANSWER, {
             answer: { decisionId: decisionRef, optionRef, values: [] },
+            // #2903: the presentation the reviewer read; the server refuses an answer naming none, or one no longer current.
+            ...presentationEchoOf(decisions, decisionRef),
             ...(comment ? { reason: comment } : {}),
             // Only when the reviewer edited the call: an absent field means "run it as proposed" (#566).
             ...(modifiedToolArgs ? { modifiedToolArgs } : {}),
             // Why the reviewer corrected the agent (#1921); refused with REASON_CODE_REJECTED unless the application declares it.
             ...(reasonCode ? { reasonCode } : {}),
         });
-    }, [run, decisions]);
+    }, [run, decisions, t]);
     const handleReassignOpen = React.useCallback((decisionRef) => {
         setReassignCandidates((previous) => {
             const next = new Map(previous);
@@ -261,24 +406,17 @@ export function FlowsActors_ApprovalQueue(props) {
         people.map((person) => ({ value: person.userId, label: person.email ?? person.userId })))))
             .catch(() => setReassignCandidates((previous) => new Map(previous).set(decisionRef, [])));
     }, [candidates]);
-    return (_jsx(AI_ApprovalQueue, { items: items, onApprove: (decisionRef, comment, modifiedToolArgs, reasonCode) => answer(decisionRef, true, comment, modifiedToolArgs, reasonCode), onDeny: (decisionRef, comment, reasonCode) => answer(decisionRef, false, comment, undefined, reasonCode), onEscalate: (decisionRef, comment) => void run(decisionRef, HumanDecision_Act.ESCALATE, comment ? { reason: comment } : {}), onClaim: (decisionRef) => void run(decisionRef, HumanDecision_Act.CLAIM, {}), onUnclaim: (decisionRef) => void run(decisionRef, HumanDecision_Act.UNCLAIM, {}), onReassignOpen: handleReassignOpen, onReassign: (decisionRef, targetUserId, comment) => void run(decisionRef, HumanDecision_Act.REASSIGN, { targetUserId, ...(comment ? { reason: comment } : {}) }), onPauseClock: (decisionRef, pauseStateRef) => void run(decisionRef, HumanDecision_Act.PAUSE_CLOCK, { pauseStateRef }), onResumeClock: (decisionRef) => void run(decisionRef, HumanDecision_Act.RESUME_CLOCK, {}), processingIds: processing, ...props }));
-}
-export function FlowsActors_DecisionRequest({ onOutcome, ...props }) {
-    const { act } = usePendingDecisions({ list: false });
-    const { tComponent } = useI18n({ component: FrontendComponentType.LOW_LEVEL_AI_APPROVAL });
-    const handleSelect = React.useCallback((decisionId, optionId) => {
-        void act(decisionId, HumanDecision_Act.ANSWER, { answer: { decisionId, optionRef: optionId, values: [] } })
-            .then((outcome) => onOutcome?.(noticeOfOutcome(outcome, (ref) => tComponent(FrontendComponentType.LOW_LEVEL_AI_APPROVAL, ref))));
-    }, [act, onOutcome, tComponent]);
-    return _jsx(AI_DecisionRequest, { ...props, onSelect: handleSelect });
-}
-export function FlowsActors_HumanInputRequest({ optionRef, fieldRef, onOutcome, ...props }) {
-    const { act } = usePendingDecisions({ list: false });
-    const { tComponent } = useI18n({ component: FrontendComponentType.LOW_LEVEL_AI_APPROVAL });
-    const handleSubmit = React.useCallback((requestId, value) => {
-        void act(requestId, HumanDecision_Act.ANSWER, { answer: { decisionId: requestId, optionRef, values: [{ ref: fieldRef, value }] } })
-            .then((outcome) => onOutcome?.(noticeOfOutcome(outcome, (ref) => tComponent(FrontendComponentType.LOW_LEVEL_AI_APPROVAL, ref))));
-    }, [act, optionRef, fieldRef, onOutcome, tComponent]);
-    return _jsx(AI_HumanInputRequest, { ...props, onSubmit: handleSubmit });
+    return (_jsx(AI_ApprovalQueue, { items: items, onApprove: (decisionRef, comment, modifiedToolArgs, reasonCode) => answer(decisionRef, true, comment, modifiedToolArgs, reasonCode), onDeny: (decisionRef, comment, reasonCode) => answer(decisionRef, false, comment, undefined, reasonCode), onEscalate: (decisionRef, comment) => void run(decisionRef, HumanDecision_Act.ESCALATE, comment ? { reason: comment } : {}), 
+        // #2526: the option the reviewer chose and the values it carries, in the one answer shape the server checks against
+        // the decision's own request (an option it never offered, or values an option does not take, is refused).
+        onAnswer: (decisionRef, optionRef, values, comment, reasonCode) => void run(decisionRef, HumanDecision_Act.ANSWER, {
+            answer: { decisionId: decisionRef, optionRef, values: [...values] },
+            ...presentationEchoOf(decisions, decisionRef),
+            ...(comment ? { reason: comment } : {}),
+            // #2539: an actor question that reviews an agent's work may carry a declared reason, as a tool approval does.
+            ...(reasonCode ? { reasonCode } : {}),
+        }), onClaim: (decisionRef) => void run(decisionRef, HumanDecision_Act.CLAIM, {}), onUnclaim: (decisionRef) => void run(decisionRef, HumanDecision_Act.UNCLAIM, {}), onReassignOpen: handleReassignOpen, onReassign: (decisionRef, targetUserId, comment) => void run(decisionRef, HumanDecision_Act.REASSIGN, { targetUserId, ...(comment ? { reason: comment } : {}) }), onPauseClock: (decisionRef, pauseStateRef) => void run(decisionRef, HumanDecision_Act.PAUSE_CLOCK, { pauseStateRef }), onResumeClock: (decisionRef) => void run(decisionRef, HumanDecision_Act.RESUME_CLOCK, {}), processingIds: processing, 
+        // #2526: a read still settling, and a read that failed, are states the inbox SHOWS — never an empty inbox.
+        isLoading: readState === PendingDecisionsReadState.LOADING, loadFailed: readState === PendingDecisionsReadState.FAILED, onRetry: () => { void refresh(); }, ...props }));
 }
 //# sourceMappingURL=approval.js.map