Resolve the formatter in a temp project, not the runner's shared depot (#29)

`Pkg.add(name="JuliaFormatter", version="2")` ran with no active project, so it
resolved into whatever environment the runner happened to have. The compat
bounds already sitting in that depot cap the resolve, which makes the installed
version a property of the machine rather than of this file: the same commit
resolved 2.3.2 on a self-hosted runner and 2.10.1 on a GitHub-hosted one.
Formatting differs across 2.x minors, so format-check returned a verdict on the
runner, not on the diff. A leftover ITensorFormatter in a shared depot also
pinned JuliaSyntax to 0.4 and turned the install into a hard resolve failure,
which presents as a flake because it depends on which runner you land on.

`Pkg.activate(; temp=true)` before the add is the fix, and the install and the
check are now one process so the environment cannot expire between them.

The version still floats, deliberately. A pin converts each new release into
permanent debt in every calling repo and rots while the ecosystem moves; the
answer to a release that reflows files is to adopt it and reformat. Isolation
is what this check needed to be reproducible, and it is orthogonal to the
version spec.

Added an assertion that the loaded version is the one the temp project holds.
`using` silently falls back to the depot's default environment when the active
project does not declare the package, which has bitten this fleet twice through
an env that looked right by its name.

The failure message now names the version CI resolved and gives the same
floating spec in a temp env, with `overwrite=true` and a retry loop, since
`overwrite=false` is a check rather than a fix and one pass does not always
converge.

Runs the script through `shell: julia --color=yes {0}` rather than `julia -e`,
which is how lab-sotashimozono/.github has run this check for months. The
failure message has to contain a Julia command with its own quotes, and that
does not survive nesting inside `-e '...'`. The two orgs' scripts are now
byte-identical, so a fix to one is a copy-paste to the other.

Verified locally on both arms rather than by CI round trip: a formatted tree
exits 0 with the success line, a misformatted one exits 1 with the message.
The YAML and the embedded script both parse.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: sotashimozono

.github/workflows/format-check.yml

@@ -1,5 +1,15 @@
 # Reusable JuliaFormatter (v2) check. Call from a repo with:
 #   jobs: { format: { uses: QAtlasHub/.github/.github/workflows/format-check.yml@main } }
+#
+# `Pkg.activate(; temp=true)` is load-bearing. A bare `Pkg.add` resolves into the runner's
+# shared/default environment, where the compat bounds already there cap the result: the same
+# commit resolved JuliaFormatter 2.3.2 on a self-hosted runner and 2.10.1 on a GitHub-hosted one,
+# and a leftover ITensorFormatter in such a depot once made the install fail outright. Same code,
+# different verdict, which presented for months as a "format-check flake".
+#
+# The version floats, deliberately. When a new 2.x reflows files the answer is to adopt it and
+# reformat, not to freeze the old one: a pin here becomes standing debt in every caller and rots
+# while the ecosystem moves. Reproducibility comes from the clean env above, not from a pin.
 name: Format Check (reusable)
 on:
   workflow_call:
@@ -13,16 +23,27 @@ jobs:
       - uses: julia-actions/setup-julia@v3
         with:
           version: '1'
-      - name: Install JuliaFormatter
-        run: julia -e 'using Pkg; Pkg.add(name="JuliaFormatter", version="2"); using JuliaFormatter; @info "JuliaFormatter $(pkgversion(JuliaFormatter))"'
-      - name: Check formatting
+      - name: JuliaFormatter check
+        shell: julia --color=yes {0}
         run: |
-          julia -e '
-            using JuliaFormatter
-            ok = format(".", verbose=true, overwrite=false)
-            if !ok
-              println(stderr, "❌ Formatting issues found. Run locally: julia -e \"using JuliaFormatter; format(\\\".\\\")\"")
+          using Pkg
+          Pkg.activate(; temp = true)                       # clean env — no depot compat capping the resolve
+          Pkg.add(PackageSpec(name = "JuliaFormatter", version = "2"))
+          using JuliaFormatter
+          v = pkgversion(JuliaFormatter)
+          # `using` falls back to the depot's default env when the active project does not declare
+          # the package, loading a different version and saying nothing, so ask the project itself.
+          declared = [p.version for (_, p) in Pkg.dependencies() if p.name == "JuliaFormatter"]
+          if declared != [v]
+              println(stderr, "❌ JuliaFormatter $v came from outside the temp project, which holds $declared.")
               exit(1)
-            end
-            println("✅ All files are properly formatted.")
-          '
+          end
+          @info "JuliaFormatter $v"
+          ok = format("."; verbose = true, overwrite = false)
+          if !ok
+              println(stderr, "❌ Not formatted, under JuliaFormatter $v. `overwrite=false` above is the check;")
+              println(stderr, "   locally you want `true`, and one pass does not always converge. Run:")
+              println(stderr, "   julia -e 'using Pkg; Pkg.activate(;temp=true); Pkg.add(PackageSpec(name=\"JuliaFormatter\", version=\"2\")); using JuliaFormatter; for _ in 1:5; format(\".\"; overwrite=true) && break end'")
+              exit(1)
+          end
+          println("✅ All files properly formatted.")