Actually, after thinking a bit longer, the behavior change to flag actions may not be acceptable. The existing behavior of flag actions was basically to invoke the action for every instance of the flag, with the value of that instance. invoke the flag at every command level. It can make sense for some applications. The problem is the context parameter.

If flag actions didn't take the context.Context parameter, they could be run before Before actions. This would make sense for applications where the flag action is used to set a global or something.

However, if the context is desired in flag actions, the only option would be collecting flag instances in another slice in Command so their local values can be accessed later when running the actions.

Having spent quite a bit of time trying to restore the behavior of flag actions while keeping the new Before logic, I can now say it's impossible. But working on that has convinced me flag actions are handled kind of incorrectly right now.

At the moment, flag actions for persistent flags are invoked multiple times, basically once per 'command-level', with the value at that level. That doesn't make a lot of sense, given that the ultimate goal of flag parsing, setup etc. is to execute the innermost command action, and the flag values at that level are the ones that should be applied to the program.

So I propose that flag actions of persistent flags should be run exactly once, with the value that will actually be set for the command action. The current behavior does make sense for local flags, so this can be kept.

@dearchap would be nice to get your input on this PR (even though it's not fully done yet). The basic change is just to run Before functions later, when the innermost values of flags have been resolved.

@fjl i'm AFK and on travel. Will get to it in a day or two. Thank you so much for your patience. I have been following all the comments in this PR closely

@fjl sorry for the late approval. The changes look good.