Some more context on the use case and where this is breaking down for us:

We are splitting infrastructure by lifecycle so we can replace a physical environment without replacing stable or account-wide resources.

The stack model is roughly:

- `$app-$account`, for resources shared across the account
- `$app-$stage`, for stable logical-stage resources
- `$app-$slot`, for resources tied to one physical network and cluster
- `$app-$stage-routing`, for stable routing that points to the active slot

Each of these is a separate Atmos stack with separate Terraform state.

A slot component can depend on account resources and platform resources from other stacks. A routing component can then depend on outputs from the selected slot. What we want is to select a bounded root, such as `$app-slot1`, and have Atmos execute that root plus its complete transitive prerequisite closure across stacks.

Atmos appears able to model the cross-stack relationships, but we are hitting two separate problems when we try to use the DAG for execution.

First, bounded execution does not expand to cross-stack prerequisites.

With Atmos 1.222.0:

```
atmos terraform apply --all -s $app-slot1
```

only selects components in `$app-slot1`. It does not add prerequisite components from `$app-$account`, the platform slot, or other dependency stacks. Removing `-s` makes `--all` much broader than the deployment unit we want.

So the DAG can describe or order dependencies within the selected execution set, but selecting one stack does not appear to select the transitive cross-stack dependency closure.

Second, configuration is evaluated before dependency execution can bootstrap fresh state.

Some downstream component inputs are Terraform state lookups from their declared prerequisites. For a new slot, those prerequisite states do not exist yet. Atmos evaluates the downstream templates and state lookups while constructing or describing the execution set, before it starts executing the DAG. The command fails on the missing state before the prerequisite component gets a chance to run.

Dependency order cannot solve that case unless component configuration is evaluated lazily, after its prerequisites have completed.

We also see `atmos list dependencies -s $app-slot1` evaluate stacks outside the requested filter before producing the filtered graph. That can fail because an unrelated stack has an inaccessible backend, an unavailable output, or environment-specific initialization requirements. Disabling template and function processing lets the command return, but templated cross-stack names are then unresolved, so it is not a useful validation of the real DAG.

The behavior we are looking for is:

1. Select one or more root stacks or components.
2. Compute their complete transitive prerequisite closure across stacks.
3. Exclude unrelated stacks from evaluation.
4. Execute the selected closure in topological order.
5. Evaluate each component after its prerequisites have completed.
6. Support a dry run or dependency listing without requiring unrelated or not-yet-created Terraform state.

Is this expected with the current dependency implementation?

Are cross-stack dependencies intended only to order components that are already in the execution set, rather than to add prerequisite stacks to that set?

Is there currently a command for bounded cross-stack dependency execution, or is an explicit workflow or composition the intended solution?

Is lazy per-component evaluation something Atmos supports or plans to support for bootstrapping a completely new stack?