@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7195.1.b5efd1d51a

package/dist/modules/workflows/components/NodeEditDialogCrudForm.js

@@ -1,20 +1,51 @@
 "use client";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useState, useEffect, useCallback, useMemo } from "react";
-import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription } from "@open-mercato/ui/primitives/dialog";
-import { Badge } from "@open-mercato/ui/primitives/badge";
 import { Alert, AlertDescription } from "@open-mercato/ui/primitives/alert";
 import { Button } from "@open-mercato/ui/primitives/button";
 import { Trash2 } from "lucide-react";
 import { CrudForm } from "@open-mercato/ui/backend/CrudForm";
+import { useT } from "@open-mercato/shared/lib/i18n/context";
 import { JsonBuilder } from "@open-mercato/ui/backend/JsonBuilder";
+import { DurationInput } from "@open-mercato/ui/backend/inputs/DurationInput";
+import { flash } from "@open-mercato/ui/backend/FlashMessages";
 import { FormFieldArrayEditor } from "./fields/FormFieldArrayEditor.js";
 import { ActivityArrayEditor } from "./fields/ActivityArrayEditor.js";
+import { useActivityTypeOptions } from "./fields/useActivityTypeOptions.js";
 import { MappingArrayEditor } from "./fields/MappingArrayEditor.js";
 import { WorkflowSelectorField } from "./fields/WorkflowSelectorField.js";
+import { RolesMultiSelect } from "./fields/RolesMultiSelect.js";
 import { StartPreConditionsEditor } from "./fields/StartPreConditionsEditor.js";
+import { AgentInvokeConfigField } from "./fields/AgentInvokeConfigField.js";
+import { IfElseRoutesField, SwitchRoutesField } from "./fields/BranchingRoutesEditor.js";
+import { RouteOrderEditor } from "./fields/RouteOrderEditor.js";
+import { TemplateTextControl } from "./fields/TemplateTextControl.js";
+import { TaskEntityBindingsField } from "./fields/TaskEntityBindingsField.js";
+import { TaskAssignmentField } from "./fields/TaskAssignmentField.js";
+import { TaskOnBreachField, TaskRemindersField } from "./fields/TaskDeadlineFields.js";
+import { AgentReviewOnBreachField } from "./fields/AgentReviewOnBreachField.js";
+import { TaskDecisionsField, TaskEditablePrefilledField } from "./fields/TaskDecisionsField.js";
+import { TASK_PRIORITY_VALUES } from "../lib/task-inspector-config.js";
+import { AGENT_REVIEW_ASSIGNMENT_MODES } from "../lib/agent-review-inspector.js";
+import { ConditionBuilder } from "@open-mercato/core/modules/business_rules/components/ConditionBuilder";
+import { InputDataPanel } from "./InputDataPanel.js";
+import { InspectorPanel } from "./InspectorPanel.js";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue
+} from "@open-mercato/ui/primitives/select";
 import { nodeToFormValues, formValuesToNodeUpdates, isJsonSchemaFormat } from "../lib/nodeFormTransforms.js";
+import {
+  isConvertibleStepType,
+  listStepTypeConversionOptions,
+  listStepTypeConversionTargets,
+  readUnmappedStepConfig
+} from "../lib/step-type-conversion.js";
 import { sanitizeId } from "../lib/graph-utils.js";
+import { isBranchingNodeType } from "../lib/branching-routes.js";
 function JsonConfigEditor({ value, setValue, disabled }) {
   return /* @__PURE__ */ jsx(
     JsonBuilder,
@@ -25,44 +56,133 @@ function JsonConfigEditor({ value, setValue, disabled }) {
     }
   );
 }
-function NodeEditDialogCrudForm({ node, isOpen, onClose, onSave, onDelete }) {
+function DurationCrudField({ id, value, setValue, disabled }) {
+  return /* @__PURE__ */ jsx(
+    DurationInput,
+    {
+      id,
+      value: typeof value === "string" ? value : "",
+      onChange: setValue,
+      disabled
+    }
+  );
+}
+function RolesCrudField({ id, value, setValue, disabled }) {
+  const roles = useMemo(
+    () => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [],
+    [value]
+  );
+  return /* @__PURE__ */ jsx(
+    RolesMultiSelect,
+    {
+      id,
+      value: roles,
+      onChange: setValue,
+      disabled
+    }
+  );
+}
+function StepTypeConversionControl({
+  nodeType,
+  onConvert
+}) {
+  const t = useT();
+  const currentType = isConvertibleStepType(nodeType) ? nodeType : null;
+  const options = useMemo(() => listStepTypeConversionOptions(nodeType), [nodeType]);
+  const [targetType, setTargetType] = useState(currentType ?? "");
+  useEffect(() => {
+    setTargetType(currentType ?? "");
+  }, [currentType]);
+  if (options.length === 0) return null;
+  const canConvert = targetType.length > 0 && targetType !== currentType;
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+    /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: t(
+      "workflows.stepConversion.description",
+      "Keeps this step\u2019s id, name, position and wiring. Configuration the new type cannot execute is parked under Unmapped configuration instead of being deleted."
+    ) }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsxs(Select, { value: targetType, onValueChange: setTargetType, children: [
+        /* @__PURE__ */ jsx(SelectTrigger, { className: "w-64", "aria-label": t("workflows.steps.stepType"), children: /* @__PURE__ */ jsx(SelectValue, { placeholder: t("workflows.stepConversion.targetPlaceholder", "Select a step type") }) }),
+        /* @__PURE__ */ jsx(SelectContent, { children: options.map((candidate) => /* @__PURE__ */ jsx(SelectItem, { value: candidate, children: t(`workflows.nodeTypes.${candidate}`) }, candidate)) })
+      ] }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          variant: "outline",
+          disabled: !canConvert,
+          onClick: () => {
+            if (canConvert) onConvert(targetType);
+          },
+          children: t("workflows.stepConversion.action", "Change type\u2026")
+        }
+      )
+    ] })
+  ] });
+}
+function UnmappedConfigDrawer({ value }) {
+  const t = useT();
+  return /* @__PURE__ */ jsxs("details", { className: "rounded-md border border-border bg-muted/30 p-3", children: [
+    /* @__PURE__ */ jsx("summary", { className: "cursor-pointer text-sm font-medium", children: t("workflows.stepConversion.unmapped.title", "Unmapped configuration") }),
+    /* @__PURE__ */ jsx("p", { className: "mt-2 text-xs text-muted-foreground", children: t(
+      "workflows.stepConversion.unmapped.description",
+      "Kept from an earlier type change. It is stored with the step but is not executed; change the step back to recover it."
+    ) }),
+    /* @__PURE__ */ jsx("pre", { className: "mt-2 max-h-64 overflow-auto rounded bg-background p-2 font-mono text-xs", children: JSON.stringify(value, null, 2) })
+  ] });
+}
+function NodeEditDialogCrudForm({ node, isOpen, onClose, onSave, onDelete, ledgerEntries, definitionId, samples, onPinSample, onUnpinSample, branchingRoutes, onSaveBranchingRoutes, routeOrder, onSaveRouteOrder, onConvertType, variant = "overlay", wide }) {
+  const t = useT();
+  const activityTypeOptions = useActivityTypeOptions();
   const [initialValues, setInitialValues] = useState({});
   const [showJsonSchemaWarning, setShowJsonSchemaWarning] = useState(false);
+  const activityTestContext = useMemo(() => {
+    if (!node || !onPinSample || !onUnpinSample) return void 0;
+    const stepId = node.id;
+    return {
+      definitionId: definitionId ?? null,
+      stepId,
+      pinnedSample: samples?.[stepId],
+      onPinSample: (data) => onPinSample(stepId, data),
+      onUnpinSample: () => onUnpinSample(stepId)
+    };
+  }, [node, definitionId, samples, onPinSample, onUnpinSample]);
   useEffect(() => {
     if (node && isOpen) {
       const values = nodeToFormValues(node);
-      setInitialValues(values);
+      setInitialValues(
+        isBranchingNodeType(node.type) ? { ...values, branchingRoutes: branchingRoutes ?? { field: "", routes: [] } } : { ...values, routeOrder: routeOrder ?? [] }
+      );
       setShowJsonSchemaWarning(isJsonSchemaFormat(node));
     }
-  }, [node, isOpen]);
+  }, [node, isOpen, branchingRoutes, routeOrder]);
   const handleSubmit = useCallback(async (values) => {
     if (!node) return;
     const sanitizedId = sanitizeId(node.id);
     if (sanitizedId !== node.id) {
-      if (typeof window !== "undefined") {
-        window.alert(
-          `\u26A0\uFE0F Step ID was sanitized from "${node.id}" to "${sanitizedId}" to match schema requirements (lowercase letters, numbers, hyphens, and underscores only).`
-        );
-      }
+      flash(t("workflows.nodeEditor.stepIdSanitized", { from: node.id, to: sanitizedId }), "warning");
     }
     try {
       const updates = formValuesToNodeUpdates(values, node);
       onSave(node.id, updates);
+      if (isBranchingNodeType(node.type) && onSaveBranchingRoutes) {
+        const routesValue = values.branchingRoutes;
+        onSaveBranchingRoutes(node.id, routesValue ?? { field: "", routes: [] });
+      } else if (onSaveRouteOrder) {
+        const entries = values.routeOrder;
+        if (Array.isArray(entries) && entries.length > 0) onSaveRouteOrder(node.id, entries);
+      }
       onClose();
     } catch (error) {
-      throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(t(message));
     }
-  }, [node, onSave, onClose]);
+  }, [node, onSave, onSaveBranchingRoutes, onSaveRouteOrder, onClose, t]);
   const handleDelete = useCallback(() => {
     if (!node || !onDelete) return;
     onDelete(node.id);
   }, [node, onDelete]);
-  const handleKeyDown = useCallback((e) => {
-    if (e.key === "Escape") {
-      onClose();
-    }
-  }, [onClose]);
-  const groups = useMemo(() => {
+  const typeGroups = useMemo(() => {
     if (!node) return [];
     if (node.type === "end") {
       return [
@@ -70,7 +190,7 @@ function NodeEditDialogCrudForm({ node, isOpen, onClose, onSave, onDelete }) {
           id: "info",
           column: 1,
           bare: true,
-          component: () => /* @__PURE__ */ jsx(Alert, { status: "information", children: /* @__PURE__ */ jsx(AlertDescription, { children: "End nodes cannot be edited. They mark the completion of the workflow." }) })
+          component: () => /* @__PURE__ */ jsx(Alert, { status: "information", children: /* @__PURE__ */ jsx(AlertDescription, { children: t("workflows.nodeEditor.endStepsNotEditable") }) })
         }
       ];
     }
@@ -80,13 +200,13 @@ function NodeEditDialogCrudForm({ node, isOpen, onClose, onSave, onDelete }) {
           id: "info",
           column: 1,
           bare: true,
-          component: () => /* @__PURE__ */ jsx(Alert, { status: "information", className: "mb-4", children: /* @__PURE__ */ jsx(AlertDescription, { children: "Start nodes mark the beginning of the workflow. You can define pre-conditions that must pass before the workflow can be started." }) })
+          component: () => /* @__PURE__ */ jsx(Alert, { status: "information", className: "mb-4", children: /* @__PURE__ */ jsx(AlertDescription, { children: t("workflows.nodeEditor.startStepsInfo") }) })
         },
         {
           id: "preConditions",
-          title: "Pre-Conditions",
+          title: t("workflows.transitions.preConditions"),
           column: 1,
-          description: "Business rules that must pass before the workflow can start",
+          description: t("workflows.fieldEditors.preConditions.description"),
           fields: ["preConditions"]
         }
       ];
@@ -94,34 +214,79 @@ function NodeEditDialogCrudForm({ node, isOpen, onClose, onSave, onDelete }) {
     const baseGroups = [
       {
         id: "basic",
-        title: "Basic Information",
+        title: t("workflows.form.groups.basic"),
         column: 1,
         fields: ["stepName", "description", "timeout"]
       }
     ];
+    if (!isBranchingNodeType(node.type) && (routeOrder?.length ?? 0) > 1) {
+      baseGroups.push({
+        id: "routeOrder",
+        title: t("workflows.routeOrder.groupTitle"),
+        column: 1,
+        description: t("workflows.routeOrder.groupDescription"),
+        fields: ["routeOrder"]
+      });
+    }
+    const advancedGroup = {
+      id: "advanced",
+      title: t("workflows.form.advancedConfiguration"),
+      column: 1,
+      description: t("workflows.form.descriptions.advancedConfig"),
+      fields: ["advancedConfig"]
+    };
+    const errorHandlingGroup = {
+      id: "errorHandling",
+      title: t("workflows.nodeEditor.groups.errorHandling", "Error Handling"),
+      column: 1,
+      description: t(
+        "workflows.nodeEditor.groups.errorHandlingDescription",
+        "Applies when this step fails and no error route is wired from its error output handle."
+      ),
+      fields: ["errorDirectiveMode", "errorDirectiveFallbackValue"]
+    };
     if (node.type === "userTask") {
       return [
-        ...baseGroups,
         {
-          id: "userTask",
-          title: "User Task Configuration",
+          id: "taskWhat",
+          title: t("workflows.tasks.inspector.what.title"),
           column: 1,
-          fields: ["assignedTo", "assignedToRoles", "formKey"]
+          fields: ["stepName", "taskInstructions"]
         },
         {
-          id: "formFields",
-          title: "Form Fields",
+          id: "taskAbout",
+          title: t("workflows.tasks.inspector.bindings.title"),
           column: 1,
-          description: "Define the form structure for this user task",
-          fields: ["formFields"]
+          fields: ["taskEntityBindings"]
         },
         {
-          id: "advanced",
-          title: "Advanced Configuration",
+          id: "taskWho",
+          title: t("workflows.tasks.inspector.who.title"),
           column: 1,
-          description: "Additional JSON configuration (userTaskConfig, retryPolicy, etc.)",
-          fields: ["advancedConfig"]
-        }
+          fields: ["assignmentMode"]
+        },
+        {
+          id: "taskWhen",
+          title: t("workflows.tasks.inspector.when.title"),
+          column: 1,
+          fields: ["taskPriority", "slaDuration", "taskReminders", "taskOnBreach"]
+        },
+        {
+          id: "taskDecisions",
+          title: t("workflows.tasks.inspector.decisions.title"),
+          column: 1,
+          description: t("workflows.form.descriptions.formFields"),
+          fields: ["taskDecisions", "formFields", "taskEditablePrefilled", "formKey"]
+        },
+        {
+          id: "basic",
+          title: t("workflows.form.groups.basic"),
+          column: 1,
+          fields: ["description", "timeout"]
+        },
+        ...baseGroups.slice(1),
+        errorHandlingGroup,
+        advancedGroup
       ];
     }
     if (node.type === "automated") {
@@ -129,24 +294,19 @@ function NodeEditDialogCrudForm({ node, isOpen, onClose, onSave, onDelete }) {
         ...baseGroups,
         {
           id: "automated",
-          title: "Automated Task Configuration",
+          title: t("workflows.nodeEditor.groups.automated"),
           column: 1,
           fields: ["activityType", "activityId"]
         },
         {
           id: "stepActivities",
-          title: "Step Activities",
+          title: t("workflows.nodeEditor.groups.stepActivities"),
           column: 1,
-          description: "Activities executed as part of this automated step",
+          description: t("workflows.nodeEditor.groups.stepActivitiesDescription"),
           fields: ["stepActivities"]
         },
-        {
-          id: "advanced",
-          title: "Advanced Configuration",
-          column: 1,
-          description: "Additional JSON configuration (retryPolicy, etc.)",
-          fields: ["advancedConfig"]
-        }
+        errorHandlingGroup,
+        advancedGroup
       ];
     }
     if (node.type === "subWorkflow") {
@@ -154,24 +314,19 @@ function NodeEditDialogCrudForm({ node, isOpen, onClose, onSave, onDelete }) {
         ...baseGroups,
         {
           id: "subWorkflow",
-          title: "Sub-Workflow Configuration",
+          title: t("workflows.form.subWorkflowConfig"),
           column: 1,
           fields: ["subWorkflowId", "subWorkflowVersion"]
         },
         {
           id: "mappings",
-          title: "Data Mappings",
+          title: t("workflows.nodeEditor.groups.mappings"),
           column: 1,
-          description: "Map data between parent and sub-workflow",
+          description: t("workflows.nodeEditor.groups.mappingsDescription"),
           fields: ["inputMappings", "outputMappings"]
         },
-        {
-          id: "advanced",
-          title: "Advanced Configuration",
-          column: 1,
-          description: "Additional JSON configuration",
-          fields: ["advancedConfig"]
-        }
+        errorHandlingGroup,
+        advancedGroup
       ];
     }
     if (node.type === "waitForSignal") {
@@ -179,79 +334,340 @@ function NodeEditDialogCrudForm({ node, isOpen, onClose, onSave, onDelete }) {
         ...baseGroups,
         {
           id: "signal",
-          title: "Signal Configuration",
+          title: t("workflows.form.signalConfig"),
           column: 1,
           fields: ["signalName", "signalTimeout"]
         },
+        advancedGroup
+      ];
+    }
+    if (node.type === "waitForTimer") {
+      return [
+        {
+          id: "basic",
+          title: t("workflows.form.groups.basic"),
+          column: 1,
+          fields: ["stepName", "description"]
+        },
         {
-          id: "advanced",
-          title: "Advanced Configuration",
+          id: "timer",
+          title: t("workflows.nodeEditor.groups.timer"),
           column: 1,
-          description: "Additional JSON configuration",
-          fields: ["advancedConfig"]
-        }
+          description: t("workflows.nodeEditor.groups.timerDescription"),
+          fields: ["timerDuration", "timerUntil"]
+        },
+        advancedGroup
+      ];
+    }
+    if (node.type === "waitForCondition") {
+      return [
+        {
+          id: "basic",
+          title: t("workflows.form.groups.basic"),
+          column: 1,
+          fields: ["stepName", "description"]
+        },
+        {
+          id: "waitCondition",
+          title: t("workflows.nodeEditor.groups.waitCondition", "Wait Condition"),
+          column: 1,
+          description: t(
+            "workflows.nodeEditor.groups.waitConditionDescription",
+            "The workflow pauses here until this condition over the run context becomes true. It is re-checked whenever the context is written and on a periodic poll."
+          ),
+          fields: ["waitCondition"]
+        },
+        {
+          id: "waitConditionTimeout",
+          title: t("workflows.nodeEditor.groups.waitConditionTimeout", "Timeout Policy"),
+          column: 1,
+          description: t(
+            "workflows.nodeEditor.groups.waitConditionTimeoutDescription",
+            "A timeout is required so a condition that never becomes true cannot hang the run forever."
+          ),
+          fields: ["waitConditionTimeout", "waitConditionOnTimeout", "waitConditionPollIntervalMs"]
+        },
+        advancedGroup
+      ];
+    }
+    if (node.type === "invokeAgent") {
+      return [
+        ...baseGroups,
+        {
+          id: "invokeAgent",
+          title: t("workflows.form.invokeAgent.sectionTitle"),
+          column: 1,
+          description: t("workflows.form.invokeAgent.sectionDescription"),
+          fields: ["agentConfig"]
+        },
+        // Review (spec §7.5): who dispositions the proposal this step raises,
+        // and by when. The same Who/When vocabulary the Task inspector authors
+        // (§6.1.3 / §6.1.4) — because the thing being authored IS a task.
+        {
+          id: "agentReviewWho",
+          title: t("workflows.form.invokeAgent.review.whoTitle"),
+          column: 1,
+          description: t("workflows.form.invokeAgent.review.whoDescription"),
+          fields: ["reviewAssignmentMode"]
+        },
+        {
+          id: "agentReviewWhen",
+          title: t("workflows.form.invokeAgent.review.whenTitle"),
+          column: 1,
+          description: t("workflows.form.invokeAgent.review.whenDescription"),
+          fields: ["reviewPriority", "reviewDeadline", "reviewReminders", "reviewOnBreach"]
+        },
+        errorHandlingGroup,
+        advancedGroup
+      ];
+    }
+    if (isBranchingNodeType(node.type)) {
+      return [
+        ...baseGroups,
+        {
+          id: "branchingRoutes",
+          title: t("workflows.branching.groupTitle", "Routes"),
+          column: 1,
+          description: t(
+            "workflows.branching.groupDescription",
+            "Routing happens on the outgoing transitions: each case is evaluated by priority, and the otherwise route runs when none matches."
+          ),
+          fields: ["branchingRoutes"]
+        },
+        errorHandlingGroup,
+        advancedGroup
       ];
     }
     return [
       ...baseGroups,
-      {
-        id: "advanced",
-        title: "Advanced Configuration",
-        column: 1,
-        description: "Additional JSON configuration",
-        fields: ["advancedConfig"]
-      }
+      advancedGroup
     ];
-  }, [node]);
+  }, [node, t]);
+  const unmappedConfig = useMemo(() => readUnmappedStepConfig(node?.data), [node]);
+  const groups = useMemo(() => {
+    if (!node) return [];
+    const extras = [];
+    if (unmappedConfig) {
+      extras.push({
+        id: "unmappedConfig",
+        column: 1,
+        bare: true,
+        component: () => /* @__PURE__ */ jsx(UnmappedConfigDrawer, { value: unmappedConfig })
+      });
+    }
+    if (onConvertType && listStepTypeConversionTargets(node.type).length > 0) {
+      extras.push({
+        id: "changeType",
+        title: t("workflows.stepConversion.groupTitle", "Change step type"),
+        column: 1,
+        bare: false,
+        component: () => /* @__PURE__ */ jsx(
+          StepTypeConversionControl,
+          {
+            nodeType: node.type,
+            onConvert: (targetType) => onConvertType(node.id, targetType)
+          }
+        )
+      });
+    }
+    return [...typeGroups, ...extras];
+  }, [node, typeGroups, unmappedConfig, onConvertType, t]);
   const fields = useMemo(() => [
-    // Basic fields
-    {
+    // Basic fields. A user task's title is the sentence the assignee reads, so
+    // it is pill-capable there (spec §6.1 "What") and a plain text input
+    // everywhere else.
+    node?.type === "userTask" ? {
+      id: "stepName",
+      label: t("workflows.tasks.inspector.what.taskTitle"),
+      type: "custom",
+      required: true,
+      component: (props) => /* @__PURE__ */ jsx(
+        TemplateTextControl,
+        {
+          id: props.id,
+          value: typeof props.value === "string" ? props.value : "",
+          onValueChange: props.setValue,
+          ledgerEntries,
+          placeholder: t("workflows.form.placeholders.stepName"),
+          disabled: props.disabled,
+          "aria-label": t("workflows.tasks.inspector.what.taskTitle")
+        }
+      )
+    } : {
       id: "stepName",
-      label: "Step Name",
+      label: t("workflows.form.stepName"),
       type: "text",
-      placeholder: "Enter step name",
+      placeholder: t("workflows.form.placeholders.stepName"),
       required: true,
-      description: "Display name for this step"
+      description: t("workflows.form.descriptions.stepName")
     },
     {
       id: "description",
-      label: "Description",
+      label: t("workflows.form.description"),
       type: "textarea",
-      placeholder: "Enter step description",
-      description: "Optional description of what this step does"
+      placeholder: t("workflows.form.placeholders.description"),
+      description: t("workflows.form.descriptions.description")
     },
     {
       id: "timeout",
-      label: "Timeout",
-      type: "text",
-      placeholder: "PT30S or 30000",
-      description: "ISO 8601 duration (e.g., PT30S) or milliseconds"
+      label: t("workflows.form.timeout"),
+      type: "custom",
+      description: t("workflows.form.descriptions.timeout"),
+      component: (props) => /* @__PURE__ */ jsx(DurationCrudField, { ...props })
     },
     // UserTask fields
     {
       id: "assignedTo",
-      label: "Assigned To",
+      label: t("workflows.form.assignedTo"),
       type: "text",
-      placeholder: "user@example.com or userId",
-      description: "User email or ID to assign this task to"
+      placeholder: t("workflows.form.placeholders.userId"),
+      description: t("workflows.form.descriptions.assignedTo")
     },
     {
       id: "assignedToRoles",
-      label: "Assigned To Roles",
-      type: "text",
-      placeholder: "admin, manager",
-      description: "Comma-separated list of roles that can claim this task"
+      label: t("workflows.form.assignedToRoles"),
+      type: "custom",
+      description: t("workflows.form.descriptions.assignedToRoles"),
+      component: (props) => /* @__PURE__ */ jsx(RolesCrudField, { ...props })
     },
     {
       id: "formKey",
-      label: "Form Key",
+      label: t("workflows.form.formKey"),
       type: "text",
-      placeholder: "approval_form",
-      description: "Optional form key for external form rendering"
+      placeholder: t("workflows.form.placeholders.formKey"),
+      description: t("workflows.form.descriptions.formKey")
+    },
+    {
+      id: "slaDuration",
+      label: t("workflows.tasks.inspector.when.deadline"),
+      type: "custom",
+      description: t("workflows.nodeEditor.slaDurationDescription"),
+      component: (props) => /* @__PURE__ */ jsx(DurationCrudField, { ...props })
+    },
+    // Task inspector sections (spec §6.1)
+    {
+      id: "taskInstructions",
+      label: t("workflows.tasks.inspector.what.instructions"),
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(
+        TemplateTextControl,
+        {
+          id: props.id,
+          value: typeof props.value === "string" ? props.value : "",
+          onValueChange: props.setValue,
+          ledgerEntries,
+          placeholder: t("workflows.tasks.inspector.what.instructionsPlaceholder"),
+          disabled: props.disabled,
+          multiline: true,
+          "aria-label": t("workflows.tasks.inspector.what.instructions")
+        }
+      )
+    },
+    {
+      id: "taskEntityBindings",
+      label: t("workflows.tasks.inspector.bindings.label"),
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(TaskEntityBindingsField, { ...props, ledgerEntries })
+    },
+    {
+      id: "assignmentMode",
+      label: t("workflows.tasks.inspector.who.label"),
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(
+        TaskAssignmentField,
+        {
+          ...props,
+          ledgerEntries,
+          portalAudience: { assigneeKind: "taskAssigneeKind", entityBindings: "taskEntityBindings" }
+        }
+      )
+    },
+    {
+      id: "taskPriority",
+      label: t("workflows.tasks.inspector.when.priority"),
+      type: "select",
+      options: TASK_PRIORITY_VALUES.map((priority) => ({
+        value: priority,
+        label: t(`workflows.tasks.inspector.when.priorities.${priority}`)
+      }))
+    },
+    {
+      id: "taskReminders",
+      label: t("workflows.tasks.inspector.when.reminders"),
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(TaskRemindersField, { ...props })
+    },
+    {
+      id: "taskOnBreach",
+      label: t("workflows.tasks.inspector.when.onBreach"),
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(TaskOnBreachField, { ...props, routeOrder })
+    },
+    // Invoke Agent — Review (spec §7.5). The assignment tabs and the reminder
+    // control are the SAME components the Task inspector renders, pointed at
+    // this section's own field ids; only the breach action set differs, because
+    // a disposition deadline escalates and never decides.
+    {
+      id: "reviewAssignmentMode",
+      label: t("workflows.tasks.inspector.who.label"),
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(
+        TaskAssignmentField,
+        {
+          ...props,
+          ledgerEntries,
+          modes: AGENT_REVIEW_ASSIGNMENT_MODES,
+          fieldIds: {
+            assignedTo: "reviewAssignedTo",
+            assignedToRoles: "reviewAssignedToRoles",
+            assignmentRule: "reviewAssignmentRule"
+          }
+        }
+      )
+    },
+    {
+      id: "reviewPriority",
+      label: t("workflows.tasks.inspector.when.priority"),
+      type: "select",
+      options: TASK_PRIORITY_VALUES.map((priority) => ({
+        value: priority,
+        label: t(`workflows.tasks.inspector.when.priorities.${priority}`)
+      }))
+    },
+    {
+      id: "reviewDeadline",
+      label: t("workflows.tasks.inspector.when.deadline"),
+      type: "custom",
+      description: t("workflows.form.invokeAgent.review.deadlineDescription"),
+      component: (props) => /* @__PURE__ */ jsx(DurationCrudField, { ...props })
+    },
+    {
+      id: "reviewReminders",
+      label: t("workflows.tasks.inspector.when.reminders"),
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(TaskRemindersField, { ...props })
+    },
+    {
+      id: "reviewOnBreach",
+      label: t("workflows.tasks.inspector.when.onBreach"),
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(AgentReviewOnBreachField, { ...props })
+    },
+    {
+      id: "taskDecisions",
+      label: t("workflows.tasks.inspector.decisions.label"),
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(TaskDecisionsField, { ...props, routeOrder })
+    },
+    {
+      id: "taskEditablePrefilled",
+      label: t("workflows.tasks.inspector.decisions.editablePrefilled"),
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(TaskEditablePrefilledField, { ...props })
     },
     {
       id: "formFields",
-      label: "Form Fields",
+      label: t("workflows.nodeEditor.groups.formFields"),
       type: "custom",
       component: (props) => /* @__PURE__ */ jsx(
         FormFieldArrayEditor,
@@ -265,160 +681,299 @@ function NodeEditDialogCrudForm({ node, isOpen, onClose, onSave, onDelete }) {
     // Automated fields
     {
       id: "activityType",
-      label: "Activity Type",
+      label: t("workflows.form.activityType"),
       type: "select",
-      options: [
-        { value: "SEND_EMAIL", label: "Send Email" },
-        { value: "CALL_API", label: "Call API" },
-        { value: "UPDATE_ENTITY", label: "Update Entity" },
-        { value: "EMIT_EVENT", label: "Emit Event" },
-        { value: "CALL_WEBHOOK", label: "Call Webhook" },
-        { value: "EXECUTE_FUNCTION", label: "Execute Function" },
-        { value: "WAIT", label: "Wait" }
-      ],
-      description: "Type of activity to execute"
+      options: activityTypeOptions,
+      description: t("workflows.nodeEditor.activityTypeDescription")
     },
     {
       id: "activityId",
-      label: "Activity ID",
+      label: t("workflows.form.activityId"),
       type: "text",
-      placeholder: "send_welcome_email",
-      description: "Unique identifier for this activity"
+      placeholder: t("workflows.form.placeholders.activityId"),
+      description: t("workflows.nodeEditor.activityIdDescription")
     },
     {
       id: "stepActivities",
-      label: "Step Activities",
+      label: t("workflows.nodeEditor.groups.stepActivities"),
       type: "custom",
-      component: (props) => /* @__PURE__ */ jsx(ActivityArrayEditor, { ...props, value: props.value })
+      component: (props) => /* @__PURE__ */ jsx(ActivityArrayEditor, { ...props, value: props.value, ledgerEntries, testContext: activityTestContext })
     },
     // SubWorkflow fields
     {
       id: "subWorkflowId",
-      label: "Sub-Workflow",
+      label: t("workflows.form.workflowToInvoke"),
       type: "custom",
       component: (props) => /* @__PURE__ */ jsx(WorkflowSelectorField, { ...props, value: props.value })
     },
     {
       id: "subWorkflowVersion",
-      label: "Version",
+      label: t("workflows.form.version"),
       type: "number",
-      placeholder: "1",
-      description: "Specific version of the sub-workflow to invoke"
+      placeholder: t("workflows.form.placeholders.version"),
+      description: t("workflows.form.descriptions.subWorkflowVersion")
     },
     {
       id: "inputMappings",
-      label: "Input Mappings",
+      label: t("workflows.nodeEditor.inputMappings"),
       type: "custom",
       component: (props) => /* @__PURE__ */ jsx(
         MappingArrayEditor,
         {
           ...props,
           value: props.value,
-          label: "Input Mappings",
-          description: "Map parent workflow data to sub-workflow input"
+          label: t("workflows.nodeEditor.inputMappings"),
+          description: t("workflows.form.descriptions.inputMapping"),
+          variablePicker: true,
+          ledgerEntries
         }
       )
     },
     {
       id: "outputMappings",
-      label: "Output Mappings",
+      label: t("workflows.nodeEditor.outputMappings"),
       type: "custom",
       component: (props) => /* @__PURE__ */ jsx(
         MappingArrayEditor,
         {
           ...props,
           value: props.value,
-          label: "Output Mappings",
-          description: "Map sub-workflow output back to parent workflow"
+          label: t("workflows.nodeEditor.outputMappings"),
+          description: t("workflows.form.descriptions.outputMapping")
         }
       )
     },
     // WaitForSignal fields
     {
       id: "signalName",
-      label: "Signal Name",
+      label: t("workflows.form.signalName"),
       type: "text",
-      placeholder: "approval_received",
-      description: "Name of the signal to wait for"
+      placeholder: t("workflows.form.placeholders.signalName"),
+      description: t("workflows.form.descriptions.signalName")
     },
     {
       id: "signalTimeout",
-      label: "Signal Timeout",
-      type: "text",
-      placeholder: "PT5M",
-      description: "How long to wait for the signal (ISO 8601 duration)"
+      label: t("workflows.nodeEditor.signalTimeout"),
+      type: "custom",
+      description: t("workflows.form.descriptions.signalTimeout"),
+      component: (props) => /* @__PURE__ */ jsx(DurationCrudField, { ...props })
+    },
+    // WaitForTimer fields
+    {
+      id: "timerDuration",
+      label: t("workflows.activities.waitDuration"),
+      type: "custom",
+      description: t("workflows.nodeEditor.timerDurationDescription"),
+      component: (props) => /* @__PURE__ */ jsx(DurationCrudField, { ...props })
+    },
+    {
+      id: "timerUntil",
+      label: t("workflows.activities.waitUntil"),
+      type: "datetime",
+      minDate: /* @__PURE__ */ new Date(),
+      description: t("workflows.nodeEditor.timerUntilDescription")
+    },
+    // Error directive fields (spec section 5.9)
+    {
+      id: "errorDirectiveMode",
+      label: t("workflows.form.errorDirective.mode", "On failure"),
+      type: "select",
+      options: [
+        { value: "fail", label: t("workflows.form.errorDirective.modeFail", "Fail the instance (default)") },
+        {
+          value: "continueWithFallback",
+          label: t("workflows.form.errorDirective.modeContinue", "Continue with a fallback value")
+        },
+        {
+          value: "failureQueue",
+          label: t("workflows.form.errorDirective.modeQueue", "Send to the failure queue")
+        }
+      ],
+      description: t(
+        "workflows.form.descriptions.errorDirectiveMode",
+        "Fail the instance, continue with a fallback value written to the run context under this step id, or park the run for triage."
+      )
+    },
+    {
+      id: "errorDirectiveFallbackValue",
+      label: t("workflows.form.errorDirective.fallbackValue", "Fallback value (JSON)"),
+      type: "textarea",
+      placeholder: '{ "ok": false }',
+      description: t(
+        "workflows.form.descriptions.errorDirectiveFallbackValue",
+        'JSON value used when the directive is "Continue with a fallback value". Typed against this step output contract; leave empty to continue without writing anything.'
+      )
+    },
+    // WaitForCondition fields
+    {
+      id: "waitCondition",
+      label: "",
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(
+        ConditionBuilder,
+        {
+          value: props.value ?? null,
+          onChangeAction: (next) => props.setValue(next),
+          entityType: "workflow:wait_condition"
+        }
+      )
+    },
+    {
+      id: "waitConditionTimeout",
+      label: t("workflows.form.waitCondition.timeout", "Timeout"),
+      type: "custom",
+      description: t("workflows.form.descriptions.waitConditionTimeout", "How long to wait before the timeout policy applies. Required."),
+      component: (props) => /* @__PURE__ */ jsx(DurationCrudField, { ...props })
+    },
+    {
+      id: "waitConditionOnTimeout",
+      label: t("workflows.form.waitCondition.onTimeout", "On timeout"),
+      type: "select",
+      options: [
+        { value: "FAIL", label: t("workflows.form.waitCondition.onTimeoutFail", "Fail the step") },
+        { value: "CONTINUE", label: t("workflows.form.waitCondition.onTimeoutContinue", "Continue with timedOut") }
+      ],
+      description: t(
+        "workflows.form.descriptions.waitConditionOnTimeout",
+        'Fail the step, or continue with "timedOut" set so an outgoing route can branch on it.'
+      )
+    },
+    {
+      id: "waitConditionPollIntervalMs",
+      label: t("workflows.form.waitCondition.pollIntervalMs", "Poll interval (ms)"),
+      type: "number",
+      placeholder: "30000",
+      description: t(
+        "workflows.form.descriptions.waitConditionPollIntervalMs",
+        "Optional backstop poll interval between 5000 and 3600000 ms, and never longer than the timeout. Defaults to 30000."
+      )
+    },
+    // InvokeAgent configuration
+    {
+      id: "agentConfig",
+      label: "",
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(AgentInvokeConfigField, { ...props, value: props.value, ledgerEntries })
+    },
+    {
+      id: "routeOrder",
+      label: "",
+      type: "custom",
+      component: (props) => /* @__PURE__ */ jsx(
+        RouteOrderEditor,
+        {
+          id: props.id,
+          value: props.value,
+          setValue: props.setValue,
+          disabled: props.disabled
+        }
+      )
+    },
+    {
+      id: "branchingRoutes",
+      label: "",
+      type: "custom",
+      component: (props) => {
+        const routesValue = props.value ?? { field: "", routes: [] };
+        if (node?.type === "switch") {
+          return /* @__PURE__ */ jsx(
+            SwitchRoutesField,
+            {
+              id: props.id,
+              value: routesValue,
+              setValue: props.setValue,
+              disabled: props.disabled,
+              ledgerEntries
+            }
+          );
+        }
+        return /* @__PURE__ */ jsx(
+          IfElseRoutesField,
+          {
+            id: props.id,
+            value: routesValue.routes,
+            setValue: (routes) => props.setValue({ ...routesValue, routes }),
+            disabled: props.disabled
+          }
+        );
+      }
     },
     // Advanced configuration
     {
       id: "advancedConfig",
-      label: "Advanced Configuration (JSON)",
+      label: t("workflows.form.advancedConfiguration"),
       type: "custom",
-      description: "Additional JSON configuration merged with the step data",
+      description: t("workflows.form.descriptions.advancedConfig"),
       component: (props) => /* @__PURE__ */ jsx(JsonConfigEditor, { ...props })
     },
     // Start node pre-conditions
     {
       id: "preConditions",
-      label: "Pre-Conditions",
+      label: t("workflows.transitions.preConditions"),
       type: "custom",
-      description: "Business rules that must pass before the workflow can start",
+      description: t("workflows.fieldEditors.preConditions.description"),
       component: (props) => /* @__PURE__ */ jsx(StartPreConditionsEditor, { ...props, value: props.value })
     }
-  ], [showJsonSchemaWarning]);
+  ], [activityTypeOptions, showJsonSchemaWarning, ledgerEntries, activityTestContext, node?.type, routeOrder, t]);
   if (!isOpen || !node) return null;
-  const nodeType = node.type || "unknown";
-  const nodeTypeLabel = nodeType.charAt(0).toUpperCase() + nodeType.slice(1).replace(/([A-Z])/g, " $1");
+  const nodeTypeLabel = t(`workflows.nodeTypes.${node.type || "automated"}`);
   const canDelete = !!onDelete;
-  return /* @__PURE__ */ jsx(Dialog, { open: isOpen, onOpenChange: onClose, children: /* @__PURE__ */ jsxs(
-    DialogContent,
+  return /* @__PURE__ */ jsxs(
+    InspectorPanel,
     {
-      className: "sm:max-w-7xl max-h-[90vh] overflow-hidden flex flex-col !p-0 [&_.grid]:!grid-cols-1",
-      onKeyDown: handleKeyDown,
+      open: isOpen,
+      onClose,
+      variant,
+      wide,
+      title: t("workflows.nodeEditor.title"),
+      typeLabel: nodeTypeLabel,
+      description: t("workflows.nodeEditor.description"),
+      recordId: node.id,
       children: [
-        /* @__PURE__ */ jsxs(DialogHeader, { className: "flex-shrink-0 p-6 pb-4 border-b border-border/70", children: [
-          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 mb-2", children: [
-            /* @__PURE__ */ jsx(DialogTitle, { children: "Edit Step" }),
-            /* @__PURE__ */ jsx(Badge, { variant: "secondary", className: "text-xs", children: nodeTypeLabel })
-          ] }),
-          /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
-            /* @__PURE__ */ jsx(DialogDescription, { children: "Configure step properties and behavior" }),
-            /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-xs text-muted-foreground", children: [
-              /* @__PURE__ */ jsx("span", { className: "font-medium", children: "ID:" }),
-              /* @__PURE__ */ jsx("code", { className: "px-1.5 py-0.5 rounded bg-muted font-mono", children: node.id })
-            ] })
-          ] })
-        ] }),
-        /* @__PURE__ */ jsxs("div", { className: "flex-1 overflow-y-auto min-h-0 px-6", children: [
-          showJsonSchemaWarning && /* @__PURE__ */ jsx(Alert, { status: "information", className: "mb-4", children: /* @__PURE__ */ jsx(AlertDescription, { className: "text-xs", children: 'This form uses JSON Schema format. Fields have been converted for visual editing. When you save, it will be converted to the simplified format. To preserve the original JSON Schema, edit it in the "Advanced Configuration (JSON)" section.' }) }),
-          /* @__PURE__ */ jsx(
+        showJsonSchemaWarning && /* @__PURE__ */ jsx(Alert, { variant: "info", className: "mb-4", children: /* @__PURE__ */ jsx(AlertDescription, { className: "text-xs", children: t("workflows.nodeEditor.jsonSchemaFormat") }) }),
+        /* @__PURE__ */ jsxs("div", { className: wide ? "flex gap-6" : void 0, children: [
+          /* @__PURE__ */ jsx("div", { className: wide ? "min-w-0 flex-1" : void 0, children: /* @__PURE__ */ jsx(
             CrudForm,
             {
+              density: "compact",
               fields,
               groups,
               initialValues,
               onSubmit: handleSubmit,
               embedded: true,
-              submitLabel: "Save Step",
+              submitLabel: t("workflows.form.saveStep"),
               extraActions: canDelete ? /* @__PURE__ */ jsxs(
                 Button,
                 {
                   type: "button",
-                  variant: "destructive",
+                  variant: "destructive-outline",
                   onClick: handleDelete,
                   children: [
                     /* @__PURE__ */ jsx(Trash2, { className: "size-4 mr-2" }),
-                    "Delete Step"
+                    t("workflows.form.deleteStep")
                   ]
                 }
               ) : void 0
+            },
+            node.id
+          ) }),
+          /* @__PURE__ */ jsx("div", { className: wide ? "sticky top-0 w-96 shrink-0 self-start" : "mt-4", children: /* @__PURE__ */ jsx(
+            InputDataPanel,
+            {
+              entries: ledgerEntries,
+              stepId: node.id,
+              samples,
+              defaultCollapsed: !wide
             }
-          )
+          ) })
         ] })
       ]
     }
-  ) });
+  );
 }
 export {
-  NodeEditDialogCrudForm
+  DurationCrudField,
+  NodeEditDialogCrudForm,
+  RolesCrudField
 };
 //# sourceMappingURL=NodeEditDialogCrudForm.js.map