Repository: gruntwork-io/terragrunt

Issue:
SIGSEGV when using include and find_in_parent_folders
## Describe the bug

I've created a directory tree to manage Grafana IaC that is setup like this:

```
systems
├── account-card
│   ├── eng_teams.hcl
│   ├── prod
│   │   ├── <app>
│   └── qa
│       ├── <app>
```

Each <app> sub directory has it's own `terragrunt.hcl` file, which will do the actual work.

This structure started with plain Terraform, so there are still tfvars files that I'm trying to replace with the combination of a HCL file, `include` and the `find_in_parent_folders` function.

I can reference `eng_teams.hcl` like this:

```hcl
include {
  path = find_in_parent_folders("eng_teams.hcl")
}
```

And it works as expect. But if I want to use another HCL right under `systems` directory, I get the following error:

```
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x1aa296d]

goroutine 9 [running]:
github.com/gruntwork-io/terragrunt/config.PartialParseConfig(0xc000b1dc80, 0xc001333300, 0x0)
	/home/circleci/project/config/config_partial.go:389 +0x3cd
github.com/gruntwork-io/terragrunt/config.TerragruntConfigFromPartialConfig(0xc000b1dc80, 0xc001333300, 0x0)
	/home/circleci/project/config/config_partial.go:326 +0x3c5
github.com/gruntwork-io/terragrunt/config.PartialParseConfigFile(0xc000b1dc80, {0xc000b163f0, 0x69}, 0x0)
	/home/circleci/project/config/config_partial.go:304 +0x1e6
github.com/gruntwork-io/terragrunt/cli/commands/run.getTerragruntConfig({0x2f44ce8, 0xc0012ddd40}, 0xc000bde008)
	/home/circleci/project/cli/commands/run/run.go:916 +0x105
github.com/gruntwork-io/terragrunt/cli/commands/run.CheckVersionConstraints({0x2f44ce8, 0xc0012ddd40}, 0xc000bde008)
	/home/circleci/project/cli/commands/run/version_check.go:37 +0x2f
github.com/gruntwork-io/terragrunt/cli/commands/run.run({0x2f44ce8, 0xc0012ddd40}, 0xc000bde008, 0xc00137bde8)
	/home/circleci/project/cli/commands/run/run.go:106 +0x186
github.com/gruntwork-io/terragrunt/cli/commands/run.Run({0x2f44ce8?, 0xc0012ddd40?}, 0xc0012eb6d0?)
	/home/circleci/project/cli/commands/run/run.go:88 +0x56
github.com/gruntwork-io/terragrunt/cli/commands/run.NewSubcommands.func1.Action.1(0xc0012eb6d0)
	/home/circleci/project/cli/commands/run/cli.go:82 +0x9c
github.com/gruntwork-io/terragrunt/cli/commands/run.NewSubcommands.func1(0x0?)
	/home/circleci/project/cli/commands/run/cli.go:63 +0x2f
github.com/gruntwork-io/terragrunt/cli/commands/common/runall.WrapCommand.func1(0x0?, 0x0?)
	/home/circleci/project/cli/commands/common/runall/cli.go:45 +0xcd
github.com/gruntwork-io/terragrunt/internal/cli.(*Command).WrapAction.func1(0x0?)
	/home/circleci/project/internal/cli/command.go:292 +0x1b
github.com/gruntwork-io/terragrunt/cli/commands/common/graph.WrapCommand.func1(0x0?, 0x0?)
	/home/circleci/project/cli/commands/common/graph/cli.go:40 +0xcd
github.com/gruntwork-io/terragrunt/internal/cli.(*Command).WrapAction.func1(0x0?)
	/home/circleci/project/internal/cli/command.go:292 +0x1b
github.com/gruntwork-io/terragrunt/cli/commands.NewShortcutsCommands.func1(0x0?)
	/home/circleci/project/cli/commands/shortcuts.go:64 +0x82
github.com/gruntwork-io/terragrunt/cli.runAction.func2()
	/home/circleci/project/cli/app.go:224 +0x47
golang.org/x/sync/errgroup.(*Group).Go.func1()
	/home/circleci/go/pkg/mod/golang.org/x/sync@v0.12.0/errgroup/errgroup.go:78 +0x50
created by golang.org/x/sync/errgroup.(*Group).Go in goroutine 1
	/home/circleci/go/pkg/mod/golang.org/x/sync@v0.12.0/errgroup/errgroup.go:75 +0x96
```

It doesn't matter the filename or the content (even if it's empty) I'm using, the result is the same.

This is the line that I'm using to reference this "global" configuration:

```hcl
include {
  path = find_in_parent_folders("_envcommon.hcl")
}
```

Once commented out or removed, the unit works as expected.

Interesting fact is that I have a tfvars (which I'm trying to replace) at the same level of `systems` and it works as expected too:

```hcl
locals {
  environment = jsondecode(read_tfvars_file("../../../../environments.tfvars.json"))
}

inputs = merge(
  { environment = basename(dirname(get_terragrunt_dir())),
    app = {
      "kind"      = "deployment",
      "namespace" = "foobar",
      "slug"      = "barfoo"
    }
  },
  local.environment
)
```

## Steps To Reproduce

1. Create the directory tree
2. Create a unit configuration at the application level
3. Create the `eng_teams.hcl` at the system level. The file only defines an `input` block.
4. Create the `_envcommon.hcl` file right under `systems`
5. Move to the application sub directory (where the unit is) and run `terragrunt plan` or `terragrunt apply`.

```hcl
terraform {
  source = "../../../../base"
}

locals {
  teams       = jsondecode(read_tfvars_file("../../../../teams.tfvars"))
  // the line below should replaced by the include of _envcommon.hcl
  environment = jsondecode(read_tfvars_file("../../../../environments.tfvars.json"))
}

include {
  path = find_in_parent_folders("eng_teams.hcl")
}

// if the line below is removed, everything works fine
include {
  path = find_in_parent_folders("_envcommon.hcl")
}

inputs = merge(
  { environment = basename(dirname(get_terragrunt_dir())),
    app = {
      "kind"      = "deployment",
      "namespace" = "foobar",
      "slug"      = "barfoo"
    }
  },
  local.teams,
  local.environment
)
```

## Expected behavior

The selected operation from terragrunt should be executed without errors, and the shared configuration can be used all other application unit's.

## Nice to haves

- [X] Terminal output
- [ ] Screenshots

## Versions

- Terragrunt version: v0.77.22
- Terraform version: v1.11.3
- Environment details: Ubuntu 22.04.5 LTS

## Additional context

`base` modules providers:

```hcl
terraform {
  required_providers {
    grafana = {
      source  = "grafana/grafana"
      version = "3.22.2"
    }
    http = {
      source  = "hashicorp/http"
      version = "3.4.5"
    }
  }
}

provider "grafana" {
  url  = "https://${var.environments.servers[var.environment]}"
  auth = var.grafana_token
}
```

Inside this module, several of modules are included with `module` blocks, all of them using relative paths in the file system.


Hints from issue comments:
@yhakbar: Thanks for reporting this, @afreitas5 . We'll take a look soon.@denis256: Fixed in https://github.com/gruntwork-io/terragrunt/releases/tag/v0.78.0

Solution patch:
diff --git a/cli/app.go b/cli/app.go
index bbf97bd5..fd3df317 100644
--- a/cli/app.go
+++ b/cli/app.go
@@ -5,36 +5,24 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"path/filepath"
-	"slices"
 	"strings"
 
 	"github.com/gruntwork-io/terragrunt/engine"
-	"github.com/gruntwork-io/terragrunt/internal/os/exec"
 	"github.com/gruntwork-io/terragrunt/internal/os/signal"
 	"github.com/gruntwork-io/terragrunt/telemetry"
-	"github.com/gruntwork-io/terragrunt/tf"
-	"golang.org/x/sync/errgroup"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 
 	"github.com/gruntwork-io/terragrunt/cli/commands"
-	"github.com/gruntwork-io/terragrunt/cli/commands/graph"
 	"github.com/gruntwork-io/terragrunt/cli/flags"
 	"github.com/gruntwork-io/terragrunt/cli/flags/global"
 
 	"github.com/gruntwork-io/go-commons/version"
 	"github.com/gruntwork-io/terragrunt/config"
 	"github.com/gruntwork-io/terragrunt/internal/errors"
-	"github.com/gruntwork-io/terragrunt/util"
-	hashicorpversion "github.com/hashicorp/go-version"
 
-	"github.com/gruntwork-io/go-commons/env"
-	runCmd "github.com/gruntwork-io/terragrunt/cli/commands/run"
-	runall "github.com/gruntwork-io/terragrunt/cli/commands/run-all"
 	"github.com/gruntwork-io/terragrunt/internal/cli"
 	"github.com/gruntwork-io/terragrunt/options"
-	"github.com/gruntwork-io/terragrunt/pkg/log/format/placeholders"
 )
 
 const (
@@ -64,7 +52,7 @@ func NewApp(opts *options.TerragruntOptions) *App {
 	app.Writer = opts.Writer
 	app.ErrWriter = opts.ErrWriter
 	app.Flags = global.NewFlagsWithDeprecatedMovedFlags(opts)
-	app.Commands = terragruntCommands.WrapAction(WrapWithTelemetry(opts))
+	app.Commands = terragruntCommands.WrapAction(commands.WrapWithTelemetry(opts))
 	app.Before = beforeAction(opts)
 	app.OsExiter = OSExiter
 	app.ExitErrHandler = ExitErrHandler
@@ -157,25 +145,6 @@ func removeNoColorFlagDuplicates(args []string) []string {
 	return filteredArgs
 }
 
-// WrapWithTelemetry wraps CLI command execution with setting of telemetry context and labels, if telemetry is disabled, just runAction the command.
-func WrapWithTelemetry(opts *options.TerragruntOptions) func(ctx *cli.Context, action cli.ActionFunc) error {
-	return func(ctx *cli.Context, action cli.ActionFunc) error {
-		return telemetry.TelemeterFromContext(ctx).Collect(ctx.Context, fmt.Sprintf("%s %s", ctx.Command.Name, opts.TerraformCommand), map[string]any{
-			"terraformCommand": opts.TerraformCommand,
-			"args":             opts.TerraformCliArgs,
-			"dir":              opts.WorkingDir,
-		}, func(childCtx context.Context) error {
-			ctx.Context = childCtx //nolint:fatcontext
-			if err := initialSetup(ctx, opts); err != nil {
-				return err
-			}
-
-			// TODO: See if this lint should be ignored
-			return runAction(ctx, opts, action) //nolint:contextcheck
-		})
-	}
-}
-
 func beforeAction(_ *options.TerragruntOptions) cli.ActionFunc {
 	return func(ctx *cli.Context) error {
 		// setting current context to the options
@@ -190,205 +159,6 @@ func beforeAction(_ *options.TerragruntOptions) cli.ActionFunc {
 	}
 }
 
-func runAction(cliCtx *cli.Context, opts *options.TerragruntOptions, action cli.ActionFunc) error {
-	ctx, cancel := context.WithCancel(cliCtx.Context)
-	defer cancel()
-
-	errGroup, ctx := errgroup.WithContext(ctx)
-
-	// Run provider cache server
-	if opts.ProviderCache {
-		server, err := InitProviderCacheServer(opts)
-		if err != nil {
-			return err
-		}
-
-		ln, err := server.Listen()
-		if err != nil {
-			return err
-		}
-		defer ln.Close() //nolint:errcheck
-
-		cliCtx.Context = tf.ContextWithTerraformCommandHook(ctx, server.TerraformCommandHook)
-
-		errGroup.Go(func() error {
-			return server.Run(ctx, ln)
-		})
-	}
-
-	// Run command action
-	errGroup.Go(func() error {
-		defer cancel()
-
-		if action != nil {
-			return action(cliCtx)
-		}
-
-		return nil
-	})
-
-	return errGroup.Wait()
-}
-
-// mostly preparing terragrunt options
-func initialSetup(cliCtx *cli.Context, opts *options.TerragruntOptions) error {
-	// convert the rest flags (intended for terraform) to one dash, e.g. `--input=true` to `-input=true`
-	args := cliCtx.Args().WithoutBuiltinCmdSep().Normalize(cli.SingleDashFlag)
-	cmdName := cliCtx.Command.Name
-
-	switch {
-	case cmdName == runCmd.CommandName:
-		fallthrough
-	case cmdName == runall.CommandName:
-		fallthrough
-	case cmdName == graph.CommandName && cliCtx.Parent().Command.IsRoot:
-		cmdName = args.CommandName()
-	default:
-		args = append([]string{cmdName}, args...)
-	}
-
-	// `terraform apply -destroy` is an alias for `terraform destroy`.
-	// It is important to resolve the alias because the `run-all` relies on terraform command to determine the order, for `destroy` command is used the reverse order.
-	if cmdName == tf.CommandNameApply && util.ListContainsElement(args, tf.FlagNameDestroy) {
-		cmdName = tf.CommandNameDestroy
-		args = append([]string{tf.CommandNameDestroy}, args.Tail()...)
-		args = util.RemoveElementFromList(args, tf.FlagNameDestroy)
-	}
-
-	// Since Terragrunt and Terraform have the same `-no-color` flag,
-	// if a user specifies `-no-color` for Terragrunt, we should propagate it to Terraform as well.
-	if opts.Logger.Formatter().DisabledColors() {
-		args = append(args, tf.FlagNameNoColor)
-	}
-
-	opts.TerraformCommand = cmdName
-	opts.TerraformCliArgs = args
-
-	opts.Env = env.Parse(os.Environ())
-
-	// --- Working Dir
-	if opts.WorkingDir == "" {
-		currentDir, err := os.Getwd()
-		if err != nil {
-			return errors.New(err)
-		}
-
-		opts.WorkingDir = currentDir
-	}
-
-	opts.WorkingDir = filepath.ToSlash(opts.WorkingDir)
-
-	workingDir, err := filepath.Abs(opts.WorkingDir)
-	if err != nil {
-		return errors.New(err)
-	}
-
-	opts.Logger = opts.Logger.WithField(placeholders.WorkDirKeyName, workingDir)
-
-	opts.RootWorkingDir = filepath.ToSlash(workingDir)
-
-	if err := opts.Logger.Formatter().SetBaseDir(opts.RootWorkingDir); err != nil {
-		return err
-	}
-
-	if opts.LogShowAbsPaths {
-		opts.Logger.Formatter().DisableRelativePaths()
-	}
-
-	// --- Download Dir
-	if opts.DownloadDir == "" {
-		opts.DownloadDir = util.JoinPath(opts.WorkingDir, util.TerragruntCacheDir)
-	}
-
-	downloadDir, err := filepath.Abs(opts.DownloadDir)
-	if err != nil {
-		return errors.New(err)
-	}
-
-	opts.DownloadDir = filepath.ToSlash(downloadDir)
-
-	// --- Terragrunt ConfigPath
-	if opts.TerragruntConfigPath == "" {
-		opts.TerragruntConfigPath = config.GetDefaultConfigPath(opts.WorkingDir)
-	} else if !filepath.IsAbs(opts.TerragruntConfigPath) &&
-		(cliCtx.Command.Name == runCmd.CommandName || slices.Contains(tf.CommandNames, cliCtx.Command.Name)) {
-		opts.TerragruntConfigPath = util.JoinPath(opts.WorkingDir, opts.TerragruntConfigPath)
-	}
-
-	opts.TerragruntConfigPath, err = filepath.Abs(opts.TerragruntConfigPath)
-	if err != nil {
-		return errors.New(err)
-	}
-
-	opts.TerraformPath = filepath.ToSlash(opts.TerraformPath)
-
-	opts.ExcludeDirs, err = util.GlobCanonicalPath(opts.WorkingDir, opts.ExcludeDirs...)
-	if err != nil {
-		return err
-	}
-
-	if len(opts.IncludeDirs) > 0 {
-		opts.Logger.Debugf("Included directories set. Excluding by default.")
-		opts.ExcludeByDefault = true
-	}
-
-	if !opts.ExcludeByDefault && len(opts.ModulesThatInclude) > 0 {
-		opts.Logger.Debugf("Modules that include set. Excluding by default.")
-		opts.ExcludeByDefault = true
-	}
-
-	if !opts.ExcludeByDefault && len(opts.UnitsReading) > 0 {
-		opts.Logger.Debugf("Units that read set. Excluding by default.")
-		opts.ExcludeByDefault = true
-	}
-
-	if !opts.ExcludeByDefault && opts.StrictInclude {
-		opts.Logger.Debugf("Strict include set. Excluding by default.")
-		opts.ExcludeByDefault = true
-	}
-
-	opts.IncludeDirs, err = util.GlobCanonicalPath(opts.WorkingDir, opts.IncludeDirs...)
-	if err != nil {
-		return err
-	}
-
-	excludeDirs, err := util.GetExcludeDirsFromFile(opts.WorkingDir, opts.ExcludesFile)
-	if err != nil {
-		return err
-	}
-
-	opts.ExcludeDirs = append(opts.ExcludeDirs, excludeDirs...)
-
-	// --- Terragrunt Version
-	terragruntVersion, err := hashicorpversion.NewVersion(cliCtx.App.Version)
-	if err != nil {
-		// Malformed Terragrunt version; set the version to 0.0
-		if terragruntVersion, err = hashicorpversion.NewVersion("0.0"); err != nil {
-			return errors.New(err)
-		}
-	}
-
-	opts.TerragruntVersion = terragruntVersion
-	// Log the terragrunt version in debug mode. This helps with debugging issues and ensuring a specific version of terragrunt used.
-	opts.Logger.Debugf("Terragrunt Version: %s", opts.TerragruntVersion)
-
-	// --- Others
-	if !opts.RunAllAutoApprove {
-		// When running in no-auto-approve mode, set parallelism to 1 so that interactive prompts work.
-		opts.Parallelism = 1
-	}
-
-	opts.OriginalTerragruntConfigPath = opts.TerragruntConfigPath
-	opts.OriginalTerraformCommand = opts.TerraformCommand
-	opts.OriginalIAMRoleOptions = opts.IAMRoleOptions
-
-	opts.RunTerragrunt = runCmd.Run
-
-	exec.PrepareConsole(opts.Logger)
-
-	return nil
-}
-
 // OSExiter is an empty function that overrides the default behavior.
 func OSExiter(exitCode int) {
 	// Do nothing. We just need to override this function, as the default value calls os.Exit, which
diff --git a/cli/commands/aws-provider-patch/cli.go b/cli/commands/aws-provider-patch/cli.go
index 93cc2a8f..adc7b5aa 100644
--- a/cli/commands/aws-provider-patch/cli.go
+++ b/cli/commands/aws-provider-patch/cli.go
@@ -35,6 +35,7 @@ import (
 	"github.com/gruntwork-io/terragrunt/cli/commands/run"
 	"github.com/gruntwork-io/terragrunt/cli/flags"
 	"github.com/gruntwork-io/terragrunt/internal/cli"
+	"github.com/gruntwork-io/terragrunt/internal/strict/controls"
 	"github.com/gruntwork-io/terragrunt/options"
 )
 
@@ -61,12 +62,25 @@ func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
 }
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
+	control := controls.NewDeprecatedCommand(CommandName)
+	opts.StrictControls.FilterByNames(controls.DeprecatedCommands, controls.CLIRedesign, CommandName).AddSubcontrolsToCategory(controls.CLIRedesignCommandsCategoryName, control)
+
 	cmd := &cli.Command{
 		Name:   CommandName,
 		Usage:  "Overwrite settings on nested AWS providers to work around a Terraform bug (issue #13018).",
 		Hidden: true,
 		Flags:  append(run.NewFlags(opts, nil), NewFlags(opts, nil)...),
-		Action: func(ctx *cli.Context) error { return Run(ctx, opts.OptionsFromContext(ctx)) },
+		Before: func(ctx *cli.Context) error {
+			if err := control.Evaluate(ctx); err != nil {
+				return cli.NewExitError(err, cli.ExitCodeGeneralError)
+			}
+
+			return nil
+		},
+		Action: func(ctx *cli.Context) error {
+			return Run(ctx, opts.OptionsFromContext(ctx))
+		},
+		DisabledErrorOnUndefinedFlag: true,
 	}
 
 	cmd = runall.WrapCommand(opts, cmd, run.Run)
diff --git a/cli/commands/backend/bootstrap/cli.go b/cli/commands/backend/bootstrap/cli.go
index fd93cb82..354d2c78 100644
--- a/cli/commands/backend/bootstrap/cli.go
+++ b/cli/commands/backend/bootstrap/cli.go
@@ -16,10 +16,9 @@ func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	cmd := &cli.Command{
-		Name:                 CommandName,
-		Usage:                "Bootstrap OpenTofu/Terraform backend infrastructure.",
-		Flags:                NewFlags(opts, nil),
-		ErrorOnUndefinedFlag: true,
+		Name:  CommandName,
+		Usage: "Bootstrap OpenTofu/Terraform backend infrastructure.",
+		Flags: NewFlags(opts, nil),
 		Action: func(ctx *cli.Context) error {
 			return Run(ctx, opts.OptionsFromContext(ctx))
 		},
diff --git a/cli/commands/backend/cli.go b/cli/commands/backend/cli.go
index 525bf7e4..e164e380 100644
--- a/cli/commands/backend/cli.go
+++ b/cli/commands/backend/cli.go
@@ -21,7 +21,6 @@ func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 			delete.NewCommand(opts),
 			migrate.NewCommand(opts),
 		},
-		ErrorOnUndefinedFlag: true,
-		Action:               cli.ShowCommandHelp,
+		Action: cli.ShowCommandHelp,
 	}
 }
diff --git a/cli/commands/backend/delete/cli.go b/cli/commands/backend/delete/cli.go
index 37400777..67682f93 100644
--- a/cli/commands/backend/delete/cli.go
+++ b/cli/commands/backend/delete/cli.go
@@ -39,10 +39,9 @@ func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	cmd := &cli.Command{
-		Name:                 CommandName,
-		Usage:                "Delete OpenTofu/Terraform state.",
-		Flags:                NewFlags(opts, nil),
-		ErrorOnUndefinedFlag: true,
+		Name:  CommandName,
+		Usage: "Delete OpenTofu/Terraform state.",
+		Flags: NewFlags(opts, nil),
 		Action: func(ctx *cli.Context) error {
 			return Run(ctx, opts.OptionsFromContext(ctx))
 		},
diff --git a/cli/commands/backend/migrate/cli.go b/cli/commands/backend/migrate/cli.go
index 4a975228..a11eba0c 100644
--- a/cli/commands/backend/migrate/cli.go
+++ b/cli/commands/backend/migrate/cli.go
@@ -33,11 +33,10 @@ func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	cmd := &cli.Command{
-		Name:                 CommandName,
-		Usage:                "Migrate OpenTofu/Terraform state from one location to another.",
-		UsageText:            usageText,
-		Flags:                NewFlags(opts, nil),
-		ErrorOnUndefinedFlag: true,
+		Name:      CommandName,
+		Usage:     "Migrate OpenTofu/Terraform state from one location to another.",
+		UsageText: usageText,
+		Flags:     NewFlags(opts, nil),
 		Action: func(ctx *cli.Context) error {
 			srcPath := ctx.Args().First()
 			if srcPath == "" {
diff --git a/cli/commands/catalog/cli.go b/cli/commands/catalog/cli.go
index ef12455a..b664d0ea 100644
--- a/cli/commands/catalog/cli.go
+++ b/cli/commands/catalog/cli.go
@@ -22,10 +22,9 @@ func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	return &cli.Command{
-		Name:                 CommandName,
-		Usage:                "Launch the user interface for searching and managing your module catalog.",
-		ErrorOnUndefinedFlag: true,
-		Flags:                NewFlags(opts, nil),
+		Name:  CommandName,
+		Usage: "Launch the user interface for searching and managing your module catalog.",
+		Flags: NewFlags(opts, nil),
 		Action: func(ctx *cli.Context) error {
 			var repoPath string
 
diff --git a/cli/commands/commands.go b/cli/commands/commands.go
index 00f72537..caa9c731 100644
--- a/cli/commands/commands.go
+++ b/cli/commands/commands.go
@@ -2,6 +2,13 @@
 package commands
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+
+	"github.com/gruntwork-io/go-commons/env"
 	"github.com/gruntwork-io/terragrunt/cli/commands/backend"
 	"github.com/gruntwork-io/terragrunt/cli/commands/dag"
 	"github.com/gruntwork-io/terragrunt/cli/commands/find"
@@ -10,9 +17,14 @@ import (
 	"github.com/gruntwork-io/terragrunt/cli/commands/list"
 	"github.com/gruntwork-io/terragrunt/cli/commands/render"
 	"github.com/gruntwork-io/terragrunt/cli/commands/stack"
+	"github.com/gruntwork-io/terragrunt/config"
 	"github.com/gruntwork-io/terragrunt/options"
+	"github.com/gruntwork-io/terragrunt/pkg/log/format/placeholders"
+	"github.com/gruntwork-io/terragrunt/telemetry"
+	"github.com/gruntwork-io/terragrunt/tf"
+	"github.com/gruntwork-io/terragrunt/util"
+	"golang.org/x/sync/errgroup"
 
-	"github.com/gruntwork-io/terragrunt/cli/commands/graph"
 	helpCmd "github.com/gruntwork-io/terragrunt/cli/commands/help"
 	versionCmd "github.com/gruntwork-io/terragrunt/cli/commands/version"
 
@@ -21,13 +33,13 @@ import (
 	awsproviderpatch "github.com/gruntwork-io/terragrunt/cli/commands/aws-provider-patch"
 	"github.com/gruntwork-io/terragrunt/cli/commands/catalog"
 	execCmd "github.com/gruntwork-io/terragrunt/cli/commands/exec"
-	graphdependencies "github.com/gruntwork-io/terragrunt/cli/commands/graph-dependencies"
 	outputmodulegroups "github.com/gruntwork-io/terragrunt/cli/commands/output-module-groups"
-	renderjson "github.com/gruntwork-io/terragrunt/cli/commands/render-json"
 	runCmd "github.com/gruntwork-io/terragrunt/cli/commands/run"
-	runall "github.com/gruntwork-io/terragrunt/cli/commands/run-all"
-	terragruntinfo "github.com/gruntwork-io/terragrunt/cli/commands/terragrunt-info"
 	"github.com/gruntwork-io/terragrunt/internal/cli"
+	"github.com/gruntwork-io/terragrunt/internal/errors"
+	"github.com/gruntwork-io/terragrunt/internal/os/exec"
+	"github.com/gruntwork-io/terragrunt/internal/providercache"
+	hashicorpversion "github.com/hashicorp/go-version"
 )
 
 // Command category names.
@@ -49,9 +61,7 @@ const (
 func New(opts *options.TerragruntOptions) cli.Commands {
 	mainCommands := cli.Commands{
 		runCmd.NewCommand(opts),  // run
-		runall.NewCommand(opts),  // run-all
 		stack.NewCommand(opts),   // stack
-		graph.NewCommand(opts),   // graph
 		execCmd.NewCommand(opts), // exec
 		backend.NewCommand(opts), // backend
 	}.SetCategory(
@@ -82,17 +92,14 @@ func New(opts *options.TerragruntOptions) cli.Commands {
 	)
 
 	configurationCommands := cli.Commands{
-		graphdependencies.NewCommand(opts),  // graph-dependencies
-		outputmodulegroups.NewCommand(opts), // output-module-groups
 		hcl.NewCommand(opts),                // hcl
 		info.NewCommand(opts),               // info
 		dag.NewCommand(opts),                // dag
-		terragruntinfo.NewCommand(opts),     // terragrunt-info
-		renderjson.NewCommand(opts),         // render-json
 		render.NewCommand(opts),             // render
 		helpCmd.NewCommand(opts),            // help (hidden)
 		versionCmd.NewCommand(opts),         // version (hidden)
 		awsproviderpatch.NewCommand(opts),   // aws-provider-patch (hidden)
+		outputmodulegroups.NewCommand(opts), // output-module-groups (hidden)
 	}.SetCategory(
 		&cli.Category{
 			Name:  ConfigurationCommandsCategoryName,
@@ -107,12 +114,225 @@ func New(opts *options.TerragruntOptions) cli.Commands {
 		},
 	)
 
-	allCommands := mainCommands.
+	allCommands := NewDeprecatedCommands(opts).
+		Merge(mainCommands...).
 		Merge(catalogCommands...).
 		Merge(discoveryCommands...).
 		Merge(configurationCommands...).
-		Merge(shortcutsCommands...).
-		Merge(NewDeprecatedCommands(opts)...)
+		Merge(shortcutsCommands...)
 
 	return allCommands
 }
+
+// WrapWithTelemetry wraps CLI command execution with setting of telemetry context and labels, if telemetry is disabled, just runAction the command.
+func WrapWithTelemetry(opts *options.TerragruntOptions) func(ctx *cli.Context, action cli.ActionFunc) error {
+	return func(ctx *cli.Context, action cli.ActionFunc) error {
+		return telemetry.TelemeterFromContext(ctx).Collect(ctx.Context, fmt.Sprintf("%s %s", ctx.Command.Name, opts.TerraformCommand), map[string]any{
+			"terraformCommand": opts.TerraformCommand,
+			"args":             opts.TerraformCliArgs,
+			"dir":              opts.WorkingDir,
+		}, func(childCtx context.Context) error {
+			ctx.Context = childCtx //nolint:fatcontext
+			if err := initialSetup(ctx, opts); err != nil {
+				return err
+			}
+
+			// TODO: See if this lint should be ignored
+			return runAction(ctx, opts, action) //nolint:contextcheck
+		})
+	}
+}
+
+func runAction(cliCtx *cli.Context, opts *options.TerragruntOptions, action cli.ActionFunc) error {
+	ctx, cancel := context.WithCancel(cliCtx.Context)
+	defer cancel()
+
+	errGroup, ctx := errgroup.WithContext(ctx)
+
+	// Run provider cache server
+	if opts.ProviderCache {
+		server, err := providercache.InitServer(opts)
+		if err != nil {
+			return err
+		}
+
+		ln, err := server.Listen()
+		if err != nil {
+			return err
+		}
+		defer ln.Close() //nolint:errcheck
+
+		cliCtx.Context = tf.ContextWithTerraformCommandHook(ctx, server.TerraformCommandHook)
+
+		errGroup.Go(func() error {
+			return server.Run(ctx, ln)
+		})
+	}
+
+	// Run command action
+	errGroup.Go(func() error {
+		defer cancel()
+
+		if action != nil {
+			return action(cliCtx)
+		}
+
+		return nil
+	})
+
+	return errGroup.Wait()
+}
+
+// mostly preparing terragrunt options
+func initialSetup(cliCtx *cli.Context, opts *options.TerragruntOptions) error {
+	// convert the rest flags (intended for terraform) to one dash, e.g. `--input=true` to `-input=true`
+	args := cliCtx.Args().WithoutBuiltinCmdSep().Normalize(cli.SingleDashFlag)
+	cmdName := cliCtx.Command.Name
+
+	if cmdName == runCmd.CommandName {
+		cmdName = args.CommandName()
+	} else {
+		args = append([]string{cmdName}, args...)
+	}
+
+	// `terraform apply -destroy` is an alias for `terraform destroy`.
+	// It is important to resolve the alias because the `run-all` relies on terraform command to determine the order, for `destroy` command is used the reverse order.
+	if cmdName == tf.CommandNameApply && util.ListContainsElement(args, tf.FlagNameDestroy) {
+		cmdName = tf.CommandNameDestroy
+		args = append([]string{tf.CommandNameDestroy}, args.Tail()...)
+		args = util.RemoveElementFromList(args, tf.FlagNameDestroy)
+	}
+
+	// Since Terragrunt and Terraform have the same `-no-color` flag,
+	// if a user specifies `-no-color` for Terragrunt, we should propagate it to Terraform as well.
+	if opts.Logger.Formatter().DisabledColors() {
+		args = append(args, tf.FlagNameNoColor)
+	}
+
+	opts.TerraformCommand = cmdName
+	opts.TerraformCliArgs = args
+
+	opts.Env = env.Parse(os.Environ())
+
+	// --- Working Dir
+	if opts.WorkingDir == "" {
+		currentDir, err := os.Getwd()
+		if err != nil {
+			return errors.New(err)
+		}
+
+		opts.WorkingDir = currentDir
+	}
+
+	opts.WorkingDir = filepath.ToSlash(opts.WorkingDir)
+
+	workingDir, err := filepath.Abs(opts.WorkingDir)
+	if err != nil {
+		return errors.New(err)
+	}
+
+	opts.Logger = opts.Logger.WithField(placeholders.WorkDirKeyName, workingDir)
+
+	opts.RootWorkingDir = filepath.ToSlash(workingDir)
+
+	if err := opts.Logger.Formatter().SetBaseDir(opts.RootWorkingDir); err != nil {
+		return err
+	}
+
+	if opts.LogShowAbsPaths {
+		opts.Logger.Formatter().DisableRelativePaths()
+	}
+
+	// --- Download Dir
+	if opts.DownloadDir == "" {
+		opts.DownloadDir = util.JoinPath(opts.WorkingDir, util.TerragruntCacheDir)
+	}
+
+	downloadDir, err := filepath.Abs(opts.DownloadDir)
+	if err != nil {
+		return errors.New(err)
+	}
+
+	opts.DownloadDir = filepath.ToSlash(downloadDir)
+
+	// --- Terragrunt ConfigPath
+	if opts.TerragruntConfigPath == "" {
+		opts.TerragruntConfigPath = config.GetDefaultConfigPath(opts.WorkingDir)
+	} else if !filepath.IsAbs(opts.TerragruntConfigPath) &&
+		(cliCtx.Command.Name == runCmd.CommandName || slices.Contains(tf.CommandNames, cliCtx.Command.Name)) {
+		opts.TerragruntConfigPath = util.JoinPath(opts.WorkingDir, opts.TerragruntConfigPath)
+	}
+
+	opts.TerragruntConfigPath, err = filepath.Abs(opts.TerragruntConfigPath)
+	if err != nil {
+		return errors.New(err)
+	}
+
+	opts.TerraformPath = filepath.ToSlash(opts.TerraformPath)
+
+	opts.ExcludeDirs, err = util.GlobCanonicalPath(opts.WorkingDir, opts.ExcludeDirs...)
+	if err != nil {
+		return err
+	}
+
+	if len(opts.IncludeDirs) > 0 {
+		opts.Logger.Debugf("Included directories set. Excluding by default.")
+		opts.ExcludeByDefault = true
+	}
+
+	if !opts.ExcludeByDefault && len(opts.ModulesThatInclude) > 0 {
+		opts.Logger.Debugf("Modules that include set. Excluding by default.")
+		opts.ExcludeByDefault = true
+	}
+
+	if !opts.ExcludeByDefault && len(opts.UnitsReading) > 0 {
+		opts.Logger.Debugf("Units that read set. Excluding by default.")
+		opts.ExcludeByDefault = true
+	}
+
+	if !opts.ExcludeByDefault && opts.StrictInclude {
+		opts.Logger.Debugf("Strict include set. Excluding by default.")
+		opts.ExcludeByDefault = true
+	}
+
+	opts.IncludeDirs, err = util.GlobCanonicalPath(opts.WorkingDir, opts.IncludeDirs...)
+	if err != nil {
+		return err
+	}
+
+	excludeDirs, err := util.GetExcludeDirsFromFile(opts.WorkingDir, opts.ExcludesFile)
+	if err != nil {
+		return err
+	}
+
+	opts.ExcludeDirs = append(opts.ExcludeDirs, excludeDirs...)
+
+	// --- Terragrunt Version
+	terragruntVersion, err := hashicorpversion.NewVersion(cliCtx.App.Version)
+	if err != nil {
+		// Malformed Terragrunt version; set the version to 0.0
+		if terragruntVersion, err = hashicorpversion.NewVersion("0.0"); err != nil {
+			return errors.New(err)
+		}
+	}
+
+	opts.TerragruntVersion = terragruntVersion
+	// Log the terragrunt version in debug mode. This helps with debugging issues and ensuring a specific version of terragrunt used.
+	opts.Logger.Debugf("Terragrunt Version: %s", opts.TerragruntVersion)
+
+	// --- Others
+	if !opts.RunAllAutoApprove {
+		// When running in no-auto-approve mode, set parallelism to 1 so that interactive prompts work.
+		opts.Parallelism = 1
+	}
+
+	opts.OriginalTerragruntConfigPath = opts.TerragruntConfigPath
+	opts.OriginalTerraformCommand = opts.TerraformCommand
+	opts.OriginalIAMRoleOptions = opts.IAMRoleOptions
+
+	opts.RunTerragrunt = runCmd.Run
+
+	exec.PrepareConsole(opts.Logger)
+
+	return nil
+}
diff --git a/cli/commands/dag/cli.go b/cli/commands/dag/cli.go
index 8351d5ed..d18ae928 100644
--- a/cli/commands/dag/cli.go
+++ b/cli/commands/dag/cli.go
@@ -22,7 +22,6 @@ func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 		Subcommands: cli.Commands{
 			graph.NewCommand(opts, prefix),
 		},
-		ErrorOnUndefinedFlag: true,
-		Action:               cli.ShowCommandHelp,
+		Action: cli.ShowCommandHelp,
 	}
 }
diff --git a/cli/commands/dag/graph/cli.go b/cli/commands/dag/graph/cli.go
index c4d8d3b0..5682aad5 100644
--- a/cli/commands/dag/graph/cli.go
+++ b/cli/commands/dag/graph/cli.go
@@ -18,10 +18,9 @@ const (
 
 func NewCommand(opts *options.TerragruntOptions, _ flags.Prefix) *cli.Command {
 	cmd := &cli.Command{
-		Name:                 CommandName,
-		Usage:                "Graph the Directed Acyclic Graph (DAG) in DOT language.",
-		UsageText:            "terragrunt dag graph",
-		ErrorOnUndefinedFlag: true,
+		Name:      CommandName,
+		Usage:     "Graph the Directed Acyclic Graph (DAG) in DOT language.",
+		UsageText: "terragrunt dag graph",
 		Action: func(ctx *cli.Context) error {
 			return Run(ctx, opts)
 		},
diff --git a/cli/commands/deprecated.go b/cli/commands/deprecated.go
index bad0953f..0e2d64b3 100644
--- a/cli/commands/deprecated.go
+++ b/cli/commands/deprecated.go
@@ -2,13 +2,20 @@
 package commands
 
 import (
-	"fmt"
+	"slices"
 
+	awsproviderpatch "github.com/gruntwork-io/terragrunt/cli/commands/aws-provider-patch"
+	"github.com/gruntwork-io/terragrunt/cli/commands/common/graph"
+	"github.com/gruntwork-io/terragrunt/cli/commands/common/runall"
+	"github.com/gruntwork-io/terragrunt/cli/commands/dag"
+	daggraph "github.com/gruntwork-io/terragrunt/cli/commands/dag/graph"
 	"github.com/gruntwork-io/terragrunt/cli/commands/hcl"
 	"github.com/gruntwork-io/terragrunt/cli/commands/hcl/format"
 	"github.com/gruntwork-io/terragrunt/cli/commands/hcl/validate"
+	"github.com/gruntwork-io/terragrunt/cli/commands/info"
+	"github.com/gruntwork-io/terragrunt/cli/commands/info/print"
+	"github.com/gruntwork-io/terragrunt/cli/commands/render"
 	"github.com/gruntwork-io/terragrunt/cli/commands/run"
-	runall "github.com/gruntwork-io/terragrunt/cli/commands/run-all"
 	"github.com/gruntwork-io/terragrunt/internal/cli"
 	"github.com/gruntwork-io/terragrunt/internal/strict/controls"
 	"github.com/gruntwork-io/terragrunt/options"
@@ -25,61 +32,253 @@ const (
 	CommandOutputAllName   = "output-all"
 	CommandValidateAllName = "validate-all"
 
-	CommandHCLFmtName         = "hclfmt"
-	CommandHCLValidateName    = "hclvalidate"
-	CommandValidateInputsName = "validate-inputs"
+	CommandRunAllName             = "run-all"
+	CommandGraphName              = "graph"
+	CommandHCLFmtName             = "hclfmt"
+	CommandHCLValidateName        = "hclvalidate"
+	CommandValidateInputsName     = "validate-inputs"
+	CommandRenderJSONName         = "render-json"
+	CommandTerragruntInfoName     = "terragrunt-info"
+	CommandOutputModuleGroupsName = "output-module-groups"
+	CommandGraphDependenciesName  = "graph-dependencies"
 )
 
-// deprecatedCommands is a map of deprecated commands to a handler that knows how to convert the command to the known
-// alternative. The handler should return the new TerragruntOptions (if any modifications are needed) and command
-// string.
-var replaceDeprecatedCommandsFuncs = map[string]replaceDeprecatedCommandFuncType{
-	CommandSpinUpName:         replaceDeprecatedCommandFunc(controls.LegacyAll, cli.Args{runall.CommandName, tf.CommandNameApply}),
-	CommandTearDownName:       replaceDeprecatedCommandFunc(controls.LegacyAll, cli.Args{runall.CommandName, tf.CommandNameDestroy}),
-	CommandApplyAllName:       replaceDeprecatedCommandFunc(controls.LegacyAll, cli.Args{runall.CommandName, tf.CommandNameApply}),
-	CommandDestroyAllName:     replaceDeprecatedCommandFunc(controls.LegacyAll, cli.Args{runall.CommandName, tf.CommandNameDestroy}),
-	CommandPlanAllName:        replaceDeprecatedCommandFunc(controls.LegacyAll, cli.Args{runall.CommandName, tf.CommandNamePlan}),
-	CommandValidateAllName:    replaceDeprecatedCommandFunc(controls.LegacyAll, cli.Args{runall.CommandName, tf.CommandNameValidate}),
-	CommandOutputAllName:      replaceDeprecatedCommandFunc(controls.LegacyAll, cli.Args{runall.CommandName, tf.CommandNameOutput}),
-	CommandHCLFmtName:         replaceDeprecatedCommandFunc(controls.CLIRedesign, cli.Args{hcl.CommandName, format.CommandName}),
-	CommandHCLValidateName:    replaceDeprecatedCommandFunc(controls.CLIRedesign, cli.Args{hcl.CommandName, validate.CommandName}),
-	CommandValidateInputsName: replaceDeprecatedCommandFunc(controls.CLIRedesign, cli.Args{hcl.CommandName, validate.CommandName, "--" + validate.InputsFlagName}),
+// NewDeprecatedCommands returns a slice of deprecated commands to convert the command to the known alternative.
+func NewDeprecatedCommands(opts *options.TerragruntOptions) cli.Commands {
+	deprecatedCommands := DeprecatedCommands{
+		// legacy-all commands
+		newDeprecatedLegacyAllCommand(CommandSpinUpName, tf.CommandNameApply),
+		newDeprecatedLegacyAllCommand(CommandTearDownName, tf.CommandNameDestroy),
+		newDeprecatedLegacyAllCommand(CommandPlanAllName, tf.CommandNamePlan),
+		newDeprecatedLegacyAllCommand(CommandApplyAllName, tf.CommandNameApply),
+		newDeprecatedLegacyAllCommand(CommandDestroyAllName, tf.CommandNameDestroy),
+		newDeprecatedLegacyAllCommand(CommandValidateAllName, tf.CommandNameValidate),
+		newDeprecatedLegacyAllCommand(CommandOutputAllName, tf.CommandNameOutput),
+
+		// `hclfmt`
+		newDeprecatedCLIRedesignCommand(CommandHCLFmtName, cli.Args{
+			hcl.CommandName, format.CommandName}),
+		// `hclvaliate`
+		newDeprecatedCLIRedesignCommand(CommandHCLValidateName, cli.Args{
+			hcl.CommandName, validate.CommandName}),
+		// `validate-inputs`
+		newDeprecatedCLIRedesignCommand(CommandValidateInputsName, cli.Args{
+			hcl.CommandName, validate.CommandName,
+			"--" + validate.InputsFlagName}),
+		// `terragrunt-info`
+		newDeprecatedCLIRedesignCommand(CommandTerragruntInfoName, cli.Args{
+			info.CommandName, print.CommandName}),
+		// `graph-dependencies`
+		newDeprecatedCLIRedesignCommand(CommandGraphDependenciesName, cli.Args{
+			dag.CommandName, daggraph.CommandName}),
+		// `render-json`
+		newDeprecatedCLIRedesignCommand(CommandRenderJSONName, cli.Args{
+			render.CommandName,
+			"--" + render.JSONFlagName,
+			"--" + render.WriteFlagName,
+			"--" + render.OutFlagName, "terragrunt_rendered.json"}),
+
+		// `run-all` commands
+		newDeprecatedCLIRedesignCommand(CommandRunAllName, cli.Args{run.CommandName, "--" + runall.AllFlagName},
+			append(DeprecatedCommands{
+				// `run-all hclfmt`
+				newDeprecatedCLIRedesignCommand(CommandHCLFmtName,
+					cli.Args{hcl.CommandName, format.CommandName,
+						"--" + runall.AllFlagName}),
+				// `run-all hclvalidate`
+				newDeprecatedCLIRedesignCommand(CommandHCLValidateName, cli.Args{
+					hcl.CommandName, validate.CommandName,
+					"--" + runall.AllFlagName}),
+				// `run-all validate-inputs`
+				newDeprecatedCLIRedesignCommand(CommandValidateInputsName, cli.Args{
+					hcl.CommandName, validate.CommandName,
+					"--" + runall.AllFlagName,
+					"--" + validate.InputsFlagName}),
+				// `run-all render-json`
+				newDeprecatedCLIRedesignCommand(CommandRenderJSONName, cli.Args{
+					render.CommandName,
+					"--" + runall.AllFlagName,
+					"--" + render.JSONFlagName,
+					"--" + render.WriteFlagName,
+					"--" + render.OutFlagName, "terragrunt_rendered.json"}),
+				// `run-all render`
+				newDeprecatedCLIRedesignCommand(render.CommandName, cli.Args{
+					render.CommandName,
+					"--" + runall.AllFlagName}),
+				// `run-all aws-provider-patch`
+				newDeprecatedCLIRedesignCommand(awsproviderpatch.CommandName, cli.Args{
+					awsproviderpatch.CommandName,
+					"--" + runall.AllFlagName}),
+				// `run-all graph-dependencies`
+				newDeprecatedCLIRedesignCommand(CommandGraphDependenciesName, cli.Args{
+					dag.CommandName, daggraph.CommandName,
+					"--" + runall.AllFlagName}),
+			},
+				// `run-all plan/apply/...`
+				newDeprecatedCLIRedesignTFCommands(cli.Args{"--" + runall.AllFlagName})...,
+			)...,
+		),
+
+		// `graph` commands
+		newDeprecatedCLIRedesignCommand(CommandGraphName, cli.Args{run.CommandName, "--" + render.JSONFlagName},
+			append(DeprecatedCommands{
+				// `graph render-json`
+				newDeprecatedCLIRedesignCommand(CommandRenderJSONName, cli.Args{
+					render.CommandName,
+					"--" + graph.GraphFlagName,
+					"--" + render.JSONFlagName,
+					"--" + render.WriteFlagName,
+					"--" + render.OutFlagName, "terragrunt_rendered.json"}),
+				// `graph render`
+				newDeprecatedCLIRedesignCommand(render.CommandName, cli.Args{
+					render.CommandName,
+					"--" + graph.GraphFlagName}),
+			},
+				// `graph plan/apply/...`
+				newDeprecatedCLIRedesignTFCommands(cli.Args{"--" + graph.GraphFlagName})...,
+			)...,
+		),
+	}
+
+	// `push/untaint/...` all TF commands that are not shortcuts
+	deprecatedDefaultCommands := newDeprecatedDefaultCommands(opts)
+
+	return append(deprecatedCommands.CLICommands(opts), deprecatedDefaultCommands...)
 }
 
-type replaceDeprecatedCommandFuncType func(opts *options.TerragruntOptions, deprecatedCommandName string) cli.ActionFunc
+func newDeprecatedLegacyAllCommand(deprecatedCommandName, tfCommandName string) *DeprecatedCommand {
+	return &DeprecatedCommand{
+		commandName: deprecatedCommandName,
+		// we can't recoomand to use `run --all plan/apply/...` as alternative for `*-all` commands
+		// because `run` command doesn't allow TF flags to be specified before `--` separator.
+		replaceWithArgs: cli.Args{tfCommandName, "--" + runall.AllFlagName},
+		controlName:     controls.LegacyAll,
+		controlCategory: controls.RunAllCommandsCategoryName,
+	}
+}
 
-// replaceDeprecatedCommandFunc returns the `Action` function of the replacement command that is assigned to the deprecated command.
-func replaceDeprecatedCommandFunc(strictControlName string, args cli.Args) replaceDeprecatedCommandFuncType {
-	return func(opts *options.TerragruntOptions, deprecatedCommandName string) cli.ActionFunc {
-		newCommandName := fmt.Sprintf("terragrunt %s", args)
+func newDeprecatedCLIRedesignCommand(deprecatedCommandName string, replaceWithArgs cli.Args, subcommands ...*DeprecatedCommand) *DeprecatedCommand {
+	cmd := &DeprecatedCommand{
+		subcommands:     subcommands,
+		commandName:     deprecatedCommandName,
+		replaceWithArgs: replaceWithArgs,
+		controlName:     controls.CLIRedesign,
+		controlCategory: controls.CLIRedesignCommandsCategoryName,
+	}
 
-		control := controls.NewDeprecatedCommand(deprecatedCommandName, newCommandName)
-		opts.StrictControls.FilterByNames(controls.DeprecatedCommands, strictControlName, deprecatedCommandName).AddSubcontrolsToCategory(controls.RunAllCommandsCategoryName, control)
+	for _, subCmd := range subcommands {
+		subCmd.parentCommand = cmd
+	}
 
-		return func(ctx *cli.Context) error {
-			if err := control.Evaluate(ctx); err != nil {
-				return cli.NewExitError(err, cli.ExitCodeGeneralError)
-			}
+	return cmd
+}
 
-			args := append(args, ctx.Args().Slice()...)
+func newDeprecatedCLIRedesignTFCommands(args cli.Args) DeprecatedCommands {
+	var cmds = make(DeprecatedCommands, len(tf.CommandNames))
 
-			return ctx.App.NewRootCommand().Run(ctx, args)
+	for i, tfCommandName := range tf.CommandNames {
+		cmds[i] = &DeprecatedCommand{
+			commandName:     tfCommandName,
+			replaceWithArgs: append(cli.Args{tfCommandName}, args...),
+			controlName:     controls.CLIRedesign,
+			controlCategory: controls.CLIRedesignCommandsCategoryName,
 		}
 	}
+
+	return cmds
 }
 
-func NewDeprecatedCommands(opts *options.TerragruntOptions) cli.Commands {
-	var commands cli.Commands
-
-	for commandName, runFunc := range replaceDeprecatedCommandsFuncs {
-		command := &cli.Command{
-			Name:   commandName,
-			Hidden: true,
-			Action: runFunc(opts, commandName),
-			Flags:  run.NewFlags(opts, nil),
+func newDeprecatedDefaultCommands(opts *options.TerragruntOptions) cli.Commands {
+	var (
+		runCmd       = run.NewCommand(opts)
+		cmds         = make(cli.Commands, 0, len(runCmd.Subcommands))
+		strictGroups = opts.StrictControls.FilterByNames(controls.DeprecatedCommands, controls.DefaultCommands)
+	)
+
+	for _, runSubCmd := range runCmd.Subcommands {
+		if isShortcutCmd := slices.Contains(shortcutCommandNames, runSubCmd.Name); isShortcutCmd {
+			continue
+		}
+
+		newCommand := "terragrunt " + run.CommandName + " -- " + runSubCmd.Name
+		control := controls.NewDeprecatedReplacedCommand(runSubCmd.Name, newCommand)
+		strictGroups.AddSubcontrolsToCategory(controls.DefaultCommandsCategoryName, control)
+
+		cmd := &cli.Command{
+			Name:       runSubCmd.Name,
+			Usage:      runSubCmd.Usage,
+			Flags:      runCmd.Flags,
+			CustomHelp: runSubCmd.CustomHelp,
+			Before: func(ctx *cli.Context) error {
+				if err := control.Evaluate(ctx); err != nil {
+					return cli.NewExitError(err, cli.ExitCodeGeneralError)
+				}
+
+				return nil
+			},
+			Action: func(ctx *cli.Context) error {
+				return runSubCmd.Action(ctx)
+			},
+			Hidden:                       true,
+			DisabledErrorOnUndefinedFlag: true,
 		}
-		commands = append(commands, command)
+
+		cmds = append(cmds, cmd)
+	}
+
+	return cmds
+}
+
+type DeprecatedCommands []*DeprecatedCommand
+
+func (deps DeprecatedCommands) CLICommands(opts *options.TerragruntOptions) cli.Commands {
+	var commands = make(cli.Commands, len(deps))
+
+	for i, dep := range deps {
+		commands[i] = dep.CLICommand(opts)
 	}
 
 	return commands
 }
+
+type DeprecatedCommand struct {
+	commandName     string
+	controlName     string
+	controlCategory string
+	subcommands     DeprecatedCommands
+	parentCommand   *DeprecatedCommand
+	replaceWithArgs cli.Args
+}
+
+func (dep DeprecatedCommand) CLICommand(opts *options.TerragruntOptions) *cli.Command {
+	newCommand := "terragrunt " + dep.replaceWithArgs.String()
+	depCommand := dep.commandName
+
+	if dep.parentCommand != nil {
+		depCommand = dep.parentCommand.commandName + " " + depCommand
+	}
+
+	control := controls.NewDeprecatedReplacedCommand(depCommand, newCommand)
+	opts.StrictControls.FilterByNames(controls.DeprecatedCommands, dep.controlName, dep.commandName).AddSubcontrolsToCategory(dep.controlCategory, control)
+
+	return &cli.Command{
+		Name:                         dep.commandName,
+		Subcommands:                  dep.subcommands.CLICommands(opts),
+		CustomHelp:                   cli.ShowAppHelp,
+		DisabledErrorOnUndefinedFlag: true,
+		Hidden:                       true,
+		Action: func(ctx *cli.Context) error {
+			if err := control.Evaluate(ctx); err != nil {
+				return cli.NewExitError(err, cli.ExitCodeGeneralError)
+			}
+
+			// Since users can specify the same arguments that are already specified in the `replaceWith Args` slice,
+			// we need to disable the check for multiple values set for the same flag.
+			// This is a minor compromise that has virtually no impact on anything.
+			cmd := ctx.App.NewRootCommand().DisableErrorOnMultipleSetFlag()
+			args := append(dep.replaceWithArgs, ctx.Args().Slice()...)
+
+			return cmd.Run(ctx, args)
+		},
+	}
+}
diff --git a/cli/commands/exec/cli.go b/cli/commands/exec/cli.go
index c03e7b75..07e5ca1f 100644
--- a/cli/commands/exec/cli.go
+++ b/cli/commands/exec/cli.go
@@ -49,8 +49,7 @@ func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 			"# Utilize the AWS CLI.\nterragrunt exec -- aws s3 ls",
 			"# Inspect `main.tf` file of module for Unit\nterragrunt exec --in-download-dir -- cat main.tf",
 		},
-		Flags:                NewFlags(opts, cmdOpts, nil),
-		ErrorOnUndefinedFlag: true,
+		Flags: NewFlags(opts, cmdOpts, nil),
 		Action: func(ctx *cli.Context) error {
 			tgArgs, cmdArgs := ctx.Args().Split(cli.BuiltinCmdSep)
 
diff --git a/cli/commands/find/cli.go b/cli/commands/find/cli.go
index f84c49e2..2d25d558 100644
--- a/cli/commands/find/cli.go
+++ b/cli/commands/find/cli.go
@@ -90,11 +90,10 @@ func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	cmdOpts := NewOptions(opts)
 
 	return &cli.Command{
-		Name:                 CommandName,
-		Aliases:              []string{CommandAlias},
-		Usage:                "Find relevant Terragrunt configurations.",
-		ErrorOnUndefinedFlag: true,
-		Flags:                NewFlags(cmdOpts, nil),
+		Name:    CommandName,
+		Aliases: []string{CommandAlias},
+		Usage:   "Find relevant Terragrunt configurations.",
+		Flags:   NewFlags(cmdOpts, nil),
 		Before: func(ctx *cli.Context) error {
 			if cmdOpts.JSON {
 				cmdOpts.Format = FormatJSON
diff --git a/cli/commands/graph-dependencies/cli.go b/cli/commands/graph-dependencies/cli.go
deleted file mode 100644
index 8fa5e058..00000000
--- a/cli/commands/graph-dependencies/cli.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// Package graphdependencies provides the command to print the terragrunt dependency graph to stdout.
-// Deprecated: This package is deprecated and will be removed in a future version.
-// Use the 'terragrunt dag graph' command instead.
-package graphdependencies
-
-import (
-	"github.com/gruntwork-io/terragrunt/cli/commands/common/graph"
-	"github.com/gruntwork-io/terragrunt/cli/commands/common/runall"
-	"github.com/gruntwork-io/terragrunt/cli/commands/run"
-	"github.com/gruntwork-io/terragrunt/internal/cli"
-	"github.com/gruntwork-io/terragrunt/options"
-)
-
-const (
-	CommandName = "graph-dependencies"
-)
-
-func NewCommand(opts *options.TerragruntOptions) *cli.Command {
-	cmd := &cli.Command{
-		Name:   CommandName,
-		Flags:  run.NewFlags(opts, nil),
-		Usage:  "Prints the terragrunt dependency graph to stdout.",
-		Action: func(ctx *cli.Context) error { return Run(ctx, opts.OptionsFromContext(ctx)) },
-	}
-
-	cmd = runall.WrapCommand(opts, cmd, run.Run)
-	cmd = graph.WrapCommand(opts, cmd, run.Run)
-
-	return cmd
-}
diff --git a/cli/commands/graph-dependencies/graph-dependencies.go b/cli/commands/graph-dependencies/graph-dependencies.go
deleted file mode 100644
index 606ab052..00000000
--- a/cli/commands/graph-dependencies/graph-dependencies.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package graphdependencies
-
-import (
-	"context"
-
-	"github.com/gruntwork-io/terragrunt/configstack"
-	"github.com/gruntwork-io/terragrunt/options"
-)
-
-// Run graph dependencies prints the dependency graph to stdout
-func Run(ctx context.Context, opts *options.TerragruntOptions) error {
-	stack, err := configstack.FindStackInSubfolders(ctx, opts)
-	if err != nil {
-		return err
-	}
-
-	// Exit early if the operation wanted is to get the graph
-	stack.Graph(opts)
-
-	return nil
-}
diff --git a/cli/commands/graph/cli.go b/cli/commands/graph/cli.go
deleted file mode 100644
index ccb246b5..00000000
--- a/cli/commands/graph/cli.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Package graph provides the `graph` command for Terragrunt.
-package graph
-
-import (
-	"context"
-	"sort"
-
-	awsproviderpatch "github.com/gruntwork-io/terragrunt/cli/commands/aws-provider-patch"
-	"github.com/gruntwork-io/terragrunt/cli/commands/common/graph"
-	graphdependencies "github.com/gruntwork-io/terragrunt/cli/commands/graph-dependencies"
-	renderjson "github.com/gruntwork-io/terragrunt/cli/commands/render-json"
-	"github.com/gruntwork-io/terragrunt/cli/commands/run"
-	terragruntinfo "github.com/gruntwork-io/terragrunt/cli/commands/terragrunt-info"
-	"github.com/gruntwork-io/terragrunt/internal/cli"
-	"github.com/gruntwork-io/terragrunt/options"
-)
-
-const CommandName = "graph"
-
-func NewCommand(opts *options.TerragruntOptions) *cli.Command {
-	return &cli.Command{
-		Name:                 CommandName,
-		Usage:                "Execute commands on the full graph of dependent modules for the current module, ensuring correct execution order.",
-		ErrorOnUndefinedFlag: true,
-		Flags:                run.NewFlags(opts, nil),
-		Subcommands:          subCommands(opts).SkipRunning(),
-		Action:               action(opts),
-	}
-}
-
-func action(opts *options.TerragruntOptions) cli.ActionFunc {
-	return func(cliCtx *cli.Context) error {
-		opts.RunTerragrunt = func(ctx context.Context, opts *options.TerragruntOptions) error {
-			if cmd := cliCtx.Command.Subcommand(opts.TerraformCommand); cmd != nil {
-				cliCtx := cliCtx.WithValue(options.ContextKey, opts)
-
-				return cmd.Action(cliCtx)
-			}
-
-			return run.Run(ctx, opts)
-		}
-
-		return graph.Run(cliCtx.Context, opts.OptionsFromContext(cliCtx))
-	}
-}
-
-func subCommands(opts *options.TerragruntOptions) cli.Commands {
-	cmds := cli.Commands{
-		terragruntinfo.NewCommand(opts),    // terragrunt-info
-		graphdependencies.NewCommand(opts), // graph-dependencies
-		renderjson.NewCommand(opts),        // render-json
-		awsproviderpatch.NewCommand(opts),  // aws-provider-patch
-	}
-	sort.Sort(cmds)
-	cmds.Add(run.NewCommand(opts))
-
-	return cmds
-}
diff --git a/cli/commands/hcl/cli.go b/cli/commands/hcl/cli.go
index 7655529f..3f1480c8 100644
--- a/cli/commands/hcl/cli.go
+++ b/cli/commands/hcl/cli.go
@@ -19,7 +19,6 @@ func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 			format.NewCommand(opts),
 			validate.NewCommand(opts),
 		},
-		ErrorOnUndefinedFlag: true,
-		Action:               cli.ShowCommandHelp,
+		Action: cli.ShowCommandHelp,
 	}
 }
diff --git a/cli/commands/hcl/format/cli.go b/cli/commands/hcl/format/cli.go
index cd126eeb..3645df96 100644
--- a/cli/commands/hcl/format/cli.go
+++ b/cli/commands/hcl/format/cli.go
@@ -81,11 +81,10 @@ func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	cmd := &cli.Command{
-		Name:                 CommandName,
-		Aliases:              []string{CommandNameAlias},
-		Usage:                "Recursively find HashiCorp Configuration Language (HCL) files and rewrite them into a canonical format.",
-		Flags:                NewFlags(opts, nil),
-		ErrorOnUndefinedFlag: true,
+		Name:    CommandName,
+		Aliases: []string{CommandNameAlias},
+		Usage:   "Recursively find HashiCorp Configuration Language (HCL) files and rewrite them into a canonical format.",
+		Flags:   NewFlags(opts, nil),
 		Action: func(ctx *cli.Context) error {
 			return Run(ctx, opts.OptionsFromContext(ctx))
 		},
diff --git a/cli/commands/hcl/validate/cli.go b/cli/commands/hcl/validate/cli.go
index c4768085..de5195d2 100644
--- a/cli/commands/hcl/validate/cli.go
+++ b/cli/commands/hcl/validate/cli.go
@@ -71,9 +71,10 @@ func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	cmd := &cli.Command{
-		Name:  CommandName,
-		Usage: "Recursively find HashiCorp Configuration Language (HCL) files and validate them.",
-		Flags: NewFlags(opts, nil),
+		Name:                         CommandName,
+		Usage:                        "Recursively find HashiCorp Configuration Language (HCL) files and validate them.",
+		Flags:                        NewFlags(opts, nil),
+		DisabledErrorOnUndefinedFlag: true,
 		Action: func(ctx *cli.Context) error {
 			return Run(ctx, opts.OptionsFromContext(ctx))
 		},
diff --git a/cli/commands/help/cli.go b/cli/commands/help/cli.go
index 9eec9ea7..7c6d78d0 100644
--- a/cli/commands/help/cli.go
+++ b/cli/commands/help/cli.go
@@ -16,9 +16,10 @@ const (
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	return &cli.Command{
-		Name:   CommandName,
-		Usage:  "Show help.",
-		Hidden: true,
+		Name:                         CommandName,
+		Usage:                        "Show help.",
+		Hidden:                       true,
+		DisabledErrorOnUndefinedFlag: true,
 		Action: func(ctx *cli.Context) error {
 			return Action(ctx, opts)
 		},
diff --git a/cli/commands/info/cli.go b/cli/commands/info/cli.go
index 1610e222..cfc221bc 100644
--- a/cli/commands/info/cli.go
+++ b/cli/commands/info/cli.go
@@ -4,7 +4,6 @@ package info
 import (
 	"github.com/gruntwork-io/terragrunt/cli/commands/info/print"
 	"github.com/gruntwork-io/terragrunt/cli/commands/info/strict"
-	"github.com/gruntwork-io/terragrunt/cli/flags"
 	"github.com/gruntwork-io/terragrunt/internal/cli"
 	"github.com/gruntwork-io/terragrunt/options"
 )
@@ -14,16 +13,13 @@ const (
 )
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
-	prefix := flags.Prefix{CommandName}
-
 	return &cli.Command{
 		Name:  CommandName,
 		Usage: "List of commands to display Terragrunt settings.",
 		Subcommands: cli.Commands{
-			strict.NewCommand(opts, prefix),
-			print.NewCommand(opts, prefix),
+			strict.NewCommand(opts),
+			print.NewCommand(opts),
 		},
-		ErrorOnUndefinedFlag: true,
-		Action:               cli.ShowCommandHelp,
+		Action: cli.ShowCommandHelp,
 	}
 }
diff --git a/cli/commands/info/print/cli.go b/cli/commands/info/print/cli.go
new file mode 100644
index 00000000..b0a246c3
--- /dev/null
+++ b/cli/commands/info/print/cli.go
@@ -0,0 +1,28 @@
+package print
+
+import (
+	"github.com/gruntwork-io/terragrunt/cli/commands/common/runall"
+	"github.com/gruntwork-io/terragrunt/cli/commands/run"
+	"github.com/gruntwork-io/terragrunt/internal/cli"
+	"github.com/gruntwork-io/terragrunt/options"
+)
+
+const (
+	CommandName = "print"
+)
+
+func NewCommand(opts *options.TerragruntOptions) *cli.Command {
+	cmd := &cli.Command{
+		Name:      CommandName,
+		Usage:     "Print out a short description of Terragrunt context.",
+		UsageText: "terragrunt info print",
+		Flags:     run.NewFlags(opts, nil),
+		Action: func(ctx *cli.Context) error {
+			return Run(ctx, opts)
+		},
+	}
+
+	cmd = runall.WrapCommand(opts, cmd, run.Run)
+
+	return cmd
+}
diff --git a/cli/commands/info/print/command.go b/cli/commands/info/print/print.go
similarity index 69%
rename from cli/commands/info/print/command.go
rename to cli/commands/info/print/print.go
index d55b9ece..4f7d9e46 100644
--- a/cli/commands/info/print/command.go
+++ b/cli/commands/info/print/print.go
@@ -13,14 +13,14 @@ import (
 	"github.com/gruntwork-io/terragrunt/config"
 	"github.com/gruntwork-io/terragrunt/internal/errors"
 
-	"github.com/gruntwork-io/terragrunt/cli/flags"
-	"github.com/gruntwork-io/terragrunt/internal/cli"
 	"github.com/gruntwork-io/terragrunt/options"
 )
 
-const (
-	CommandName = "print"
-)
+func Run(ctx context.Context, opts *options.TerragruntOptions) error {
+	target := run.NewTargetWithErrorHandler(run.TargetPointDownloadSource, handleTerragruntContextPrint, handleTerragruntContextPrintWithError)
+
+	return run.RunWithTarget(ctx, opts, target)
+}
 
 // InfoOutput represents the structured output of the info command
 type InfoOutput struct {
@@ -32,26 +32,6 @@ type InfoOutput struct {
 	WorkingDir       string `json:"working_dir"`
 }
 
-func NewListFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
-	return run.NewFlags(opts, prefix)
-}
-
-func NewCommand(opts *options.TerragruntOptions, prefix flags.Prefix) *cli.Command {
-	prefix = prefix.Append(CommandName)
-
-	return &cli.Command{
-		Name:                 CommandName,
-		Usage:                "Print out a short description of Terragrunt context.",
-		UsageText:            "terragrunt info print",
-		Flags:                NewListFlags(opts, prefix),
-		ErrorOnUndefinedFlag: true,
-		Action: func(ctx *cli.Context) error {
-			target := run.NewTargetWithErrorHandler(run.TargetPointDownloadSource, handleTerragruntContextPrint, handleTerragruntContextPrintWithError)
-			return run.RunWithTarget(ctx, opts, target)
-		},
-	}
-}
-
 func handleTerragruntContextPrint(_ context.Context, opts *options.TerragruntOptions, _ *config.TerragruntConfig) error {
 	return printTerragruntContext(opts)
 }
diff --git a/cli/commands/info/strict/command.go b/cli/commands/info/strict/command.go
index 5e0a88a0..2c39b432 100644
--- a/cli/commands/info/strict/command.go
+++ b/cli/commands/info/strict/command.go
@@ -34,24 +34,20 @@ func NewListFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flag
 	}
 }
 
-func NewCommand(opts *options.TerragruntOptions, prefix flags.Prefix) *cli.Command {
-	prefix = prefix.Append(CommandName)
-
+func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	return &cli.Command{
 		Name:  CommandName,
 		Usage: "Command associated with strict control settings.",
 		Subcommands: cli.Commands{
 			&cli.Command{
-				Name:                 ListCommandName,
-				Flags:                NewListFlags(opts, prefix),
-				Usage:                "List the strict control settings.",
-				UsageText:            "terragrunt info strict list [options] <name>",
-				ErrorOnUndefinedFlag: true,
-				Action:               ListAction(opts),
+				Name:      ListCommandName,
+				Flags:     NewListFlags(opts, nil),
+				Usage:     "List the strict control settings.",
+				UsageText: "terragrunt info strict list [options] <name>",
+				Action:    ListAction(opts),
 			},
 		},
-		ErrorOnUndefinedFlag: true,
-		Action:               cli.ShowCommandHelp,
+		Action: cli.ShowCommandHelp,
 	}
 }
 
diff --git a/cli/commands/list/cli.go b/cli/commands/list/cli.go
index ecd2dbbf..b0bb4a97 100644
--- a/cli/commands/list/cli.go
+++ b/cli/commands/list/cli.go
@@ -93,11 +93,10 @@ func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	cmdOpts := NewOptions(opts)
 
 	return &cli.Command{
-		Name:                 CommandName,
-		Aliases:              []string{CommandAlias},
-		Usage:                "List relevant Terragrunt configurations.",
-		ErrorOnUndefinedFlag: true,
-		Flags:                NewFlags(cmdOpts, nil),
+		Name:    CommandName,
+		Aliases: []string{CommandAlias},
+		Usage:   "List relevant Terragrunt configurations.",
+		Flags:   NewFlags(cmdOpts, nil),
 		Before: func(ctx *cli.Context) error {
 			if cmdOpts.Tree {
 				cmdOpts.Format = FormatTree
diff --git a/cli/commands/output-module-groups/cli.go b/cli/commands/output-module-groups/cli.go
index 734dc9b3..1f308649 100644
--- a/cli/commands/output-module-groups/cli.go
+++ b/cli/commands/output-module-groups/cli.go
@@ -2,8 +2,10 @@
 package outputmodulegroups
 
 import (
+	"github.com/gruntwork-io/terragrunt/cli/commands/find"
 	"github.com/gruntwork-io/terragrunt/cli/commands/run"
 	"github.com/gruntwork-io/terragrunt/internal/cli"
+	"github.com/gruntwork-io/terragrunt/internal/strict/controls"
 	"github.com/gruntwork-io/terragrunt/options"
 )
 
@@ -14,6 +16,11 @@ const (
 )
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
+	newCommand := "terragrunt " + find.CommandName + " --" + find.JSONFlagName
+
+	control := controls.NewDeprecatedReplacedCommand(CommandName, newCommand)
+	opts.StrictControls.FilterByNames(controls.DeprecatedCommands, controls.CLIRedesign, CommandName).AddSubcontrolsToCategory(controls.CLIRedesignCommandsCategoryName, control)
+
 	return &cli.Command{
 		Name:  CommandName,
 		Flags: run.NewFlags(opts, nil),
@@ -22,14 +29,24 @@ func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 			subCommandFunc(SubCommandApply, opts),
 			subCommandFunc(SubCommandDestroy, opts),
 		},
+		DisabledErrorOnUndefinedFlag: true,
+		Hidden:                       true,
+		Before: func(ctx *cli.Context) error {
+			if err := control.Evaluate(ctx); err != nil {
+				return cli.NewExitError(err, cli.ExitCodeGeneralError)
+			}
+
+			return nil
+		},
 		Action: func(ctx *cli.Context) error { return Run(ctx, opts.OptionsFromContext(ctx)) },
 	}
 }
 
 func subCommandFunc(cmd string, opts *options.TerragruntOptions) *cli.Command {
 	return &cli.Command{
-		Name:  cmd,
-		Usage: "Recursively find terragrunt modules in the current directory tree and output the dependency order as a list of list in JSON for the " + cmd,
+		Name:                         cmd,
+		Usage:                        "Recursively find terragrunt modules in the current directory tree and output the dependency order as a list of list in JSON for the " + cmd,
+		DisabledErrorOnUndefinedFlag: true,
 		Action: func(ctx *cli.Context) error {
 			opts.TerraformCommand = cmd
 			return Run(ctx, opts.OptionsFromContext(ctx))
diff --git a/cli/commands/render-json/cli.go b/cli/commands/render-json/cli.go
deleted file mode 100644
index 0df082c7..00000000
--- a/cli/commands/render-json/cli.go
+++ /dev/null
@@ -1,69 +0,0 @@
-// Package renderjson provides the command to render the final terragrunt config, with all variables, includes, and functions resolved, as json.
-// Deprecated: This package is deprecated and will be removed in a future version.
-// Use the 'terragrunt render' command instead.
-package renderjson
-
-import (
-	"github.com/gruntwork-io/terragrunt/cli/commands/common/graph"
-	"github.com/gruntwork-io/terragrunt/cli/commands/common/runall"
-	"github.com/gruntwork-io/terragrunt/cli/commands/run"
-	"github.com/gruntwork-io/terragrunt/cli/flags"
-	"github.com/gruntwork-io/terragrunt/internal/cli"
-	"github.com/gruntwork-io/terragrunt/options"
-)
-
-const (
-	CommandName = "render-json"
-
-	OutFlagName                     = "out"
-	WithMetadataFlagName            = "with-metadata"
-	DisableDependentModulesFlagName = "disable-dependent-modules"
-)
-
-func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
-	tgPrefix := prefix.Prepend(flags.TgPrefix)
-	terragruntPrefix := flags.Prefix{flags.TerragruntPrefix}
-	terragruntPrefixControl := flags.StrictControlsByCommand(opts.StrictControls, CommandName)
-
-	return cli.Flags{
-		flags.NewFlag(&cli.GenericFlag[string]{
-			Name:        OutFlagName,
-			EnvVars:     tgPrefix.EnvVars(OutFlagName),
-			Destination: &opts.JSONOut,
-			Usage:       "The file path that terragrunt should use when rendering the terragrunt.hcl config as json.",
-		},
-			flags.WithDeprecatedNames(terragruntPrefix.FlagNames("json-out"), terragruntPrefixControl)),
-
-		flags.NewFlag(&cli.BoolFlag{
-			Name:        WithMetadataFlagName,
-			EnvVars:     tgPrefix.EnvVars(WithMetadataFlagName),
-			Destination: &opts.RenderJSONWithMetadata,
-			Usage:       "Add metadata to the rendered JSON file.",
-		}),
-
-		flags.NewFlag(&cli.BoolFlag{
-			Name:        DisableDependentModulesFlagName,
-			EnvVars:     tgPrefix.EnvVars(DisableDependentModulesFlagName),
-			Destination: &opts.JSONDisableDependentModules,
-			Usage:       "Disable identification of dependent modules rendering json config.",
-		},
-			flags.WithDeprecatedNames(terragruntPrefix.FlagNames("json-disable-dependent-modules"), terragruntPrefixControl)),
-	}
-}
-
-func NewCommand(opts *options.TerragruntOptions) *cli.Command {
-	prefix := flags.Prefix{CommandName}
-
-	cmd := &cli.Command{
-		Name:        CommandName,
-		Usage:       "Render the final terragrunt config, with all variables, includes, and functions resolved, as json.",
-		Description: "This is useful for enforcing policies using static analysis tools like Open Policy Agent, or for debugging your terragrunt config.",
-		Flags:       append(run.NewFlags(opts, nil), NewFlags(opts, prefix)...),
-		Action:      func(ctx *cli.Context) error { return Run(ctx, opts.OptionsFromContext(ctx)) },
-	}
-
-	cmd = runall.WrapCommand(opts, cmd, run.Run)
-	cmd = graph.WrapCommand(opts, cmd, run.Run)
-
-	return cmd
-}
diff --git a/cli/commands/render-json/render-json.go b/cli/commands/render-json/render-json.go
deleted file mode 100644
index c86a131e..00000000
--- a/cli/commands/render-json/render-json.go
+++ /dev/null
@@ -1,112 +0,0 @@
-// `render-json` command takes the parsed TerragruntConfig struct and renders it out as JSON so that it can be processed by
-// other tools. To make it easier to maintain, this uses the cty representation as an intermediary.
-// NOTE: An unspecified advantage of using the cty representation is that the final block outputs would be a map
-// representation, which is easier to work with than the list representation that will be returned by a naive go-struct
-// to json conversion.
-
-package renderjson
-
-import (
-	"context"
-	"encoding/json"
-	"os"
-	"path/filepath"
-
-	"github.com/gruntwork-io/terragrunt/configstack"
-
-	"github.com/zclconf/go-cty/cty"
-	ctyjson "github.com/zclconf/go-cty/cty/json"
-
-	"github.com/gruntwork-io/terragrunt/cli/commands/run"
-	"github.com/gruntwork-io/terragrunt/config"
-	"github.com/gruntwork-io/terragrunt/internal/ctyhelper"
-	"github.com/gruntwork-io/terragrunt/internal/errors"
-	"github.com/gruntwork-io/terragrunt/options"
-	"github.com/gruntwork-io/terragrunt/util"
-)
-
-func Run(ctx context.Context, opts *options.TerragruntOptions) error {
-	target := run.NewTarget(run.TargetPointParseConfig, runRenderJSON)
-
-	return run.RunWithTarget(ctx, opts, target)
-}
-
-func runRenderJSON(ctx context.Context, opts *options.TerragruntOptions, cfg *config.TerragruntConfig) error {
-	if cfg == nil {
-		return errors.New("terragrunt was not able to render the config as json because it received no config. This is almost certainly a bug in Terragrunt. Please open an issue on github.com/gruntwork-io/terragrunt with this message and the contents of your terragrunt.hcl")
-	}
-
-	if !opts.JSONDisableDependentModules {
-		dependentModules := configstack.FindWhereWorkingDirIsIncluded(ctx, opts, cfg)
-
-		var dependentModulesPath []*string
-		for _, module := range dependentModules {
-			dependentModulesPath = append(dependentModulesPath, &module.Path)
-		}
-
-		cfg.DependentModulesPath = dependentModulesPath
-		cfg.SetFieldMetadata(config.MetadataDependentModules, map[string]any{config.FoundInFile: opts.TerragruntConfigPath})
-	}
-
-	var terragruntConfigCty cty.Value
-
-	if opts.RenderJSONWithMetadata {
-		cty, err := config.TerragruntConfigAsCtyWithMetadata(cfg)
-		if err != nil {
-			return err
-		}
-
-		terragruntConfigCty = cty
-	} else {
-		cty, err := config.TerragruntConfigAsCty(cfg)
-		if err != nil {
-			return err
-		}
-
-		terragruntConfigCty = cty
-	}
-
-	jsonBytes, err := marshalCtyValueJSONWithoutType(terragruntConfigCty)
-	if err != nil {
-		return err
-	}
-
-	jsonOutPath := opts.JSONOut
-	if !filepath.IsAbs(jsonOutPath) {
-		terragruntConfigDir := filepath.Dir(opts.TerragruntConfigPath)
-		jsonOutPath = filepath.Join(terragruntConfigDir, jsonOutPath)
-	}
-
-	if err := util.EnsureDirectory(filepath.Dir(jsonOutPath)); err != nil {
-		return err
-	}
-
-	opts.Logger.Debugf("Rendering config %s to JSON %s", opts.TerragruntConfigPath, jsonOutPath)
-
-	const ownerWriteGlobalReadPerms = 0644
-	if err := os.WriteFile(jsonOutPath, jsonBytes, ownerWriteGlobalReadPerms); err != nil {
-		return errors.New(err)
-	}
-
-	return nil
-}
-
-// marshalCtyValueJSONWithoutType marshals the given cty.Value object into a JSON object that does not have the type.
-// Using ctyjson directly would render a json object with two attributes, "value" and "type", and this function returns
-// just the "value".
-// NOTE: We have to do two marshalling passes so that we can extract just the value.
-func marshalCtyValueJSONWithoutType(ctyVal cty.Value) ([]byte, error) {
-	jsonBytesIntermediate, err := ctyjson.Marshal(ctyVal, cty.DynamicPseudoType)
-	if err != nil {
-		return nil, errors.New(err)
-	}
-
-	var ctyJSONOutput ctyhelper.CtyJSONOutput
-	if err := json.Unmarshal(jsonBytesIntermediate, &ctyJSONOutput); err != nil {
-		return nil, errors.New(err)
-	}
-
-	jsonBytes, err := json.Marshal(ctyJSONOutput.Value)
-
-	return jsonBytes, errors.New(err)
-}
diff --git a/cli/commands/render/cli.go b/cli/commands/render/cli.go
index 9badf9bc..dd647089 100644
--- a/cli/commands/render/cli.go
+++ b/cli/commands/render/cli.go
@@ -2,6 +2,7 @@
 package render
 
 import (
+	"github.com/gruntwork-io/terragrunt/cli/commands/common/graph"
 	"github.com/gruntwork-io/terragrunt/cli/commands/common/runall"
 	"github.com/gruntwork-io/terragrunt/cli/commands/run"
 	"github.com/gruntwork-io/terragrunt/cli/flags"
@@ -24,6 +25,8 @@ const (
 
 func NewFlags(opts *Options, prefix flags.Prefix) cli.Flags {
 	tgPrefix := prefix.Prepend(flags.TgPrefix)
+	terragruntPrefix := flags.Prefix{flags.TerragruntPrefix}
+	terragruntPrefixControl := flags.StrictControlsByCommand(opts.StrictControls, CommandName)
 
 	return cli.Flags{
 		flags.NewFlag(&cli.GenericFlag[string]{
@@ -80,21 +83,31 @@ func NewFlags(opts *Options, prefix flags.Prefix) cli.Flags {
 			EnvVars:     tgPrefix.EnvVars(OutFlagName),
 			Destination: &opts.OutputPath,
 			Usage:       "The file name that terragrunt should use when rendering the terragrunt.hcl config (next to the unit configuration).",
-		}),
+		},
+			flags.WithDeprecatedFlagName("json-out", terragruntPrefixControl),                          // `--json-out`
+			flags.WithDeprecatedEnvVars(tgPrefix.EnvVars("render-json-out"), terragruntPrefixControl),  // `TG_RENDER_JSON_OUT`
+			flags.WithDeprecatedNames(terragruntPrefix.FlagNames("json-out"), terragruntPrefixControl), // `--terragrunt-json-out`, `TERRAGRUNT_JSON_OUT`
+		),
 
 		flags.NewFlag(&cli.BoolFlag{
 			Name:        WithMetadataFlagName,
 			EnvVars:     tgPrefix.EnvVars(WithMetadataFlagName),
 			Destination: &opts.RenderMetadata,
 			Usage:       "Add metadata to the rendered output file.",
-		}),
+		},
+			flags.WithDeprecatedEnvVars(tgPrefix.EnvVars("render-json-with-metadata"), terragruntPrefixControl), // `TG_RENDER_JSON_WITH_METADATA`
+			flags.WithDeprecatedNames(terragruntPrefix.FlagNames("with-metadata"), terragruntPrefixControl),     // `--terragrunt-with-metadata`, `TERRAGRUNT_WITH_METADATA`
+		),
 
 		flags.NewFlag(&cli.BoolFlag{
 			Name:        DisableDependentModulesFlagName,
 			EnvVars:     tgPrefix.EnvVars(DisableDependentModulesFlagName),
 			Destination: &opts.DisableDependentModules,
 			Usage:       "Disable identification of dependent modules when rendering config.",
-		}),
+		},
+			flags.WithDeprecatedEnvVars(tgPrefix.EnvVars("render-json-disable-dependent-modules"), terragruntPrefixControl),  // `TG_RENDER_JSON_DISABLE_DEPENDENT_MODULES`
+			flags.WithDeprecatedNames(terragruntPrefix.FlagNames("json-disable-dependent-modules"), terragruntPrefixControl), // `--terragrunt-json-disable-dependent-modules`, `TERRAGRUNT_JSON_DISABLE_DEPENDENT_MODULES`
+		),
 	}
 }
 
@@ -114,10 +127,11 @@ func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 
 			return Run(ctx, renderOpts)
 		},
-		ErrorOnUndefinedFlag: true,
 	}
 
 	cmd = runall.WrapCommand(opts, cmd, run.Run)
+	// TODO: For backward compatibility, remove after getting rid of the `render-json` command, as supporting the `graph` flag for the `render` command is pointless.
+	cmd = graph.WrapCommand(opts, cmd, run.Run)
 
 	return cmd
 }
diff --git a/cli/commands/run-all/cli.go b/cli/commands/run-all/cli.go
deleted file mode 100644
index 3f42ae96..00000000
--- a/cli/commands/run-all/cli.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// Package runall provides the `run-all` command that runs a terraform command against a 'stack' by running the specified command in each subfolder.
-package runall
-
-import (
-	"context"
-	"sort"
-
-	awsproviderpatch "github.com/gruntwork-io/terragrunt/cli/commands/aws-provider-patch"
-	"github.com/gruntwork-io/terragrunt/cli/commands/common/runall"
-	graphdependencies "github.com/gruntwork-io/terragrunt/cli/commands/graph-dependencies"
-	"github.com/gruntwork-io/terragrunt/cli/commands/render"
-	renderjson "github.com/gruntwork-io/terragrunt/cli/commands/render-json"
-	"github.com/gruntwork-io/terragrunt/cli/commands/run"
-	terragruntinfo "github.com/gruntwork-io/terragrunt/cli/commands/terragrunt-info"
-	"github.com/gruntwork-io/terragrunt/internal/cli"
-	"github.com/gruntwork-io/terragrunt/options"
-)
-
-const (
-	CommandName = "run-all"
-)
-
-func NewCommand(opts *options.TerragruntOptions) *cli.Command {
-	return &cli.Command{
-		Name:        CommandName,
-		Usage:       "Run a terraform command against a 'stack' by running the specified command in each subfolder.",
-		Description: "The command will recursively find terragrunt modules in the current directory tree and run the terraform command in dependency order (unless the command is destroy, in which case the command is run in reverse dependency order).",
-		Subcommands: subCommands(opts).SkipRunning(),
-		Action:      action(opts),
-		Flags:       run.NewFlags(opts, nil),
-	}
-}
-
-func action(opts *options.TerragruntOptions) cli.ActionFunc {
-	return func(cliCtx *cli.Context) error {
-		opts.RunTerragrunt = func(ctx context.Context, opts *options.TerragruntOptions) error {
-			if cmd := cliCtx.Command.Subcommand(opts.TerraformCommand); cmd != nil {
-				cliCtx := cliCtx.WithValue(options.ContextKey, opts)
-				return cmd.Action(cliCtx)
-			}
-
-			return run.Run(ctx, opts)
-		}
-
-		return runall.Run(cliCtx.Context, opts.OptionsFromContext(cliCtx))
-	}
-}
-
-func subCommands(opts *options.TerragruntOptions) cli.Commands {
-	cmds := cli.Commands{
-		terragruntinfo.NewCommand(opts),    // terragrunt-info
-		graphdependencies.NewCommand(opts), // graph-dependencies
-		render.NewCommand(opts),            // render
-		renderjson.NewCommand(opts),        // render-json
-		awsproviderpatch.NewCommand(opts),  // aws-provider-patch
-	}
-
-	sort.Sort(cmds)
-
-	// add terraform command `*` after sorting to put the command at the end of the list in the help.
-	cmds.Add(run.NewCommand(opts))
-
-	return cmds
-}
diff --git a/cli/commands/run/cli.go b/cli/commands/run/cli.go
index f0dc5ee7..c4437438 100644
--- a/cli/commands/run/cli.go
+++ b/cli/commands/run/cli.go
@@ -29,9 +29,8 @@ func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 			//
 			// "# Run a plan against a Stack of configurations in the current directory\nterragrunt run --all -- plan",
 		},
-		Flags:                NewFlags(opts, nil),
-		ErrorOnUndefinedFlag: true,
-		Subcommands:          NewSubcommands(opts),
+		Flags:       NewFlags(opts, nil),
+		Subcommands: NewSubcommands(opts),
 		Action: func(ctx *cli.Context) error {
 			if len(ctx.Args()) == 0 {
 				return cli.ShowCommandHelp(ctx)
@@ -54,11 +53,10 @@ func NewSubcommands(opts *options.TerragruntOptions) cli.Commands {
 		usage, visible := tf.CommandUsages[name]
 
 		subcommand := &cli.Command{
-			Name:                 name,
-			Usage:                usage,
-			Hidden:               !visible,
-			CustomHelp:           ShowTFHelp(opts),
-			ErrorOnUndefinedFlag: true,
+			Name:       name,
+			Usage:      usage,
+			Hidden:     !visible,
+			CustomHelp: ShowTFHelp(opts),
 			Action: func(ctx *cli.Context) error {
 				return Action(opts)(ctx)
 			},
diff --git a/cli/commands/scaffold/cli.go b/cli/commands/scaffold/cli.go
index c3f749b5..fff8800b 100644
--- a/cli/commands/scaffold/cli.go
+++ b/cli/commands/scaffold/cli.go
@@ -83,10 +83,9 @@ func NewFlags(opts *options.TerragruntOptions, prefix flags.Prefix) cli.Flags {
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	return &cli.Command{
-		Name:                 CommandName,
-		Usage:                "Scaffold a new Terragrunt module.",
-		ErrorOnUndefinedFlag: true,
-		Flags:                NewFlags(opts, nil),
+		Name:  CommandName,
+		Usage: "Scaffold a new Terragrunt module.",
+		Flags: NewFlags(opts, nil),
 		Action: func(ctx *cli.Context) error {
 			var moduleURL, templateURL string
 
diff --git a/cli/commands/shortcuts.go b/cli/commands/shortcuts.go
index 79d71e18..9a88ae0f 100644
--- a/cli/commands/shortcuts.go
+++ b/cli/commands/shortcuts.go
@@ -4,8 +4,6 @@ import (
 	"slices"
 
 	"github.com/gruntwork-io/terragrunt/internal/cli"
-	"github.com/gruntwork-io/terragrunt/internal/strict"
-	"github.com/gruntwork-io/terragrunt/internal/strict/controls"
 	"github.com/gruntwork-io/terragrunt/options"
 	"github.com/gruntwork-io/terragrunt/tf"
 
@@ -31,39 +29,25 @@ var (
 
 func NewShortcutsCommands(opts *options.TerragruntOptions) cli.Commands {
 	var (
-		runCmd       = run.NewCommand(opts)
-		cmds         = make(cli.Commands, len(runCmd.Subcommands))
-		strictGroups = opts.StrictControls.FilterByNames(controls.DeprecatedCommands, controls.DefaultCommands)
+		runCmd = run.NewCommand(opts)
+		cmds   = make(cli.Commands, 0, len(runCmd.Subcommands))
 	)
 
-	for i, runSubCmd := range runCmd.Subcommands {
-		var (
-			isNotShortcutCmd = !slices.Contains(shortcutCommandNames, runSubCmd.Name)
-			control          strict.Control
-		)
-
-		if isNotShortcutCmd {
-			newCommand := "terragrunt run -- " + runSubCmd.Name
-			control = controls.NewDeprecatedCommand(runSubCmd.Name, newCommand)
-			strictGroups.AddSubcontrolsToCategory(controls.DefaultCommandsCategoryName, control)
+	for _, runSubCmd := range runCmd.Subcommands {
+		if isNotShortcutCmd := !slices.Contains(shortcutCommandNames, runSubCmd.Name); isNotShortcutCmd {
+			continue
 		}
 
-		cmds[i] = &cli.Command{
-			Name:       runSubCmd.Name,
-			Usage:      runSubCmd.Usage,
-			Hidden:     isNotShortcutCmd,
-			Flags:      runCmd.Flags,
-			CustomHelp: runSubCmd.CustomHelp,
-			Action: func(ctx *cli.Context) error {
-				if isNotShortcutCmd {
-					if err := control.Evaluate(ctx); err != nil {
-						return cli.NewExitError(err, cli.ExitCodeGeneralError)
-					}
-				}
-
-				return runSubCmd.Action(ctx)
-			},
+		cmd := &cli.Command{
+			Name:                         runSubCmd.Name,
+			Usage:                        runSubCmd.Usage,
+			Flags:                        runCmd.Flags,
+			CustomHelp:                   runSubCmd.CustomHelp,
+			Action:                       runSubCmd.Action,
+			DisabledErrorOnUndefinedFlag: true,
 		}
+
+		cmds = append(cmds, cmd)
 	}
 
 	return cmds
diff --git a/cli/commands/stack/cli.go b/cli/commands/stack/cli.go
index 34b6e0f6..135d66cb 100644
--- a/cli/commands/stack/cli.go
+++ b/cli/commands/stack/cli.go
@@ -29,9 +29,8 @@ const (
 // NewCommand builds the command for stack.
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	return &cli.Command{
-		Name:                 CommandName,
-		Usage:                "Terragrunt stack commands.",
-		ErrorOnUndefinedFlag: true,
+		Name:  CommandName,
+		Usage: "Terragrunt stack commands.",
 		Subcommands: cli.Commands{
 			&cli.Command{
 				Name:  generateCommandName,
diff --git a/cli/commands/terragrunt-info/cli.go b/cli/commands/terragrunt-info/cli.go
deleted file mode 100644
index 6974ff5a..00000000
--- a/cli/commands/terragrunt-info/cli.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Package terragruntinfo provides the command to emit limited terragrunt state on stdout and exits.
-package terragruntinfo
-
-import (
-	"github.com/gruntwork-io/terragrunt/cli/commands/common/graph"
-	"github.com/gruntwork-io/terragrunt/cli/commands/common/runall"
-	"github.com/gruntwork-io/terragrunt/cli/commands/run"
-	"github.com/gruntwork-io/terragrunt/internal/cli"
-	"github.com/gruntwork-io/terragrunt/options"
-)
-
-const (
-	CommandName = "terragrunt-info"
-)
-
-func NewCommand(opts *options.TerragruntOptions) *cli.Command {
-	cmd := &cli.Command{
-		Name:   CommandName,
-		Flags:  run.NewFlags(opts, nil),
-		Usage:  "Emits limited terragrunt state on stdout and exits.",
-		Action: func(ctx *cli.Context) error { return Run(ctx, opts.OptionsFromContext(ctx)) },
-	}
-
-	cmd = runall.WrapCommand(opts, cmd, run.Run)
-	cmd = graph.WrapCommand(opts, cmd, run.Run)
-
-	return cmd
-}
diff --git a/cli/commands/terragrunt-info/terragrunt-info.go b/cli/commands/terragrunt-info/terragrunt-info.go
deleted file mode 100644
index 2b18ddd0..00000000
--- a/cli/commands/terragrunt-info/terragrunt-info.go
+++ /dev/null
@@ -1,70 +0,0 @@
-// Package terragruntinfo provides information about Terragrunt configuration.
-// Deprecated: This package is deprecated and will be removed in a future version.
-// Use the newer package `print` instead.
-package terragruntinfo
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-
-	"github.com/gruntwork-io/terragrunt/internal/errors"
-
-	"github.com/gruntwork-io/terragrunt/cli/commands/run"
-	"github.com/gruntwork-io/terragrunt/config"
-	"github.com/gruntwork-io/terragrunt/options"
-)
-
-func Run(ctx context.Context, opts *options.TerragruntOptions) error {
-	target := run.NewTargetWithErrorHandler(run.TargetPointDownloadSource, runTerragruntInfo, runErrorTerragruntInfo)
-
-	return run.RunWithTarget(ctx, opts, target)
-}
-
-// TerragruntInfoGroup is the output emit as JSON by 'terragrunt-info':
-type TerragruntInfoGroup struct {
-	ConfigPath       string `json:"ConfigPath"`
-	DownloadDir      string `json:"DownloadDir"`
-	IamRole          string `json:"IamRole"`
-	TerraformBinary  string `json:"TerraformBinary"`
-	TerraformCommand string `json:"TerraformCommand"`
-	WorkingDir       string `json:"WorkingDir"`
-}
-
-func printTerragruntInfo(opts *options.TerragruntOptions) error {
-	group := TerragruntInfoGroup{
-		ConfigPath:       opts.TerragruntConfigPath,
-		DownloadDir:      opts.DownloadDir,
-		IamRole:          opts.IAMRoleOptions.RoleARN,
-		TerraformBinary:  opts.TerraformPath,
-		TerraformCommand: opts.TerraformCommand,
-		WorkingDir:       opts.WorkingDir,
-	}
-
-	b, err := json.MarshalIndent(group, "", "  ")
-	if err != nil {
-		opts.Logger.Errorf("JSON error marshalling terragrunt-info")
-
-		return errors.New(err)
-	}
-
-	if _, err := fmt.Fprintf(opts.Writer, "%s\n", b); err != nil {
-		return errors.New(err)
-	}
-
-	return nil
-}
-
-func runTerragruntInfo(ctx context.Context, opts *options.TerragruntOptions, cfg *config.TerragruntConfig) error {
-	return printTerragruntInfo(opts)
-}
-
-func runErrorTerragruntInfo(opts *options.TerragruntOptions, cfg *config.TerragruntConfig, err error) error {
-	opts.Logger.Debugf("Fetching terragrunt-info: %v", err)
-
-	if err := printTerragruntInfo(opts); err != nil {
-		opts.Logger.Errorf("Error printing terragrunt-info: %v", err)
-	}
-
-	return err
-}
diff --git a/cli/commands/version/cli.go b/cli/commands/version/cli.go
index 4a4f4dd9..4706330f 100644
--- a/cli/commands/version/cli.go
+++ b/cli/commands/version/cli.go
@@ -12,9 +12,10 @@ const (
 
 func NewCommand(opts *options.TerragruntOptions) *cli.Command {
 	return &cli.Command{
-		Name:   CommandName,
-		Usage:  "Show terragrunt version.",
-		Hidden: true,
+		Name:                         CommandName,
+		Usage:                        "Show terragrunt version.",
+		Hidden:                       true,
+		DisabledErrorOnUndefinedFlag: true,
 		Action: func(ctx *cli.Context) error {
 			return cli.NewExitError(Action(ctx), 0)
 		},
diff --git a/cli/flags/error_handler.go b/cli/flags/error_handler.go
index 624ff76f..0624f932 100644
--- a/cli/flags/error_handler.go
+++ b/cli/flags/error_handler.go
@@ -26,11 +26,11 @@ func ErrorHandler(commands cli.Commands) cli.FlagErrHandlerFunc {
 				cmdHint  = strings.Join(cmds.Names(), " ")
 			)
 
-			if ctx.Parent().Command == nil {
-				return NewGlobalFlagHintError(undefFlag, cmdHint, flagHint)
+			if ctx.Parent().Command != nil {
+				return NewCommandFlagHintError(ctx.Command.Name, undefFlag, cmdHint, flagHint)
 			}
 
-			return NewCommandFlagHintError(ctx.Command.Name, undefFlag, cmdHint, flagHint)
+			return NewGlobalFlagHintError(undefFlag, cmdHint, flagHint)
 		}
 
 		return err
diff --git a/cli/flags/flag.go b/cli/flags/flag.go
index aff88210..538d586a 100644
--- a/cli/flags/flag.go
+++ b/cli/flags/flag.go
@@ -82,7 +82,7 @@ func (newFlag *Flag) Value() cli.FlagValue {
 			continue
 		}
 
-		if deprecatedFlagValue := deprecatedFlag.Value(); deprecatedFlagValue.IsSet() {
+		if deprecatedFlagValue := deprecatedFlag.Value(); deprecatedFlagValue != nil && deprecatedFlagValue.IsSet() {
 			newValue := deprecatedFlagValue.String()
 
 			if newFlag.Flag.Value().IsNegativeBoolFlag() && deprecatedFlagValue.IsBoolFlag() {
@@ -171,7 +171,7 @@ func (newFlag *Flag) Parse(args cli.Args) error {
 			break
 		}
 
-		if errStr := err.Error(); !strings.HasPrefix(errStr, cli.ErrFlagUndefined) {
+		if errStr := err.Error(); !strings.HasPrefix(errStr, cli.ErrMsgFlagUndefined) {
 			break
 		}
 
diff --git a/config/config.go b/config/config.go
index 61206fcc..2c63db0e 100644
--- a/config/config.go
+++ b/config/config.go
@@ -1288,9 +1288,11 @@ func ParseConfig(ctx *ParsingContext, file *hclparse.File, includeFromChild *Inc
 		errs = errs.Append(err)
 	}
 
-	ctx = ctx.WithTrackInclude(baseBlocks.TrackInclude)
-	ctx = ctx.WithFeatures(baseBlocks.FeatureFlags)
-	ctx = ctx.WithLocals(baseBlocks.Locals)
+	if baseBlocks != nil {
+		ctx = ctx.WithTrackInclude(baseBlocks.TrackInclude)
+		ctx = ctx.WithFeatures(baseBlocks.FeatureFlags)
+		ctx = ctx.WithLocals(baseBlocks.Locals)
+	}
 
 	if ctx.DecodedDependencies == nil {
 		// Decode just the `dependency` blocks, retrieving the outputs from the target terragrunt config in the
diff --git a/config/config_partial.go b/config/config_partial.go
index 48cd12f5..b0c01809 100644
--- a/config/config_partial.go
+++ b/config/config_partial.go
@@ -383,9 +383,11 @@ func PartialParseConfig(ctx *ParsingContext, file *hclparse.File, includeFromChi
 		errs = errs.Append(err)
 	}
 
-	ctx = ctx.WithTrackInclude(baseBlocks.TrackInclude)
-	ctx = ctx.WithFeatures(baseBlocks.FeatureFlags)
-	ctx = ctx.WithLocals(baseBlocks.Locals)
+	if baseBlocks != nil {
+		ctx = ctx.WithTrackInclude(baseBlocks.TrackInclude)
+		ctx = ctx.WithFeatures(baseBlocks.FeatureFlags)
+		ctx = ctx.WithLocals(baseBlocks.Locals)
+	}
 
 	// Set parsed Locals on the parsed config
 	output, err := convertToTerragruntConfig(ctx, file.ConfigPath, &terragruntConfigFile{})
diff --git a/docs/_docs/04_reference/02-cli-options.md b/docs/_docs/04_reference/02-cli-options.md
index 37c83604..fc1d135c 100644
--- a/docs/_docs/04_reference/02-cli-options.md
+++ b/docs/_docs/04_reference/02-cli-options.md
@@ -20,8 +20,6 @@ The main commands available in Terragrunt are:
   - [OpenTofu shortcuts](#opentofu-shortcuts)
   - [run](#run)
   - [exec](#exec)
-  - [run-all](#run-all)
-  - [graph](#graph)
 
 The commands relevant to managing a Terragrunt stack are:
 
@@ -57,15 +55,9 @@ The commands relevant to discovering Terragrunt configurations are:
 The commands used for managing Terragrunt configuration itself are:
 
 - [Configuration commands](#configuration-commands)
-  - [graph-dependencies](#graph-dependencies)
-  - [hclfmt](#hclfmt)
-  - [hclvalidate](#hclvalidate)
-  - [output-module-groups](#output-module-groups)
-  - [render-json](#render-json)
+  - [render](#render)
   - [info](#info)
   - [dag](#dag)
-  - [terragrunt-info](#terragrunt-info)
-  - [validate-inputs](#validate-inputs)
 
 ### Main commands
 
@@ -151,156 +143,6 @@ $ terragrunt exec -- env | grep 'TF_VAR_message'
 TF_VAR_message=Hello, Terragrunt!
 ```
 
-#### run-all
-
-Runs the provided OpenTofu/Terraform command against a [stack](/docs/getting-started/terminology/#stack).
-The command will recursively find terragrunt [units](/docs/getting-started/terminology/#unit) in the current directory
-tree and run the OpenTofu/Terraform command in dependency order (unless the command is destroy,
-in which case the command is run in reverse dependency order).
-
-Make sure to read about the [stacks feature](/docs/features/stacks) for context.
-
-Example:
-
-```bash
-terragrunt run-all apply
-```
-
-This will recursively search the current working directory for any folders that contain Terragrunt units and run
-`apply` in each one, concurrently, while respecting ordering defined via
-[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
-[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
-
-**[WARNING] Do not set [TF_PLUGIN_CACHE_DIR](https://opentofu.org/docs/cli/config/config-file/#provider-plugin-cache) when using `run-all`**
-
-Instead take advantage of the built-in [Provider Cache Server](/docs/features/provider-cache-server/) that
-mitigates some of the limitations of using the OpenTofu/Terraform Provider Plugin Cache directly.
-
-We are [working with the OpenTofu team to improve this behavior](https://github.com/opentofu/opentofu/issues/1483) so that you don't have to worry about this in the future.
-
-**[NOTE] Use `run-all` with care if you have unapplied dependencies**.
-
-If you have a stack of Terragrunt units with dependencies between them via `dependency` blocks
-and you've never deployed them, then commands like `run-all plan` will fail,
-as it won't be possible to resolve outputs of `dependency` blocks without applying them first.
-
-The solution for this is to take advantage of [mock outputs in dependency blocks](/docs/reference/config-blocks-and-attributes/#dependency).
-
-**[NOTE]** Using `run-all` with `apply` or `destroy` silently adds the `-auto-approve` flag to the command line
-arguments passed to OpenTofu/Terraform due to issues with shared `stdin` making individual approvals impossible.
-
-**[NOTE]** Using the OpenTofu/Terraform [-detailed-exitcode](https://opentofu.org/docs/cli/commands/plan/#other-options)
-flag with the `run-all` command results in an aggregate exit code being returned, rather than the exit code of any particular unit.
-
-The algorithm for determining the aggregate exit code is as follows:
-
-- If any unit throws a 1, Terragrunt will throw a 1.
-- If any unit throws a 2, but nothing throws a 1, Terragrunt will throw a 2.
-- If nothing throws a non-zero, Terragrunt will throw a 0.
-
-#### graph
-
-Run the provided OpenTofu/Terraform command against the graph of dependencies for the unit in the current working directory. The graph consists of all units that depend on the unit in the current working directory via a `dependency` or `dependencies` blocks, plus all the units that depend on those units, and all the units that depend on those units, and so on, recursively up the tree, up to the Git repository root, or the path specified via the optional `--graph-root` argument.
-
-The Command will be executed following the order of dependencies: so it'll run on the unit in the current working directory first, then on units that depend on it directly, then on the units that depend on those units, and so on. Note that if the command is `destroy`, it will run in the opposite order (the final dependents, then their dependencies, etc. up to the unit you ran the command in).
-
-Example:
-Having below dependencies:
-[![dependency-graph](/assets/img/collections/documentation/dependency-graph.png){: width="80%" }]({{site.baseurl}}/assets/img/collections/documentation/dependency-graph.png)
-
-Running `terragrunt graph apply` in `eks` module will lead to the following execution order:
-
-```text
-Group 1
-- Module project/eks
-
-Group 2
-- Module project/services/eks-service-1
-- Module project/services/eks-service-2
-
-Group 3
-- Module project/services/eks-service-2-v2
-- Module project/services/eks-service-3
-- Module project/services/eks-service-5
-
-Group 4
-- Module project/services/eks-service-3-v2
-- Module project/services/eks-service-4
-
-Group 5
-- Module project/services/eks-service-3-v3
-```
-
-Notes:
-
-- `lambda` units aren't included in the graph, because they are not dependent on `eks` unit.
-- execution is from bottom up based on dependencies
-
-Running `terragrunt graph destroy` in `eks` unit will lead to the following execution order:
-
-```text
-Group 1
-- Module project/services/eks-service-2-v2
-- Module project/services/eks-service-3-v3
-- Module project/services/eks-service-4
-- Module project/services/eks-service-5
-
-Group 2
-- Module project/services/eks-service-3-v2
-
-Group 3
-- Module project/services/eks-service-3
-
-Group 4
-- Module project/services/eks-service-1
-- Module project/services/eks-service-2
-
-Group 5
-- Module project/eks
-```
-
-Notes:
-
-- execution is in reverse order, first are destroyed "top" units and in the end `eks`
-- `lambda` units aren't affected at all
-
-Running `terragrunt graph apply` in `services/eks-service-3`:
-
-```text
-Group 1
-- Module project/services/eks-service-3
-
-Group 2
-- Module project/services/eks-service-3-v2
-- Module project/services/eks-service-4
-
-Group 3
-- Module project/services/eks-service-3-v3
-
-```
-
-Notes:
-
-- in execution are included only services dependent from `eks-service-3`
-
-Running `terragrunt graph destroy` in `services/eks-service-3`:
-
-```text
-Group 1
-- Module project/services/eks-service-3-v3
-- Module project/services/eks-service-4
-
-Group 2
-- Module project/services/eks-service-3-v2
-
-Group 3
-- Module project/services/eks-service-3
-```
-
-Notes:
-
-- destroy will be executed only on subset of services dependent from `eks-service-3`
-
 ### Stack commands
 
 The `terragrunt stack` commands provide an interface for managing collections of Terragrunt units defined in `terragrunt.stack.hcl` files.
@@ -1179,1865 +1021,1972 @@ This will sort the output based on the dependency graph, as if the `destroy` com
 
 ### Configuration commands
 
-#### graph-dependencies
+#### render
 
-Prints the Terragrunt dependency graph, in DOT format, to `stdout`. You can generate charts from DOT format using tools
-such as [GraphViz](http://www.graphviz.org/).
+Render the Terragrunt configuration in the current working directory, with as much work done as possible beforehand (that is, with all includes merged, dependencies resolved/interpolated, function calls executed, etc).
 
 Example:
 
-```bash
-terragrunt graph-dependencies
+The following `terragrunt.hcl`:
+
+```hcl
+locals {
+  aws_region = "us-east-1"
+}
+
+inputs = {
+  aws_region = local.aws_region
+}
 ```
 
-This will recursively search the current working directory for any folders that contain Terragrunt modules and build
-the dependency graph based on [`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
-[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks. This may produce output such as:
+Renders to the following HCL by default:
 
-```text
-digraph {
-  "mgmt/bastion-host" ;
-  "mgmt/bastion-host" -> "mgmt/vpc";
-  "mgmt/bastion-host" -> "mgmt/kms-master-key";
-  "mgmt/kms-master-key" ;
-  "mgmt/vpc" ;
-  "stage/backend-app" ;
-  "stage/backend-app" -> "stage/vpc";
-  "stage/backend-app" -> "mgmt/bastion-host";
-  "stage/backend-app" -> "stage/mysql";
-  "stage/backend-app" -> "stage/search-app";
-  "stage/frontend-app" ;
-  "stage/frontend-app" -> "stage/vpc";
-  "stage/frontend-app" -> "mgmt/bastion-host";
-  "stage/frontend-app" -> "stage/backend-app";
-  "stage/mysql" ;
-  "stage/mysql" -> "stage/vpc";
-  "stage/redis" ;
-  "stage/redis" -> "stage/vpc";
-  "stage/search-app" ;
-  "stage/search-app" -> "stage/vpc";
-  "stage/search-app" -> "stage/redis";
-  "stage/vpc" ;
-  "stage/vpc" -> "mgmt/vpc";
+```bash
+$ terragrunt render
+locals {
+  aws_region = "us-east-1"
+}
+inputs = {
+  aws_region = "us-east-1"
 }
 ```
 
-#### hclfmt
+Note the resolution of the `aws_region` local, making it easier to read the final evaluated configuration at a glance.
 
-Recursively find hcl files and rewrite them into a canonical format.
+Renders to the following JSON when the `--format json` flag is used:
+
+```bash
+$ terragrunt render --format json
+{
+  "locals": { "aws_region": "us-east-1" },
+  "inputs": { "aws_region": "us-east-1" }
+  // NOTE: other attributes are omitted for brevity
+}
+```
+
+You can also use the `--write` flag to write the rendered configuration to a canonically named file in the same working directory as the `terragrunt.hcl` file.
 
 Example:
 
 ```bash
-terragrunt hclfmt
+# Note the use of the `--json` shortcut flag.
+terragrunt render --json --write
 ```
 
-This will recursively search the current working directory for any folders that contain Terragrunt configuration files
-and run the equivalent of `tofu fmt`/`terraform fmt` on them.
-
-#### hclvalidate
+This will write the rendered configuration to `terragrunt.rendered.json` in the current working directory.
 
-Find all hcl files from the configuration stack and validate them.
+This can be useful when rendering many configurations in a given directory, and you want to keep the rendered configurations in the same directory as the original configurations, without leveraging external tools or scripts.
 
-Example:
+This is also useful when combined with the `--all` flag, which will render all configurations discovered from the current working directory.
 
 ```bash
-terragrunt hclvalidate
+# Note the use of the `-w` alias for the `--write` flag.
+terragrunt render --all --json -w
 ```
 
-This will search all hcl files from the configuration stack in the current working directory and run the equivalent
-of `tofu validate`/`terraform validate` on them.
+This will render all configurations discovered from the current working directory and write the rendered configurations to `terragrunt.rendered.json` files adjacent to the configurations they are derived from.
 
-For convenience in programmatically parsing these findings, you can also pass the `--json` flag to output the results in JSON format.
+#### info
+
+The `info` command is used to display information about Terragrunt settings.
+
+It will soon replace the [`terragrunt-info`](#terragrunt-info) command. See the [CLI Redesign](/docs/reference/experiments/#cli-redesign) documentation for more information.
+
+##### Strict command
+
+Displays current strict controls.
 
 Example:
 
 ```bash
-terragrunt hclvalidate --json
+terragrunt info strict
 ```
 
-In addition, you can pass the `--show-config-path` flag to only output paths of the invalid config files, delimited by newlines. This can be especially useful when combined with the [queue-excludes-file](#queue-excludes-file) flag.
+You can also view detailed information on a specific control by specifying its name in the command line.
 
 Example:
 
 ```bash
-terragrunt hclvalidate --show-config-path
+terragrunt info strict deprecated-flags
 ```
 
-#### output-module-groups
+##### Print command
 
-Output groups of modules ordered for apply (or destroy) as a list of list in JSON.
+Print out a short description of the current Terragrunt context.
 
 Example:
 
 ```bash
-terragrunt output-module-groups <sub-command>
+terragrunt info print
 ```
 
-Optional sub-commands:
-
-- apply (default)
-- destroy
-
-This will recursively search the current working directory for any folders that contain Terragrunt modules and build
-the dependency graph based on [`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
-[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks and output the graph as a JSON list of list (unless the sub-command is destroy, in which case the command will output the reverse dependency order).
-
-This can be be useful in several scenarios, such as in CICD, when determining apply order or searching for all files to apply with CLI options
-such as [`--units-that-include`](#units-that-include)
+This command outputs a JSON object that includes useful contextual information such as the path to the configuration file,
+working directory, download cache location, the IAM role in use, and the Terraform (or Tofu) binary being invoked.
 
-This may produce output such as:
+Example output:
 
 ```json
 {
-  "Group 1": ["stage/frontend-app"],
-  "Group 2": ["stage/backend-app"],
-  "Group 3": ["mgmt/bastion-host", "stage/search-app"],
-  "Group 4": ["mgmt/kms-master-key", "stage/mysql", "stage/redis"],
-  "Group 5": ["stage/vpc"],
-  "Group 6": ["mgmt/vpc"]
+  "config_path": "/example/path/terragrunt.hcl",
+  "download_dir": "/example/path/.terragrunt-cache",
+  "iam_role": "",
+  "terraform_binary": "tofu",
+  "terraform_command": "print",
+  "working_dir": "/example/path"
 }
 ```
 
-#### render
-
-Render the Terragrunt configuration in the current working directory, with as much work done as possible beforehand (that is, with all includes merged, dependencies resolved/interpolated, function calls executed, etc).
+#### dag
 
-Example:
+The `dag` command is used to interact with the Directed Acyclic Graph.
 
-The following `terragrunt.hcl`:
+It will soon replace the [`graph-dependencies`](#graph-dependencies) command. See the [CLI Redesign](/docs/reference/experiments/#cli-redesign) documentation for more information.
 
-```hcl
-locals {
-  aws_region = "us-east-1"
-}
+##### dag graph
 
-inputs = {
-  aws_region = local.aws_region
-}
-```
+Print a visual representation of the Terragrunt dependency graph in DOT language format. This command analyzes your Terragrunt configuration and outputs a directed acyclic graph (DAG) showing the relationships and dependencies between your Terraform modules.
 
-Renders to the following HCL by default:
+Example usage:
 
 ```bash
-$ terragrunt render
-locals {
-  aws_region = "us-east-1"
-}
-inputs = {
-  aws_region = "us-east-1"
-}
+terragrunt dag graph
 ```
 
-Note the resolution of the `aws_region` local, making it easier to read the final evaluated configuration at a glance.
-
-Renders to the following JSON when the `--format json` flag is used:
+The output can be piped to Graphviz tools to generate visual diagrams:
 
 ```bash
-$ terragrunt render --format json
-{
-  "locals": { "aws_region": "us-east-1" },
-  "inputs": { "aws_region": "us-east-1" }
-  // NOTE: other attributes are omitted for brevity
-}
+terragrunt dag graph  | dot -Tpng > graph.png
 ```
 
-You can also use the `--write` flag to write the rendered configuration to a canonically named file in the same working directory as the `terragrunt.hcl` file.
-
-Example:
-
-```bash
-# Note the use of the `--json` shortcut flag.
-terragrunt render --json --write
-```
+## Flags
 
-This will write the rendered configuration to `terragrunt.rendered.json` in the current working directory.
+- [Flags](#flags)
+  - [all](#all)
+  - [graph](#graph)
+  - [auth-provider-cmd](#auth-provider-cmd)
+  - [config](#config)
+  - [tf-path](#tf-path)
+  - [no-auto-init](#no-auto-init)
+  - [no-auto-approve](#no-auto-approve)
+  - [no-auto-retry](#no-auto-retry)
+  - [non-interactive](#non-interactive)
+  - [working-dir](#working-dir)
+  - [download-dir](#download-dir)
+  - [source](#source)
+  - [source-map](#source-map)
+  - [source-update](#source-update)
+  - [iam-assume-role](#iam-assume-role)
+  - [iam-assume-role-duration](#iam-assume-role-duration)
+  - [iam-assume-role-session-name](#iam-assume-role-session-name)
+  - [iam-assume-role-web-identity-token](#iam-assume-role-web-identity-token)
+  - [queue-ignore-errors](#queue-ignore-errors)
+  - [queue-excludes-file](#queue-excludes-file)
+  - [queue-exclude-dir](#queue-exclude-dir)
+  - [queue-include-dir](#queue-include-dir)
+  - [queue-strict-include](#queue-strict-include)
+  - [queue-ignore-dag-order](#queue-ignore-dag-order)
+  - [queue-exclude-external](#queue-exclude-external)
+  - [queue-include-external](#queue-include-external)
+  - [strict-validate](#strict-validate)
+  - [parallelism](#parallelism)
+  - [inputs-debug](#inputs-debug)
+  - [log-level](#log-level)
+  - [log-format](#log-format)
+  - [log-custom-format](#log-custom-format)
+  - [log-disable](#log-disable)
+  - [log-show-abs-paths](#log-show-abs-paths)
+  - [no-color](#no-color)
+  - [check](#check)
+  - [diff](#diff)
+  - [hclfmt-file](#hclfmt-file)
+  - [hclfmt-exclude-dir](#hclfmt-exclude-dir)
+  - [hclfmt-stdin](#hclfmt-stdin)
+  - [hclvalidate-json](#hclvalidate-json)
+  - [hclvalidate-show-config-path](#hclvalidate-show-config-path)
+  - [disable-dependent-modules](#disable-dependent-modules)
+  - [out](#out)
+  - [units-that-include](#units-that-include)
+  - [queue-include-units-reading](#queue-include-units-reading)
+  - [dependency-fetch-output-from-state](#dependency-fetch-output-from-state)
+  - [use-partial-parse-config-cache](#use-partial-parse-config-cache)
+  - [backend-require-bootstrap](#backend-require-bootstrap)
+  - [disable-bucket-update](#disable-bucket-update)
+  - [disable-command-validation](#disable-command-validation)
+  - [provider-cache](#provider-cache)
+  - [provider-cache-dir](#provider-cache-dir)
+  - [provider-cache-hostname](#provider-cache-hostname)
+  - [provider-cache-port](#provider-cache-port)
+  - [provider-cache-token](#provider-cache-token)
+  - [provider-cache-registry-names](#provider-cache-registry-names)
+  - [out-dir](#out-dir)
+  - [json-out-dir](#json-out-dir)
+  - [tf-forward-stdout](#tf-forward-stdout)
+  - [no-destroy-dependencies-check](#no-destroy-dependencies-check)
+  - [feature](#feature)
+  - [experiment](#experiment)
+  - [experiment-mode](#experiment-mode)
+  - [strict-control](#strict-control)
+  - [strict-mode](#strict-mode)
+  - [in-download-dir](#in-download-dir)
 
-This can be useful when rendering many configurations in a given directory, and you want to keep the rendered configurations in the same directory as the original configurations, without leveraging external tools or scripts.
+### all
 
-This is also useful when combined with the `--all` flag, which will render all configurations discovered from the current working directory.
+<!-- markdownlint-disable MD033 -->
 
-```bash
-# Note the use of the `-w` alias for the `--write` flag.
-terragrunt render --all --json -w
-```
+**CLI Arg**: `--all`<br/>
+**CLI Alias**: `-a`<br/>
+**Environment Variable**: `TG_ALL` (set to `true`)<br/>
 
-This will render all configurations discovered from the current working directory and write the rendered configurations to `terragrunt.rendered.json` files adjacent to the configurations they are derived from.
+This is equivalent to the soon to be deprecated `run-all` command.
 
-#### render-json
+Runs the provided OpenTofu/Terraform command against a [stack](/docs/getting-started/terminology/#stack).
+The command will recursively find terragrunt [units](/docs/getting-started/terminology/#unit) in the current directory
+tree and run the OpenTofu/Terraform command in dependency order (unless the command is destroy,
+in which case the command is run in reverse dependency order).
 
-Render out the final interpreted `terragrunt.hcl` file (that is, with all the includes merged, dependencies
-resolved/interpolated, function calls executed, etc) as json.
+Make sure to read about the [stacks feature](/docs/features/stacks) for context.
 
 Example:
 
-The following `terragrunt.hcl`:
+```bash
+terragrunt run --all apply
+```
 
-```hcl
-locals {
-  aws_region = "us-east-1"
-}
+This will recursively search the current working directory for any folders that contain Terragrunt units and run
+`apply` in each one, concurrently, while respecting ordering defined via
+[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
+[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
 
-inputs = {
-  aws_region = local.aws_region
-}
-```
+**[WARNING] Do not set [TF_PLUGIN_CACHE_DIR](https://opentofu.org/docs/cli/config/config-file/#provider-plugin-cache) when using `run --all`**
 
-Renders to the following `terragrunt_rendered.json`:
+Instead take advantage of the built-in [Provider Cache Server](/docs/features/provider-cache-server/) that
+mitigates some of the limitations of using the OpenTofu/Terraform Provider Plugin Cache directly.
 
-```json
-{
-  "locals": { "aws_region": "us-east-1" },
-  "inputs": { "aws_region": "us-east-1" }
-  // NOTE: other attributes are omitted for brevity
-}
-```
+We are [working with the OpenTofu team to improve this behavior](https://github.com/opentofu/opentofu/issues/1483) so that you don't have to worry about this in the future.
 
-You can use the CLI option `--out` to configure where terragrunt renders out the json representation.
+**[NOTE] Use `run --all` with care if you have unapplied dependencies**.
 
-To generate json with metadata can be specified argument `--with-metadata` which will add metadata to the json output.
+If you have a stack of Terragrunt units with dependencies between them via `dependency` blocks
+and you've never deployed them, then commands like `run --all plan` will fail,
+as it won't be possible to resolve outputs of `dependency` blocks without applying them first.
 
-Example:
+The solution for this is to take advantage of [mock outputs in dependency blocks](/docs/reference/config-blocks-and-attributes/#dependency).
 
-```json
-{
-  "inputs": {
-    "aws_region": {
-      "metadata": {
-        "found_in_file": "/example/terragrunt.hcl"
-      },
-      "value": "us-east-1"
-    }
-  },
-  "locals": {
-    "aws_region": {
-      "metadata": {
-        "found_in_file": "/example/terragrunt.hcl"
-      },
-      "value": "us-east-1"
-    }
-  }
-  // NOTE: other attributes are omitted for brevity
-}
-```
+**[NOTE]** Using `run --all` with `apply` or `destroy` silently adds the `-auto-approve` flag to the command line
+arguments passed to OpenTofu/Terraform due to issues with shared `stdin` making individual approvals impossible.
 
-#### info
+**[NOTE]** Using the OpenTofu/Terraform [-detailed-exitcode](https://opentofu.org/docs/cli/commands/plan/#other-options)
+flag with the `run --all` command results in an aggregate exit code being returned, rather than the exit code of any particular unit.
 
-The `info` command is used to display information about Terragrunt settings.
+The algorithm for determining the aggregate exit code is as follows:
 
-It will soon replace the [`terragrunt-info`](#terragrunt-info) command. See the [CLI Redesign](/docs/reference/experiments/#cli-redesign) documentation for more information.
+- If any unit throws a 1, Terragrunt will throw a 1.
+- If any unit throws a 2, but nothing throws a 1, Terragrunt will throw a 2.
+- If nothing throws a non-zero, Terragrunt will throw a 0.
 
-##### Strict command
+<!-- markdownlint-disable MD024 -->
+### graph
 
-Displays current strict controls.
+**CLI Arg**: `--graph`<br/>
+**Environment Variable**: `TG_GRAPH`<br/>
 
-Example:
+This is equivalent to the soon to be deprecated `graph` command.
 
-```bash
-terragrunt info strict
-```
+Run the provided OpenTofu/Terraform command against the graph of dependencies for the unit in the current working directory. The graph consists of all units that depend on the unit in the current working directory via a `dependency` or `dependencies` blocks, plus all the units that depend on those units, and all the units that depend on those units, and so on, recursively up the tree, up to the Git repository root, or the path specified via the optional `--graph-root` argument.
 
-You can also view detailed information on a specific control by specifying its name in the command line.
+The Command will be executed following the order of dependencies: so it'll run on the unit in the current working directory first, then on units that depend on it directly, then on the units that depend on those units, and so on. Note that if the command is `destroy`, it will run in the opposite order (the final dependents, then their dependencies, etc. up to the unit you ran the command in).
 
 Example:
+Having below dependencies:
+[![dependency-graph](/assets/img/collections/documentation/dependency-graph.png){: width="80%" }]({{site.baseurl}}/assets/img/collections/documentation/dependency-graph.png)
 
-```bash
-terragrunt info strict deprecated-flags
-```
+Running `terragrunt run --graph apply` in `eks` module will lead to the following execution order:
 
-##### Print command
+```text
+Group 1
+- Module project/eks
 
-Print out a short description of the current Terragrunt context.
+Group 2
+- Module project/services/eks-service-1
+- Module project/services/eks-service-2
 
-Example:
+Group 3
+- Module project/services/eks-service-2-v2
+- Module project/services/eks-service-3
+- Module project/services/eks-service-5
 
-```bash
-terragrunt info print
+Group 4
+- Module project/services/eks-service-3-v2
+- Module project/services/eks-service-4
+
+Group 5
+- Module project/services/eks-service-3-v3
 ```
 
-This command outputs a JSON object that includes useful contextual information such as the path to the configuration file,
-working directory, download cache location, the IAM role in use, and the Terraform (or Tofu) binary being invoked.
+Notes:
 
-Example output:
+- `lambda` units aren't included in the graph, because they are not dependent on `eks` unit.
+- execution is from bottom up based on dependencies
 
-```json
-{
-  "config_path": "/example/path/terragrunt.hcl",
-  "download_dir": "/example/path/.terragrunt-cache",
-  "iam_role": "",
-  "terraform_binary": "tofu",
-  "terraform_command": "print",
-  "working_dir": "/example/path"
-}
+Running `terragrunt run --graph destroy` in `eks` unit will lead to the following execution order:
+
+```text
+Group 1
+- Module project/services/eks-service-2-v2
+- Module project/services/eks-service-3-v3
+- Module project/services/eks-service-4
+- Module project/services/eks-service-5
+
+Group 2
+- Module project/services/eks-service-3-v2
+
+Group 3
+- Module project/services/eks-service-3
+
+Group 4
+- Module project/services/eks-service-1
+- Module project/services/eks-service-2
+
+Group 5
+- Module project/eks
 ```
 
-#### dag
+Notes:
 
-The `dag` command is used to interact with the Directed Acyclic Graph.
+- execution is in reverse order, first are destroyed "top" units and in the end `eks`
+- `lambda` units aren't affected at all
 
-It will soon replace the [`graph-dependencies`](#graph-dependencies) command. See the [CLI Redesign](/docs/reference/experiments/#cli-redesign) documentation for more information.
+Running `terragrunt run --graph apply` in `services/eks-service-3`:
 
-##### dag graph
+```text
+Group 1
+- Module project/services/eks-service-3
 
-Print a visual representation of the Terragrunt dependency graph in DOT language format. This command analyzes your Terragrunt configuration and outputs a directed acyclic graph (DAG) showing the relationships and dependencies between your Terraform modules.
+Group 2
+- Module project/services/eks-service-3-v2
+- Module project/services/eks-service-4
 
-Example usage:
+Group 3
+- Module project/services/eks-service-3-v3
 
-```bash
-terragrunt dag graph
 ```
 
-The output can be piped to Graphviz tools to generate visual diagrams:
+Notes:
 
-```bash
-terragrunt dag graph  | dot -Tpng > graph.png
-```
+- in execution are included only services dependent from `eks-service-3`
 
-#### terragrunt-info
+Running `terragrunt run --graph destroy` in `services/eks-service-3`:
 
-Emits limited terragrunt state on `stdout` in a JSON format and exits.
+```text
+Group 1
+- Module project/services/eks-service-3-v3
+- Module project/services/eks-service-4
 
-Example:
+Group 2
+- Module project/services/eks-service-3-v2
 
-```bash
-terragrunt terragrunt-info
+Group 3
+- Module project/services/eks-service-3
 ```
 
-Might produce output such as:
+Notes:
+
+- destroy will be executed only on subset of services dependent from `eks-service-3`
+
+### auth-provider-cmd
+
+**CLI Arg**: `--auth-provider-cmd`<br/>
+**CLI Arg Alias**: `--terragrunt-auth-provider-cmd` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_AUTH_PROVIDER_CMD`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_AUTH_PROVIDER_CMD` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--auth-provider-cmd "command [arguments]"`<br/>
+
+The command and arguments used to obtain authentication credentials dynamically. If specified, Terragrunt runs this command whenever it might need authentication. This includes HCL parsing, where it might be useful to authenticate with a cloud provider _before_ running HCL functions like [`get_aws_account_id`](/docs/reference/built-in-functions/#get_aws_account_id) where authentication has to already have taken place. It can also be useful for HCL functions like [`run_cmd`](/docs/reference/built-in-functions/#run_cmd) where it may be useful to be authenticated before calling the function.
+
+The output must be valid JSON of the following schema:
 
 ```json
 {
-  "ConfigPath": "/example/path/terragrunt.hcl",
-  "DownloadDir": "/example/path/.terragrunt-cache",
-  "IamRole": "",
-  "TerraformBinary": "terraform",
-  "TerraformCommand": "terragrunt-info",
-  "WorkingDir": "/example/path"
+  "awsCredentials": {
+    "ACCESS_KEY_ID": "",
+    "SECRET_ACCESS_KEY": "",
+    "SESSION_TOKEN": ""
+  },
+  "awsRole": {
+    "roleARN": "",
+    "sessionName": "",
+    "duration": 0,
+    "webIdentityToken": ""
+  },
+  "envs": {
+    "ANY_KEY": ""
+  }
 }
 ```
 
-#### validate-inputs
+This allows Terragrunt to acquire different credentials at runtime without changing any `terragrunt.hcl` configuration. You can use this flag to set arbitrary credentials for continuous integration, authentication with providers other than AWS and more.
 
-Emits information about the input variables that are configured with the given
-terragrunt configuration. Specifically, this command will print out unused
-inputs (inputs that are not defined as an OpenTofu/Terraform variable in the
-corresponding module) and undefined required inputs (required OpenTofu/Terraform
-variables that are not currently being passed in).
+As long as the standard output of the command passed to `auth-provider-cmd` results in JSON matching the schema above, corresponding environment variables will be set (and/or roles assumed) before Terragrunt begins parsing an `terragrunt.hcl` file or running an OpenTofu/Terraform command.
 
-Example:
+The simplest approach to leverage this flag is to write a script that fetches desired credentials, and emits them to STDOUT in the JSON format listed above:
 
 ```bash
-> terragrunt validate-inputs
-The following inputs passed in by terragrunt are unused:
+#!/usr/bin/env bash
 
-    - foo
-    - bar
+echo -n '{"envs": {"KEY": "a secret"}}'
+```
 
+You can use any technology for the authentication provider you'd like, however, as long as Terragrunt can execute it. The expected pattern for using this flag is to author a script/program that will dynamically fetch secret values from a secret store, etc. then emit them to STDOUT for consumption by Terragrunt.
 
-The following required inputs are missing:
+Note that more specific configurations (e.g. `awsCredentials`) take precedence over less specific configurations (e.g. `envs`).
 
-    - baz
+If you would like to set credentials for AWS with this method, you are encouraged to use `awsCredentials` instead of `envs`, as these keys will be validated to conform to the officially supported environment variables expected by the AWS SDK.
+
+Similarly, if you would like Terragrunt to assume an AWS role on your behalf, you are encouraged to use the `awsRole` configuration instead of `envs`.
+
+Other credential configurations will be supported in the future, but until then, if your provider authenticates via environment variables, you can use the `envs` field to fetch credentials dynamically from a secret store, etc before Terragrunt executes any IAC.
+
+**Note**: The `awsRole` configuration is only used when the `awsCredentials` configuration is not present. If both are present, the `awsCredentials` configuration will take precedence.
+
+### config
+
+**CLI Arg**: `--config`<br/>
+**CLI Arg Alias**: `--terragrunt-config` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_CONFIG`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_CONFIG` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--config /path/to/terragrunt.hcl`<br/>
+
+A custom path to the `terragrunt.hcl` or `terragrunt.hcl.json` file. The
+default path is `terragrunt.hcl` (preferred) or `terragrunt.hcl.json` in the current directory (see
+[Configuration]({{site.baseurl}}/docs/getting-started/configuration/#configuration) for a slightly more nuanced
+explanation). This argument is not used with the `run-all` commands.
+
+### tf-path
+
+**CLI Arg**: `--tf-path`<br/>
+**CLI Arg Alias**: `--terragrunt-tfpath` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_TF_PATH`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_TFPATH` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--tf-path /path/to/tofu-or-terraform-binary`<br/>
+
+An explicit path to the `tofu` or `terraform` binary you wish to have Terragrunt use.
+
+Note that if you _only_ have `terraform` installed, and available in your PATH, Terragrunt will automatically use that binary.
+
+If you have _both_ `terraform` and `tofu` installed, and you want to use `terraform`, you can set the `TG_TF_PATH` to `terraform`.
+
+If you have _multiple_ versions of `tofu` and/or `terraform` available, or you have a custom wrapper for `tofu` or `terraform`, you can set the `TG_TF_PATH` to the absolute path of the executable you want to use.
+
+**NOTE**: This will override the `terraform` binary that is used by `terragrunt` in all instances, including
+`dependency` lookups. This setting will also override any [terraform_binary]({{site.baseurl}}/docs/reference/config-blocks-and-attributes/#terraform_binary)
+configuration values specified in the `terragrunt.hcl` config for both the top level, and dependency lookups.
+
+### no-auto-init
+
+**CLI Arg**: `--no-auto-init`<br/>
+**CLI Arg Alias**: `--terragrunt-no-auto-init` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_NO_AUTO_INIT` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_NO_AUTO_INIT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+_(Prior to Terragrunt v0.48.6, this environment variable was called `TERRAGRUNT_AUTO_INIT` (set to `false`), and is still available for backwards compatibility)_
+
+When passed in, don't automatically run `terraform init` when other commands are run (e.g. `terragrunt apply`). Useful
+if you want to pass custom arguments to `terraform init` that are specific to a user or execution environment, and
+therefore cannot be specified as `extra_arguments`. For example, `-plugin-dir`. You must run `terragrunt init`
+yourself in this case if needed. `terragrunt` will fail if it detects that `init` is needed, but auto init is
+disabled. See [Auto-Init]({{site.baseurl}}/docs/features/auto-init#auto-init)
+
+### no-auto-approve
+
+**CLI Arg**: `--no-auto-approve`<br/>
+**CLI Arg Alias**: `--terragrunt-no-auto-approve` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_NO_AUTO_APPROVE` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_NO_AUTO_APPROVE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+_(Prior to Terragrunt v0.48.6, this environment variable was called `TERRAGRUNT_AUTO_APPROVE` (set to `false`), and is still available for backwards compatibility)_
+**Commands**:
+
+- [run-all](#run-all)
+
+When passed in, Terragrunt will no longer automatically append `-auto-approve` to the underlying OpenTofu/Terraform commands run
+with `run-all`. Note that due to the interactive prompts, this flag will also **automatically assume
+`--parallelism 1`**.
 
+### no-auto-retry
+
+**CLI Arg**: `--no-auto-retry`<br/>
+**CLI Arg Alias**: `--terragrunt-no-auto-retry` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_NO_AUTO_RETRY` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_NO_AUTO_RETRY` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+_(Prior to Terragrunt v0.48.6, this environment variable was called `TERRAGRUNT_AUTO_RETRY` (set to `false`), and is still available for backwards compatibility)_
+
+When passed in, don't automatically retry commands which fail with transient errors. See
+[Feature Flags, Errors and Excludes]({{site.baseurl}}/docs/features/runtime-control#errors)
+
+### non-interactive
+
+**CLI Arg**: `--non-interactive`<br/>
+**CLI Arg Alias**: `--terragrunt-non-interactive` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_NON_INTERACTIVE` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_NON_INTERACTIVE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+_(Prior to Terragrunt v0.48.6, this environment variable was called `TF_INPUT` (set to `false`), and is still available for backwards compatibility. NOTE: [TF_INPUT](https://developer.hashicorp.com/terraform/cli/config/environment-variables#tf_input) is native to OpenTofu/Terraform!)_
+
+When passed in, don't show interactive user prompts. This will default the answer for all Terragrunt (not OpenTofu/Terraform) prompts to `yes` except for
+the listed cases below. This is useful if you need to run Terragrunt in an automated setting (e.g. from a script). May
+also be specified with the [TF_INPUT](https://www.terraform.io/docs/configuration/environment-variables.html#tf_input) environment variable.
+
+This setting will default to `no` for the following cases:
+
+- Prompts related to pulling in external dependencies. You can force include external dependencies using the
+  [--queue-include-external](#queue-include-external) option.
+
+Note that this does not impact the behavior of OpenTofu/Terraform commands invoked by Terragrunt.
+
+e.g.
+
+```bash
+terragrunt --non-interactive apply -auto-approve
 ```
 
-Note that this only checks for variables passed in in the following ways:
+Is how you would make Terragrunt apply without any user prompts from Terragrunt or OpenTofu/Terraform.
 
-- Configured `inputs` attribute.
+### working-dir
 
-- var files defined on `terraform.extra_arguments` blocks using `required_var_files` and `optional_var_files`.
+**CLI Arg**: `--working-dir`<br/>
+**CLI Arg Alias**: `--terragrunt-working-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_WORKING_DIR`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_WORKING_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--working-dir /path/to/working-directory`<br/>
 
-- `-var-file` and `-var` CLI arguments defined on `terraform.extra_arguments` using `arguments`.
+Set the directory where Terragrunt should execute the `terraform` command. Default is the current working directory.
+Note that for the `run-all` commands, this parameter has a different meaning: Terragrunt will apply or destroy all the
+OpenTofu/Terraform modules in the subfolders of the `working-dir`, running `terraform` in the root of each module it
+finds.
 
-- `-var-file` and `-var` CLI arguments passed to terragrunt.
+### download-dir
 
-- Automatically loaded var files (`terraform.tfvars`, `terraform.tfvars.json`, `*.auto.tfvars`, `*.auto.tfvars.json`)
+**CLI Arg**: `--download-dir`<br/>
+**CLI Arg Alias**: `--terragrunt-download-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_DOWNLOAD_DIR`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_DOWNLOAD` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--download-dir /path/to/dir-to-download-terraform-code`<br/>
 
-- `TF_VAR` environment variables defined on `terraform.extra_arguments` blocks.
+The path where to download OpenTofu/Terraform code when using [remote OpenTofu/Terraform
+configurations](https://blog.gruntwork.io/terragrunt-how-to-keep-your-terraform-code-dry-and-maintainable-f61ae06959d8).
+Default is `.terragrunt-cache` in the working directory. We recommend adding this folder to your `.gitignore`.
 
-- `TF_VAR` environment variables defined in the environment.
+### source
 
-Be aware that other ways to pass variables to `tofu`/`terraform` are not checked by this command.
+**CLI Arg**: `--source`<br/>
+**CLI Arg Alias**: `--terragrunt-source` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_SOURCE`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_SOURCE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--source /path/to/local-terraform-code`<br/>
 
-Additionally, there are **two modes** in which the `validate-inputs` command can be run: **relaxed** (default) and **strict**.
+Download OpenTofu/Terraform configurations from the specified source into a temporary folder, and run OpenTofu/Terraform in that temporary
+folder. The source should use the same syntax as the [OpenTofu/Terraform module
+source](https://www.terraform.io/docs/modules/sources.html) parameter. If you specify this argument for the `run-all`
+commands, Terragrunt will assume this is the local file path for all of your OpenTofu/Terraform modules, and for each module
+processed by the `run-all` command, Terragrunt will automatically append the path of `source` parameter in each module
+to the `--source` parameter you passed in.
 
-If you run the `validate-inputs` command without flags, relaxed mode will be enabled by default. In relaxed mode, any unused variables
-that are passed, but not used by the underlying OpenTofu/Terraform configuration, will generate a warning, but not an error. Missing required variables will _always_ return an error, whether `validate-inputs` is running in relaxed or strict mode.
+### source-map
 
-To enable strict mode, you can pass the `--strict-validate` flag like so:
+**CLI Arg**: `--source-map`<br/>
+**CLI Arg Alias**: `--terragrunt-source-map` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_SOURCE_MAP` (encoded as comma separated value, e.g., `source1=dest1,source2=dest2`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_SOURCE_MAP` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--source-map git::ssh://github.com=/path/to/local-terraform-code`<br/>
+
+Can be supplied multiple times: `--source-map source1=dest1 --source-map source2=dest2`
+
+The `--source-map source=dest` param replaces any `source` URL (including the source URL of a config pulled
+in with `dependency` blocks) that has root `source` with `dest`.
+
+For example:
 
 ```bash
-> terragrunt validate-inputs --strict-validate
+terragrunt apply --source-map github.com/org/modules.git=/local/path/to/modules
 ```
 
-When running in strict mode, `validate-inputs` will return an error if there are unused inputs.
+The above would replace `terraform { source = "github.com/org/modules.git//xxx" }` with `terraform { source = /local/path/to/modules//xxx }` regardless of
+whether you were running `apply`, or `run-all`, or using a `dependency`.
 
-This command will exit with an error if terragrunt detects any unused inputs or undefined required inputs.
+**NOTE**: This setting is ignored if you pass in `--source`.
 
-## Flags
+Note that this only performs literal matches on the URL portion. For example, a map key of
+`ssh://git@github.com/gruntwork-io/terragrunt.git` will only match terragrunt configurations with source `source =
+"ssh://git@github.com/gruntwork-io/terragrunt.git//xxx"` and not sources of the form `source =
+"git::ssh://git@github.com/gruntwork-io/terragrunt.git//xxx"`. The latter requires a map key of
+`git::ssh://git@github.com/gruntwork-io/terragrunt.git`.
 
-- [Commands](#commands)
-  - [Main commands](#main-commands)
-    - [OpenTofu shortcuts](#opentofu-shortcuts)
-    - [run](#run)
-    - [exec](#exec)
-    - [run-all](#run-all)
-    - [graph](#graph)
-  - [Stack commands](#stack-commands)
-    - [stack generate](#stack-generate)
-    - [stack run](#stack-run)
-    - [stack output](#stack-output)
-    - [stack clean](#stack-clean)
-  - [Backend commands](#backend-commands)
-    - [backend bootstrap](#backend-bootstrap)
-    - [backend delete](#backend-delete)
-    - [backend migrate](#backend-migrate)
-  - [HCL commands](#hcl-commands)
-    - [hcl validate](#hcl-validate)
-    - [hcl format](#hcl-format)
-  - [Catalog commands](#catalog-commands)
-    - [catalog](#catalog)
-    - [scaffold](#scaffold)
-  - [Discovery commands](#discovery-commands)
-    - [find](#find)
-      - [Find Output Format](#find-output-format)
-      - [Find DAG Mode](#find-dag-mode)
-      - [Find Queue Construct As](#find-queue-construct-as)
-      - [Find Dependencies](#find-dependencies)
-      - [Find Exclude](#find-exclude)
-      - [Find External Dependencies](#find-external-dependencies)
-      - [Find Hidden Configurations](#find-hidden-configurations)
-    - [list](#list)
-      - [List Output Format](#list-output-format)
-        - [Text Format (Default)](#text-format-default)
-        - [Long Format](#long-format)
-        - [Tree Format](#tree-format)
-      - [DAG Mode](#dag-mode)
-      - [List Queue Construct As](#list-queue-construct-as)
-  - [Configuration commands](#configuration-commands)
-    - [graph-dependencies](#graph-dependencies)
-    - [hclfmt](#hclfmt)
-    - [hclvalidate](#hclvalidate)
-    - [output-module-groups](#output-module-groups)
-    - [render](#render)
-    - [render-json](#render-json)
-    - [info](#info)
-      - [Strict command](#strict-command)
-      - [Print command](#print-command)
-    - [dag](#dag)
-      - [dag graph](#dag-graph)
-    - [terragrunt-info](#terragrunt-info)
-    - [validate-inputs](#validate-inputs)
-- [Flags](#flags)
-  - [all](#all)
-  - [graph](#graph-1)
-  - [auth-provider-cmd](#auth-provider-cmd)
-  - [config](#config)
-  - [tf-path](#tf-path)
-  - [no-auto-init](#no-auto-init)
-  - [no-auto-approve](#no-auto-approve)
-  - [no-auto-retry](#no-auto-retry)
-  - [non-interactive](#non-interactive)
-  - [working-dir](#working-dir)
-  - [download-dir](#download-dir)
-  - [source](#source)
-  - [source-map](#source-map)
-  - [source-update](#source-update)
-  - [iam-assume-role](#iam-assume-role)
-  - [iam-assume-role-duration](#iam-assume-role-duration)
-  - [iam-assume-role-session-name](#iam-assume-role-session-name)
-  - [iam-assume-role-web-identity-token](#iam-assume-role-web-identity-token)
-  - [queue-ignore-errors](#queue-ignore-errors)
-  - [queue-excludes-file](#queue-excludes-file)
-  - [queue-exclude-dir](#queue-exclude-dir)
-  - [queue-include-dir](#queue-include-dir)
-  - [queue-strict-include](#queue-strict-include)
-  - [queue-ignore-dag-order](#queue-ignore-dag-order)
-  - [queue-exclude-external](#queue-exclude-external)
-  - [queue-include-external](#queue-include-external)
-  - [strict-validate](#strict-validate)
-  - [parallelism](#parallelism)
-  - [inputs-debug](#inputs-debug)
-  - [log-level](#log-level)
-  - [log-format](#log-format)
-  - [log-custom-format](#log-custom-format)
-  - [log-disable](#log-disable)
-  - [log-show-abs-paths](#log-show-abs-paths)
-  - [no-color](#no-color)
-  - [check](#check)
-  - [diff](#diff)
-  - [hclfmt-file](#hclfmt-file)
-  - [hclfmt-exclude-dir](#hclfmt-exclude-dir)
-  - [hclfmt-stdin](#hclfmt-stdin)
-  - [hclvalidate-json](#hclvalidate-json)
-  - [hclvalidate-show-config-path](#hclvalidate-show-config-path)
-  - [disable-dependent-modules](#disable-dependent-modules)
-  - [out](#out)
-  - [units-that-include](#units-that-include)
-  - [queue-include-units-reading](#queue-include-units-reading)
-  - [dependency-fetch-output-from-state](#dependency-fetch-output-from-state)
-  - [use-partial-parse-config-cache](#use-partial-parse-config-cache)
-  - [backend-require-bootstrap](#backend-require-bootstrap)
-  - [disable-bucket-update](#disable-bucket-update)
-  - [disable-command-validation](#disable-command-validation)
-  - [provider-cache](#provider-cache)
-  - [provider-cache-dir](#provider-cache-dir)
-  - [provider-cache-hostname](#provider-cache-hostname)
-  - [provider-cache-port](#provider-cache-port)
-  - [provider-cache-token](#provider-cache-token)
-  - [provider-cache-registry-names](#provider-cache-registry-names)
-  - [out-dir](#out-dir)
-  - [json-out-dir](#json-out-dir)
-  - [tf-forward-stdout](#tf-forward-stdout)
-  - [no-destroy-dependencies-check](#no-destroy-dependencies-check)
-  - [feature](#feature)
-  - [experiment](#experiment)
-  - [experiment-mode](#experiment-mode)
-  - [strict-control](#strict-control)
-  - [strict-mode](#strict-mode)
-  - [in-download-dir](#in-download-dir)
-- [Deprecated](#deprecated)
-  - [Deprecated Commands](#deprecated-commands)
-    - [plan-all](#plan-all)
-    - [apply-all](#apply-all)
-    - [output-all](#output-all)
-    - [destroy-all](#destroy-all)
-    - [validate-all](#validate-all)
-  - [Deprecated Flags](#deprecated-flags)
-    - [terragrunt-include-module-prefix](#terragrunt-include-module-prefix)
-    - [terragrunt-json-log](#terragrunt-json-log)
-    - [terragrunt-tf-logs-to-json](#terragrunt-tf-logs-to-json)
-    - [terragrunt-disable-log-formatting](#terragrunt-disable-log-formatting)
+### source-update
 
-### all
+**CLI Arg**: `--source-update`<br/>
+**CLI Arg Alias**: `--terragrunt-source-update` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_SOURCE_UPDATE` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_SOURCE_UPDATE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-<!-- markdownlint-disable MD033 -->
+When passed in, delete the contents of the temporary folder before downloading OpenTofu/Terraform source code into it.
 
-**CLI Arg**: `--all`<br/>
-**CLI Alias**: `-a`<br/>
-**Environment Variable**: `TG_ALL` (set to `true`)<br/>
+### iam-assume-role
 
-This is equivalent to the soon to be deprecated `run-all` command.
+**CLI Arg**: `--iam-assume-role`<br/>
+**CLI Arg Alias**: `--terragrunt-iam-role` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_IAM_ASSUME_ROLE`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_IAM_ROLE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--iam-assume-role "arn:aws:iam::ACCOUNT_ID:role/ROLE_NAME"`<br/>
 
-Runs the provided OpenTofu/Terraform command against a [stack](/docs/getting-started/terminology/#stack).
-The command will recursively find terragrunt [units](/docs/getting-started/terminology/#unit) in the current directory
-tree and run the OpenTofu/Terraform command in dependency order (unless the command is destroy,
-in which case the command is run in reverse dependency order).
+Assume the specified IAM role ARN before running OpenTofu/Terraform or AWS commands. This is a convenient way to use Terragrunt
+and OpenTofu/Terraform with multiple AWS accounts.
 
-Make sure to read about the [stacks feature](/docs/features/stacks) for context.
+When using this option, AWS authentication takes place right before an OpenTofu/Terraform run. This takes place after `terragrunt.hcl` files are fully parsed, so HCL functions like [`get_aws_account_id`](/docs/reference/built-in-functions/#get_aws_account_id) and [`run_cmd`](/docs/reference/built-in-functions/#run_cmd) will not run after assuming the role. If you need roles to be assumed prior to parsing Terragrunt configurations, use [`auth-provider-cmd`](#auth-provider-cmd) instead.
 
-Example:
+### iam-assume-role-duration
+
+**CLI Arg**: `--iam-assume-role-duration`<br/>
+**CLI Arg Alias**: `--terragrunt-iam-assume-role-duration` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_IAM_ASSUME_ROLE_DURATION`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_IAM_ASSUME_ROLE_DURATION` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--iam-assume-role-duration 3600`<br/>
+
+Uses the specified duration as the session duration (in seconds) for the STS session which assumes the role defined in `--iam-assume-role`.
+
+### iam-assume-role-session-name
+
+**CLI Arg**: `--iam-assume-role-session-name`<br/>
+**CLI Arg Alias**: `--terragrunt-iam-assume-role-session-name` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_IAM_ASSUME_ROLE_SESSION_NAME`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_IAM_ASSUME_ROLE_SESSION_NAME` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--iam-assume-role-session-name "terragrunt-iam-role-session-name"`<br/>
+
+Used as the session name for the STS session which assumes the role defined in `--iam-assume-role`.
+
+### iam-assume-role-web-identity-token
+
+**CLI Arg**: `--iam-assume-role-web-identity-token`<br/>
+**CLI Arg Alias**: `--terragrunt-iam-web-identity-token` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_IAM_ASSUME_ROLE_WEB_IDENTITY_TOKEN`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_IAM_ASSUME_ROLE_WEB_IDENTITY_TOKEN` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--iam-assume-role-web-identity-token [/path/to/web-identity-token | web-identity-token-value]`<br/>
 
-```bash
-terragrunt run --all apply
-```
+Used as the web identity token for assuming a role temporarily using the AWS Security Token Service (STS) with the [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) API.
 
-This will recursively search the current working directory for any folders that contain Terragrunt units and run
-`apply` in each one, concurrently, while respecting ordering defined via
-[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
-[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
+### queue-ignore-errors
 
-**[WARNING] Do not set [TF_PLUGIN_CACHE_DIR](https://opentofu.org/docs/cli/config/config-file/#provider-plugin-cache) when using `run --all`**
+**CLI Arg**: `--queue-ignore-errors`<br/>
+**CLI Arg Alias**: `--terragrunt-ignore-dependency-errors` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_QUEUE_IGNORE_ERRORS`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_IGNORE_DEPENDENCY_ERRORS` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-Instead take advantage of the built-in [Provider Cache Server](/docs/features/provider-cache-server/) that
-mitigates some of the limitations of using the OpenTofu/Terraform Provider Plugin Cache directly.
+When passed in, the `*-all` commands continue processing components even if a dependency fails
 
-We are [working with the OpenTofu team to improve this behavior](https://github.com/opentofu/opentofu/issues/1483) so that you don't have to worry about this in the future.
+### queue-excludes-file
 
-**[NOTE] Use `run --all` with care if you have unapplied dependencies**.
+**CLI Arg**: `--queue-excludes-file`<br/>
+**CLI Arg Alias**: `--terragrunt-excludes-file` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_QUEUE_EXCLUDES_FILE`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_EXCLUDES_FILE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--queue-excludes-file /path/to/file`<br/>
 
-If you have a stack of Terragrunt units with dependencies between them via `dependency` blocks
-and you've never deployed them, then commands like `run --all plan` will fail,
-as it won't be possible to resolve outputs of `dependency` blocks without applying them first.
+Path to a file with a list of directories that need to be excluded when running *-all commands, by default `.terragrunt-excludes`. Modules under these directories will be
+excluded during execution of the commands. If a relative path is specified, it should be relative from
+[--working-dir](#working-dir). This will only exclude the module, not its dependencies.
 
-The solution for this is to take advantage of [mock outputs in dependency blocks](/docs/reference/config-blocks-and-attributes/#dependency).
+This flag has been designed to integrate nicely with the `hclvalidate` command, which can return a list of invalid files delimited by newlines when passed the `--show-config-path` flag. To integrate the two, you can run something like the following using bash process substitution:
 
-**[NOTE]** Using `run --all` with `apply` or `destroy` silently adds the `-auto-approve` flag to the command line
-arguments passed to OpenTofu/Terraform due to issues with shared `stdin` making individual approvals impossible.
+```bash
+terragrunt run-all plan --queue-excludes-file <(terragrunt hclvalidate --show-config-path)
+```
 
-**[NOTE]** Using the OpenTofu/Terraform [-detailed-exitcode](https://opentofu.org/docs/cli/commands/plan/#other-options)
-flag with the `run --all` command results in an aggregate exit code being returned, rather than the exit code of any particular unit.
+### queue-exclude-dir
 
-The algorithm for determining the aggregate exit code is as follows:
+**CLI Arg**: `--queue-exclude-dir`<br/>
+**CLI Arg Alias**: `--terragrunt-exclude-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_QUEUE_EXCLUDE_DIR`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_EXCLUDE_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--queue-exclude-dir /path/to/dirs/to/exclude*`<br/>
 
-- If any unit throws a 1, Terragrunt will throw a 1.
-- If any unit throws a 2, but nothing throws a 1, Terragrunt will throw a 2.
-- If nothing throws a non-zero, Terragrunt will throw a 0.
+Can be supplied multiple times: `--queue-exclude-dir /path/to/dirs/to/exclude --queue-exclude-dir /another/path/to/dirs/to/exclude`
 
-<!-- markdownlint-disable MD024 -->
-### graph
+Unix-style glob of directories to exclude when running `*-all` commands. Modules under these directories will be
+excluded during execution of the commands. If a relative path is specified, it should be relative from
+[--working-dir](#working-dir). Flag can be specified multiple times. This will only exclude the
+module, not its dependencies.
 
-**CLI Arg**: `--graph`<br/>
-**Environment Variable**: `TG_GRAPH`<br/>
+Please note that the glob curly braces expansion is not taken in account using environment variable unlike of its equivalent as a parameter on the command line.
+You should consider using `TG_QUEUE_EXCLUDE_DIR="foo/module,bar/module"` instead of `TG_QUEUE_EXCLUDE_DIR="{foo,bar}/module"`.
 
-This is equivalent to the soon to be deprecated `graph` command.
+### queue-include-dir
 
-Run the provided OpenTofu/Terraform command against the graph of dependencies for the unit in the current working directory. The graph consists of all units that depend on the unit in the current working directory via a `dependency` or `dependencies` blocks, plus all the units that depend on those units, and all the units that depend on those units, and so on, recursively up the tree, up to the Git repository root, or the path specified via the optional `--graph-root` argument.
+**CLI Arg**: `--queue-include-dir`<br/>
+**CLI Arg Alias**: `--terragrunt-include-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_QUEUE_INCLUDE_DIR`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_INCLUDE_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--queue-include-dir /path/to/dirs/to/include*`<br/>
 
-The Command will be executed following the order of dependencies: so it'll run on the unit in the current working directory first, then on units that depend on it directly, then on the units that depend on those units, and so on. Note that if the command is `destroy`, it will run in the opposite order (the final dependents, then their dependencies, etc. up to the unit you ran the command in).
+Can be supplied multiple times: `--queue-include-dir /path/to/dirs/to/include --queue-include-dir /another/path/to/dirs/to/include`
 
-Example:
-Having below dependencies:
-[![dependency-graph](/assets/img/collections/documentation/dependency-graph.png){: width="80%" }]({{site.baseurl}}/assets/img/collections/documentation/dependency-graph.png)
+Unix-style glob of directories to include when running `*-all` commands. Only modules under these directories (and all
+dependent modules) will be included during execution of the commands. If a relative path is specified, it should be
+relative from `--working-dir`. Flag can be specified multiple times.
 
-Running `terragrunt run --graph apply` in `eks` module will lead to the following execution order:
+Please note that the glob curly braces expansion is not taken in account using environment variable unlike of its equivalent as a parameter on the command line.
+You should consider using `TG_QUEUE_INCLUDE_DIR="foo/module,bar/module"` instead of `TG_QUEUE_INCLUDE_DIR="{foo,bar}/module"`.
 
-```text
-Group 1
-- Module project/eks
+### queue-strict-include
 
-Group 2
-- Module project/services/eks-service-1
-- Module project/services/eks-service-2
+**CLI Arg**: `--queue-strict-include`<br/>
+**CLI Arg Alias**: `--terragrunt-strict-include` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_QUEUE_STRICT_INCLUDE`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_STRICT_INCLUDE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-Group 3
-- Module project/services/eks-service-2-v2
-- Module project/services/eks-service-3
-- Module project/services/eks-service-5
+When passed in, only modules under the directories passed in with [--queue-include-dir](#queue-include-dir)
+will be included. All dependencies of the included directories will be excluded if they are not in the included
+directories. If no [--queue-include-dir](#queue-include-dir) flags are included, terragrunt will not include
+any modules during the execution of the commands.
 
-Group 4
-- Module project/services/eks-service-3-v2
-- Module project/services/eks-service-4
+### queue-ignore-dag-order
 
-Group 5
-- Module project/services/eks-service-3-v3
-```
+**CLI Arg**: `--queue-ignore-dag-order`<br/>
+**CLI Arg Alias**: `--terragrunt-ignore-dependency-order` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_QUEUE_IGNORE_DAG_ORDER`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_IGNORE_DEPENDENCY_ORDER` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-Notes:
+When passed in, ignore the dependencies between units when running `*-all` commands.
 
-- `lambda` units aren't included in the graph, because they are not dependent on `eks` unit.
-- execution is from bottom up based on dependencies
+### queue-exclude-external
 
-Running `terragrunt run --graph destroy` in `eks` unit will lead to the following execution order:
+**CLI Arg**: `--queue-exclude-external`<br/>
+**CLI Arg Alias**: `--terragrunt-ignore-external-dependencies` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_QUEUE_EXCLUDE_EXTERNAL`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_IGNORE_EXTERNAL_DEPENDENCIES` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-```text
-Group 1
-- Module project/services/eks-service-2-v2
-- Module project/services/eks-service-3-v3
-- Module project/services/eks-service-4
-- Module project/services/eks-service-5
+When passed in, don't attempt to include any external dependencies when running `*-all` commands. Note that an external
+dependency is a dependency that is outside the current terragrunt working directory, and is not respective to the
+included directories with `queue-include-dir`.
 
-Group 2
-- Module project/services/eks-service-3-v2
+### queue-include-external
 
-Group 3
-- Module project/services/eks-service-3
+**CLI Arg**: `--queue-include-external`<br/>
+**CLI Arg Alias**: `--terragrunt-include-external-dependencies` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_QUEUE_INCLUDE_EXTERNAL`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_INCLUDE_EXTERNAL_DEPENDENCIES` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-Group 4
-- Module project/services/eks-service-1
-- Module project/services/eks-service-2
+When passed in, include any external dependencies when running `*-all` without asking. Note that an external
+dependency is a dependency that is outside the current terragrunt working directory, and is not respective to the
+included directories with `queue-include-dir`.
 
-Group 5
-- Module project/eks
-```
+### strict-validate
 
-Notes:
+**CLI Arg**: `--strict-validate`<br/>
+**CLI Arg Alias**: `--terragrunt-strict-validate` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_STRICT_VALIDATE`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_STRICT_VALIDATE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-- execution is in reverse order, first are destroyed "top" units and in the end `eks`
-- `lambda` units aren't affected at all
+When passed in, and running `terragrunt validate-inputs`, enables strict mode for the `validate-inputs` command. When strict mode is enabled, an error will be returned if any variables required by the underlying OpenTofu/Terraform configuration are not passed in, OR if any unused variables are passed in. By default, `terragrunt validate-inputs` runs in relaxed mode. In relaxed mode, an error is only returned when a variable required by the underlying OpenTofu/Terraform configuration is not passed in.
 
-Running `terragrunt run --graph apply` in `services/eks-service-3`:
+### parallelism
 
-```text
-Group 1
-- Module project/services/eks-service-3
+**CLI Arg**: `--parallelism`<br/>
+**CLI Arg Alias**: `--terragrunt-parallelism` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_PARALLELISM`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_PARALLELISM` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-Group 2
-- Module project/services/eks-service-3-v2
-- Module project/services/eks-service-4
+When passed in, limit the number of units that are run concurrently to this number during \*-all commands.
+The exception is the `terraform init` command, which is always executed sequentially if the [OpenTofu provider plugin cache](https://opentofu.org/docs/cli/config/config-file/#provider-plugin-cache) is used. This is because the provider plugin cache is not guaranteed to be concurrency safe when used in isolation.
 
-Group 3
-- Module project/services/eks-service-3-v3
+To safely access provider cache concurrently, enable the [Provider Cache Server](https://terragrunt.gruntwork.io/docs/features/provider-cache-server/).
 
-```
+### inputs-debug
 
-Notes:
+**CLI Arg**: `--inputs-debug`<br/>
+**CLI Arg Alias**: `--terragrunt-debug` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_DEBUG_INPUTS`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_DEBUG` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-- in execution are included only services dependent from `eks-service-3`
+When passed in, Terragrunt will create a tfvars file that can be used to invoke the terraform module in the same way
+that Terragrunt invokes the module, so that you can debug issues with the terragrunt config. See
+[Debugging]({{site.baseurl}}/docs/features/debugging) for additional details.
 
-Running `terragrunt run --graph destroy` in `services/eks-service-3`:
+### log-level
 
-```text
-Group 1
-- Module project/services/eks-service-3-v3
-- Module project/services/eks-service-4
+**CLI Arg**: `--log-level`<br/>
+**CLI Arg Alias**: `--terragrunt-log-level` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_LOG_LEVEL`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_LOG_LEVEL` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--log-level <LOG_LEVEL>`<br/>
 
-Group 2
-- Module project/services/eks-service-3-v2
+When passed it, sets logging level for terragrunt. All supported levels are:
 
-Group 3
-- Module project/services/eks-service-3
-```
+- `stderr`
+- `stdout`
+- `error`
+- `warn`
+- `info` (this is the default)
+- `debug`
+- `trace`
 
-Notes:
+Where the first two control the logging of Terraform/OpenTofu output.
 
-- destroy will be executed only on subset of services dependent from `eks-service-3`
+### log-format
 
-### auth-provider-cmd
+**CLI Arg**: `--log-format`<br/>
+**CLI Arg Alias**: `--terragrunt-log-format` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_LOG_FORMAT`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_LOG_FORMAT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--log-format <LOG_FORMAT>`<br/>
 
-**CLI Arg**: `--auth-provider-cmd`<br/>
-**CLI Arg Alias**: `--terragrunt-auth-provider-cmd` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_AUTH_PROVIDER_CMD`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_AUTH_PROVIDER_CMD` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--auth-provider-cmd "command [arguments]"`<br/>
+There are four log format presets:
 
-The command and arguments used to obtain authentication credentials dynamically. If specified, Terragrunt runs this command whenever it might need authentication. This includes HCL parsing, where it might be useful to authenticate with a cloud provider _before_ running HCL functions like [`get_aws_account_id`](/docs/reference/built-in-functions/#get_aws_account_id) where authentication has to already have taken place. It can also be useful for HCL functions like [`run_cmd`](/docs/reference/built-in-functions/#run_cmd) where it may be useful to be authenticated before calling the function.
+- `pretty` (this is the default)
+- `bare` (old Terragrunt logging, pre-[v0.67.0](https://github.com/gruntwork-io/terragrunt/tree/v0.67.0))
+- `json`
+- `key-value`
 
-The output must be valid JSON of the following schema:
+### log-custom-format
 
-```json
-{
-  "awsCredentials": {
-    "ACCESS_KEY_ID": "",
-    "SECRET_ACCESS_KEY": "",
-    "SESSION_TOKEN": ""
-  },
-  "awsRole": {
-    "roleARN": "",
-    "sessionName": "",
-    "duration": 0,
-    "webIdentityToken": ""
-  },
-  "envs": {
-    "ANY_KEY": ""
-  }
-}
-```
+**CLI Arg**: `--log-custom-format`<br/>
+**CLI Arg Alias**: `--terragrunt-log-custom-format` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_LOG_CUSTOM_FORMAT`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_LOG_CUSTOM_FORMAT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--log-custom-format <LOG_CUSTOM_FORMAT>`<br/>
 
-This allows Terragrunt to acquire different credentials at runtime without changing any `terragrunt.hcl` configuration. You can use this flag to set arbitrary credentials for continuous integration, authentication with providers other than AWS and more.
+This allows you to customize logging however you like.
 
-As long as the standard output of the command passed to `auth-provider-cmd` results in JSON matching the schema above, corresponding environment variables will be set (and/or roles assumed) before Terragrunt begins parsing an `terragrunt.hcl` file or running an OpenTofu/Terraform command.
+Make sure to read [Custom Log Format](https://terragrunt.gruntwork.io/docs/features/log-formatting) for syntax details.
 
-The simplest approach to leverage this flag is to write a script that fetches desired credentials, and emits them to STDOUT in the JSON format listed above:
+### log-disable
 
-```bash
-#!/usr/bin/env bash
+**CLI Arg**: `--log-disable`<br/>
+**CLI Arg Alias**: `--terragrunt-log-disable` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_LOG_DISABLE`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_LOG_DISABLE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-echo -n '{"envs": {"KEY": "a secret"}}'
-```
+Disable logging. This flag also enables [tf-forward-stdout](#tf-forward-stdout).
 
-You can use any technology for the authentication provider you'd like, however, as long as Terragrunt can execute it. The expected pattern for using this flag is to author a script/program that will dynamically fetch secret values from a secret store, etc. then emit them to STDOUT for consumption by Terragrunt.
+### log-show-abs-paths
 
-Note that more specific configurations (e.g. `awsCredentials`) take precedence over less specific configurations (e.g. `envs`).
+**CLI Arg**: `--log-show-abs-paths`<br/>
+**CLI Arg Alias**: `--terragrunt-log-show-abs-paths` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_LOG_SHOW_ABS_PATHS`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_LOG_SHOW_ABS_PATHS` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-If you would like to set credentials for AWS with this method, you are encouraged to use `awsCredentials` instead of `envs`, as these keys will be validated to conform to the officially supported environment variables expected by the AWS SDK.
+If specified, Terragrunt paths in logs will be absolute. By default, the paths are relative to the working directory.
 
-Similarly, if you would like Terragrunt to assume an AWS role on your behalf, you are encouraged to use the `awsRole` configuration instead of `envs`.
+### no-color
 
-Other credential configurations will be supported in the future, but until then, if your provider authenticates via environment variables, you can use the `envs` field to fetch credentials dynamically from a secret store, etc before Terragrunt executes any IAC.
+**CLI Arg**: `--no-color`<br/>
+**CLI Arg Alias**: `--terragrunt-no-color` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_NO_COLOR`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_NO_COLOR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-**Note**: The `awsRole` configuration is only used when the `awsCredentials` configuration is not present. If both are present, the `awsCredentials` configuration will take precedence.
+If specified, Terragrunt output won't contain any color.
 
-### config
+NOTE: This option also disables OpenTofu/Terraform output colors by propagating the OpenTofu/Terraform [`-no-color`](https://developer.hashicorp.com/terraform/cli/commands/plan#no-color) argument.
 
-**CLI Arg**: `--config`<br/>
-**CLI Arg Alias**: `--terragrunt-config` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_CONFIG`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_CONFIG` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--config /path/to/terragrunt.hcl`<br/>
+### check
 
-A custom path to the `terragrunt.hcl` or `terragrunt.hcl.json` file. The
-default path is `terragrunt.hcl` (preferred) or `terragrunt.hcl.json` in the current directory (see
-[Configuration]({{site.baseurl}}/docs/getting-started/configuration/#configuration) for a slightly more nuanced
-explanation). This argument is not used with the `run-all` commands.
+**CLI Arg**: `--check`<br/>
+**CLI Arg Alias**: `--terragrunt-check` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_HCLFMT_CHECK` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_CHECK` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-### tf-path
+- [hclfmt](#hclfmt)
 
-**CLI Arg**: `--tf-path`<br/>
-**CLI Arg Alias**: `--terragrunt-tfpath` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_TF_PATH`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_TFPATH` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--tf-path /path/to/tofu-or-terraform-binary`<br/>
+When passed in, run `hclfmt` in check only mode instead of actively overwriting the files. This will cause the
+command to exit with exit code 1 if there are any files that are not formatted.
 
-An explicit path to the `tofu` or `terraform` binary you wish to have Terragrunt use.
+### diff
 
-Note that if you _only_ have `terraform` installed, and available in your PATH, Terragrunt will automatically use that binary.
+**CLI Arg**: `--diff`<br/>
+**CLI Arg Alias**: `--terragrunt-diff` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_HCLFMT_DIFF` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_DIFF` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-If you have _both_ `terraform` and `tofu` installed, and you want to use `terraform`, you can set the `TG_TF_PATH` to `terraform`.
+- [hclfmt](#hclfmt)
 
-If you have _multiple_ versions of `tofu` and/or `terraform` available, or you have a custom wrapper for `tofu` or `terraform`, you can set the `TG_TF_PATH` to the absolute path of the executable you want to use.
+When passed in, running `hclfmt` will print diff between original and modified file versions.
 
-**NOTE**: This will override the `terraform` binary that is used by `terragrunt` in all instances, including
-`dependency` lookups. This setting will also override any [terraform_binary]({{site.baseurl}}/docs/reference/config-blocks-and-attributes/#terraform_binary)
-configuration values specified in the `terragrunt.hcl` config for both the top level, and dependency lookups.
+### hclfmt-file
 
-### no-auto-init
+**CLI Arg**: `--file`<br/>
+**CLI Arg Alias**: `--terragrunt-hclfmt-file` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_HCLFMT_FILE` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_HCLFMT_FILE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--file /path/to/terragrunt.hcl`<br/>
+**Commands**:
 
-**CLI Arg**: `--no-auto-init`<br/>
-**CLI Arg Alias**: `--terragrunt-no-auto-init` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_NO_AUTO_INIT` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_NO_AUTO_INIT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-_(Prior to Terragrunt v0.48.6, this environment variable was called `TERRAGRUNT_AUTO_INIT` (set to `false`), and is still available for backwards compatibility)_
+- [hclfmt](#hclfmt)
 
-When passed in, don't automatically run `terraform init` when other commands are run (e.g. `terragrunt apply`). Useful
-if you want to pass custom arguments to `terraform init` that are specific to a user or execution environment, and
-therefore cannot be specified as `extra_arguments`. For example, `-plugin-dir`. You must run `terragrunt init`
-yourself in this case if needed. `terragrunt` will fail if it detects that `init` is needed, but auto init is
-disabled. See [Auto-Init]({{site.baseurl}}/docs/features/auto-init#auto-init)
+When passed in, run `hclfmt` only on the specified file.
 
-### no-auto-approve
+### hclfmt-exclude-dir
 
-**CLI Arg**: `--no-auto-approve`<br/>
-**CLI Arg Alias**: `--terragrunt-no-auto-approve` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_NO_AUTO_APPROVE` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_NO_AUTO_APPROVE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-_(Prior to Terragrunt v0.48.6, this environment variable was called `TERRAGRUNT_AUTO_APPROVE` (set to `false`), and is still available for backwards compatibility)_
+**CLI Arg**: `--exclude-dir`<br/>
+**CLI Arg Alias**: `--terragrunt-hclfmt-exclude-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_HCLFMT_EXCLUDE_DIR`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_HCLFMT_EXCLUDE_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--exclude-dir /path/to/dir`<br/>
 **Commands**:
 
-- [run-all](#run-all)
+- [hclfmt](#hclfmt)
 
-When passed in, Terragrunt will no longer automatically append `-auto-approve` to the underlying OpenTofu/Terraform commands run
-with `run-all`. Note that due to the interactive prompts, this flag will also **automatically assume
-`--parallelism 1`**.
+Can be supplied multiple times: `--exclude-dir .back --exclude-dir .archive`<br/>
+When passed in, `hclfmt` will ignore files in the specified directories.
 
-### no-auto-retry
+### hclfmt-stdin
 
-**CLI Arg**: `--no-auto-retry`<br/>
-**CLI Arg Alias**: `--terragrunt-no-auto-retry` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_NO_AUTO_RETRY` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_NO_AUTO_RETRY` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-_(Prior to Terragrunt v0.48.6, this environment variable was called `TERRAGRUNT_AUTO_RETRY` (set to `false`), and is still available for backwards compatibility)_
+**CLI Arg**: `--stdin`<br/>
+**CLI Arg Alias**: `--terragrunt-hclfmt-stdin` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_HCLFMT_STDIN` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_HCLFMT_STDIN` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-When passed in, don't automatically retry commands which fail with transient errors. See
-[Feature Flags, Errors and Excludes]({{site.baseurl}}/docs/features/runtime-control#errors)
+- [hclfmt](#hclfmt)
 
-### non-interactive
+When passed in, run `hclfmt` only on hcl passed to `stdin`, result is printed to `stdout`.
 
-**CLI Arg**: `--non-interactive`<br/>
-**CLI Arg Alias**: `--terragrunt-non-interactive` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_NON_INTERACTIVE` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_NON_INTERACTIVE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-_(Prior to Terragrunt v0.48.6, this environment variable was called `TF_INPUT` (set to `false`), and is still available for backwards compatibility. NOTE: [TF_INPUT](https://developer.hashicorp.com/terraform/cli/config/environment-variables#tf_input) is native to OpenTofu/Terraform!)_
+### hclvalidate-json
 
-When passed in, don't show interactive user prompts. This will default the answer for all Terragrunt (not OpenTofu/Terraform) prompts to `yes` except for
-the listed cases below. This is useful if you need to run Terragrunt in an automated setting (e.g. from a script). May
-also be specified with the [TF_INPUT](https://www.terraform.io/docs/configuration/environment-variables.html#tf_input) environment variable.
+**CLI Arg**: `--json`<br/>
+**CLI Arg Alias**: `--terragrunt-hclvalidate-json` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_HCLVALIDATE_JSON` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_HCLVALIDATE_JSON` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-This setting will default to `no` for the following cases:
+- [hclvalidate](#hclvalidate)
 
-- Prompts related to pulling in external dependencies. You can force include external dependencies using the
-  [--queue-include-external](#queue-include-external) option.
+When passed in, render the output in the JSON format.
 
-Note that this does not impact the behavior of OpenTofu/Terraform commands invoked by Terragrunt.
+### hclvalidate-show-config-path
 
-e.g.
+**CLI Arg**: `--show-config-path`<br/>
+**CLI Arg Alias**: `--terragrunt-hclvalidate-show-config-path` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_HCLVALIDATE_SHOW_CONFIG_PATH` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_HCLVALIDATE_SHOW_CONFIG_PATH` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-```bash
-terragrunt --non-interactive apply -auto-approve
-```
+- [hclvalidate](#hclvalidate)
 
-Is how you would make Terragrunt apply without any user prompts from Terragrunt or OpenTofu/Terraform.
+When passed in, output a list of files with invalid configuration.
 
-### working-dir
+### disable-dependent-modules
 
-**CLI Arg**: `--working-dir`<br/>
-**CLI Arg Alias**: `--terragrunt-working-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_WORKING_DIR`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_WORKING_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--working-dir /path/to/working-directory`<br/>
+**CLI Arg**: `--disable-dependent-modules`<br/>
+**CLI Arg Alias**: `--terragrunt-json-disable-dependent-modules` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_RENDER_JSON_DISABLE_DEPENDENT_MODULES` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_JSON_DISABLE_DEPENDENT_MODULES` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-Set the directory where Terragrunt should execute the `terraform` command. Default is the current working directory.
-Note that for the `run-all` commands, this parameter has a different meaning: Terragrunt will apply or destroy all the
-OpenTofu/Terraform modules in the subfolders of the `working-dir`, running `terraform` in the root of each module it
-finds.
+- [render-json](#render-json)
 
-### download-dir
+When `--disable-dependent-modules` is set, the process of identifying dependent modules will be disabled during JSON rendering.
+This lead to a faster rendering process, but the output will not include any dependent units.
 
-**CLI Arg**: `--download-dir`<br/>
-**CLI Arg Alias**: `--terragrunt-download-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_DOWNLOAD_DIR`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_DOWNLOAD` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--download-dir /path/to/dir-to-download-terraform-code`<br/>
+### out
 
-The path where to download OpenTofu/Terraform code when using [remote OpenTofu/Terraform
-configurations](https://blog.gruntwork.io/terragrunt-how-to-keep-your-terraform-code-dry-and-maintainable-f61ae06959d8).
-Default is `.terragrunt-cache` in the working directory. We recommend adding this folder to your `.gitignore`.
+**CLI Arg**: `--out`<br/>
+**CLI Arg Alias**: `--terragrunt-json-out` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_RENDER_JSON_OUT` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_JSON_OUT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--out /path/to/terragrunt_rendered.json`<br/>
+**Commands**:
 
-### source
+- [render-json](#render-json)
 
-**CLI Arg**: `--source`<br/>
-**CLI Arg Alias**: `--terragrunt-source` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_SOURCE`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_SOURCE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--source /path/to/local-terraform-code`<br/>
+When passed in, render the json representation in this file.
 
-Download OpenTofu/Terraform configurations from the specified source into a temporary folder, and run OpenTofu/Terraform in that temporary
-folder. The source should use the same syntax as the [OpenTofu/Terraform module
-source](https://www.terraform.io/docs/modules/sources.html) parameter. If you specify this argument for the `run-all`
-commands, Terragrunt will assume this is the local file path for all of your OpenTofu/Terraform modules, and for each module
-processed by the `run-all` command, Terragrunt will automatically append the path of `source` parameter in each module
-to the `--source` parameter you passed in.
+### units-that-include
 
-### source-map
+**CLI Arg**: `--units-that-include`<br/>
+**CLI Arg Alias**: `--terragrunt-modules-that-include` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_UNITS_THAT_INCLUDE`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_MODULES_THAT_INCLUDE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Requires an argument**: `--units-that-include /path/to/included-terragrunt.hcl`<br/>
+**Commands**:
 
-**CLI Arg**: `--source-map`<br/>
-**CLI Arg Alias**: `--terragrunt-source-map` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_SOURCE_MAP` (encoded as comma separated value, e.g., `source1=dest1,source2=dest2`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_SOURCE_MAP` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--source-map git::ssh://github.com=/path/to/local-terraform-code`<br/>
+- [run](#run)
+- [run-all](#run-all)
+
+When passed in, `run-all` will only run the command against Terragrunt modules that include the specified file.
+
+This applies to the set of modules that are identified based on all the existing criteria for deciding which modules to
+include. For example, consider the following folder structure:
+
+```tree
+.
+├── _envcommon
+│   └── data-stores
+│       └── aurora.hcl
+├── dev
+│   └── us-west-2
+│       └── dev
+│           ├── data-stores
+│           │   └── aurora
+│           │       └── terragrunt.hcl
+│           └── networking
+│               └── vpc
+│                   └── terragrunt.hcl
+└── stage
+    └── us-west-2
+        └── stage
+            ├── data-stores
+            │   └── aurora
+            │       └── terragrunt.hcl
+            └── networking
+                └── vpc
+                    └── terragrunt.hcl
+```
 
-Can be supplied multiple times: `--source-map source1=dest1 --source-map source2=dest2`
+Suppose that both `dev/us-west-2/dev/data-stores/aurora/terragrunt.hcl` and
+`stage/us-west-2/stage/data-stores/aurora/terragrunt.hcl` had the following contents:
 
-The `--source-map source=dest` param replaces any `source` URL (including the source URL of a config pulled
-in with `dependency` blocks) that has root `source` with `dest`.
+```hcl
+include "envcommon" {
+  path = "../../../../../_envcommon/data-stores/aurora.hcl"
+}
+```
 
-For example:
+If you run the command `run-all init --units-that-include ../_envcommon/data-stores/aurora.hcl` from the
+`dev` folder, only `dev/us-west-2/dev/data-stores/aurora` will be run; not `stage/us-west-2/stage/data-stores/aurora`.
+This is because `run-all` by default restricts the modules to only those that are direct descendents of the current
+folder you are running from. If you also pass in `--queue-include-dir ../stage`, then it will now include
+`stage/us-west-2/stage/data-stores/aurora` because now the `stage` folder is in consideration.
 
-```bash
-terragrunt apply --source-map github.com/org/modules.git=/local/path/to/modules
-```
+In other words, Terragrunt will always first find all the modules that should be included before applying this filter,
+and then will apply this filter on the set of modules that it found.
 
-The above would replace `terraform { source = "github.com/org/modules.git//xxx" }` with `terraform { source = /local/path/to/modules//xxx }` regardless of
-whether you were running `apply`, or `run-all`, or using a `dependency`.
+You can pass this argument in multiple times to provide a list of include files to consider. When multiple files are
+passed in, the set will be the union of modules that includes at least one of the files in the list.
 
-**NOTE**: This setting is ignored if you pass in `--source`.
+**NOTE**: When using relative paths, the paths are relative to the working directory. This is either the current working
+directory, or any path passed in to [working-dir](#working-dir).
 
-Note that this only performs literal matches on the URL portion. For example, a map key of
-`ssh://git@github.com/gruntwork-io/terragrunt.git` will only match terragrunt configurations with source `source =
-"ssh://git@github.com/gruntwork-io/terragrunt.git//xxx"` and not sources of the form `source =
-"git::ssh://git@github.com/gruntwork-io/terragrunt.git//xxx"`. The latter requires a map key of
-`git::ssh://git@github.com/gruntwork-io/terragrunt.git`.
+**TIP**: This flag is functionally covered by the `--queue-include-units-reading` flag, but is more explicitly
+only for the `include` configuration block.
 
-### source-update
+### queue-include-units-reading
 
-**CLI Arg**: `--source-update`<br/>
-**CLI Arg Alias**: `--terragrunt-source-update` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_SOURCE_UPDATE` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_SOURCE_UPDATE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**CLI Arg**: `--queue-include-units-reading`<br/>
+**Environment Variable**: `TERRAGRUNT_QUEUE_INCLUDE_UNITS_READING`<br/>
+**CLI Arg Alias**: `--terragrunt-queue-include-units-reading` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable Alias**: `TG_QUEUE_INCLUDE_UNITS_READING` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-When passed in, delete the contents of the temporary folder before downloading OpenTofu/Terraform source code into it.
+- [run](#run)
+- [run-all](#run-all)
 
-### iam-assume-role
+This flag works very similarly to the `--units-that-include` flag, but instead of looking only for included configurations,
+it also looks for configurations that read a given file.
 
-**CLI Arg**: `--iam-assume-role`<br/>
-**CLI Arg Alias**: `--terragrunt-iam-role` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_IAM_ASSUME_ROLE`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_IAM_ROLE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--iam-assume-role "arn:aws:iam::ACCOUNT_ID:role/ROLE_NAME"`<br/>
+When passed in, the `*-all` commands will include all units (modules) that read a given file into the queue. This is useful
+when you want to trigger an update on all units that read or include a given file using HCL functions in their configurations.
 
-Assume the specified IAM role ARN before running OpenTofu/Terraform or AWS commands. This is a convenient way to use Terragrunt
-and OpenTofu/Terraform with multiple AWS accounts.
+Consider the following folder structure:
 
-When using this option, AWS authentication takes place right before an OpenTofu/Terraform run. This takes place after `terragrunt.hcl` files are fully parsed, so HCL functions like [`get_aws_account_id`](/docs/reference/built-in-functions/#get_aws_account_id) and [`run_cmd`](/docs/reference/built-in-functions/#run_cmd) will not run after assuming the role. If you need roles to be assumed prior to parsing Terragrunt configurations, use [`auth-provider-cmd`](#auth-provider-cmd) instead.
+```tree
+.
+├── reading-shared-hcl
+│   └── terragrunt.hcl
+├── also-reading-shared-hcl
+│   └── terragrunt.hcl
+├── not-reading-shared-hcl
+│   └── terragrunt.hcl
+└── shared.hcl
+```
 
-### iam-assume-role-duration
+Suppose that `reading-shared-hcl` and `also-reading-shared-hcl` both read `shared.hcl` in their configurations, like so:
 
-**CLI Arg**: `--iam-assume-role-duration`<br/>
-**CLI Arg Alias**: `--terragrunt-iam-assume-role-duration` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_IAM_ASSUME_ROLE_DURATION`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_IAM_ASSUME_ROLE_DURATION` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--iam-assume-role-duration 3600`<br/>
+```hcl
+locals {
+ shared = read_terragrunt_config(find_in_parent_folders("shared.hcl"))
+}
+```
 
-Uses the specified duration as the session duration (in seconds) for the STS session which assumes the role defined in `--iam-assume-role`.
+If you run the command `run-all init --queue-include-units-reading shared.hcl` from the root folder, both
+`reading-shared-hcl` and `also-reading-shared-hcl` will be run; not `not-reading-shared-hcl`.
 
-### iam-assume-role-session-name
+This is because the `read_terragrunt_config` HCL function has a special hook that allows Terragrunt to track that it has
+read the file `shared.hcl`. This hook is used by all native HCL functions that Terragrunt supports which read files.
 
-**CLI Arg**: `--iam-assume-role-session-name`<br/>
-**CLI Arg Alias**: `--terragrunt-iam-assume-role-session-name` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_IAM_ASSUME_ROLE_SESSION_NAME`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_IAM_ASSUME_ROLE_SESSION_NAME` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--iam-assume-role-session-name "terragrunt-iam-role-session-name"`<br/>
+Note, however, that there are certain scenarios where Terragrunt may not be able to track that a file has been read this way.
 
-Used as the session name for the STS session which assumes the role defined in `--iam-assume-role`.
+For example, you may be using a bash script to read a file via `run_cmd`, or reading the file via OpenTofu code. To support these
+use-cases, the [mark_as_read](/docs/reference/built-in-functions/#mark_as_read) function can be used to manually mark a file as read.
 
-### iam-assume-role-web-identity-token
+That would look something like this:
 
-**CLI Arg**: `--iam-assume-role-web-identity-token`<br/>
-**CLI Arg Alias**: `--terragrunt-iam-web-identity-token` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_IAM_ASSUME_ROLE_WEB_IDENTITY_TOKEN`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_IAM_ASSUME_ROLE_WEB_IDENTITY_TOKEN` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--iam-assume-role-web-identity-token [/path/to/web-identity-token | web-identity-token-value]`<br/>
+```hcl
+locals {
+  filename = mark_as_read("file-read-by-tofu.txt")
+}
 
-Used as the web identity token for assuming a role temporarily using the AWS Security Token Service (STS) with the [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) API.
+inputs = {
+  filename = local.filename
+}
+```
 
-### queue-ignore-errors
+**⚠️**: Due to the way that Terragrunt parses configurations during a `run-all`, functions will only properly mark files as read
+if they are used in the `locals` block. Reading a file directly in the `inputs` block will not mark the file as read, as the `inputs`
+block is not evaluated until _after_ the queue has been populated with units to run.
 
-**CLI Arg**: `--queue-ignore-errors`<br/>
-**CLI Arg Alias**: `--terragrunt-ignore-dependency-errors` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_QUEUE_IGNORE_ERRORS`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_IGNORE_DEPENDENCY_ERRORS` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+### dependency-fetch-output-from-state
 
-When passed in, the `*-all` commands continue processing components even if a dependency fails
+**CLI Arg**: `--dependency-fetch-output-from-state`<br/>
+**CLI Arg Alias**: `--terragrunt-fetch-dependency-output-from-state` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_DEPENDENCY_FETCH_OUTPUT_FROM_STATE` (set to `true`)<br/>
+**Environment Variable Alias**:  `TERRAGRUNT_FETCH_DEPENDENCY_OUTPUT_FROM_STATE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-### queue-excludes-file
+When using many dependencies, this option can speed up the dependency processing by fetching dependency output directly
+from the state file instead of using `tofu/terraform output` to fetch them.
 
-**CLI Arg**: `--queue-excludes-file`<br/>
-**CLI Arg Alias**: `--terragrunt-excludes-file` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_QUEUE_EXCLUDES_FILE`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_EXCLUDES_FILE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--queue-excludes-file /path/to/file`<br/>
+At this time, the only backend that supports this feature is the AWS S3 backend.
 
-Path to a file with a list of directories that need to be excluded when running *-all commands, by default `.terragrunt-excludes`. Modules under these directories will be
-excluded during execution of the commands. If a relative path is specified, it should be relative from
-[--working-dir](#working-dir). This will only exclude the module, not its dependencies.
+**NOTE**: Avoid using this flag without pinning the version of OpenTofu/Terraform you are using. There is no guarantee that OpenTofu/Terraform will maintain the existing schema of their state files, so there is also no guarantee that the flag will work as expected in future versions of OpenTofu/Terraform. They have not changed the schema of the state file in a long time, but there is no guarantee that they will not change it in the future. We are coordinating with the OpenTofu team to encourage stability in the state file schema, unless significant performance improvements can be made to OpenTofu output fetching to make this flag unnecessary.
 
-This flag has been designed to integrate nicely with the `hclvalidate` command, which can return a list of invalid files delimited by newlines when passed the `--show-config-path` flag. To integrate the two, you can run something like the following using bash process substitution:
+Direct output fetching is a performance optimization. For more details on performance optimizations, their tradeoffs, and other performance tips, read the dedicated [Performance documentation](/docs/troubleshooting/performance).
 
-```bash
-terragrunt run-all plan --queue-excludes-file <(terragrunt hclvalidate --show-config-path)
-```
+### use-partial-parse-config-cache
 
-### queue-exclude-dir
+**CLI Arg**: `--use-partial-parse-config-cache`<br/>
+**CLI Arg Alias**: `--terragrunt-use-partial-parse-config-cache` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_USE_PARTIAL_PARSE_CONFIG_CACHE` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_USE_PARTIAL_PARSE_CONFIG_CACHE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-**CLI Arg**: `--queue-exclude-dir`<br/>
-**CLI Arg Alias**: `--terragrunt-exclude-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_QUEUE_EXCLUDE_DIR`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_EXCLUDE_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--queue-exclude-dir /path/to/dirs/to/exclude*`<br/>
+This flag can be used to drastically decrease time required for parsing Terragrunt files. The effect will only show if a lot of similar includes are expected such as the root terragrunt configuration (e.g. `root.hcl`) include.
+NOTE: This is an experimental feature, use with caution.
 
-Can be supplied multiple times: `--queue-exclude-dir /path/to/dirs/to/exclude --queue-exclude-dir /another/path/to/dirs/to/exclude`
+The reason you might want to use this flag is that Terragrunt frequently only needs to perform a partial parse of Terragrunt configurations.
 
-Unix-style glob of directories to exclude when running `*-all` commands. Modules under these directories will be
-excluded during execution of the commands. If a relative path is specified, it should be relative from
-[--working-dir](#working-dir). Flag can be specified multiple times. This will only exclude the
-module, not its dependencies.
+This is the case for scenarios like:
 
-Please note that the glob curly braces expansion is not taken in account using environment variable unlike of its equivalent as a parameter on the command line.
-You should consider using `TG_QUEUE_EXCLUDE_DIR="foo/module,bar/module"` instead of `TG_QUEUE_EXCLUDE_DIR="{foo,bar}/module"`.
+- Building the Directed Acyclic Graph (DAG) during a `run-all` command where only the `dependency` blocks need to be evaluated to determine run order.
+- Parsing the `terraform` block to determine state configurations for fetching `dependency` outputs.
+- Determining whether Terragrunt execution behavior has to change like for `prevent_destroy` or `skip` flags in configuration.
 
-### queue-include-dir
+These configurations are generally safe to cache, but due to the nature of HCL being a dynamic configuration language, there are some edge cases where caching these can lead to incorrect behavior.
 
-**CLI Arg**: `--queue-include-dir`<br/>
-**CLI Arg Alias**: `--terragrunt-include-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_QUEUE_INCLUDE_DIR`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_INCLUDE_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--queue-include-dir /path/to/dirs/to/include*`<br/>
+Once this flag has been tested thoroughly, we will consider making it the default behavior.
 
-Can be supplied multiple times: `--queue-include-dir /path/to/dirs/to/include --queue-include-dir /another/path/to/dirs/to/include`
+### backend-require-bootstrap
 
-Unix-style glob of directories to include when running `*-all` commands. Only modules under these directories (and all
-dependent modules) will be included during execution of the commands. If a relative path is specified, it should be
-relative from `--working-dir`. Flag can be specified multiple times.
+**CLI Arg**: `--backend-require-bootstrap`<br/>
+**CLI Arg Alias**: `--terragrunt-fail-on-state-bucket-creation` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_BACKEND_REQUIRE_BOOTSTRAP` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_FAIL_ON_STATE_BUCKET_CREATION` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-Please note that the glob curly braces expansion is not taken in account using environment variable unlike of its equivalent as a parameter on the command line.
-You should consider using `TG_QUEUE_INCLUDE_DIR="foo/module,bar/module"` instead of `TG_QUEUE_INCLUDE_DIR="{foo,bar}/module"`.
+When this flag is set, Terragrunt will fail and exit if it is necessary to create the remote state bucket.
 
-### queue-strict-include
+### disable-bucket-update
 
-**CLI Arg**: `--queue-strict-include`<br/>
-**CLI Arg Alias**: `--terragrunt-strict-include` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_QUEUE_STRICT_INCLUDE`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_STRICT_INCLUDE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**CLI Arg**: `--disable-bucket-update`<br/>
+**CLI Arg Alias**: `--terragrunt-disable-bucket-update` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_DISABLE_BUCKET_UPDATE` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_DISABLE_BUCKET_UPDATE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-When passed in, only modules under the directories passed in with [--queue-include-dir](#queue-include-dir)
-will be included. All dependencies of the included directories will be excluded if they are not in the included
-directories. If no [--queue-include-dir](#queue-include-dir) flags are included, terragrunt will not include
-any modules during the execution of the commands.
+When this flag is set, Terragrunt does not update the remote state bucket, which is useful to set if the state bucket is managed by a third party.
 
-### queue-ignore-dag-order
+### disable-command-validation
 
-**CLI Arg**: `--queue-ignore-dag-order`<br/>
-**CLI Arg Alias**: `--terragrunt-ignore-dependency-order` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_QUEUE_IGNORE_DAG_ORDER`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_IGNORE_DEPENDENCY_ORDER` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**CLI Arg**: `--disable-command-validation`<br/>
+**CLI Arg Alias**: `--terragrunt-disable-command-validation` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_DISABLE_COMMAND_VALIDATION` (set to `true`)<br/>
+**Environment Variable Alias**: `TERRAGRUNT_DISABLE_COMMAND_VALIDATION` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-When passed in, ignore the dependencies between units when running `*-all` commands.
+When this flag is set, Terragrunt will not validate the terraform command, which can be useful when need to use non-existent commands in hooks.
 
-### queue-exclude-external
+### provider-cache
 
-**CLI Arg**: `--queue-exclude-external`<br/>
-**CLI Arg Alias**: `--terragrunt-ignore-external-dependencies` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_QUEUE_EXCLUDE_EXTERNAL`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_IGNORE_EXTERNAL_DEPENDENCIES` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**CLI Arg**: `--provider-cache`<br/>
+**CLI Arg Alias**: `--terragrunt-provider-cache` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_PROVIDER_CACHE`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-When passed in, don't attempt to include any external dependencies when running `*-all` commands. Note that an external
-dependency is a dependency that is outside the current terragrunt working directory, and is not respective to the
-included directories with `queue-include-dir`.
+- [run-all](#run-all)
 
-### queue-include-external
+Enables Terragrunt's provider caching. This forces OpenTofu/Terraform to make provider requests through the Terragrunt Provider Cache server. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
 
-**CLI Arg**: `--queue-include-external`<br/>
-**CLI Arg Alias**: `--terragrunt-include-external-dependencies` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_QUEUE_INCLUDE_EXTERNAL`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_INCLUDE_EXTERNAL_DEPENDENCIES` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+### provider-cache-dir
 
-When passed in, include any external dependencies when running `*-all` without asking. Note that an external
-dependency is a dependency that is outside the current terragrunt working directory, and is not respective to the
-included directories with `queue-include-dir`.
+**CLI Arg**: `--provider-cache-dir`<br/>
+**CLI Arg Alias**: `--terragrunt-provider-cache-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_PROVIDER_CACHE_DIR`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-### strict-validate
+- [run-all](#run-all)
+
+The path to the Terragrunt provider cache directory. By default, `terragrunt/providers` folder in the user cache directory: `$HOME/.cache` on Unix systems, `$HOME/Library/Caches` on Darwin, `%LocalAppData%` on Windows. The file structure of the cache directory is identical to the OpenTofu/Terraform [plugin_cache_dir](https://opentofu.org/docs/cli/config/config-file/#provider-plugin-cache) directory. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
 
-**CLI Arg**: `--strict-validate`<br/>
-**CLI Arg Alias**: `--terragrunt-strict-validate` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_STRICT_VALIDATE`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_STRICT_VALIDATE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+### provider-cache-hostname
 
-When passed in, and running `terragrunt validate-inputs`, enables strict mode for the `validate-inputs` command. When strict mode is enabled, an error will be returned if any variables required by the underlying OpenTofu/Terraform configuration are not passed in, OR if any unused variables are passed in. By default, `terragrunt validate-inputs` runs in relaxed mode. In relaxed mode, an error is only returned when a variable required by the underlying OpenTofu/Terraform configuration is not passed in.
+**CLI Arg**: `--provider-cache-hostname`<br/>
+**CLI Arg Alias**: `--terragrunt-provider-cache-hostname` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_PROVIDER_CACHE_HOSTNAME`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE_HOSTNAME` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-### parallelism
+- [run-all](#run-all)
 
-**CLI Arg**: `--parallelism`<br/>
-**CLI Arg Alias**: `--terragrunt-parallelism` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_PARALLELISM`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_PARALLELISM` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+The hostname of the Terragrunt Provider Cache server. By default, 'localhost'. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
 
-When passed in, limit the number of units that are run concurrently to this number during \*-all commands.
-The exception is the `terraform init` command, which is always executed sequentially if the [OpenTofu provider plugin cache](https://opentofu.org/docs/cli/config/config-file/#provider-plugin-cache) is used. This is because the provider plugin cache is not guaranteed to be concurrency safe when used in isolation.
+### provider-cache-port
 
-To safely access provider cache concurrently, enable the [Provider Cache Server](https://terragrunt.gruntwork.io/docs/features/provider-cache-server/).
+**CLI Arg**: `--provider-cache-port`<br/>
+**CLI Arg Alias**: `--terragrunt-provider-cache-port` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_PROVIDER_CACHE_PORT`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE_PORT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-### inputs-debug
+- [run-all](#run-all)
 
-**CLI Arg**: `--inputs-debug`<br/>
-**CLI Arg Alias**: `--terragrunt-debug` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_DEBUG_INPUTS`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_DEBUG` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+The port of the Terragrunt Provider Cache server. By default, assigned automatically. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
 
-When passed in, Terragrunt will create a tfvars file that can be used to invoke the terraform module in the same way
-that Terragrunt invokes the module, so that you can debug issues with the terragrunt config. See
-[Debugging]({{site.baseurl}}/docs/features/debugging) for additional details.
+### provider-cache-token
 
-### log-level
+**CLI Arg**: `--provider-cache-token`<br/>
+**CLI Arg Alias**: `--terragrunt-provider-cache-token` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_PROVIDER_CACHE_TOKEN`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE_TOKEN` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-**CLI Arg**: `--log-level`<br/>
-**CLI Arg Alias**: `--terragrunt-log-level` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_LOG_LEVEL`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_LOG_LEVEL` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--log-level <LOG_LEVEL>`<br/>
+- [run-all](#run-all)
 
-When passed it, sets logging level for terragrunt. All supported levels are:
+The Token for authentication on the Terragrunt Provider Cache server. By default, assigned automatically. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
 
-- `stderr`
-- `stdout`
-- `error`
-- `warn`
-- `info` (this is the default)
-- `debug`
-- `trace`
+### provider-cache-registry-names
 
-Where the first two control the logging of Terraform/OpenTofu output.
+**CLI Arg**: `--provider-cache-registry-names`<br/>
+**CLI Arg Alias**: `--terragrunt-provider-cache-registry-names` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_PROVIDER_CACHE_REGISTRY_NAMES`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE_REGISTRY_NAMES` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-### log-format
+- [run-all](#run-all)
 
-**CLI Arg**: `--log-format`<br/>
-**CLI Arg Alias**: `--terragrunt-log-format` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_LOG_FORMAT`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_LOG_FORMAT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--log-format <LOG_FORMAT>`<br/>
+The list of remote registries to cached by Terragrunt Provider Cache server. By default, 'registry.terraform.io', 'registry.opentofu.org'. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
 
-There are four log format presets:
+### out-dir
 
-- `pretty` (this is the default)
-- `bare` (old Terragrunt logging, pre-[v0.67.0](https://github.com/gruntwork-io/terragrunt/tree/v0.67.0))
-- `json`
-- `key-value`
+**CLI Arg**: `--out-dir`<br/>
+**CLI Arg Alias**: `--terragrunt-out-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_OUT_DIR`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_OUT_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-### log-custom-format
+- [run-all](#run-all)
 
-**CLI Arg**: `--log-custom-format`<br/>
-**CLI Arg Alias**: `--terragrunt-log-custom-format` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_LOG_CUSTOM_FORMAT`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_LOG_CUSTOM_FORMAT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--log-custom-format <LOG_CUSTOM_FORMAT>`<br/>
+Specify the plan output directory for the `*-all` commands. Useful to save plans between runs in a single place.
 
-This allows you to customize logging however you like.
+### json-out-dir
 
-Make sure to read [Custom Log Format](https://terragrunt.gruntwork.io/docs/features/log-formatting) for syntax details.
+**CLI Arg**: `--json-out-dir`<br/>
+**CLI Arg Alias**: `--terragrunt-json-out-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_JSON_OUT_DIR`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_JSON_OUT_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Commands**:
 
-### log-disable
+- [run-all](#run-all)
 
-**CLI Arg**: `--log-disable`<br/>
-**CLI Arg Alias**: `--terragrunt-log-disable` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_LOG_DISABLE`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_LOG_DISABLE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+Specify the output directory for the `*-all` commands to store plans in JSON format. Useful to read plans programmatically.
 
-Disable logging. This flag also enables [tf-forward-stdout](#tf-forward-stdout).
+### tf-forward-stdout
 
-### log-show-abs-paths
+**CLI Arg**: `--tf-forward-stdout`<br/>
+**CLI Arg Alias**: `--terragrunt-forward-tf-stdout` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_TF_FORWARD_STDOUT`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_FORWARD_TF_STDOUT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-**CLI Arg**: `--log-show-abs-paths`<br/>
-**CLI Arg Alias**: `--terragrunt-log-show-abs-paths` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_LOG_SHOW_ABS_PATHS`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_LOG_SHOW_ABS_PATHS` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+If specified, the output of Terraform/OpenTofu commands will be printed as is. By default, all logs, except when using the `output` command or `-json` flags, are integrated into the Terragrunt log.
 
-If specified, Terragrunt paths in logs will be absolute. By default, the paths are relative to the working directory.
+The example of what the log looks like without the `--tf-forward-stdout` flag specified:
 
-### no-color
+```bash
+14:19:25.081 INFO   [app] Running command: tofu plan -input=false
+14:19:25.174 STDOUT [app] tofu: OpenTofu used the selected providers to generate the following execution
+14:19:25.174 STDOUT [app] tofu: plan. Resource actions are indicated with the following symbols:
+14:19:25.174 STDOUT [app] tofu:   + create
+14:19:25.174 STDOUT [app] tofu: OpenTofu will perform the following actions:
+```
 
-**CLI Arg**: `--no-color`<br/>
-**CLI Arg Alias**: `--terragrunt-no-color` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_NO_COLOR`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_NO_COLOR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+The example of what the log looks like with the `--tf-forward-stdout` flag specified:
 
-If specified, Terragrunt output won't contain any color.
+```bash
+14:19:25.081 INFO   [app] Running command: tofu plan -input=false
 
-NOTE: This option also disables OpenTofu/Terraform output colors by propagating the OpenTofu/Terraform [`-no-color`](https://developer.hashicorp.com/terraform/cli/commands/plan#no-color) argument.
+OpenTofu used the selected providers to generate the following execution
+plan. Resource actions are indicated with the following symbols:
+  + create
 
-### check
+OpenTofu will perform the following actions:
+```
 
-**CLI Arg**: `--check`<br/>
-**CLI Arg Alias**: `--terragrunt-check` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_HCLFMT_CHECK` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_CHECK` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+### no-destroy-dependencies-check
 
-- [hclfmt](#hclfmt)
+**CLI Arg**: `--no-destroy-dependencies-check`<br/>
+**CLI Arg Alias**: `--terragrunt-no-destroy-dependencies-check` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**Environment Variable**: `TG_NO_DESTROY_DEPENDENCIES_CHECK`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_NO_DESTROY_DEPENDENCIES_CHECK` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-When passed in, run `hclfmt` in check only mode instead of actively overwriting the files. This will cause the
-command to exit with exit code 1 if there are any files that are not formatted.
+If specified, Terragrunt will not check dependent units when running the `destroy` command.
 
-### diff
+By default, Terragrunt checks dependent units when running `destroy` command to provide a warning that other units may be not work correctly if their dependency is destroyed.
 
-**CLI Arg**: `--diff`<br/>
-**CLI Arg Alias**: `--terragrunt-diff` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_HCLFMT_DIFF` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_DIFF` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+### feature
 
-- [hclfmt](#hclfmt)
+**CLI Arg**: `--feature`<br/>
+**Environment Variable**: `TG_FEATURE`<br/>
+**Environment Variable Alias**: `TERRAGRUNT_FEATURE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
 
-When passed in, running `hclfmt` will print diff between original and modified file versions.
+Feature flags in Terragrunt allow users to dynamically control configuration behavior through CLI arguments or environment variables.
 
-### hclfmt-file
+These flags enable a more flexible and controlled deployment process, particularly in monorepo contexts with interdependent infrastructure units.
 
-**CLI Arg**: `--file`<br/>
-**CLI Arg Alias**: `--terragrunt-hclfmt-file` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_HCLFMT_FILE` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_HCLFMT_FILE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--file /path/to/terragrunt.hcl`<br/>
-**Commands**:
+Example HCL flags definition:
 
-- [hclfmt](#hclfmt)
+```hcl
+feature "string_feature_flag" {
+  default = "test"
+}
 
-When passed in, run `hclfmt` only on the specified file.
+feature "int_feature_flag" {
+  default = 777
+}
 
-### hclfmt-exclude-dir
+feature "bool_feature_flag" {
+  default = false
+}
 
-**CLI Arg**: `--exclude-dir`<br/>
-**CLI Arg Alias**: `--terragrunt-hclfmt-exclude-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_HCLFMT_EXCLUDE_DIR`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_HCLFMT_EXCLUDE_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--exclude-dir /path/to/dir`<br/>
-**Commands**:
+terraform {
+  before_hook "conditional_command" {
+    commands = ["apply", "plan", "destroy"]
+    execute  = feature.bool_feature_flag.value ? ["sh", "-c", "echo running conditional bool_feature_flag"] : [ "sh", "-c", "exit", "0" ]
+  }
+}
 
-- [hclfmt](#hclfmt)
+inputs = {
+  string_feature_flag = feature.string_feature_flag.value
+  int_feature_flag = feature.int_feature_flag.value
+}
 
-Can be supplied multiple times: `--exclude-dir .back --exclude-dir .archive`<br/>
-When passed in, `hclfmt` will ignore files in the specified directories.
+```
 
-### hclfmt-stdin
+Setting a feature flag through the CLI:
 
-**CLI Arg**: `--stdin`<br/>
-**CLI Arg Alias**: `--terragrunt-hclfmt-stdin` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_HCLFMT_STDIN` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_HCLFMT_STDIN` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+```bash
+terragrunt --feature int_feature_flag=123 --feature bool_feature_flag=true --feature string_feature_flag=app1 apply
+```
 
-- [hclfmt](#hclfmt)
+Setting feature flags through environment variables:
 
-When passed in, run `hclfmt` only on hcl passed to `stdin`, result is printed to `stdout`.
+```bash
+export TERRAGRUNT_FEATURE=int_feature_flag=123,bool_feature_flag=true,string_feature_flag=app1
+terragrunt apply
+```
 
-### hclvalidate-json
+### experiment
 
-**CLI Arg**: `--json`<br/>
-**CLI Arg Alias**: `--terragrunt-hclvalidate-json` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_HCLVALIDATE_JSON` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_HCLVALIDATE_JSON` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+**CLI Arg**: `--experiment`<br/>
+**Environment Variable**: `TG_EXPERIMENT`<br/>
 
-- [hclvalidate](#hclvalidate)
+Enable experimental features in Terragrunt before they're stable.
 
-When passed in, render the output in the JSON format.
+For more information, see the [Experiments](/docs/reference/experiments) documentation.
 
-### hclvalidate-show-config-path
+### experiment-mode
 
-**CLI Arg**: `--show-config-path`<br/>
-**CLI Arg Alias**: `--terragrunt-hclvalidate-show-config-path` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_HCLVALIDATE_SHOW_CONFIG_PATH` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_HCLVALIDATE_SHOW_CONFIG_PATH` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+**CLI Arg**: `--experiment-mode`<br/>
+**Environment Variable**: `TG_EXPERIMENT_MODE`<br/>
 
-- [hclvalidate](#hclvalidate)
+Enable all experimental features in Terragrunt before they're stable.
 
-When passed in, output a list of files with invalid configuration.
+For more information, see the [Experiments](/docs/reference/experiments) documentation.
 
-### disable-dependent-modules
+### strict-control
 
-**CLI Arg**: `--disable-dependent-modules`<br/>
-**CLI Arg Alias**: `--terragrunt-json-disable-dependent-modules` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_RENDER_JSON_DISABLE_DEPENDENT_MODULES` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_JSON_DISABLE_DEPENDENT_MODULES` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+**CLI Arg**: `--strict-control`<br/>
+**Environment Variable**: `TERRAGRUNT_STRICT_CONTROL`<br/>
 
-- [render-json](#render-json)
+Enable strict controls that opt-in future breaking changes in Terragrunt.
 
-When `--disable-dependent-modules` is set, the process of identifying dependent modules will be disabled during JSON rendering.
-This lead to a faster rendering process, but the output will not include any dependent units.
+For more information, see the [Strict Mode](/docs/reference/strict-mode) documentation.
 
-### out
+### strict-mode
 
-**CLI Arg**: `--out`<br/>
-**CLI Arg Alias**: `--terragrunt-json-out` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_RENDER_JSON_OUT` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_JSON_OUT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--out /path/to/terragrunt_rendered.json`<br/>
-**Commands**:
+**CLI Arg**: `--strict-mode`<br/>
+**Environment Variable**: `TERRAGRUNT_STRICT_MODE`<br/>
 
-- [render-json](#render-json)
+Enable all strict controls that opt-in future breaking changes in Terragrunt.
 
-When passed in, render the json representation in this file.
+For more information, see the [Strict Mode](/docs/reference/strict-mode) documentation.
 
-### units-that-include
+### in-download-dir
 
-**CLI Arg**: `--units-that-include`<br/>
-**CLI Arg Alias**: `--terragrunt-modules-that-include` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_UNITS_THAT_INCLUDE`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_MODULES_THAT_INCLUDE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Requires an argument**: `--units-that-include /path/to/included-terragrunt.hcl`<br/>
+**CLI Arg**: `--in-download-dir`<br/>
+**Environment Variable**: `TG_IN_DOWNLOAD_DIR`<br/>
 **Commands**:
 
-- [run](#run)
-- [run-all](#run-all)
+- [exec](#exec)
 
-When passed in, `run-all` will only run the command against Terragrunt modules that include the specified file.
+Execute the provided command in the download directory.
 
-This applies to the set of modules that are identified based on all the existing criteria for deciding which modules to
-include. For example, consider the following folder structure:
+## Deprecated
 
-```tree
-.
-├── _envcommon
-│   └── data-stores
-│       └── aurora.hcl
-├── dev
-│   └── us-west-2
-│       └── dev
-│           ├── data-stores
-│           │   └── aurora
-│           │       └── terragrunt.hcl
-│           └── networking
-│               └── vpc
-│                   └── terragrunt.hcl
-└── stage
-    └── us-west-2
-        └── stage
-            ├── data-stores
-            │   └── aurora
-            │       └── terragrunt.hcl
-            └── networking
-                └── vpc
-                    └── terragrunt.hcl
-```
+### Deprecated Commands
 
-Suppose that both `dev/us-west-2/dev/data-stores/aurora/terragrunt.hcl` and
-`stage/us-west-2/stage/data-stores/aurora/terragrunt.hcl` had the following contents:
+The following are deprecated commands that are no longer recommended for use. They are still available for backwards compatibility, but will be removed in a future release.
 
-```hcl
-include "envcommon" {
-  path = "../../../../../_envcommon/data-stores/aurora.hcl"
-}
-```
+- [Deprecated Commands](#deprecated-commands)
+  - [plan-all (DEPRECATED: use run --all plan)](#plan-all)
+  - [apply-all (DEPRECATED: use run --all apply)](#apply-all)
+  - [output-all (DEPRECATED: use run --all output)](#output-all)
+  - [destroy-all (DEPRECATED: use run --all destroy)](#destroy-all)
+  - [validate-all (DEPRECATED: use run --all validate)](#validate-all)
+  - [run-all (DEPRECATED: use run --all)](#run-all)
+  - [graph (DEPRECATED: use run --graph)](#graph)
+  - [graph-dependencies (DEPRECATED: use dag graph)](#graph-dependencies)
 
-If you run the command `run-all init --units-that-include ../_envcommon/data-stores/aurora.hcl` from the
-`dev` folder, only `dev/us-west-2/dev/data-stores/aurora` will be run; not `stage/us-west-2/stage/data-stores/aurora`.
-This is because `run-all` by default restricts the modules to only those that are direct descendents of the current
-folder you are running from. If you also pass in `--queue-include-dir ../stage`, then it will now include
-`stage/us-west-2/stage/data-stores/aurora` because now the `stage` folder is in consideration.
+#### plan-all
 
-In other words, Terragrunt will always first find all the modules that should be included before applying this filter,
-and then will apply this filter on the set of modules that it found.
+**DEPRECATED: Use `run-all plan` instead.**
 
-You can pass this argument in multiple times to provide a list of include files to consider. When multiple files are
-passed in, the set will be the union of modules that includes at least one of the files in the list.
+Display the plans of a `stack` by running `terragrunt plan` in each subfolder. Make sure to read [Execute OpenTofu/Terraform
+commands on multiple modules at once](/docs/features/stacks) for
+context.
 
-**NOTE**: When using relative paths, the paths are relative to the working directory. This is either the current working
-directory, or any path passed in to [working-dir](#working-dir).
+Example:
 
-**TIP**: This flag is functionally covered by the `--queue-include-units-reading` flag, but is more explicitly
-only for the `include` configuration block.
+```bash
+terragrunt run-all plan
+```
 
-### queue-include-units-reading
+This will recursively search the current working directory for any folders that contain Terragrunt modules and run
+`plan` in each one, concurrently, while respecting ordering defined via
+[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
+[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
 
-**CLI Arg**: `--queue-include-units-reading`<br/>
-**Environment Variable**: `TERRAGRUNT_QUEUE_INCLUDE_UNITS_READING`<br/>
-**CLI Arg Alias**: `--terragrunt-queue-include-units-reading` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable Alias**: `TG_QUEUE_INCLUDE_UNITS_READING` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+**[WARNING] `run-all plan` is currently broken for certain use cases**. If you have a stack of Terragrunt modules with
+dependencies between them—either via `dependency` blocks or `terraform_remote_state` data sources—and you've never
+deployed them, then `run-all plan` will fail as it will not be possible to resolve the `dependency` blocks or
+`terraform_remote_state` data sources! Please [see here for more
+information](https://github.com/gruntwork-io/terragrunt/issues/720#issuecomment-497888756).
 
-- [run](#run)
-- [run-all](#run-all)
+#### apply-all
 
-This flag works very similarly to the `--units-that-include` flag, but instead of looking only for included configurations,
-it also looks for configurations that read a given file.
+**DEPRECATED: Use `run-all apply` instead.**
 
-When passed in, the `*-all` commands will include all units (modules) that read a given file into the queue. This is useful
-when you want to trigger an update on all units that read or include a given file using HCL functions in their configurations.
+Apply a `stack` by running `terragrunt apply` in each subfolder. Make sure to read [Execute OpenTofu/Terraform
+commands on multiple modules at once](/docs/features/stacks) for
+context.
 
-Consider the following folder structure:
+Example:
 
-```tree
-.
-├── reading-shared-hcl
-│   └── terragrunt.hcl
-├── also-reading-shared-hcl
-│   └── terragrunt.hcl
-├── not-reading-shared-hcl
-│   └── terragrunt.hcl
-└── shared.hcl
+```bash
+terragrunt apply-all
 ```
 
-Suppose that `reading-shared-hcl` and `also-reading-shared-hcl` both read `shared.hcl` in their configurations, like so:
+This will recursively search the current working directory for any folders that contain Terragrunt modules and run
+`apply` in each one, concurrently, while respecting ordering defined via
+[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
+[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
 
-```hcl
-locals {
- shared = read_terragrunt_config(find_in_parent_folders("shared.hcl"))
-}
-```
+**[NOTE]** Using `apply-all` silently adds the `-auto-approve` flag to the command line arguments passed to OpenTofu/Terraform
+due to issues with shared `stdin` making individual approvals impossible. Please [see here for more
+information](https://github.com/gruntwork-io/terragrunt/issues/386#issuecomment-358306268)
 
-If you run the command `run-all init --queue-include-units-reading shared.hcl` from the root folder, both
-`reading-shared-hcl` and `also-reading-shared-hcl` will be run; not `not-reading-shared-hcl`.
+#### output-all
 
-This is because the `read_terragrunt_config` HCL function has a special hook that allows Terragrunt to track that it has
-read the file `shared.hcl`. This hook is used by all native HCL functions that Terragrunt supports which read files.
+**DEPRECATED: Use `run-all output` instead.**
 
-Note, however, that there are certain scenarios where Terragrunt may not be able to track that a file has been read this way.
+Display the outputs of a `stack` by running `terragrunt output` in each subfolder. Make sure to read [Execute OpenTofu/Terraform
+commands on multiple modules at once](/docs/features/stacks) for
+context.
 
-For example, you may be using a bash script to read a file via `run_cmd`, or reading the file via OpenTofu code. To support these
-use-cases, the [mark_as_read](/docs/reference/built-in-functions/#mark_as_read) function can be used to manually mark a file as read.
+Example:
 
-That would look something like this:
+```bash
+terragrunt output-all
+```
 
-```hcl
-locals {
-  filename = mark_as_read("file-read-by-tofu.txt")
-}
+This will recursively search the current working directory for any folders that contain Terragrunt modules and run
+`output` in each one, concurrently, while respecting ordering defined via
+[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
+[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
 
-inputs = {
-  filename = local.filename
-}
-```
+**[WARNING] `output-all` is currently broken for certain use cases**. If you have a stack of Terragrunt modules with
+dependencies between them—either via `dependency` blocks or `terraform_remote_state` data sources—and you've never
+deployed them, then `output-all` will fail as it will not be possible to resolve the `dependency` blocks or
+`terraform_remote_state` data sources! Please [see here for more
+information](https://github.com/gruntwork-io/terragrunt/issues/720#issuecomment-497888756).
 
-**⚠️**: Due to the way that Terragrunt parses configurations during a `run-all`, functions will only properly mark files as read
-if they are used in the `locals` block. Reading a file directly in the `inputs` block will not mark the file as read, as the `inputs`
-block is not evaluated until _after_ the queue has been populated with units to run.
+#### destroy-all
 
-### dependency-fetch-output-from-state
+**DEPRECATED: Use `run-all destroy` instead.**
 
-**CLI Arg**: `--dependency-fetch-output-from-state`<br/>
-**CLI Arg Alias**: `--terragrunt-fetch-dependency-output-from-state` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_DEPENDENCY_FETCH_OUTPUT_FROM_STATE` (set to `true`)<br/>
-**Environment Variable Alias**:  `TERRAGRUNT_FETCH_DEPENDENCY_OUTPUT_FROM_STATE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+Destroy a `stack` by running `terragrunt destroy` in each subfolder. Make sure to read [Execute OpenTofu/Terraform
+commands on multiple modules at once](/docs/features/stacks) for
+context.
 
-When using many dependencies, this option can speed up the dependency processing by fetching dependency output directly
-from the state file instead of using `tofu/terraform output` to fetch them.
+Example:
 
-At this time, the only backend that supports this feature is the AWS S3 backend.
+```bash
+terragrunt destroy-all
+```
 
-**NOTE**: Avoid using this flag without pinning the version of OpenTofu/Terraform you are using. There is no guarantee that OpenTofu/Terraform will maintain the existing schema of their state files, so there is also no guarantee that the flag will work as expected in future versions of OpenTofu/Terraform. They have not changed the schema of the state file in a long time, but there is no guarantee that they will not change it in the future. We are coordinating with the OpenTofu team to encourage stability in the state file schema, unless significant performance improvements can be made to OpenTofu output fetching to make this flag unnecessary.
+This will recursively search the current working directory for any folders that contain Terragrunt modules and run
+`destroy` in each one, concurrently, while respecting ordering defined via
+[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
+[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
 
-Direct output fetching is a performance optimization. For more details on performance optimizations, their tradeoffs, and other performance tips, read the dedicated [Performance documentation](/docs/troubleshooting/performance).
+**[NOTE]** Using `destroy-all` silently adds the `-auto-approve` flag to the command line arguments passed to OpenTofu/Terraform
+due to issues with shared `stdin` making individual approvals impossible. Please [see here for more
+information](https://github.com/gruntwork-io/terragrunt/issues/386#issuecomment-358306268)
 
-### use-partial-parse-config-cache
+#### validate-all
 
-**CLI Arg**: `--use-partial-parse-config-cache`<br/>
-**CLI Arg Alias**: `--terragrunt-use-partial-parse-config-cache` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_USE_PARTIAL_PARSE_CONFIG_CACHE` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_USE_PARTIAL_PARSE_CONFIG_CACHE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+**DEPRECATED: Use `run-all validate` instead.**
 
-This flag can be used to drastically decrease time required for parsing Terragrunt files. The effect will only show if a lot of similar includes are expected such as the root terragrunt configuration (e.g. `root.hcl`) include.
-NOTE: This is an experimental feature, use with caution.
+Validate `stack` by running `terragrunt validate` in each subfolder. Make sure to read [Execute OpenTofu/Terraform
+commands on multiple modules at once](/docs/features/stacks) for
+context.
 
-The reason you might want to use this flag is that Terragrunt frequently only needs to perform a partial parse of Terragrunt configurations.
+Example:
 
-This is the case for scenarios like:
+```bash
+terragrunt validate-all
+```
 
-- Building the Directed Acyclic Graph (DAG) during a `run-all` command where only the `dependency` blocks need to be evaluated to determine run order.
-- Parsing the `terraform` block to determine state configurations for fetching `dependency` outputs.
-- Determining whether Terragrunt execution behavior has to change like for `prevent_destroy` or `skip` flags in configuration.
+This will recursively search the current working directory for any folders that contain Terragrunt modules and run
+`validate` in each one, concurrently, while respecting ordering defined via
+[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
+[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
 
-These configurations are generally safe to cache, but due to the nature of HCL being a dynamic configuration language, there are some edge cases where caching these can lead to incorrect behavior.
+#### run-all
 
-Once this flag has been tested thoroughly, we will consider making it the default behavior.
+**DEPRECATED: Use `run --all` instead.**
 
-### backend-require-bootstrap
+Runs the provided OpenTofu/Terraform command against a [stack](/docs/getting-started/terminology/#stack).
+The command will recursively find terragrunt [units](/docs/getting-started/terminology/#unit) in the current directory
+tree and run the OpenTofu/Terraform command in dependency order (unless the command is destroy,
+in which case the command is run in reverse dependency order).
 
-**CLI Arg**: `--backend-require-bootstrap`<br/>
-**CLI Arg Alias**: `--terragrunt-fail-on-state-bucket-creation` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_BACKEND_REQUIRE_BOOTSTRAP` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_FAIL_ON_STATE_BUCKET_CREATION` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+Make sure to read about the [stacks feature](/docs/features/stacks) for context.
 
-When this flag is set, Terragrunt will fail and exit if it is necessary to create the remote state bucket.
+Example:
 
-### disable-bucket-update
+```bash
+terragrunt run --all apply  # New syntax
+```
 
-**CLI Arg**: `--disable-bucket-update`<br/>
-**CLI Arg Alias**: `--terragrunt-disable-bucket-update` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_DISABLE_BUCKET_UPDATE` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_DISABLE_BUCKET_UPDATE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+This will recursively search the current working directory for any folders that contain Terragrunt units and run
+`apply` in each one, concurrently, while respecting ordering defined via
+[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
+[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
 
-When this flag is set, Terragrunt does not update the remote state bucket, which is useful to set if the state bucket is managed by a third party.
+**[WARNING] Do not set [TF_PLUGIN_CACHE_DIR](https://opentofu.org/docs/cli/config/config-file/#provider-plugin-cache) when using `run-all`**
 
-### disable-command-validation
+Instead take advantage of the built-in [Provider Cache Server](/docs/features/provider-cache-server/) that
+mitigates some of the limitations of using the OpenTofu/Terraform Provider Plugin Cache directly.
 
-**CLI Arg**: `--disable-command-validation`<br/>
-**CLI Arg Alias**: `--terragrunt-disable-command-validation` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_DISABLE_COMMAND_VALIDATION` (set to `true`)<br/>
-**Environment Variable Alias**: `TERRAGRUNT_DISABLE_COMMAND_VALIDATION` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+We are [working with the OpenTofu team to improve this behavior](https://github.com/opentofu/opentofu/issues/1483) so that you don't have to worry about this in the future.
 
-When this flag is set, Terragrunt will not validate the terraform command, which can be useful when need to use non-existent commands in hooks.
+**[NOTE] Use `run-all` with care if you have unapplied dependencies**.
 
-### provider-cache
+If you have a stack of Terragrunt units with dependencies between them via `dependency` blocks
+and you've never deployed them, then commands like `run-all plan` will fail,
+as it won't be possible to resolve outputs of `dependency` blocks without applying them first.
 
-**CLI Arg**: `--provider-cache`<br/>
-**CLI Arg Alias**: `--terragrunt-provider-cache` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_PROVIDER_CACHE`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+The solution for this is to take advantage of [mock outputs in dependency blocks](/docs/reference/config-blocks-and-attributes/#dependency).
 
-- [run-all](#run-all)
+**[NOTE]** Using `run-all` with `apply` or `destroy` silently adds the `-auto-approve` flag to the command line
+arguments passed to OpenTofu/Terraform due to issues with shared `stdin` making individual approvals impossible.
 
-Enables Terragrunt's provider caching. This forces OpenTofu/Terraform to make provider requests through the Terragrunt Provider Cache server. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
+**[NOTE]** Using the OpenTofu/Terraform [-detailed-exitcode](https://opentofu.org/docs/cli/commands/plan/#other-options)
+flag with the `run-all` command results in an aggregate exit code being returned, rather than the exit code of any particular unit.
 
-### provider-cache-dir
+The algorithm for determining the aggregate exit code is as follows:
 
-**CLI Arg**: `--provider-cache-dir`<br/>
-**CLI Arg Alias**: `--terragrunt-provider-cache-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_PROVIDER_CACHE_DIR`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+- If any unit throws a 1, Terragrunt will throw a 1.
+- If any unit throws a 2, but nothing throws a 1, Terragrunt will throw a 2.
+- If nothing throws a non-zero, Terragrunt will throw a 0.
 
-- [run-all](#run-all)
+#### graph
 
-The path to the Terragrunt provider cache directory. By default, `terragrunt/providers` folder in the user cache directory: `$HOME/.cache` on Unix systems, `$HOME/Library/Caches` on Darwin, `%LocalAppData%` on Windows. The file structure of the cache directory is identical to the OpenTofu/Terraform [plugin_cache_dir](https://opentofu.org/docs/cli/config/config-file/#provider-plugin-cache) directory. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
+**DEPRECATED: Use `run --graph` instead.**
 
-### provider-cache-hostname
+Run the provided OpenTofu/Terraform command against the graph of dependencies for the unit in the current working directory. The graph consists of all units that depend on the unit in the current working directory via a `dependency` or `dependencies` blocks, plus all the units that depend on those units, and all the units that depend on those units, and so on, recursively up the tree, up to the Git repository root, or the path specified via the optional `--graph-root` argument.
 
-**CLI Arg**: `--provider-cache-hostname`<br/>
-**CLI Arg Alias**: `--terragrunt-provider-cache-hostname` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_PROVIDER_CACHE_HOSTNAME`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE_HOSTNAME` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+The Command will be executed following the order of dependencies: so it'll run on the unit in the current working directory first, then on units that depend on it directly, then on the units that depend on those units, and so on. Note that if the command is `destroy`, it will run in the opposite order (the final dependents, then their dependencies, etc. up to the unit you ran the command in).
 
-- [run-all](#run-all)
+Example:
+Given the following dependencies:
+[![dependency-graph](/assets/img/collections/documentation/dependency-graph.png){: width="80%" }]({{site.baseurl}}/assets/img/collections/documentation/dependency-graph.png)
 
-The hostname of the Terragrunt Provider Cache server. By default, 'localhost'. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
+Running `terragrunt graph apply` in `eks` module will lead to the following execution order:
 
-### provider-cache-port
+```text
+Group 1
+- Module project/eks
 
-**CLI Arg**: `--provider-cache-port`<br/>
-**CLI Arg Alias**: `--terragrunt-provider-cache-port` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_PROVIDER_CACHE_PORT`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE_PORT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+Group 2
+- Module project/services/eks-service-1
+- Module project/services/eks-service-2
 
-- [run-all](#run-all)
+Group 3
+- Module project/services/eks-service-2-v2
+- Module project/services/eks-service-3
+- Module project/services/eks-service-5
 
-The port of the Terragrunt Provider Cache server. By default, assigned automatically. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
+Group 4
+- Module project/services/eks-service-3-v2
+- Module project/services/eks-service-4
 
-### provider-cache-token
+Group 5
+- Module project/services/eks-service-3-v3
+```
 
-**CLI Arg**: `--provider-cache-token`<br/>
-**CLI Arg Alias**: `--terragrunt-provider-cache-token` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_PROVIDER_CACHE_TOKEN`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE_TOKEN` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+Notes:
 
-- [run-all](#run-all)
+- `lambda` units aren't included in the graph, because they are not dependent on `eks` unit.
+- execution is from bottom up based on dependencies
 
-The Token for authentication on the Terragrunt Provider Cache server. By default, assigned automatically. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
+Running `terragrunt graph destroy` in `eks` unit will lead to the following execution order:
 
-### provider-cache-registry-names
+```text
+Group 1
+- Module project/services/eks-service-2-v2
+- Module project/services/eks-service-3-v3
+- Module project/services/eks-service-4
+- Module project/services/eks-service-5
 
-**CLI Arg**: `--provider-cache-registry-names`<br/>
-**CLI Arg Alias**: `--terragrunt-provider-cache-registry-names` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_PROVIDER_CACHE_REGISTRY_NAMES`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_PROVIDER_CACHE_REGISTRY_NAMES` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+Group 2
+- Module project/services/eks-service-3-v2
 
-- [run-all](#run-all)
+Group 3
+- Module project/services/eks-service-3
 
-The list of remote registries to cached by Terragrunt Provider Cache server. By default, 'registry.terraform.io', 'registry.opentofu.org'. Make sure to read [Provider Cache Server](/docs/features/provider-cache-server) for context.
+Group 4
+- Module project/services/eks-service-1
+- Module project/services/eks-service-2
 
-### out-dir
+Group 5
+- Module project/eks
+```
 
-**CLI Arg**: `--out-dir`<br/>
-**CLI Arg Alias**: `--terragrunt-out-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_OUT_DIR`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_OUT_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+Notes:
 
-- [run-all](#run-all)
+- execution is in reverse order, first are destroyed "top" units and in the end `eks`
+- `lambda` units aren't affected at all
 
-Specify the plan output directory for the `*-all` commands. Useful to save plans between runs in a single place.
+Running `terragrunt graph apply` in `services/eks-service-3`:
 
-### json-out-dir
+```text
+Group 1
+- Module project/services/eks-service-3
 
-**CLI Arg**: `--json-out-dir`<br/>
-**CLI Arg Alias**: `--terragrunt-json-out-dir` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_JSON_OUT_DIR`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_JSON_OUT_DIR` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Commands**:
+Group 2
+- Module project/services/eks-service-3-v2
+- Module project/services/eks-service-4
 
-- [run-all](#run-all)
+Group 3
+- Module project/services/eks-service-3-v3
 
-Specify the output directory for the `*-all` commands to store plans in JSON format. Useful to read plans programmatically.
+```
 
-### tf-forward-stdout
+Notes:
 
-**CLI Arg**: `--tf-forward-stdout`<br/>
-**CLI Arg Alias**: `--terragrunt-forward-tf-stdout` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_TF_FORWARD_STDOUT`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_FORWARD_TF_STDOUT` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+- in execution are included only services dependent from `eks-service-3`
 
-If specified, the output of Terraform/OpenTofu commands will be printed as is. By default, all logs, except when using the `output` command or `-json` flags, are integrated into the Terragrunt log.
+Running `terragrunt graph destroy` in `services/eks-service-3`:
 
-The example of what the log looks like without the `--tf-forward-stdout` flag specified:
+```text
+Group 1
+- Module project/services/eks-service-3-v3
+- Module project/services/eks-service-4
 
-```bash
-14:19:25.081 INFO   [app] Running command: tofu plan -input=false
-14:19:25.174 STDOUT [app] tofu: OpenTofu used the selected providers to generate the following execution
-14:19:25.174 STDOUT [app] tofu: plan. Resource actions are indicated with the following symbols:
-14:19:25.174 STDOUT [app] tofu:   + create
-14:19:25.174 STDOUT [app] tofu: OpenTofu will perform the following actions:
+Group 2
+- Module project/services/eks-service-3-v2
+
+Group 3
+- Module project/services/eks-service-3
 ```
 
-The example of what the log looks like with the `--tf-forward-stdout` flag specified:
+Notes:
 
-```bash
-14:19:25.081 INFO   [app] Running command: tofu plan -input=false
+- destroy will be executed only on subset of services dependent from `eks-service-3`
 
-OpenTofu used the selected providers to generate the following execution
-plan. Resource actions are indicated with the following symbols:
-  + create
+#### graph-dependencies
 
-OpenTofu will perform the following actions:
-```
+**DEPRECATED: Use `dag graph` instead.**
 
-### no-destroy-dependencies-check
+Prints the Terragrunt dependency graph, in DOT format, to `stdout`. You can generate charts from DOT format using tools
+such as [GraphViz](http://www.graphviz.org/).
 
-**CLI Arg**: `--no-destroy-dependencies-check`<br/>
-**CLI Arg Alias**: `--terragrunt-no-destroy-dependencies-check` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
-**Environment Variable**: `TG_NO_DESTROY_DEPENDENCIES_CHECK`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_NO_DESTROY_DEPENDENCIES_CHECK` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+Example:
 
-If specified, Terragrunt will not check dependent units when running the `destroy` command.
+```bash
+terragrunt graph-dependencies
+```
 
-By default, Terragrunt checks dependent units when running `destroy` command to provide a warning that other units may be not work correctly if their dependency is destroyed.
+This will recursively search the current working directory for any folders that contain Terragrunt modules and build
+the dependency graph based on [`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
+[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks. This may produce output such as:
 
-### feature
+```text
+digraph {
+  "mgmt/bastion-host" ;
+  "mgmt/bastion-host" -> "mgmt/vpc";
+  "mgmt/bastion-host" -> "mgmt/kms-master-key";
+  "mgmt/kms-master-key" ;
+  "mgmt/vpc" ;
+  "stage/backend-app" ;
+  "stage/backend-app" -> "stage/vpc";
+  "stage/backend-app" -> "mgmt/bastion-host";
+  "stage/backend-app" -> "stage/mysql";
+  "stage/backend-app" -> "stage/search-app";
+  "stage/frontend-app" ;
+  "stage/frontend-app" -> "stage/vpc";
+  "stage/frontend-app" -> "mgmt/bastion-host";
+  "stage/frontend-app" -> "stage/backend-app";
+  "stage/mysql" ;
+  "stage/mysql" -> "stage/vpc";
+  "stage/redis" ;
+  "stage/redis" -> "stage/vpc";
+  "stage/search-app" ;
+  "stage/search-app" -> "stage/vpc";
+  "stage/search-app" -> "stage/redis";
+  "stage/vpc" ;
+  "stage/vpc" -> "mgmt/vpc";
+}
+```
 
-**CLI Arg**: `--feature`<br/>
-**Environment Variable**: `TG_FEATURE`<br/>
-**Environment Variable Alias**: `TERRAGRUNT_FEATURE` (deprecated: [See migration guide](/docs/migrate/cli-redesign/))<br/>
+#### hclfmt
 
-Feature flags in Terragrunt allow users to dynamically control configuration behavior through CLI arguments or environment variables.
+**DEPRECATED: Use `hcl format` instead.**
 
-These flags enable a more flexible and controlled deployment process, particularly in monorepo contexts with interdependent infrastructure units.
+Recursively find hcl files and rewrite them into a canonical format.
 
-Example HCL flags definition:
+Example:
 
-```hcl
-feature "string_feature_flag" {
-  default = "test"
-}
+```bash
+terragrunt hclfmt
+```
+
+This will recursively search the current working directory for any folders that contain Terragrunt configuration files
+and run the equivalent of `tofu fmt`/`terraform fmt` on them.
 
-feature "int_feature_flag" {
-  default = 777
-}
+#### hclvalidate
 
-feature "bool_feature_flag" {
-  default = false
-}
+**DEPRECATED: Use `hcl validate` instead.**
 
-terraform {
-  before_hook "conditional_command" {
-    commands = ["apply", "plan", "destroy"]
-    execute  = feature.bool_feature_flag.value ? ["sh", "-c", "echo running conditional bool_feature_flag"] : [ "sh", "-c", "exit", "0" ]
-  }
-}
+Find all hcl files from the configuration stack and validate them.
 
-inputs = {
-  string_feature_flag = feature.string_feature_flag.value
-  int_feature_flag = feature.int_feature_flag.value
-}
+Example:
 
+```bash
+terragrunt hclvalidate
 ```
 
-Setting a feature flag through the CLI:
+This will search all hcl files from the configuration stack in the current working directory and run the equivalent
+of `tofu validate`/`terraform validate` on them.
+
+For convenience in programmatically parsing these findings, you can also pass the `--json` flag to output the results in JSON format.
+
+Example:
 
 ```bash
-terragrunt --feature int_feature_flag=123 --feature bool_feature_flag=true --feature string_feature_flag=app1 apply
+terragrunt hclvalidate --json
 ```
 
-Setting feature flags through environment variables:
+In addition, you can pass the `--show-config-path` flag to only output paths of the invalid config files, delimited by newlines. This can be especially useful when combined with the [queue-excludes-file](#queue-excludes-file) flag.
+
+Example:
 
 ```bash
-export TERRAGRUNT_FEATURE=int_feature_flag=123,bool_feature_flag=true,string_feature_flag=app1
-terragrunt apply
+terragrunt hclvalidate --show-config-path
 ```
 
-### experiment
+#### output-module-groups
 
-**CLI Arg**: `--experiment`<br/>
-**Environment Variable**: `TG_EXPERIMENT`<br/>
+**DEPRECATED: Use `find --dag --json` or `list --dag --tree` instead.**
 
-Enable experimental features in Terragrunt before they're stable.
+Output groups of modules ordered for apply (or destroy) as a list of list in JSON.
 
-For more information, see the [Experiments](/docs/reference/experiments) documentation.
+Example:
 
-### experiment-mode
+```bash
+terragrunt output-module-groups <sub-command>
+```
 
-**CLI Arg**: `--experiment-mode`<br/>
-**Environment Variable**: `TG_EXPERIMENT_MODE`<br/>
+Optional sub-commands:
 
-Enable all experimental features in Terragrunt before they're stable.
+- apply (default)
+- destroy
 
-For more information, see the [Experiments](/docs/reference/experiments) documentation.
+This will recursively search the current working directory for any folders that contain Terragrunt modules and build
+the dependency graph based on [`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
+[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks and output the graph as a JSON list of list (unless the sub-command is destroy, in which case the command will output the reverse dependency order).
 
-### strict-control
+This can be be useful in several scenarios, such as in CICD, when determining apply order or searching for all files to apply with CLI options
+such as [`--units-that-include`](#units-that-include)
 
-**CLI Arg**: `--strict-control`<br/>
-**Environment Variable**: `TERRAGRUNT_STRICT_CONTROL`<br/>
+This may produce output such as:
 
-Enable strict controls that opt-in future breaking changes in Terragrunt.
+```json
+{
+  "Group 1": ["stage/frontend-app"],
+  "Group 2": ["stage/backend-app"],
+  "Group 3": ["mgmt/bastion-host", "stage/search-app"],
+  "Group 4": ["mgmt/kms-master-key", "stage/mysql", "stage/redis"],
+  "Group 5": ["stage/vpc"],
+  "Group 6": ["mgmt/vpc"]
+}
+```
 
-For more information, see the [Strict Mode](/docs/reference/strict-mode) documentation.
+#### render-json
 
-### strict-mode
+**DEPRECATED: Use `render --json -w` instead.**
 
-**CLI Arg**: `--strict-mode`<br/>
-**Environment Variable**: `TERRAGRUNT_STRICT_MODE`<br/>
+Render out the final interpreted `terragrunt.hcl` file (that is, with all the includes merged, dependencies
+resolved/interpolated, function calls executed, etc) as json.
 
-Enable all strict controls that opt-in future breaking changes in Terragrunt.
+Example:
 
-For more information, see the [Strict Mode](/docs/reference/strict-mode) documentation.
+The following `terragrunt.hcl`:
 
-### in-download-dir
+```hcl
+locals {
+  aws_region = "us-east-1"
+}
 
-**CLI Arg**: `--in-download-dir`<br/>
-**Environment Variable**: `TG_IN_DOWNLOAD_DIR`<br/>
-**Commands**:
+inputs = {
+  aws_region = local.aws_region
+}
+```
 
-- [exec](#exec)
+Renders to the following `terragrunt_rendered.json`:
 
-Execute the provided command in the download directory.
+```json
+{
+  "locals": { "aws_region": "us-east-1" },
+  "inputs": { "aws_region": "us-east-1" }
+  // NOTE: other attributes are omitted for brevity
+}
+```
 
-## Deprecated
+You can use the CLI option `--out` to configure where terragrunt renders out the json representation.
 
-### Deprecated Commands
+To generate json with metadata can be specified argument `--with-metadata` which will add metadata to the json output.
 
-The following are deprecated commands that are no longer recommended for use. They are still available for backwards compatibility, but will be removed in a future release.
+Example:
 
-- [Deprecated Commands](#deprecated-commands)
-  - [plan-all (DEPRECATED: use run-all)](#plan-all)
-  - [apply-all (DEPRECATED: use run-all)](#apply-all)
-  - [output-all (DEPRECATED: use run-all)](#output-all)
-  - [destroy-all (DEPRECATED: use run-all)](#destroy-all)
-  - [validate-all (DEPRECATED: use run-all)](#validate-all)
+```json
+{
+  "inputs": {
+    "aws_region": {
+      "metadata": {
+        "found_in_file": "/example/terragrunt.hcl"
+      },
+      "value": "us-east-1"
+    }
+  },
+  "locals": {
+    "aws_region": {
+      "metadata": {
+        "found_in_file": "/example/terragrunt.hcl"
+      },
+      "value": "us-east-1"
+    }
+  }
+  // NOTE: other attributes are omitted for brevity
+}
+```
 
-#### plan-all
+#### terragrunt-info
 
-**DEPRECATED: Use `run-all plan` instead.**
+**DEPRECATED: Use `info print` instead.**
 
-Display the plans of a `stack` by running `terragrunt plan` in each subfolder. Make sure to read [Execute OpenTofu/Terraform
-commands on multiple modules at once](/docs/features/stacks) for
-context.
+Emits limited terragrunt state on `stdout` in a JSON format and exits.
 
 Example:
 
 ```bash
-terragrunt run-all plan
+terragrunt terragrunt-info
 ```
 
-This will recursively search the current working directory for any folders that contain Terragrunt modules and run
-`plan` in each one, concurrently, while respecting ordering defined via
-[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
-[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
+Might produce output such as:
 
-**[WARNING] `run-all plan` is currently broken for certain use cases**. If you have a stack of Terragrunt modules with
-dependencies between them—either via `dependency` blocks or `terraform_remote_state` data sources—and you've never
-deployed them, then `run-all plan` will fail as it will not be possible to resolve the `dependency` blocks or
-`terraform_remote_state` data sources! Please [see here for more
-information](https://github.com/gruntwork-io/terragrunt/issues/720#issuecomment-497888756).
+```json
+{
+  "ConfigPath": "/example/path/terragrunt.hcl",
+  "DownloadDir": "/example/path/.terragrunt-cache",
+  "IamRole": "",
+  "TerraformBinary": "terraform",
+  "TerraformCommand": "terragrunt-info",
+  "WorkingDir": "/example/path"
+}
+```
 
-#### apply-all
+#### validate-inputs
 
-**DEPRECATED: Use `run-all apply` instead.**
+**DEPRECATED: Use `hcl validate --inputs` or `hcl validate --inputs --strict` instead.**
 
-Apply a `stack` by running `terragrunt apply` in each subfolder. Make sure to read [Execute OpenTofu/Terraform
-commands on multiple modules at once](/docs/features/stacks) for
-context.
+Emits information about the input variables that are configured with the given
+terragrunt configuration. Specifically, this command will print out unused
+inputs (inputs that are not defined as an OpenTofu/Terraform variable in the
+corresponding module) and undefined required inputs (required OpenTofu/Terraform
+variables that are not currently being passed in).
 
 Example:
 
 ```bash
-terragrunt apply-all
-```
-
-This will recursively search the current working directory for any folders that contain Terragrunt modules and run
-`apply` in each one, concurrently, while respecting ordering defined via
-[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
-[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
-
-**[NOTE]** Using `apply-all` silently adds the `-auto-approve` flag to the command line arguments passed to OpenTofu/Terraform
-due to issues with shared `stdin` making individual approvals impossible. Please [see here for more
-information](https://github.com/gruntwork-io/terragrunt/issues/386#issuecomment-358306268)
+> terragrunt validate-inputs
+The following inputs passed in by terragrunt are unused:
 
-#### output-all
+    - foo
+    - bar
 
-**DEPRECATED: Use `run-all output` instead.**
 
-Display the outputs of a `stack` by running `terragrunt output` in each subfolder. Make sure to read [Execute OpenTofu/Terraform
-commands on multiple modules at once](/docs/features/stacks) for
-context.
+The following required inputs are missing:
 
-Example:
+    - baz
 
-```bash
-terragrunt output-all
 ```
 
-This will recursively search the current working directory for any folders that contain Terragrunt modules and run
-`output` in each one, concurrently, while respecting ordering defined via
-[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
-[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
-
-**[WARNING] `output-all` is currently broken for certain use cases**. If you have a stack of Terragrunt modules with
-dependencies between them—either via `dependency` blocks or `terraform_remote_state` data sources—and you've never
-deployed them, then `output-all` will fail as it will not be possible to resolve the `dependency` blocks or
-`terraform_remote_state` data sources! Please [see here for more
-information](https://github.com/gruntwork-io/terragrunt/issues/720#issuecomment-497888756).
+Note that this only checks for variables passed in in the following ways:
 
-#### destroy-all
+- Configured `inputs` attribute.
 
-**DEPRECATED: Use `run-all destroy` instead.**
+- var files defined on `terraform.extra_arguments` blocks using `required_var_files` and `optional_var_files`.
 
-Destroy a `stack` by running `terragrunt destroy` in each subfolder. Make sure to read [Execute OpenTofu/Terraform
-commands on multiple modules at once](/docs/features/stacks) for
-context.
+- `-var-file` and `-var` CLI arguments defined on `terraform.extra_arguments` using `arguments`.
 
-Example:
+- `-var-file` and `-var` CLI arguments passed to terragrunt.
 
-```bash
-terragrunt destroy-all
-```
+- Automatically loaded var files (`terraform.tfvars`, `terraform.tfvars.json`, `*.auto.tfvars`, `*.auto.tfvars.json`)
 
-This will recursively search the current working directory for any folders that contain Terragrunt modules and run
-`destroy` in each one, concurrently, while respecting ordering defined via
-[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
-[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
+- `TF_VAR` environment variables defined on `terraform.extra_arguments` blocks.
 
-**[NOTE]** Using `destroy-all` silently adds the `-auto-approve` flag to the command line arguments passed to OpenTofu/Terraform
-due to issues with shared `stdin` making individual approvals impossible. Please [see here for more
-information](https://github.com/gruntwork-io/terragrunt/issues/386#issuecomment-358306268)
+- `TF_VAR` environment variables defined in the environment.
 
-#### validate-all
+Be aware that other ways to pass variables to `tofu`/`terraform` are not checked by this command.
 
-**DEPRECATED: Use `run-all validate` instead.**
+Additionally, there are **two modes** in which the `validate-inputs` command can be run: **relaxed** (default) and **strict**.
 
-Validate `stack` by running `terragrunt validate` in each subfolder. Make sure to read [Execute OpenTofu/Terraform
-commands on multiple modules at once](/docs/features/stacks) for
-context.
+If you run the `validate-inputs` command without flags, relaxed mode will be enabled by default. In relaxed mode, any unused variables
+that are passed, but not used by the underlying OpenTofu/Terraform configuration, will generate a warning, but not an error. Missing required variables will _always_ return an error, whether `validate-inputs` is running in relaxed or strict mode.
 
-Example:
+To enable strict mode, you can pass the `--strict-validate` flag like so:
 
 ```bash
-terragrunt validate-all
+> terragrunt validate-inputs --strict-validate
 ```
 
-This will recursively search the current working directory for any folders that contain Terragrunt modules and run
-`validate` in each one, concurrently, while respecting ordering defined via
-[`dependency`](/docs/reference/config-blocks-and-attributes/#dependency) and
-[`dependencies`](/docs/reference/config-blocks-and-attributes/#dependencies) blocks.
+When running in strict mode, `validate-inputs` will return an error if there are unused inputs.
+
+This command will exit with an error if terragrunt detects any unused inputs or undefined required inputs.
 
 ### Deprecated Flags
 
diff --git a/internal/cli/app.go b/internal/cli/app.go
index 57dcf20a..316255ab 100644
--- a/internal/cli/app.go
+++ b/internal/cli/app.go
@@ -75,6 +75,12 @@ type App struct {
 
 	// Autocomplete enables or disables subcommand auto-completion support.
 	Autocomplete bool
+
+	// DisabledErrorOnUndefinedFlag prevents the application to exit and return an error on any undefined flag.
+	DisabledErrorOnUndefinedFlag bool
+
+	// DisabledErrorOnMultipleSetFlag prevents the application to exit and return an error if any flag is set multiple times.
+	DisabledErrorOnMultipleSetFlag bool
 }
 
 // NewApp returns app new App instance.
@@ -166,19 +172,20 @@ func (app *App) VisibleCommands() Commands {
 
 func (app *App) NewRootCommand() *Command {
 	return &Command{
-		Name:                 app.Name,
-		Before:               app.Before,
-		After:                app.After,
-		Action:               app.Action,
-		Usage:                app.Usage,
-		UsageText:            app.UsageText,
-		Description:          app.Description,
-		Examples:             app.Examples,
-		Flags:                app.Flags,
-		Subcommands:          app.Commands,
-		Complete:             app.Complete,
-		IsRoot:               true,
-		ErrorOnUndefinedFlag: true,
+		Name:                           app.Name,
+		Before:                         app.Before,
+		After:                          app.After,
+		Action:                         app.Action,
+		Usage:                          app.Usage,
+		UsageText:                      app.UsageText,
+		Description:                    app.Description,
+		Examples:                       app.Examples,
+		Flags:                          app.Flags,
+		Subcommands:                    app.Commands,
+		Complete:                       app.Complete,
+		IsRoot:                         true,
+		DisabledErrorOnUndefinedFlag:   app.DisabledErrorOnUndefinedFlag,
+		DisabledErrorOnMultipleSetFlag: app.DisabledErrorOnMultipleSetFlag,
 	}
 }
 
diff --git a/internal/cli/command.go b/internal/cli/command.go
index 3469c00f..962a7a99 100644
--- a/internal/cli/command.go
+++ b/internal/cli/command.go
@@ -72,8 +72,11 @@ type Command struct {
 	// Hidden hides the command from help.
 	Hidden bool
 
-	// ErrorOnUndefinedFlag causes the application to exit and return an error on any undefined flag.
-	ErrorOnUndefinedFlag bool
+	// DisabledErrorOnUndefinedFlag prevents the application to exit and return an error on any undefined flag.
+	DisabledErrorOnUndefinedFlag bool
+
+	// DisabledErrorOnMultipleSetFlag prevents the application to exit and return an error if any flag is set multiple times.
+	DisabledErrorOnMultipleSetFlag bool
 }
 
 // Names returns the names including short names and aliases.
@@ -122,16 +125,12 @@ func (cmd *Command) VisibleSubcommands() Commands {
 // If this is the final command, starts its execution.
 func (cmd *Command) Run(ctx *Context, args Args) (err error) {
 	args, err = cmd.parseFlags(ctx, args.Slice())
-	ctx = ctx.NewCommandContext(cmd, args)
-
 	if err != nil {
-		if flagErrHandler := ctx.App.FlagErrHandler; flagErrHandler != nil {
-			err = flagErrHandler(ctx, err)
-		}
-
 		return NewExitError(err, ExitCodeGeneralError)
 	}
 
+	ctx = ctx.NewCommandContext(cmd, args)
+
 	subCmdName := ctx.Args().CommandName()
 	subCmdArgs := ctx.Args().Remove(subCmdName)
 	subCmd := cmd.Subcommand(subCmdName)
@@ -179,12 +178,28 @@ func (cmd *Command) Run(ctx *Context, args Args) (err error) {
 func (cmd *Command) parseFlags(ctx *Context, args Args) ([]string, error) {
 	var undefArgs Args
 
-	flagSet, err := cmd.Flags.NewFlagSet(cmd.Name)
+	errHandler := func(err error) error {
+		if err == nil {
+			return nil
+		}
+
+		if cmd.DisabledErrorOnMultipleSetFlag && IsMultipleTimesSettingError(err) {
+			return nil
+		}
+
+		if flagErrHandler := ctx.App.FlagErrHandler; flagErrHandler != nil {
+			err = flagErrHandler(ctx.NewCommandContext(cmd, args), err)
+		}
+
+		return err
+	}
+
+	flagSet, err := cmd.Flags.NewFlagSet(cmd.Name, errHandler)
 	if err != nil {
 		return nil, err
 	}
 
-	flagSetWithSubcommandScope, err := cmd.Flags.WithSubcommandScope().NewFlagSet(cmd.Name)
+	flagSetWithSubcommandScope, err := cmd.Flags.WithSubcommandScope().NewFlagSet(cmd.Name, errHandler)
 	if err != nil {
 		return nil, err
 	}
@@ -195,26 +210,26 @@ func (cmd *Command) parseFlags(ctx *Context, args Args) ([]string, error) {
 
 	args, builtinCmd := args.Split(BuiltinCmdSep)
 
-	for i := 0; ; i++ {
+	for i := 0; len(args) > 0; i++ {
 		if i == 0 {
 			args, err = cmd.flagSetParse(ctx, flagSet, args)
 		} else {
 			args, err = cmd.flagSetParse(ctx, flagSetWithSubcommandScope, args)
 		}
 
+		if len(args) != 0 {
+			undefArgs = append(undefArgs, args[0])
+			args = args[1:]
+		}
+
 		if err != nil {
 			if !errors.As(err, new(UndefinedFlagError)) ||
 				(cmd.Subcommands.Get(undefArgs.Get(0)) == nil) {
-				return nil, err
+				if err = errHandler(err); err != nil {
+					return undefArgs, err
+				}
 			}
 		}
-
-		if len(args) == 0 {
-			break
-		}
-
-		undefArgs = append(undefArgs, args[0])
-		args = args[1:]
 	}
 
 	if len(builtinCmd) > 0 {
@@ -241,13 +256,12 @@ func (cmd *Command) flagSetParse(ctx *Context, flagSet *libflag.FlagSet, args Ar
 		// check if the error is due to an undefArgs flag
 		var undefArg string
 
-		err = flagSet.Parse(args)
-		if err == nil {
+		if err = flagSet.Parse(args); err == nil {
 			break
 		}
 
-		if errStr := err.Error(); strings.HasPrefix(errStr, ErrFlagUndefined) {
-			undefArg = strings.Trim(strings.TrimPrefix(errStr, ErrFlagUndefined), " -")
+		if errStr := err.Error(); strings.HasPrefix(errStr, ErrMsgFlagUndefined) {
+			undefArg = strings.Trim(strings.TrimPrefix(errStr, ErrMsgFlagUndefined), " -")
 			err = UndefinedFlagError(undefArg)
 		} else {
 			break
@@ -268,7 +282,7 @@ func (cmd *Command) flagSetParse(ctx *Context, flagSet *libflag.FlagSet, args Ar
 			}
 		}
 
-		if cmd.ErrorOnUndefinedFlag && !ctx.shellComplete {
+		if !cmd.DisabledErrorOnUndefinedFlag && !ctx.shellComplete {
 			break
 		}
 
@@ -295,3 +309,12 @@ func (cmd *Command) WrapAction(fn func(ctx *Context, action ActionFunc) error) *
 
 	return &clone
 }
+
+// DisableErrorOnMultipleSetFlag returns cloned commands with disabled the check for multiple values set for the same flag.
+func (cmd *Command) DisableErrorOnMultipleSetFlag() *Command {
+	newCmd := *cmd
+	newCmd.DisabledErrorOnMultipleSetFlag = true
+	newCmd.Subcommands = newCmd.Subcommands.DisableErrorOnMultipleSetFlag()
+
+	return &newCmd
+}
diff --git a/internal/cli/commands.go b/internal/cli/commands.go
index a15f0420..b8c9b1ca 100644
--- a/internal/cli/commands.go
+++ b/internal/cli/commands.go
@@ -149,3 +149,14 @@ func (commands Commands) GetCategories() Categories {
 func (commands Commands) Merge(cmds ...*Command) Commands {
 	return append(commands, cmds...)
 }
+
+// DisableErrorOnMultipleSetFlag returns a cloned command with disabled the check for multiple values set for the same flag.
+func (commands Commands) DisableErrorOnMultipleSetFlag() Commands {
+	var newCommands = make(Commands, len(commands))
+
+	for i := range commands {
+		newCommands[i] = commands[i].DisableErrorOnMultipleSetFlag()
+	}
+
+	return newCommands
+}
diff --git a/internal/cli/errors.go b/internal/cli/errors.go
index 6fd26d45..15aeb9f9 100644
--- a/internal/cli/errors.go
+++ b/internal/cli/errors.go
@@ -1,8 +1,10 @@
 package cli
 
 import (
-	"errors"
 	"fmt"
+	"strings"
+
+	"errors"
 
 	"github.com/urfave/cli/v2"
 )
@@ -107,10 +109,19 @@ func (err InvalidValueError) Unwrap() error {
 	return err.underlyingError
 }
 
-const ErrFlagUndefined = "flag provided but not defined:"
+const ErrMsgFlagUndefined = "flag provided but not defined:"
 
 type UndefinedFlagError string
 
 func (flag UndefinedFlagError) Error() string {
-	return ErrFlagUndefined + " -" + string(flag)
+	return ErrMsgFlagUndefined + " -" + string(flag)
+}
+
+var (
+	ErrMultipleTimesSettingFlag   = errors.New("setting the flag multiple times")
+	ErrMultipleTimesSettingEnvVar = errors.New("setting the env var multiple times")
+)
+
+func IsMultipleTimesSettingError(err error) bool {
+	return strings.Contains(err.Error(), ErrMultipleTimesSettingFlag.Error()) || strings.Contains(err.Error(), ErrMultipleTimesSettingEnvVar.Error())
 }
diff --git a/internal/cli/flag.go b/internal/cli/flag.go
index f8c482e5..162e2f10 100644
--- a/internal/cli/flag.go
+++ b/internal/cli/flag.go
@@ -111,31 +111,43 @@ type flagValueGetter struct {
 }
 
 func (flag *flagValueGetter) EnvSet(val string) error {
+	var err error
+
 	if !flag.envHasBeenSet {
 		// may contain a default value or an env var, so it needs to be cleared before the first setting.
 		flag.value.Reset()
 		flag.envHasBeenSet = true
 	} else if !flag.multipleSet {
-		return errors.Errorf("setting the env var multiple times")
+		err = errors.New(ErrMultipleTimesSettingEnvVar)
 	}
 
 	flag.flagValue.name = flag.valueName
 
-	return flag.flagValue.value.Set(val)
+	if err := flag.flagValue.value.Set(val); err != nil {
+		return err
+	}
+
+	return err
 }
 
 func (flag *flagValueGetter) Set(val string) error {
+	var err error
+
 	if !flag.hasBeenSet {
 		// may contain a default value or an env var, so it needs to be cleared before the first setting.
 		flag.value.Reset()
 		flag.hasBeenSet = true
 	} else if !flag.multipleSet {
-		return errors.Errorf("setting the flag multiple times")
+		err = errors.New(ErrMultipleTimesSettingFlag)
 	}
 
 	flag.flagValue.name = flag.valueName
 
-	return flag.flagValue.value.Set(val)
+	if err := flag.flagValue.value.Set(val); err != nil {
+		return err
+	}
+
+	return err
 }
 
 type Value interface {
diff --git a/internal/cli/flags.go b/internal/cli/flags.go
index 5026b4c1..8306585e 100644
--- a/internal/cli/flags.go
+++ b/internal/cli/flags.go
@@ -20,21 +20,21 @@ func (flags Flags) Parse(args Args) error {
 	return nil
 }
 
-func (flags Flags) NewFlagSet(cmdName string) (*libflag.FlagSet, error) {
+func (flags Flags) NewFlagSet(cmdName string, errHandler func(err error) error) (*libflag.FlagSet, error) {
 	flagSet := libflag.NewFlagSet(cmdName, libflag.ContinueOnError)
 	flagSet.SetOutput(io.Discard)
 
-	if err := flags.Apply(flagSet); err != nil {
-		return nil, err
-	}
+	err := flags.Apply(flagSet, errHandler)
 
-	return flagSet, nil
+	return flagSet, err
 }
 
-func (flags Flags) Apply(flagSet *libflag.FlagSet) error {
+func (flags Flags) Apply(flagSet *libflag.FlagSet, errHandler func(err error) error) error {
 	for _, flag := range flags {
 		if err := flag.Apply(flagSet); err != nil {
-			return err
+			if err = errHandler(err); err != nil {
+				return err
+			}
 		}
 	}
 
diff --git a/cli/provider_cache.go b/internal/providercache/provider_cache.go
similarity index 97%
rename from cli/provider_cache.go
rename to internal/providercache/provider_cache.go
index c4e30c9f..1be08870 100644
--- a/cli/provider_cache.go
+++ b/internal/providercache/provider_cache.go
@@ -1,4 +1,5 @@
-package cli
+// Package providercache provides initialization of the Terragrunt provider caching server for caching OpenTofu providers.
+package providercache
 
 import (
 	"context"
@@ -60,7 +61,7 @@ type ProviderCache struct {
 	providerService *services.ProviderService
 }
 
-func InitProviderCacheServer(opts *options.TerragruntOptions) (*ProviderCache, error) {
+func InitServer(opts *options.TerragruntOptions) (*ProviderCache, error) {
 	// ProviderCacheDir has the same file structure as terraform plugin_cache_dir.
 	// https://developer.hashicorp.com/terraform/cli/config/config-file#provider-plugin-cache
 	if opts.ProviderCacheDir == "" {
@@ -340,7 +341,11 @@ func runTerraformCommand(ctx context.Context, opts *options.TerragruntOptions, a
 
 // providerCacheEnvironment returns TF_* name/value ENVs, which we use to force terraform processes to make requests through our cache server (proxy) instead of making direct requests to the origin servers.
 func providerCacheEnvironment(opts *options.TerragruntOptions, cliConfigFile string) map[string]string {
-	envs := opts.Env
+	// make copy + ensure non-nil
+	envs := make(map[string]string, len(opts.Env))
+	for k, v := range opts.Env {
+		envs[k] = v
+	}
 
 	for _, registryName := range opts.ProviderCacheRegistryNames {
 		envName := fmt.Sprintf(tf.EnvNameTFTokenFmt, strings.ReplaceAll(registryName, ".", "_"))
diff --git a/internal/strict/controls/deprecated_command.go b/internal/strict/controls/deprecated_command.go
index 5f73c3af..98dff763 100644
--- a/internal/strict/controls/deprecated_command.go
+++ b/internal/strict/controls/deprecated_command.go
@@ -7,12 +7,13 @@ import (
 )
 
 const (
-	DefaultCommandsCategoryName = "Default commands"
-	RunAllCommandsCategoryName  = "`*-all` commands"
+	DefaultCommandsCategoryName     = "Default commands"
+	RunAllCommandsCategoryName      = "`*-all` commands"
+	CLIRedesignCommandsCategoryName = "CLI redesign commands"
 )
 
-// NewDeprecatedCommand declares the deprecated command.
-func NewDeprecatedCommand(command, newCommand string) *Control {
+// NewDeprecatedReplacedCommand declares the deprecated command that has an alternative command.
+func NewDeprecatedReplacedCommand(command, newCommand string) *Control {
 	return &Control{
 		Name:        command,
 		Description: "replaced with: " + newCommand,
@@ -20,3 +21,13 @@ func NewDeprecatedCommand(command, newCommand string) *Control {
 		Warning:     fmt.Sprintf("The `%s` command is deprecated and will be removed in a future version of Terragrunt. Use `%s` instead.", command, newCommand),
 	}
 }
+
+// NewDeprecatedCommand declares the deprecated command.
+func NewDeprecatedCommand(command string) *Control {
+	return &Control{
+		Name:        command,
+		Description: "no replaced command",
+		Error:       errors.Errorf("The `%s` command is no longer supported.", command),
+		Warning:     fmt.Sprintf("The `%s` command is deprecated and will be removed in a future version of Terragrunt.", command),
+	}
+}



Test patch:
diff --git a/cli/app_test.go b/cli/app_test.go
index fb5211a4..f18dce7d 100644
--- a/cli/app_test.go
+++ b/cli/app_test.go
@@ -13,7 +13,6 @@ import (
 	awsproviderpatch "github.com/gruntwork-io/terragrunt/cli/commands/aws-provider-patch"
 	outputmodulegroups "github.com/gruntwork-io/terragrunt/cli/commands/output-module-groups"
 	"github.com/gruntwork-io/terragrunt/cli/commands/run"
-	runall "github.com/gruntwork-io/terragrunt/cli/commands/run-all"
 	"github.com/gruntwork-io/terragrunt/cli/flags"
 	"github.com/gruntwork-io/terragrunt/cli/flags/global"
 	"github.com/gruntwork-io/terragrunt/config"
@@ -482,8 +481,8 @@ func TestTerragruntHelp(t *testing.T) {
 			notExpected: commands.CommandHCLFmtName,
 		},
 		{
-			args:     []string{"terragrunt", commands.CommandPlanAllName, "--help"},
-			expected: runall.CommandName,
+			args:     []string{"terragrunt", run.CommandName, "--help"},
+			expected: run.CommandName,
 		},
 	}
 
@@ -559,7 +558,7 @@ func runAppTest(args []string, opts *options.TerragruntOptions) (*options.Terrag
 	app.Flags = append(global.NewFlags(opts, nil), run.NewFlags(opts, nil)...)
 	app.Commands = append(
 		commands.NewDeprecatedCommands(opts),
-		terragruntCommands...).WrapAction(cli.WrapWithTelemetry(opts))
+		terragruntCommands...).WrapAction(commands.WrapWithTelemetry(opts))
 	app.OsExiter = cli.OSExiter
 	app.Action = func(ctx *clipkg.Context) error {
 		opts.TerraformCliArgs = append(opts.TerraformCliArgs, ctx.Args()...)
@@ -588,19 +587,19 @@ func TestAutocomplete(t *testing.T) { //nolint:paralleltest
 	}{
 		{
 			"",
-			[]string{"graph-dependencies", "hcl", "output-module-groups", "render-json", "run-all", "terragrunt-info"},
+			[]string{"hcl", "render", "run"},
 		},
 		{
 			"--versio",
 			[]string{"--version"},
 		},
 		{
-			"render-json -",
+			"render -",
 			[]string{"--out", "--with-metadata"},
 		},
 		{
-			"run-all ren",
-			[]string{"render", "render-json"},
+			"run pla",
+			[]string{"plan"},
 		},
 	}
 
@@ -611,7 +610,7 @@ func TestAutocomplete(t *testing.T) { //nolint:paralleltest
 		opts := options.NewTerragruntOptionsWithWriters(output, os.Stderr)
 		app := cli.NewApp(opts)
 
-		app.Commands = app.Commands.FilterByNames([]string{"graph-dependencies", "hcl", "output-module-groups", "render-json", "run-all", "terragrunt-info"})
+		app.Commands = app.Commands.FilterByNames([]string{"hcl", "render", "run"})
 
 		err := app.Run([]string{"terragrunt"})
 		require.NoError(t, err)
diff --git a/cli/commands/graph-dependencies/graph-dependencies_test.go b/cli/commands/graph-dependencies/graph-dependencies_test.go
deleted file mode 100644
index e5527fef..00000000
--- a/cli/commands/graph-dependencies/graph-dependencies_test.go
+++ /dev/null
@@ -1,54 +0,0 @@
-package graphdependencies_test
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-
-	graphdependencies "github.com/gruntwork-io/terragrunt/cli/commands/graph-dependencies"
-	"github.com/gruntwork-io/terragrunt/options"
-	"github.com/stretchr/testify/require"
-)
-
-// Run a benchmark on runGraphDependencies for all fixtures possible.
-// This should reveal regression on execution time due to new, changed or removed features.
-func BenchmarkRunGraphDependencies(b *testing.B) {
-	// Setup
-	b.StopTimer()
-	cwd, err := os.Getwd()
-	require.NoError(b, err)
-
-	testDir := "../../../test/fixtures"
-
-	fixtureDirs := []struct {
-		description          string
-		workingDir           string
-		usePartialParseCache bool
-	}{
-		{"PartialParseBenchmarkRegressionCaching", "regressions/benchmark-parsing/production/deployment-group-1/webserver/terragrunt.hcl", true},
-		{"PartialParseBenchmarkRegressionNoCache", "regressions/benchmark-parsing/production/deployment-group-1/webserver/terragrunt.hcl", false},
-		{"PartialParseBenchmarkRegressionIncludesCaching", "regressions/benchmark-parsing-includes/production/deployment-group-1/webserver/terragrunt.hcl", true},
-		{"PartialParseBenchmarkRegressionIncludesNoCache", "regressions/benchmark-parsing-includes/production/deployment-group-1/webserver/terragrunt.hcl", false},
-	}
-
-	// Run benchmarks
-	for _, fixture := range fixtureDirs {
-		b.Run(fixture.description, func(b *testing.B) {
-			workingDir := filepath.Join(cwd, testDir, fixture.workingDir)
-			terragruntOptions, err := options.NewTerragruntOptionsForTest(workingDir)
-			if fixture.usePartialParseCache {
-				terragruntOptions.UsePartialParseConfigCache = true
-			} else {
-				terragruntOptions.UsePartialParseConfigCache = false
-			}
-			require.NoError(b, err)
-
-			b.ResetTimer()
-			b.StartTimer()
-			err = graphdependencies.Run(context.Background(), terragruntOptions)
-			b.StopTimer()
-			require.NoError(b, err)
-		})
-	}
-}
diff --git a/cli/help_test.go b/cli/help_test.go
index a0b62b22..18031183 100644
--- a/cli/help_test.go
+++ b/cli/help_test.go
@@ -73,7 +73,6 @@ func TestCommandHelpTemplate(t *testing.T) {
 				Usage:   "Run the specified OpenTofu/Terraform command following the Directed Acyclic Graph (DAG) of dependencies.",
 			},
 		},
-		ErrorOnUndefinedFlag: true,
 	}
 
 	var out bytes.Buffer
diff --git a/internal/cli/command_test.go b/internal/cli/command_test.go
index f65b69f8..fd48a503 100644
--- a/internal/cli/command_test.go
+++ b/internal/cli/command_test.go
@@ -55,11 +55,12 @@ func TestCommandRun(t *testing.T) {
 							After:  skip,
 						},
 						&cli.Command{
-							Name:   "cmd-bar",
-							Flags:  cli.Flags{&cli.BoolFlag{Name: "bar"}},
-							Before: action(2, nil),
-							Action: action(3, []string{"one", "-two"}),
-							After:  action(4, nil),
+							Name:                         "cmd-bar",
+							Flags:                        cli.Flags{&cli.BoolFlag{Name: "bar"}},
+							Before:                       action(2, nil),
+							Action:                       action(3, []string{"one", "-two"}),
+							After:                        action(4, nil),
+							DisabledErrorOnUndefinedFlag: true,
 						},
 					},
 				},
@@ -75,10 +76,11 @@ func TestCommandRun(t *testing.T) {
 					After:  action(4, nil),
 					Subcommands: cli.Commands{
 						&cli.Command{
-							Name:   "cmd-bar",
-							Flags:  cli.Flags{&cli.BoolFlag{Name: "bar"}},
-							Before: action(2, nil),
-							After:  action(3, nil),
+							Name:                         "cmd-bar",
+							Flags:                        cli.Flags{&cli.BoolFlag{Name: "bar"}},
+							Before:                       action(2, nil),
+							After:                        action(3, nil),
+							DisabledErrorOnUndefinedFlag: true,
 						},
 					},
 				},
@@ -94,13 +96,15 @@ func TestCommandRun(t *testing.T) {
 					After:  action(5, nil),
 					Subcommands: cli.Commands{
 						&cli.Command{
-							Name:   "cmd-bar",
-							Flags:  cli.Flags{&cli.BoolFlag{Name: "bar"}},
-							Before: action(2, nil),
-							Action: action(3, []string{"one", "-two"}),
-							After:  action(4, nil),
+							Name:                         "cmd-bar",
+							Flags:                        cli.Flags{&cli.BoolFlag{Name: "bar"}},
+							Before:                       action(2, nil),
+							Action:                       action(3, []string{"one", "-two"}),
+							After:                        action(4, nil),
+							DisabledErrorOnUndefinedFlag: true,
 						},
 					},
+					DisabledErrorOnUndefinedFlag: true,
 				},
 			}
 		},
@@ -114,11 +118,12 @@ func TestCommandRun(t *testing.T) {
 					After:  action(5, nil),
 					Subcommands: cli.Commands{
 						&cli.Command{
-							Name:   "cmd-bar",
-							Flags:  cli.Flags{&cli.GenericFlag[string]{Name: "bar"}},
-							Before: action(2, nil),
-							Action: action(3, []string{"one", "-two"}),
-							After:  action(4, nil),
+							Name:                         "cmd-bar",
+							Flags:                        cli.Flags{&cli.GenericFlag[string]{Name: "bar"}},
+							Before:                       action(2, nil),
+							Action:                       action(3, []string{"one", "-two"}),
+							After:                        action(4, nil),
+							DisabledErrorOnUndefinedFlag: true,
 						},
 					},
 				},
diff --git a/cli/provider_cache_test.go b/internal/providercache/provider_cache_test.go
similarity index 94%
rename from cli/provider_cache_test.go
rename to internal/providercache/provider_cache_test.go
index 18031b01..643d8cea 100644
--- a/cli/provider_cache_test.go
+++ b/internal/providercache/provider_cache_test.go
@@ -1,4 +1,4 @@
-package cli_test
+package providercache_test
 
 import (
 	"context"
@@ -12,7 +12,7 @@ import (
 	"testing"
 
 	"github.com/google/uuid"
-	"github.com/gruntwork-io/terragrunt/cli"
+	"github.com/gruntwork-io/terragrunt/internal/providercache"
 	"github.com/gruntwork-io/terragrunt/options"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 	"github.com/gruntwork-io/terragrunt/tf/cache"
@@ -43,12 +43,12 @@ func createFakeProvider(t *testing.T, cacheDir, relativePath string) string {
 func TestProviderCache(t *testing.T) {
 	t.Parallel()
 
-	token := fmt.Sprintf("%s:%s", cli.APIKeyAuth, uuid.New().String())
+	token := fmt.Sprintf("%s:%s", providercache.APIKeyAuth, uuid.New().String())
 
 	providerCacheDir := t.TempDir()
 	pluginCacheDir := t.TempDir()
 
-	opts := []cache.Option{cache.WithToken(token), cache.WithCacheProviderHTTPStatusCode(cli.CacheProviderHTTPStatusCode)}
+	opts := []cache.Option{cache.WithToken(token), cache.WithCacheProviderHTTPStatusCode(providercache.CacheProviderHTTPStatusCode)}
 
 	testCases := []struct {
 		expectedBodyReg    *regexp.Regexp
@@ -184,7 +184,7 @@ func TestProviderCacheWithProviderCacheDir(t *testing.T) {
 		unsetEnv(t, "HOME")
 		unsetEnv(t, "XDG_CACHE_HOME")
 
-		_, err := cli.InitProviderCacheServer(&options.TerragruntOptions{
+		_, err := providercache.InitServer(&options.TerragruntOptions{
 			ProviderCacheDir: cacheDir,
 		})
 		require.NoError(t, err, "ProviderCache shouldn't read HOME environment variable")
@@ -196,7 +196,7 @@ func TestProviderCacheWithProviderCacheDir(t *testing.T) {
 
 		t.Setenv("HOME", home)
 
-		_, err := cli.InitProviderCacheServer(&options.TerragruntOptions{
+		_, err := providercache.InitServer(&options.TerragruntOptions{
 			ProviderCacheDir: cacheDir,
 		})
 		require.NoError(t, err)
diff --git a/test/fixtures/regressions/include-error/_envcommon.hcl b/test/fixtures/regressions/include-error/_envcommon.hcl
new file mode 100644
index 00000000..eeee7a4b
--- /dev/null
+++ b/test/fixtures/regressions/include-error/_envcommon.hcl
@@ -0,0 +1,4 @@
+
+inputs = {
+  common_config = "Common Config"
+}
diff --git a/test/fixtures/regressions/include-error/project/app/terragrunt.hcl b/test/fixtures/regressions/include-error/project/app/terragrunt.hcl
new file mode 100644
index 00000000..bd6015be
--- /dev/null
+++ b/test/fixtures/regressions/include-error/project/app/terragrunt.hcl
@@ -0,0 +1,17 @@
+
+include {
+  path = find_in_parent_folders("eng_teams.hcl")
+}
+
+include {
+  path = find_in_parent_folders("_envcommon.hcl")
+}
+
+inputs = {
+  app = {
+    "kind"      = "deployment",
+    "namespace" = "foobar",
+    "slug"      = "bar-foo",
+    "data"      = "46521694",
+  }
+}
diff --git a/test/fixtures/regressions/include-error/project/eng_teams.hcl b/test/fixtures/regressions/include-error/project/eng_teams.hcl
new file mode 100644
index 00000000..6b9b6d89
--- /dev/null
+++ b/test/fixtures/regressions/include-error/project/eng_teams.hcl
@@ -0,0 +1,4 @@
+
+inputs = {
+  team_name = "Test Team"
+}
diff --git a/test/integration_debug_test.go b/test/integration_debug_test.go
index 499e61bc..d8d9901f 100644
--- a/test/integration_debug_test.go
+++ b/test/integration_debug_test.go
@@ -24,11 +24,6 @@ const (
 	fixtureRenderJSONRegression   = "fixtures/render-json-regression"
 )
 
-var (
-	fixtureRenderJSONMainModulePath = filepath.Join(fixtureRenderJSON, "main")
-	fixtureRenderJSONDepModulePath  = filepath.Join(fixtureRenderJSON, "dep")
-)
-
 func TestDebugGeneratedInputs(t *testing.T) {
 	t.Parallel()
 
@@ -185,13 +180,20 @@ func TestTerragruntValidateInputsWithStrictModeDisabledAndUnusedInputs(t *testin
 func TestRenderJSONConfig(t *testing.T) {
 	t.Parallel()
 
-	tmpDir := t.TempDir()
-	jsonOut := filepath.Join(tmpDir, "terragrunt_rendered.json")
+	helpers.CleanupTerraformFolder(t, fixtureRenderJSON)
+	tmpEnvPath := helpers.CopyEnvironment(t, fixtureRenderJSON)
+	rootPath := util.JoinPath(tmpEnvPath, fixtureRenderJSON)
+
+	fixtureRenderJSONMainModulePath := filepath.Join(rootPath, "main")
+	fixtureRenderJSONDepModulePath := filepath.Join(rootPath, "dep")
 
 	helpers.CleanupTerraformFolder(t, fixtureRenderJSONMainModulePath)
 	helpers.CleanupTerraformFolder(t, fixtureRenderJSONDepModulePath)
 
-	helpers.RunTerragrunt(t, "terragrunt run-all apply -auto-approve --terragrunt-non-interactive --terragrunt-log-level trace --terragrunt-working-dir "+fixtureRenderJSON)
+	tmpDir := t.TempDir()
+	jsonOut := filepath.Join(tmpDir, "terragrunt_rendered.json")
+
+	helpers.RunTerragrunt(t, "terragrunt run-all apply -auto-approve --terragrunt-non-interactive --terragrunt-log-level trace --terragrunt-working-dir "+rootPath)
 	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render-json --terragrunt-non-interactive --terragrunt-log-level trace --terragrunt-working-dir %s --terragrunt-json-out %s", fixtureRenderJSONMainModulePath, jsonOut))
 
 	jsonBytes, err := os.ReadFile(jsonOut)
diff --git a/test/integration_json_test.go b/test/integration_json_test.go
index 70723944..05a78fd2 100644
--- a/test/integration_json_test.go
+++ b/test/integration_json_test.go
@@ -37,7 +37,7 @@ func TestRenderJsonAttributesMetadata(t *testing.T) {
 
 	jsonOut := filepath.Join(tmpDir, "terragrunt_rendered.json")
 
-	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render-json --with-metadata --non-interactive --log-level trace --working-dir %s  --json-out %s", tmpDir, jsonOut))
+	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render-json --with-metadata --non-interactive --log-level trace --working-dir %s --json-out %s", tmpDir, jsonOut))
 
 	jsonBytes, err := os.ReadFile(jsonOut)
 	require.NoError(t, err)
@@ -964,7 +964,7 @@ func TestRenderJsonDependentModulesMetadataTerraform(t *testing.T) {
 	tmpDir := util.JoinPath(tmpEnvPath, testFixtureDestroyWarning, "vpc")
 
 	jsonOut := filepath.Join(tmpDir, "terragrunt_rendered.json")
-	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render-json --with-metadata --terragrunt-non-interactive --terragrunt-log-level trace --terragrunt-working-dir %s  --terragrunt-json-out %s", tmpDir, jsonOut))
+	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render-json --with-metadata --terragrunt-non-interactive --terragrunt-log-level trace --terragrunt-working-dir %s --terragrunt-json-out %s", tmpDir, jsonOut))
 
 	jsonBytes, err := os.ReadFile(jsonOut)
 	require.NoError(t, err)
@@ -987,7 +987,7 @@ func TestRenderJsonDependentModulesMetadataTerraformExp(t *testing.T) {
 	tmpDir := util.JoinPath(tmpEnvPath, testFixtureDestroyWarning, "vpc")
 
 	jsonOut := filepath.Join(tmpDir, "terragrunt.rendered.json")
-	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render --json -w --with-metadata --non-interactive --log-level trace --working-dir %s  --out %s", tmpDir, jsonOut))
+	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render --json -w --with-metadata --non-interactive --log-level trace --working-dir %s --out %s", tmpDir, jsonOut))
 
 	jsonBytes, err := os.ReadFile(jsonOut)
 	require.NoError(t, err)
@@ -1002,27 +1002,6 @@ func TestRenderJsonDependentModulesMetadataTerraformExp(t *testing.T) {
 	assert.Contains(t, dependentModules, util.JoinPath(tmpEnvPath, testFixtureDestroyWarning, "app-v2"))
 }
 
-func TestTerragruntRenderJsonHelp(t *testing.T) {
-	t.Parallel()
-
-	helpers.CleanupTerraformFolder(t, testFixtureHooksInitOnceWithSourceNoBackend)
-	tmpEnvPath := helpers.CopyEnvironment(t, "fixtures/hooks/init-once")
-	rootPath := util.JoinPath(tmpEnvPath, testFixtureHooksInitOnceWithSourceNoBackend)
-
-	showStdout := bytes.Buffer{}
-	showStderr := bytes.Buffer{}
-
-	err := helpers.RunTerragruntCommand(t, "terragrunt render-json --help --terragrunt-non-interactive --terragrunt-working-dir "+rootPath, &showStdout, &showStderr)
-	require.NoError(t, err)
-
-	helpers.LogBufferContentsLineByLine(t, showStdout, "show stdout")
-
-	output := showStdout.String()
-
-	assert.Contains(t, output, "terragrunt render-json")
-	assert.Contains(t, output, "--with-metadata")
-}
-
 func TestTerragruntRenderJsonHelpExp(t *testing.T) {
 	t.Parallel()
 
@@ -1052,7 +1031,7 @@ func TestRenderJsonDependentModulesTerraform(t *testing.T) {
 	tmpDir := util.JoinPath(tmpEnvPath, testFixtureDestroyWarning, "vpc")
 
 	jsonOut := filepath.Join(tmpDir, "terragrunt_rendered.json")
-	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render-json --terragrunt-non-interactive --terragrunt-log-level trace --terragrunt-working-dir %s  --terragrunt-json-out %s", tmpDir, jsonOut))
+	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render-json --terragrunt-non-interactive --terragrunt-log-level trace --terragrunt-working-dir %s --terragrunt-json-out %s", tmpDir, jsonOut))
 
 	jsonBytes, err := os.ReadFile(jsonOut)
 	require.NoError(t, err)
@@ -1074,7 +1053,7 @@ func TestRenderJsonDependentModulesTerraformExp(t *testing.T) {
 	tmpDir := util.JoinPath(tmpEnvPath, testFixtureDestroyWarning, "vpc")
 
 	jsonOut := filepath.Join(tmpDir, "terragrunt.rendered.json")
-	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render --json -w --non-interactive --log-level trace --working-dir %s  --out %s", tmpDir, jsonOut))
+	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render --json -w --non-interactive --log-level trace --working-dir %s --out %s", tmpDir, jsonOut))
 
 	jsonBytes, err := os.ReadFile(jsonOut)
 	require.NoError(t, err)
@@ -1096,7 +1075,7 @@ func TestRenderJsonDisableDependentModulesTerraform(t *testing.T) {
 	tmpDir := util.JoinPath(tmpEnvPath, testFixtureDestroyWarning, "vpc")
 
 	jsonOut := filepath.Join(tmpDir, "terragrunt_rendered.json")
-	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render-json --terragrunt-json-disable-dependent-modules --terragrunt-non-interactive --terragrunt-log-level trace --terragrunt-working-dir %s  --terragrunt-json-out %s", tmpDir, jsonOut))
+	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render-json --terragrunt-json-disable-dependent-modules --terragrunt-non-interactive --terragrunt-log-level trace --terragrunt-working-dir %s --terragrunt-json-out %s", tmpDir, jsonOut))
 
 	jsonBytes, err := os.ReadFile(jsonOut)
 	require.NoError(t, err)
@@ -1116,7 +1095,7 @@ func TestRenderJsonDisableDependentModulesTerraformExp(t *testing.T) {
 	tmpDir := util.JoinPath(tmpEnvPath, testFixtureDestroyWarning, "vpc")
 
 	jsonOut := filepath.Join(tmpDir, "terragrunt.rendered.json")
-	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render --json -w --disable-dependent-modules --non-interactive --log-level trace --working-dir %s  --out %s", tmpDir, jsonOut))
+	helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt render --json -w --disable-dependent-modules --non-interactive --log-level trace --working-dir %s --out %s", tmpDir, jsonOut))
 
 	jsonBytes, err := os.ReadFile(jsonOut)
 	require.NoError(t, err)
diff --git a/test/integration_regressions_test.go b/test/integration_regressions_test.go
index ab774d2b..c57dd500 100644
--- a/test/integration_regressions_test.go
+++ b/test/integration_regressions_test.go
@@ -85,3 +85,15 @@ func TestMockOutputsMergeWithState(t *testing.T) {
 	helpers.LogBufferContentsLineByLine(t, stdout, "shallow-map-executed")
 	require.NoError(t, err)
 }
+
+func TestIncludeError(t *testing.T) {
+	t.Parallel()
+
+	helpers.CleanupTerraformFolder(t, testFixtureRegressions)
+	tmpEnvPath := helpers.CopyEnvironment(t, testFixtureRegressions)
+	rootPath := util.JoinPath(tmpEnvPath, testFixtureRegressions, "include-error", "project", "app")
+
+	_, _, err := helpers.RunTerragruntCommandWithOutput(t, "terragrunt plan --terragrunt-non-interactive --terragrunt-working-dir "+rootPath)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "include blocks without label")
+}
diff --git a/test/integration_strict_test.go b/test/integration_strict_test.go
index 528be632..b744e2fa 100644
--- a/test/integration_strict_test.go
+++ b/test/integration_strict_test.go
@@ -28,7 +28,7 @@ func TestStrictMode(t *testing.T) {
 			name:           "plan-all",
 			controls:       []string{},
 			strictMode:     false,
-			expectedStderr: "The `plan-all` command is deprecated and will be removed in a future version of Terragrunt. Use `terragrunt run-all plan` instead.",
+			expectedStderr: "The `plan-all` command is deprecated and will be removed in a future version of Terragrunt. Use `terragrunt plan --all` instead.",
 			expectedError:  nil,
 		},
 		{
@@ -36,14 +36,14 @@ func TestStrictMode(t *testing.T) {
 			controls:       []string{"deprecated-commands"},
 			strictMode:     false,
 			expectedStderr: "",
-			expectedError:  errors.New("The `plan-all` command is no longer supported. Use `terragrunt run-all plan` instead."),
+			expectedError:  errors.New("The `plan-all` command is no longer supported. Use `terragrunt plan --all` instead."),
 		},
 		{
 			name:           "plan-all with strict mode",
 			controls:       []string{},
 			strictMode:     true,
 			expectedStderr: "",
-			expectedError:  errors.New("The `plan-all` command is no longer supported. Use `terragrunt run-all plan` instead."),
+			expectedError:  errors.New("The `plan-all` command is no longer supported. Use `terragrunt plan --all` instead."),
 		},
 	}
 
diff --git a/test/integration_test.go b/test/integration_test.go
index 2e2366bd..bcd265c0 100644
--- a/test/integration_test.go
+++ b/test/integration_test.go
@@ -593,9 +593,9 @@ func TestTerragruntExcludesFile(t *testing.T) {
 
 			helpers.CleanupTerraformFolder(t, testFixtureExcludesFile)
 
-			helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt run-all apply -auto-approve --terragrunt-non-interactive --terragrunt-working-dir %s %s", rootPath, tc.flags))
+			helpers.RunTerragrunt(t, fmt.Sprintf("terragrunt run apply --all --terragrunt-non-interactive --terragrunt-working-dir %s %s -- -auto-approve", rootPath, tc.flags))
 
-			stdout, _, err := helpers.RunTerragruntCommandWithOutput(t, fmt.Sprintf("terragrunt run-all output --terragrunt-non-interactive --terragrunt-working-dir %s %s", rootPath, tc.flags))
+			stdout, _, err := helpers.RunTerragruntCommandWithOutput(t, fmt.Sprintf("terragrunt run output --all --terragrunt-non-interactive --terragrunt-working-dir %s %s", rootPath, tc.flags))
 			require.NoError(t, err)
 
 			actualOutput := strings.Split(strings.TrimSpace(stdout), "\n")