@stigmer/react 3.0.9-dev.20260615153829 → 3.1.0

package/src/workflow/WorkflowExecutionViewer.tsx

@@ -20,7 +20,8 @@ import { ExecutionInspector } from "./execution-inspector";
 import { ExecutionComparisonPicker } from "./execution-comparison/ExecutionComparisonPicker";
 import { ExecutionComparisonView } from "./execution-comparison/ExecutionComparisonView";
 import { WorkflowExecutionApprovalCard } from "./WorkflowExecutionApprovalCard";
-import type { WorkflowPendingApproval } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
+import { WorkflowFileReviewList, type WorkflowFileDecisionSubmit } from "./WorkflowFileReviewList";
+import type { WorkflowPendingApproval, WorkflowPendingFileReview } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
 import type { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { ResizableSplit } from "../internal/ResizableSplit";
 
@@ -287,7 +288,9 @@ export const WorkflowExecutionViewer = memo(function WorkflowExecutionViewer({
         onClose={handleCloseComparePicker}
       />
 
-      {/* Action error banner (lifecycle actions: cancel, pause, recover, etc.) */}
+      {/* Action error banner — lifecycle actions only (cancel/terminate/pause/
+          resume/recover). Approval failures are per-gate and surface in-card on
+          the failing approval card, never here. */}
       {actions.error && (
         <div className="flex items-center gap-2 border-b border-destructive/20 bg-destructive/5 px-4 py-2">
           <p className="flex-1 text-xs text-destructive">{actions.error.message}</p>
@@ -365,9 +368,11 @@ export const WorkflowExecutionViewer = memo(function WorkflowExecutionViewer({
                     onNavigateToAgentExecution={onNavigateToAgentExecution}
                     pendingApprovals={execution?.status?.pendingApprovals}
                     onSubmitApproval={actions.submitApproval}
-                    isSubmittingApproval={actions.isSubmitting}
+                    approvalSubmittingToolCallIds={actions.approvalSubmittingToolCallIds}
+                    approvalErrorsByToolCallId={actions.approvalErrorsByToolCallId}
                     onSubmitTaskApproval={actions.submitTaskApproval}
-                    isSubmittingTaskApproval={actions.isSubmitting}
+                    taskApprovalSubmittingTaskNames={actions.taskApprovalSubmittingTaskNames}
+                    taskApprovalErrorsByTaskName={actions.taskApprovalErrorsByTaskName}
                     className="min-h-0 flex-1"
                   />
 
@@ -403,9 +408,16 @@ export const WorkflowExecutionViewer = memo(function WorkflowExecutionViewer({
           onNavigateToAgentExecution={onNavigateToAgentExecution}
           taskStates={effectiveTaskStates}
           onSubmitTaskApproval={actions.submitTaskApproval}
-          isSubmittingApproval={actions.isSubmitting}
+          taskApprovalSubmittingTaskNames={actions.taskApprovalSubmittingTaskNames}
+          taskApprovalErrorsByTaskName={actions.taskApprovalErrorsByTaskName}
           pendingApprovals={execution?.status?.pendingApprovals}
           onSubmitApproval={actions.submitApproval}
+          approvalSubmittingToolCallIds={actions.approvalSubmittingToolCallIds}
+          approvalErrorsByToolCallId={actions.approvalErrorsByToolCallId}
+          pendingFileReviews={execution?.status?.pendingFileReviews}
+          onSubmitFileDecision={actions.submitFileDecision}
+          fileDecisionSubmittingKeys={actions.fileDecisionSubmittingKeys}
+          fileDecisionErrorsByKey={actions.fileDecisionErrorsByKey}
         />
       </div>
       </>
@@ -449,9 +461,16 @@ function ExecutionBottomPanel({
   onNavigateToAgentExecution,
   taskStates,
   onSubmitTaskApproval,
-  isSubmittingApproval,
+  taskApprovalSubmittingTaskNames,
+  taskApprovalErrorsByTaskName,
   pendingApprovals,
   onSubmitApproval,
+  approvalSubmittingToolCallIds,
+  approvalErrorsByToolCallId,
+  pendingFileReviews,
+  onSubmitFileDecision,
+  fileDecisionSubmittingKeys,
+  fileDecisionErrorsByKey,
 }: {
   events: WorkflowExecutionTimelineProps["events"];
   streamState: WorkflowExecutionTimelineProps["streamState"];
@@ -462,28 +481,39 @@ function ExecutionBottomPanel({
   onNavigateToAgentExecution?: (id: string) => void;
   taskStates: ReadonlyMap<string, DerivedTaskState>;
   onSubmitTaskApproval: WorkflowExecutionTimelineProps["onSubmitTaskApproval"];
-  isSubmittingApproval: boolean;
+  taskApprovalSubmittingTaskNames: ReadonlySet<string>;
+  taskApprovalErrorsByTaskName: ReadonlyMap<string, Error>;
   pendingApprovals?: readonly WorkflowPendingApproval[];
   onSubmitApproval?: (toolCallId: string, action: ApprovalAction, comment?: string) => Promise<unknown>;
+  approvalSubmittingToolCallIds: ReadonlySet<string>;
+  approvalErrorsByToolCallId: ReadonlyMap<string, Error>;
+  pendingFileReviews?: readonly WorkflowPendingFileReview[];
+  onSubmitFileDecision: WorkflowFileDecisionSubmit;
+  fileDecisionSubmittingKeys: ReadonlySet<string>;
+  fileDecisionErrorsByKey: ReadonlyMap<string, Error>;
 }) {
   const [collapsed, setCollapsed] = useState(false);
   const [activeTab, setActiveTab] = useState<BottomTab>("waterfall");
-  const prevApprovalCountRef = useRef(0);
+  const prevHitlCountRef = useRef(0);
 
   const approvalCount = pendingApprovals?.length ?? 0;
-  const hasApprovals = approvalCount > 0;
+  const fileReviewCount = pendingFileReviews?.length ?? 0;
+  // Both HITL kinds (tool approvals + file reviews) share the one "Approvals" tab.
+  const hitlCount = approvalCount + fileReviewCount;
+  const hasHitl = hitlCount > 0;
 
-  // Auto-switch to Approvals tab when new approvals arrive
+  // Auto-switch to the Approvals tab when a new HITL gate (approval or file
+  // review) arrives; leave it when everything is resolved.
   useEffect(() => {
-    if (approvalCount > prevApprovalCountRef.current && approvalCount > 0) {
+    if (hitlCount > prevHitlCountRef.current && hitlCount > 0) {
       setActiveTab("approvals");
       setCollapsed(false);
     }
-    if (approvalCount === 0 && activeTab === "approvals") {
+    if (hitlCount === 0 && activeTab === "approvals") {
       setActiveTab("waterfall");
     }
-    prevApprovalCountRef.current = approvalCount;
-  }, [approvalCount, activeTab]);
+    prevHitlCountRef.current = hitlCount;
+  }, [hitlCount, activeTab]);
 
   return (
     <div className="border-t border-[var(--stgm-border,#e5e5e5)]">
@@ -516,9 +546,9 @@ function ExecutionBottomPanel({
           isActive={activeTab === "events"}
           onClick={() => { setActiveTab("events"); setCollapsed(false); }}
         />
-        {hasApprovals && (
+        {hasHitl && (
           <TabButton
-            label={`Approvals (${approvalCount})`}
+            label={`Approvals (${hitlCount})`}
             isActive={activeTab === "approvals"}
             onClick={() => { setActiveTab("approvals"); setCollapsed(false); }}
           />
@@ -546,24 +576,38 @@ function ExecutionBottomPanel({
               onNavigateToAgentExecution={onNavigateToAgentExecution}
               taskStates={taskStates}
               onSubmitTaskApproval={onSubmitTaskApproval}
-              isSubmittingApproval={isSubmittingApproval}
+              taskApprovalSubmittingTaskNames={taskApprovalSubmittingTaskNames}
+              taskApprovalErrorsByTaskName={taskApprovalErrorsByTaskName}
               className="h-full"
             />
           )}
-          {activeTab === "approvals" && pendingApprovals && onSubmitApproval && (
+          {activeTab === "approvals" && (
             <div className="h-full overflow-y-auto px-4 py-3">
               <div className="space-y-3">
-                {pendingApprovals.map((pa) => (
-                  <WorkflowExecutionApprovalCard
-                    key={pa.approval?.toolCallId ?? pa.childAgentExecutionId}
-                    prompt={pa.approval?.message || `Tool "${pa.approval?.toolName}" requires approval`}
-                    toolCallId={pa.approval?.toolCallId ?? ""}
-                    approvers={[]}
-                    timeoutSeconds={0}
-                    onSubmitApproval={onSubmitApproval}
-                    isSubmitting={isSubmittingApproval}
+                {pendingApprovals && onSubmitApproval && pendingApprovals.map((pa) => {
+                  const toolCallId = pa.approval?.toolCallId ?? "";
+                  return (
+                    <WorkflowExecutionApprovalCard
+                      key={toolCallId || pa.childAgentExecutionId}
+                      prompt={pa.approval?.message || `Tool "${pa.approval?.toolName}" requires approval`}
+                      toolCallId={toolCallId}
+                      approvers={[]}
+                      timeoutSeconds={0}
+                      onSubmitApproval={onSubmitApproval}
+                      isSubmitting={approvalSubmittingToolCallIds.has(toolCallId)}
+                      error={approvalErrorsByToolCallId.get(toolCallId) ?? null}
+                    />
+                  );
+                })}
+                {pendingFileReviews && pendingFileReviews.length > 0 && (
+                  <WorkflowFileReviewList
+                    pendingFileReviews={pendingFileReviews}
+                    onSubmitFileDecision={onSubmitFileDecision}
+                    submittingDecisionKeys={fileDecisionSubmittingKeys}
+                    decisionErrors={fileDecisionErrorsByKey}
+                    onNavigateToAgentExecution={onNavigateToAgentExecution}
                   />
-                ))}
+                )}
               </div>
             </div>
           )}

package/src/workflow/WorkflowFileReviewList.tsx

@@ -0,0 +1,152 @@
+"use client";
+
+import { useMemo } from "react";
+import {
+  FileChangeSetStatus,
+  type FileDecisionAction,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { WorkflowPendingFileReview } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
+import { displayFileChangeSets } from "@stigmer/sdk";
+import { cn } from "@stigmer/theme";
+import { FileReviewCard } from "../execution/FileReviewCard";
+import type { FileDecisionOptions } from "../execution/useFileReview";
+import { useExecutionStream } from "../execution/useExecutionStream";
+
+/**
+ * Submit handler for a workflow-level file decision, matching
+ * `useWorkflowExecutionActions().submitFileDecision`. The child id is bound per
+ * card so the surface only needs the card-level `(action, options)`.
+ */
+export type WorkflowFileDecisionSubmit = (
+  childAgentExecutionId: string,
+  changeSetId: string,
+  action: FileDecisionAction,
+  options?: FileDecisionOptions,
+) => void;
+
+/** Props for {@link WorkflowFileReviewList}. */
+export interface WorkflowFileReviewListProps {
+  /**
+   * The parent workflow's surfaced file-review references
+   * (`status.pending_file_reviews`) — one entry per child agent execution.
+   */
+  readonly pendingFileReviews: readonly WorkflowPendingFileReview[];
+  /** Forwards a decision to the child (see {@link WorkflowFileDecisionSubmit}). */
+  readonly onSubmitFileDecision: WorkflowFileDecisionSubmit;
+  /** In-flight decision keys (pass `fileDecisionSubmittingKeys` straight through). */
+  readonly submittingDecisionKeys?: ReadonlySet<string>;
+  /** Per-decision failures (pass `fileDecisionErrorsByKey` straight through). */
+  readonly decisionErrors?: ReadonlyMap<string, Error>;
+  /**
+   * Optional deep-link to open the child agent execution in its own view. When
+   * provided, each child's review renders a "View agent execution" affordance.
+   * Routing is the host's responsibility (DD-004).
+   */
+  readonly onNavigateToAgentExecution?: (agentExecutionId: string) => void;
+  /** Additional CSS class names for the root container. */
+  readonly className?: string;
+}
+
+/**
+ * Renders the child agent file reviews surfaced on a parent WorkflowExecution.
+ *
+ * Reference-only, derive-from-child: the parent status carries only
+ * {@link WorkflowPendingFileReview} references (child id + change set ids). This
+ * list mounts one {@link WorkflowChildFileReview} per referenced child, which
+ * streams that child's execution and reuses the agent-level {@link FileReviewCard}
+ * to render the actual diff — the heavy content stays single-sourced on the child.
+ * A decision is forwarded to the child via `WorkflowExecution.submitFileDecision`.
+ *
+ * This is the file-review sibling of the workflow tool-approval surface
+ * (`WorkflowExecutionApprovalCard`). Empty `pendingFileReviews` renders nothing.
+ */
+export function WorkflowFileReviewList({
+  pendingFileReviews,
+  onSubmitFileDecision,
+  submittingDecisionKeys,
+  decisionErrors,
+  onNavigateToAgentExecution,
+  className,
+}: WorkflowFileReviewListProps): React.ReactElement | null {
+  if (pendingFileReviews.length === 0) return null;
+
+  return (
+    <div className={cn("stgm space-y-3", className)}>
+      {pendingFileReviews.map((ref) => (
+        <WorkflowChildFileReview
+          key={ref.childAgentExecutionId}
+          reference={ref}
+          onSubmitFileDecision={onSubmitFileDecision}
+          submittingDecisionKeys={submittingDecisionKeys}
+          decisionErrors={decisionErrors}
+          onNavigateToAgentExecution={onNavigateToAgentExecution}
+        />
+      ))}
+    </div>
+  );
+}
+
+interface WorkflowChildFileReviewProps {
+  readonly reference: WorkflowPendingFileReview;
+  readonly onSubmitFileDecision: WorkflowFileDecisionSubmit;
+  readonly submittingDecisionKeys?: ReadonlySet<string>;
+  readonly decisionErrors?: ReadonlyMap<string, Error>;
+  readonly onNavigateToAgentExecution?: (agentExecutionId: string) => void;
+}
+
+/**
+ * Streams a single referenced child agent execution and renders its
+ * AWAITING_REVIEW change sets (intersected with the parent's surfaced reference,
+ * so a decision always targets a gate the workflow has actually surfaced).
+ */
+function WorkflowChildFileReview({
+  reference,
+  onSubmitFileDecision,
+  submittingDecisionKeys,
+  decisionErrors,
+  onNavigateToAgentExecution,
+}: WorkflowChildFileReviewProps): React.ReactElement | null {
+  const childId = reference.childAgentExecutionId;
+  const { execution } = useExecutionStream(childId);
+
+  const changeSets = useMemo(() => {
+    const referenced = new Set(reference.changeSetId);
+    return displayFileChangeSets(execution?.status).filter(
+      (cs) =>
+        cs.status === FileChangeSetStatus.AWAITING_REVIEW &&
+        referenced.has(cs.id) &&
+        cs.changes.length > 0,
+    );
+  }, [execution?.status, reference.changeSetId]);
+
+  // Nothing to show yet (child still loading, or its projection has not caught up
+  // to the reference). The parent list already signals "review pending" for this
+  // child by virtue of the reference existing.
+  if (changeSets.length === 0) return null;
+
+  return (
+    <div className="space-y-2">
+      {onNavigateToAgentExecution && (
+        <button
+          type="button"
+          onClick={() => onNavigateToAgentExecution(childId)}
+          className="text-xs text-muted-foreground hover:text-foreground underline underline-offset-2"
+        >
+          View agent execution
+        </button>
+      )}
+      {changeSets.map((changeSet) => (
+        <FileReviewCard
+          key={changeSet.id}
+          fileChangeSet={changeSet}
+          interactive
+          submittingDecisionKeys={submittingDecisionKeys}
+          decisionErrors={decisionErrors}
+          onSubmit={(action, options) =>
+            onSubmitFileDecision(childId, changeSet.id, action, options)
+          }
+        />
+      ))}
+    </div>
+  );
+}

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}
       />,
     );