@stigmer/react 3.0.9-dev.20260616060535 → 3.1.0

package/src/workflow/WorkflowTaskApprovalCard.tsx

@@ -4,6 +4,8 @@ import { memo, useCallback, useEffect, useMemo, useState } from "react";
 import Markdown from "react-markdown";
 import { cn } from "@stigmer/theme";
 import { MARKDOWN_COMPONENTS, REMARK_PLUGINS } from "../internal/markdown-components";
+import { DecisionButton, type DecisionVariant } from "../internal/DecisionButton";
+import { InCardDecisionError } from "../internal/InCardDecisionError";
 
 /** Outcome descriptor for UI rendering. */
 export interface TaskOutcome {
@@ -44,8 +46,15 @@ export interface WorkflowTaskApprovalCardProps {
     formData?: Record<string, unknown>,
     comment?: string,
   ) => Promise<unknown>;
-  /** True while the submission RPC is in flight. */
+  /** True while this gate's submission RPC is in flight. */
   readonly isSubmitting: boolean;
+  /**
+   * This gate's last failed decision, or `null`. Surfaced in-card beside the
+   * outcome buttons (via the shared {@link InCardDecisionError}) — supply
+   * {@link useWorkflowExecutionActions}'s `taskApprovalErrorsByTaskName` for
+   * this `taskName`.
+   */
+  readonly error?: Error | null;
   /** Additional CSS class names for the root container. */
   readonly className?: string;
 }
@@ -92,6 +101,7 @@ export const WorkflowTaskApprovalCard = memo(function WorkflowTaskApprovalCard({
   formSchema,
   onSubmit,
   isSubmitting,
+  error,
   className,
 }: WorkflowTaskApprovalCardProps) {
   const outcomes = outcomesProp.length > 0 ? outcomesProp : DEFAULT_OUTCOMES;
@@ -134,8 +144,10 @@ export const WorkflowTaskApprovalCard = memo(function WorkflowTaskApprovalCard({
       role="form"
       aria-label={`Approval decision for ${taskName}`}
       aria-busy={isSubmitting}
+      // Neutral card + 2px warning left accent — the quiet Cursor-grade chrome
+      // shared with ApprovalCard. (Replaces the old amber `bg-warning/5` fill.)
       className={cn(
-        "mt-2 rounded-lg border border-warning/30 bg-warning/5 p-3",
+        "mt-2 rounded-lg border border-border-prominent border-l-2 border-l-warning p-3",
         className,
       )}
     >
@@ -198,75 +210,34 @@ export const WorkflowTaskApprovalCard = memo(function WorkflowTaskApprovalCard({
 
       <div className="flex flex-wrap gap-2">
         {outcomes.map((outcome, index) => (
-          <OutcomeButton
+          <DecisionButton
             key={outcome.name}
             label={outcome.label || capitalize(outcome.name)}
-            outcomeName={outcome.name}
             variant={resolveVariant(outcome.name, index, outcomes.length)}
+            onClick={() => handleSubmit(outcome.name)}
             isActive={activeOutcome === outcome.name}
             isSubmitting={isSubmitting}
-            onClick={handleSubmit}
           />
         ))}
       </div>
-    </div>
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Internal sub-components
-// ---------------------------------------------------------------------------
 
-type ButtonVariant = "primary" | "destructive" | "secondary";
-
-function OutcomeButton({
-  label,
-  outcomeName,
-  variant,
-  isActive,
-  isSubmitting,
-  onClick,
-}: {
-  readonly label: string;
-  readonly outcomeName: string;
-  readonly variant: ButtonVariant;
-  readonly isActive: boolean;
-  readonly isSubmitting: boolean;
-  readonly onClick: (name: string) => void;
-}) {
-  const variantClasses: Record<ButtonVariant, string> = {
-    primary: cn(
-      "bg-success text-success-foreground hover:bg-success/90",
-      "disabled:bg-success/50 disabled:text-success-foreground/70",
-    ),
-    destructive: cn(
-      "bg-destructive text-destructive-foreground hover:bg-destructive-hover",
-      "disabled:bg-destructive-subtle0 disabled:text-destructive-foreground/70",
-    ),
-    secondary: cn(
-      "border border-border bg-background text-foreground hover:bg-muted",
-      "disabled:bg-muted-faint disabled:text-muted-foreground-faint",
-    ),
-  };
-
-  return (
-    <button
-      type="button"
-      disabled={isSubmitting}
-      onClick={() => onClick(outcomeName)}
-      aria-label={label}
-      className={cn(
-        "inline-flex items-center justify-center gap-1.5 rounded-md px-3 py-1.5 text-xs font-medium transition-colors",
-        "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
-        "disabled:cursor-not-allowed",
-        variantClasses[variant],
+      {/* A failed decision surfaces HERE, beside this gate's outcome buttons —
+          not in the viewer's lifecycle banner. A workflow can hold many gates at
+          once, so a failure must name the one it belongs to; the optimistic
+          spinner has already reverted, and this explains the snap-back. Shared
+          with the agent ApprovalCard / FileReviewCard via InCardDecisionError. */}
+      {error && (
+        <div className="mt-2">
+          <InCardDecisionError
+            error={error}
+            leadIn="submit decision"
+            cursorTarget="wf-task-approval-error"
+          />
+        </div>
       )}
-    >
-      {isActive && isSubmitting ? <SpinnerIcon /> : null}
-      {label}
-    </button>
+    </div>
   );
-}
+});
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -296,42 +267,23 @@ function resolveVariant(
   outcomeName: string,
   index: number,
   total: number,
-): ButtonVariant {
+): DecisionVariant {
+  // The first outcome is the recommended action (the quiet neutral chip).
   if (index === 0) return "primary";
 
   const lower = outcomeName.toLowerCase();
   if (lower === "reject" || lower === "deny" || lower.includes("reject")) {
-    return "destructive";
+    return "danger";
   }
 
+  // In a simple two-outcome form, the trailing outcome is the negative one.
   if (index === total - 1 && total === 2) {
-    return "destructive";
+    return "danger";
   }
 
-  return "secondary";
+  return "ghost";
 }
 
 function capitalize(s: string): string {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
-
-// ---------------------------------------------------------------------------
-// Inline SVG icons
-// ---------------------------------------------------------------------------
-
-function SpinnerIcon() {
-  return (
-    <svg
-      width="10"
-      height="10"
-      viewBox="0 0 12 12"
-      fill="none"
-      stroke="currentColor"
-      strokeWidth="1.5"
-      className="animate-spin"
-      aria-hidden="true"
-    >
-      <path d="M6 1.5A4.5 4.5 0 1 1 1.5 6" strokeLinecap="round" />
-    </svg>
-  );
-}

package/src/workflow/__tests__/ExecutionInspector.test.tsx

@@ -88,7 +88,6 @@ describe("ExecutionInspector — approval gating", () => {
         events={[approvalRequested]}
         taskStates={new Map([[TASK, makeTaskState(TASK, "waiting_approval")]])}
         onSubmitTaskApproval={vi.fn().mockResolvedValue(undefined)}
-        isSubmittingTaskApproval={false}
       />,
     );
 
@@ -97,6 +96,36 @@ describe("ExecutionInspector — approval gating", () => {
     expect(screen.getByRole("button", { name: "Reject" })).toBeTruthy();
   });
 
+  it("surfaces this gate's keyed failure in-card, beside the outcome buttons", () => {
+    render(
+      <ExecutionInspector
+        selectedTaskName={TASK}
+        events={[approvalRequested]}
+        taskStates={new Map([[TASK, makeTaskState(TASK, "waiting_approval")]])}
+        onSubmitTaskApproval={vi.fn().mockResolvedValue(undefined)}
+        taskApprovalErrorsByTaskName={new Map([[TASK, new Error("signal failed")]])}
+      />,
+    );
+
+    expect(screen.getByText(/Couldn.t submit decision — signal failed/)).toBeTruthy();
+  });
+
+  it("marks only this gate's buttons as submitting via the keyed set", () => {
+    render(
+      <ExecutionInspector
+        selectedTaskName={TASK}
+        events={[approvalRequested]}
+        taskStates={new Map([[TASK, makeTaskState(TASK, "waiting_approval")]])}
+        onSubmitTaskApproval={vi.fn().mockResolvedValue(undefined)}
+        taskApprovalSubmittingTaskNames={new Set([TASK])}
+      />,
+    );
+
+    expect(
+      (screen.getByRole("button", { name: "Approve Plan" }) as HTMLButtonElement).disabled,
+    ).toBe(true);
+  });
+
   it("renders the read-only decision summary once the gate is resolved", () => {
     render(
       <ExecutionInspector
@@ -111,7 +140,6 @@ describe("ExecutionInspector — approval gating", () => {
           }),
         ]}
         onSubmitTaskApproval={vi.fn().mockResolvedValue(undefined)}
-        isSubmittingTaskApproval={false}
       />,
     );
 

package/src/workflow/__tests__/WorkflowExecutionApprovalCard.test.tsx

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { WorkflowExecutionApprovalCard } from "../WorkflowExecutionApprovalCard";
+
+// ApprovalAction enum: 1 = APPROVE, 3 = REJECT.
+const APPROVE = 1;
+const REJECT = 3;
+
+const defaultProps = {
+  prompt: "The agent wants to delete /tmp/x. Approve?",
+  toolCallId: "tc-1",
+  approvers: [] as readonly string[],
+  timeoutSeconds: 0,
+  onSubmitApproval: vi.fn().mockResolvedValue(undefined),
+  isSubmitting: false,
+};
+
+afterEach(cleanup);
+
+describe("WorkflowExecutionApprovalCard", () => {
+  describe("content", () => {
+    it("renders the prompt", () => {
+      render(<WorkflowExecutionApprovalCard {...defaultProps} />);
+      expect(screen.getByText(defaultProps.prompt)).toBeTruthy();
+    });
+
+    it("lists approvers and the timeout when provided", () => {
+      render(
+        <WorkflowExecutionApprovalCard
+          {...defaultProps}
+          approvers={["alice", "bob"]}
+          timeoutSeconds={120}
+        />,
+      );
+      expect(screen.getByText("Approvers: alice, bob")).toBeTruthy();
+      expect(screen.getByText("Expires in 2m")).toBeTruthy();
+    });
+  });
+
+  describe("submission", () => {
+    it("submits APPROVE with the comment", () => {
+      const onSubmitApproval = vi.fn().mockResolvedValue(undefined);
+      render(
+        <WorkflowExecutionApprovalCard {...defaultProps} onSubmitApproval={onSubmitApproval} />,
+      );
+      fireEvent.change(screen.getByPlaceholderText("Comment (optional)"), {
+        target: { value: "ok" },
+      });
+      fireEvent.click(screen.getByRole("button", { name: "Approve" }));
+      expect(onSubmitApproval).toHaveBeenCalledWith("tc-1", APPROVE, "ok");
+    });
+
+    it("submits REJECT with no comment as undefined", () => {
+      const onSubmitApproval = vi.fn().mockResolvedValue(undefined);
+      render(
+        <WorkflowExecutionApprovalCard {...defaultProps} onSubmitApproval={onSubmitApproval} />,
+      );
+      fireEvent.click(screen.getByRole("button", { name: "Reject" }));
+      expect(onSubmitApproval).toHaveBeenCalledWith("tc-1", REJECT, undefined);
+    });
+  });
+
+  describe("quiet chrome & buttons (shared DecisionButton)", () => {
+    it("uses neutral card chrome + warning accent, never the old amber fill", () => {
+      render(<WorkflowExecutionApprovalCard {...defaultProps} />);
+      const card = screen.getByRole("alert");
+      expect(card.className).toContain("border-border-prominent");
+      expect(card.className).toContain("border-l-warning");
+      expect(card.className).not.toContain("bg-warning");
+    });
+
+    it("Approve is the neutral chip (not loud green); Reject is a quiet danger ghost (not a red fill)", () => {
+      render(<WorkflowExecutionApprovalCard {...defaultProps} />);
+      const approve = screen.getByRole("button", { name: "Approve" });
+      expect(approve.className).toContain("bg-accent");
+      expect(approve.className).not.toContain("bg-success");
+
+      const reject = screen.getByRole("button", { name: "Reject" });
+      expect(reject.className).toContain("hover:text-destructive");
+      expect(reject.className).not.toContain("bg-destructive text-destructive-foreground");
+      // No opacity-modifier debt (e.g. the old hover:bg-destructive/10).
+      expect(reject.className).not.toMatch(/\/\d+(?:\s|$)/);
+    });
+  });
+
+  describe("loading state", () => {
+    it("disables both buttons while submitting", () => {
+      render(<WorkflowExecutionApprovalCard {...defaultProps} isSubmitting />);
+      expect(
+        (screen.getByRole("button", { name: "Approve" }) as HTMLButtonElement).disabled,
+      ).toBe(true);
+      expect(
+        (screen.getByRole("button", { name: "Reject" }) as HTMLButtonElement).disabled,
+      ).toBe(true);
+    });
+
+    it("shows the spinner on the clicked button during submission", () => {
+      const { rerender } = render(<WorkflowExecutionApprovalCard {...defaultProps} />);
+      fireEvent.click(screen.getByRole("button", { name: "Reject" }));
+      rerender(<WorkflowExecutionApprovalCard {...defaultProps} isSubmitting />);
+
+      expect(
+        screen.getByRole("button", { name: "Reject" }).querySelector(".animate-spin"),
+      ).toBeTruthy();
+      expect(
+        screen.getByRole("button", { name: "Approve" }).querySelector(".animate-spin"),
+      ).toBeNull();
+    });
+  });
+
+  describe("in-card decision error", () => {
+    it("renders the failure notice beside the actions when error is set", () => {
+      render(
+        <WorkflowExecutionApprovalCard
+          {...defaultProps}
+          error={new Error("gate already resolved")}
+        />,
+      );
+      expect(
+        screen.getByText(/Couldn.t submit decision — gate already resolved/),
+      ).toBeTruthy();
+    });
+
+    it("renders no failure notice when error is null", () => {
+      render(<WorkflowExecutionApprovalCard {...defaultProps} error={null} />);
+      expect(screen.queryByText(/Couldn.t submit decision/)).toBeNull();
+    });
+  });
+});

package/src/workflow/__tests__/WorkflowFileReviewList.test.tsx

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { FileChangeSetStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+// Mock the child execution stream: each child id maps to a canned execution.
+const mockExecutions: Record<string, any> = {};
+vi.mock("../../execution/useExecutionStream", () => ({
+  useExecutionStream: (id: string | null) => ({
+    execution: id ? (mockExecutions[id] ?? null) : null,
+  }),
+}));
+
+// Stub FileReviewCard to a minimal control that surfaces its wiring, so the test
+// exercises the container's mapping/forwarding — not the card's diff rendering.
+vi.mock("../../execution/FileReviewCard", () => ({
+  FileReviewCard: (props: any) => (
+    <button
+      data-testid={`card-${props.fileChangeSet.id}`}
+      onClick={() => props.onSubmit(1 /* APPROVE */, { expectedDigest: "d" })}
+    >
+      review {props.fileChangeSet.id}
+    </button>
+  ),
+}));
+
+import { WorkflowFileReviewList } from "../WorkflowFileReviewList";
+
+function awaitingSet(id: string) {
+  return { id, status: FileChangeSetStatus.AWAITING_REVIEW, changes: [{ id: "fc" }] };
+}
+
+beforeEach(() => {
+  for (const k of Object.keys(mockExecutions)) delete mockExecutions[k];
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("WorkflowFileReviewList", () => {
+  it("renders nothing when there are no references", () => {
+    const { container } = render(
+      <WorkflowFileReviewList pendingFileReviews={[]} onSubmitFileDecision={vi.fn()} />,
+    );
+    expect(container.firstChild).toBeNull();
+  });
+
+  it("renders a card for a referenced AWAITING_REVIEW set and forwards the decision with child routing", () => {
+    mockExecutions["aex-1"] = { status: { fileChangeSets: [awaitingSet("fcs-1")] } };
+    const onSubmit = vi.fn();
+
+    render(
+      <WorkflowFileReviewList
+        pendingFileReviews={[{ childAgentExecutionId: "aex-1", changeSetId: ["fcs-1"] } as any]}
+        onSubmitFileDecision={onSubmit}
+      />,
+    );
+
+    const card = screen.getByTestId("card-fcs-1");
+    fireEvent.click(card);
+    expect(onSubmit).toHaveBeenCalledWith("aex-1", "fcs-1", 1, { expectedDigest: "d" });
+  });
+
+  it("does not render a set that is not in the surfaced reference", () => {
+    // Child has an AWAITING set fcs-2, but the parent only surfaced fcs-1.
+    mockExecutions["aex-1"] = {
+      status: { fileChangeSets: [awaitingSet("fcs-1"), awaitingSet("fcs-2")] },
+    };
+
+    render(
+      <WorkflowFileReviewList
+        pendingFileReviews={[{ childAgentExecutionId: "aex-1", changeSetId: ["fcs-1"] } as any]}
+        onSubmitFileDecision={vi.fn()}
+      />,
+    );
+
+    expect(screen.getByTestId("card-fcs-1")).toBeTruthy();
+    expect(screen.queryByTestId("card-fcs-2")).toBeNull();
+  });
+
+  it("does not render a referenced set that is no longer AWAITING_REVIEW", () => {
+    mockExecutions["aex-1"] = {
+      status: { fileChangeSets: [{ id: "fcs-1", status: FileChangeSetStatus.DECIDED, changes: [{ id: "fc" }] }] },
+    };
+
+    render(
+      <WorkflowFileReviewList
+        pendingFileReviews={[{ childAgentExecutionId: "aex-1", changeSetId: ["fcs-1"] } as any]}
+        onSubmitFileDecision={vi.fn()}
+      />,
+    );
+
+    expect(screen.queryByTestId("card-fcs-1")).toBeNull();
+  });
+
+  it("renders reviews for multiple parallel children independently", () => {
+    mockExecutions["aex-1"] = { status: { fileChangeSets: [awaitingSet("fcs-1")] } };
+    mockExecutions["aex-2"] = { status: { fileChangeSets: [awaitingSet("fcs-2")] } };
+
+    render(
+      <WorkflowFileReviewList
+        pendingFileReviews={[
+          { childAgentExecutionId: "aex-1", changeSetId: ["fcs-1"] } as any,
+          { childAgentExecutionId: "aex-2", changeSetId: ["fcs-2"] } as any,
+        ]}
+        onSubmitFileDecision={vi.fn()}
+      />,
+    );
+
+    expect(screen.getByTestId("card-fcs-1")).toBeTruthy();
+    expect(screen.getByTestId("card-fcs-2")).toBeTruthy();
+  });
+
+  it("shows a deep-link affordance when onNavigateToAgentExecution is provided", () => {
+    mockExecutions["aex-1"] = { status: { fileChangeSets: [awaitingSet("fcs-1")] } };
+    const onNavigate = vi.fn();
+
+    render(
+      <WorkflowFileReviewList
+        pendingFileReviews={[{ childAgentExecutionId: "aex-1", changeSetId: ["fcs-1"] } as any]}
+        onSubmitFileDecision={vi.fn()}
+        onNavigateToAgentExecution={onNavigate}
+      />,
+    );
+
+    fireEvent.click(screen.getByText("View agent execution"));
+    expect(onNavigate).toHaveBeenCalledWith("aex-1");
+  });
+});

package/src/workflow/__tests__/WorkflowTaskApprovalCard.test.tsx

@@ -37,14 +37,19 @@ describe("WorkflowTaskApprovalCard", () => {
     });
   });
 
-  describe("button variants", () => {
-    it("first outcome gets primary variant (success colors)", () => {
+  // The buttons now share the quiet, token-only DecisionButton primitive:
+  // first outcome = neutral chip (`primary`), reject/deny or the trailing of two
+  // = ghost-`danger`, middle outcomes = neutral `ghost`. No loud success/destructive
+  // fills, and no `bg-token/NN` opacity modifiers.
+  describe("button variants (quiet hierarchy)", () => {
+    it("first outcome is the neutral chip (primary), never the loud success green", () => {
       render(<WorkflowTaskApprovalCard {...defaultProps} />);
       const btn = screen.getByRole("button", { name: "Approve" });
-      expect(btn.className).toContain("bg-success");
+      expect(btn.className).toContain("bg-accent");
+      expect(btn.className).not.toContain("bg-success");
     });
 
-    it('outcome named "reject" gets destructive variant', () => {
+    it('outcome named "reject" is a quiet danger ghost (no red fill)', () => {
       const outcomes: TaskOutcome[] = [
         { name: "approve", label: "Approve" },
         { name: "reject", label: "Reject" },
@@ -52,10 +57,11 @@ describe("WorkflowTaskApprovalCard", () => {
       ];
       render(<WorkflowTaskApprovalCard {...defaultProps} outcomes={outcomes} />);
       const btn = screen.getByRole("button", { name: "Reject" });
-      expect(btn.className).toContain("bg-destructive");
+      expect(btn.className).toContain("hover:text-destructive");
+      expect(btn.className).not.toContain("bg-destructive text-destructive-foreground");
     });
 
-    it('outcome named "deny" gets destructive variant', () => {
+    it('outcome named "deny" is a quiet danger ghost (no red fill)', () => {
       const outcomes: TaskOutcome[] = [
         { name: "approve", label: "Approve" },
         { name: "deny", label: "Deny" },
@@ -63,20 +69,21 @@ describe("WorkflowTaskApprovalCard", () => {
       ];
       render(<WorkflowTaskApprovalCard {...defaultProps} outcomes={outcomes} />);
       const btn = screen.getByRole("button", { name: "Deny" });
-      expect(btn.className).toContain("bg-destructive");
+      expect(btn.className).toContain("hover:text-destructive");
+      expect(btn.className).not.toContain("bg-destructive text-destructive-foreground");
     });
 
-    it("second of two outcomes gets destructive variant (binary fallback)", () => {
+    it("second of two outcomes is the danger ghost (binary fallback)", () => {
       const outcomes: TaskOutcome[] = [
         { name: "accept", label: "Accept" },
         { name: "decline", label: "Decline" },
       ];
       render(<WorkflowTaskApprovalCard {...defaultProps} outcomes={outcomes} />);
       const btn = screen.getByRole("button", { name: "Decline" });
-      expect(btn.className).toContain("bg-destructive");
+      expect(btn.className).toContain("hover:text-destructive");
     });
 
-    it("middle outcomes in 3+ get secondary variant", () => {
+    it("middle outcomes in 3+ are neutral ghosts (no resting fill)", () => {
       const outcomes: TaskOutcome[] = [
         { name: "approve", label: "Approve" },
         { name: "defer", label: "Defer" },
@@ -84,7 +91,16 @@ describe("WorkflowTaskApprovalCard", () => {
       ];
       render(<WorkflowTaskApprovalCard {...defaultProps} outcomes={outcomes} />);
       const btn = screen.getByRole("button", { name: "Defer" });
-      expect(btn.className).toContain("bg-background");
+      expect(btn.className).toContain("text-muted-foreground");
+      expect(btn.className).not.toMatch(/(?:^|\s)bg-/);
+    });
+
+    it("the card uses neutral chrome + warning accent, never the old amber fill", () => {
+      render(<WorkflowTaskApprovalCard {...defaultProps} />);
+      const card = screen.getByRole("form");
+      expect(card.className).toContain("border-border-prominent");
+      expect(card.className).toContain("border-l-warning");
+      expect(card.className).not.toContain("bg-warning");
     });
   });
 
@@ -232,6 +248,22 @@ describe("WorkflowTaskApprovalCard", () => {
     });
   });
 
+  describe("in-card decision error", () => {
+    it("renders the failure notice beside the outcomes when error is set", () => {
+      render(
+        <WorkflowTaskApprovalCard {...defaultProps} error={new Error("signal failed")} />,
+      );
+      expect(
+        screen.getByText(/Couldn.t submit decision — signal failed/),
+      ).toBeTruthy();
+    });
+
+    it("renders no failure notice when error is null", () => {
+      render(<WorkflowTaskApprovalCard {...defaultProps} error={null} />);
+      expect(screen.queryByText(/Couldn.t submit decision/)).toBeNull();
+    });
+  });
+
   describe("accessibility", () => {
     it('root element has role="form"', () => {
       render(<WorkflowTaskApprovalCard {...defaultProps} />);