TL;DR: Two of your locals reference each other (`a = local.b`, `b = local.a`), so neither can ever be evaluated. The error never says "circular", which is why it's hard to grep for. Compute the shared value once and have both locals read it.

```text
Error: Can't evaluate expression

  on terragrunt.hcl line 5, in locals:

   5:   b = local.a

The local reference 'a' is not evaluated. Either it is not ready yet in the current pass, or
there was an error evaluating it in an earlier stage.
```

## Steps

1. Run `terragrunt render` to find the first unresolvable local.
   Expected: render stops at the failing local.
2. Trace its references: does the chain lead back to itself (directly, or through `read_terragrunt_config` that reads the file it started in)?
   Expected: you find the loop.
3. Break it: compute the shared part once in a third local and have both reference that, or move the shared value into a file both read.
   Expected: the reference graph is acyclic.
4. Re-run.
   Expected: locals evaluate; the error is gone.

## When this applies

- `Can't evaluate expression` / `is not evaluated` pointing at a `locals` block.
- After a rename, where a local now references itself under the new name.

## When it doesn't apply

- The same message with NO cycle: "or there was an error evaluating it in an earlier stage" means something the local calls failed (`read_terragrunt_config` on a missing file, `get_env` with no default). Fix the underlying call.
- `Error: Unsupported attribute` on `local.x`: the local doesn't exist at all, different fix.

## Tool versions

All Terragrunt 1.x (reproduced on 1.1.3).

## Why it happens

Terragrunt evaluates locals in passes, resolving references incrementally. A cycle means no pass can ever resolve either side, and the error reports the symptom ("not evaluated") rather than the cause ("circular").

## Edge cases

- Indirect cycles through `read_terragrunt_config` are the sneaky ones: file A reads file B which reads file A. `render --log-level debug` shows the evaluation order.
- `dependency` outputs are not resolvable inside `locals` at all; a local reaching for them fails the same way without being circular.