eDSL - implement an action that could be used only once in the sequence

Question

I'm developing the following eDSL :

import Control.Monad.Free

type CommandHandler
      = PersistedCommand -> Maybe AggregateSnapshot -> CommandDirective

data CommandDirective = Reject RejectionReason
                      | SkipBecauseAlreadyProcessed
                      | Transact (CommandTransaction ())

type RejectionReason = String

data Action a = PersistEvent Event a
              | UpdateSnapshot AggregateSnapshot a
              | GetCurrentTime (UTCTime -> a )
              | GetNewEventId (EventId -> a) deriving (Functor)

type CommandTransaction a = Free Action a

persistEvent :: Event -> CommandTransaction ()
persistEvent event = Free . PersistEvent event $ Pure ()

updateSnapshot :: AggregateSnapshot -> CommandTransaction ()
updateSnapshot aggregateSnapshot
        = Free . UpdateSnapshot aggregateSnapshot $ Pure ()

getNewEventID :: CommandTransaction EventId
getNewEventID = Free $ GetNewEventId Pure

getCurrentTime :: CommandTransaction UTCTime
getCurrentTime = Free $ GetCurrentTime Pure

I would like UpdateSnapshot to be used only once in a sequence not twice as I'm doing now. I could do it with phantom types and then UpdateSnapshot will be the last element of the action chain. But It's kind of semantically wrong and it does not work for 2 actions with the same nature then....

e.g : 2 last updateSnapshot should not be valid :

do
 now <- getCurrentTime
 eventId <- getNewEventID
 persistEvent $ WorkspaceCreated
                 { eventId = eventId
                 , createdOn = now
                 , workspaceId = workspaceId }
 updateSnapshot $ AggregateSnapshot
          { lastOffsetConsumed = 0
          , commandsProcessed = Set.fromList [commandId]
          , state = AggregateState { aggregateId = workspaceId } }
 updateSnapshot $ AggregateSnapshot
          { lastOffsetConsumed = 0
          , commandsProcessed = Set.fromList [commandId]
          , state = AggregateState { aggregateId = workspaceId } }