diff --git a/CHANGELOG.md b/CHANGELOG.md
index c3894758..5c6eb21c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,12 @@ All notable changes to this project are documented here.
   under `opaque`. Any other unresolved line is still an error and
   nothing is written. A list with 22 `--from-commit` lines and seven
   site recipes failed whole before.
+- `examples/easyconfigs-pr-overlap/fetch-prs.sh` and
+  `examples/eessi-pr-overlap/fetch-prs.sh` request each page of open pull
+  requests and of changed files, 100 at a time. The open list does not
+  stop at 500. A changed-file list that stops at GitHub's cap of 3000 is
+  kept: the pull request is still written, with `file_list_truncated`
+  set, and the record notes `truncated at GitHub's limit`.
 - `stack order` exits 1 when runtime requirements of one name at one
   toolchain have no version that satisfies every one of them. The error
   names each requester and the version it resolved. Eigen 3.4.1 required
@@ -29,6 +35,19 @@ All notable changes to this project are documented here.
 
 ### Added
 
+- `stack order --installed` stops the build order at modules already on
+  the machine. A file is a module listing and a directory is an Lmod
+  tree, read the same way as `stack gap --installed`. The version is the
+  full module version. A listed module is left out of the order, and so
+  are the dependencies that were installed with it. `--filter-deps`
+  still drops dependencies first. The modules that remain are chosen
+  with the synthetic GCC-family rule `recipe hierarchy --export`
+  prints. Stdout reports `installed=` as how many modules the walk
+  stopped at. `eb_stack_order` takes the same `installed` list.
+- The Model Context Protocol manual lists one tool for every CLI
+  command. `docs/orgmode/reference/mcp.org` names each tool, including
+  the recipe and easyblock tools that have no command. A test fails
+  when a subcommand's tool is absent from that page.
 - `stack shadow` reports a site-layer recipe that shadows a module the
   EESSI base stack already provides. `--base` is an Lmod tree or a module
   listing, loaded with the same inventory reader as `stack gap`. The same
@@ -270,6 +289,9 @@ include `stack gap`, `stack oom`, `stack from-commit`, `rebuild-set`,
   `source probe:`. With no `--arch` all three are still probed. With one
   family there is nothing to compare with, so a source it cannot fetch
   is `unreachable` rather than `arch-missing`, and still exits 1.
+  Two families compare only with each other: a miss is `arch-missing`
+  when the other named family fetched that source slot, and
+  `unreachable` when neither did.
 - `classify_build_failure` classes `No space left on device` and
   `Disk quota exceeded` as `resource`. A full disk in an EasyBuild log was
   `compile` before.
diff --git a/README.md b/README.md
index ff1ac8d9..838f2e75 100644
--- a/README.md
+++ b/README.md
@@ -402,7 +402,8 @@ for `pr-overlap`, `rebuild-set`, `component-reach`, and `easyblock-reach`.
 `eb-stack mcp --workspace ROOT` (or `EB_STACK_WORKSPACE`) is the root for the
 recipe file tools.
 
-- `eb_package_inspect`, `eb_package_plan`, `eb_package_bump`;
+- `eb_package_inspect`, `eb_package_plan`, `eb_package_bump`,
+  `eb_package_latest`;
 - `eb_recipe_read`, `eb_recipe_list`, `eb_recipe_edit`, `eb_recipe_write`,
   `eb_recipe_grep`, `eb_recipe_apply_suggestion`, `eb_recipe_diff`,
   `eb_dep_versions`;
@@ -411,7 +412,11 @@ recipe file tools.
 - `eb_module_lint`, `eb_easyblock_dry_run`, `eb_build_log`, `eb_build_test`
   (easyblocks; `eb_build_test` only with `EB_STACK_ALLOW_BUILD=1`);
 - `eb_stack_solve`, `eb_stack_sbom`, `eb_stack_order`,
-  `eb_stack_easystack`, `eb_stack_sections`, `eb_stack_from_commit`;
+  `eb_stack_easystack`, `eb_stack_gap`, `eb_stack_provided`,
+  `eb_stack_shadow`, `eb_stack_batch`, `eb_stack_shard`,
+  `eb_stack_arch`, `eb_stack_files`, `eb_stack_generation`,
+  `eb_stack_cuda_cc`, `eb_stack_known_failures`, `eb_stack_oom`,
+  `eb_stack_bot_classify`, `eb_stack_sections`, `eb_stack_from_commit`;
 - `eb_component_reach` (same query as `component-reach`, including a purl or a CVE id);
 - `eb_target_list`, `eb_target_doctor`;
 - `eb_campaign_run`, `eb_campaign_status`;
diff --git a/docs/orgmode/howto/arch-unsupported.org b/docs/orgmode/howto/arch-unsupported.org
index 01374e1d..b44ed802 100644
--- a/docs/orgmode/howto/arch-unsupported.org
+++ b/docs/orgmode/howto/arch-unsupported.org
@@ -199,4 +199,40 @@ same source slot resolves to a file that exists on another
 architecture. ~--arch x86_64~ on this fixture probes only the x86_64
 wheel, which the server has, and exits 0.
 
+** Two architectures
+
+What it does: ~--arch x86_64 --arch aarch64 --probe-sources~ probes
+those two families and no other. A target such as ~x86_64/amd/zen4~
+is still the family before the slash. Naming a family and one of its
+targets, ~--arch aarch64 --arch aarch64/neoverse_v1~, probes that
+family once. The order of the flags does not change the report.
+
+Why you'd use it: two bot targets failed the fetch and a third was
+not in the run. The comparison is between the families that were
+named. A family left off the command is not fetched, and it does not
+turn ~arch-missing~ into ~unreachable~ or the other way around.
+
+#+begin_src bash
+eb-stack stack arch \
+  --arch x86_64 \
+  --arch aarch64 \
+  --easystack tests/source_probe_fixtures/easystacks/kaleido.yml \
+  --easyconfigs tests/source_probe_fixtures/easyconfigs \
+  --probe-sources
+#+end_src
+
+On the same copy and server it prints:
+
+#+begin_example
+Kaleido-0.2.1-GCCcore-15.2.0.eb source kaleido-0.2.1-manylinux2014-aarch64.whl is arch-missing on aarch64: __BASE_URL__/kaleido-0.2.1-manylinux2014-aarch64.whl (attempt 1/3 HEAD=status:404 RANGE=status:404)
+parse_failed=0 unsupported=0 flagged=0 source_unreachable=0 source_arch_missing=1
+#+end_example
+
+How to read it: the x86_64 wheel is on the server, so the aarch64
+wheel is ~arch-missing~. riscv64 is not named and is not probed. The
+same command with ~--arch aarch64 --arch riscv64~ prints both wheels
+as ~unreachable~, with ~source_unreachable=2~ and
+~source_arch_missing=0~, because neither probed family fetched the
+source slot. The x86_64 wheel is not consulted.
+
 See [[file:../reference/cli.org][the command-line reference]].
diff --git a/docs/orgmode/howto/easyconfigs-pr-overlap.org b/docs/orgmode/howto/easyconfigs-pr-overlap.org
index 197881b8..86b82edc 100644
--- a/docs/orgmode/howto/easyconfigs-pr-overlap.org
+++ b/docs/orgmode/howto/easyconfigs-pr-overlap.org
@@ -138,7 +138,11 @@ writes one JSON file per open PR that changes an easyconfig. Run it
 from a clone of easybuild-easyconfigs whose ~origin~ is that
 repository, with ~gh~ authenticated for public reads. Set
 ~EB_STACK_CHECKOUT~ to the eb-stack checkout. The script reads base
-text from ~develop~ and does not check a PR out.
+text from ~develop~ and does not check a PR out. Open pull requests
+are read 100 per page, with no stop at 500. Changed files are read
+100 per page through GitHub's cap of 3000. A pull request whose file
+list stops there is still written, with ~file_list_truncated~ set.
+~pr-overlap~ notes ~truncated at GitHub's limit~.
 
 #+begin_src bash
 : "${EB_STACK_CHECKOUT:?set this to an eb-stack checkout}"
diff --git a/docs/orgmode/howto/pr-overlap.org b/docs/orgmode/howto/pr-overlap.org
index 662c1d10..d692db1b 100644
--- a/docs/orgmode/howto/pr-overlap.org
+++ b/docs/orgmode/howto/pr-overlap.org
@@ -153,9 +153,12 @@ EasyBuild version these easystacks name.
 differ from that version.
 ~examples/eessi-pr-overlap/fetch-prs.sh~ reads every open PR and writes
 one JSON file per PR that changes an easystack for that EESSI version.
-It pages through the GitHub pulls API 100 at a time with no upper
-limit, so a repository with more open PRs than one listing returns is
-still read in full. It fetches each PR head into the clone as
+It pages through the GitHub pulls API 100 at a time with no stop at
+500, so a repository with more open PRs than one listing returns is
+still read in full. Changed files are read 100 per page through
+GitHub's cap of 3000. A pull request whose file list stops there is
+still written, with ~file_list_truncated~ set, and the record notes
+~truncated at GitHub's limit~. It fetches each PR head into the clone as
 ~refs/remotes/pr/N~ and does not check it out. ~--eessi-version~
 defaults to ~2026.06~.
 
diff --git a/docs/orgmode/howto/solve-lock.org b/docs/orgmode/howto/solve-lock.org
index 3296e290..d26edf3d 100644
--- a/docs/orgmode/howto/solve-lock.org
+++ b/docs/orgmode/howto/solve-lock.org
@@ -118,6 +118,25 @@ eb-stack stack order \
 requirement. The hash file is one ~<sha256>  <module>~ line per build.
 See [[file:../reference/cli.org][the CLI reference]].
 
+~--installed~ stops the walk at modules the site already has, the way
+the robot does. ~--filter-deps~ still drops dependencies before that
+walk. The two compose: a filtered dependency is gone, and a listed
+module is a leaf whose own dependencies are not ordered.
+
+#+begin_src bash
+eb-stack stack order \
+  --easyconfigs fixtures/gromacs_2025_to_next/easyconfigs \
+  --root GROMACS \
+  --installed fixtures/stack_order_installed/installed.txt \
+  --filter-deps FFTW \
+  --out /tmp/build-order.txt
+#+end_src
+
+The order file has no ~OpenBLAS~ path and no ~FFTW~ path. ~GROMACS~ is
+still in it. Standard output ends with ~installed=1~ and then
+~order=/tmp/build-order.txt builds=~. ~installed=1~ is OpenBLAS. FFTW
+was filtered, so it is not a leaf the walk stopped at.
+
 * One lock per toolchain family
 
 A foss solve only sees the foss hierarchy.
diff --git a/docs/orgmode/reference/cli.org b/docs/orgmode/reference/cli.org
index f0c858c2..860a75da 100644
--- a/docs/orgmode/reference/cli.org
+++ b/docs/orgmode/reference/cli.org
@@ -432,6 +432,7 @@ eb-stack stack order \
   --easyconfigs TREE [--easyconfigs OVERLAY]... \
   --root NAME [--root NAME==VERSION]... \
   [--filter-deps NAME,NAME...] \
+  [--installed LIST]... \
   [--out /tmp/build-order.txt] \
   [--oldest] \
   [--easystack-out /tmp/order.yml] \
@@ -644,7 +645,20 @@ not repin a recipe. See [[file:../howto/solve-lock.org][Order every pinned build
 ~name==version~ pins one build. ~--filter-deps~ drops each named
 dependency before that order is built, together with the subtree under
 it, using the same matching as ~stack solve~; when the flag is absent
-the command reads ~EASYBUILD_FILTER_DEPS~. ~--oldest~ takes the oldest
+the command reads ~EASYBUILD_FILTER_DEPS~. ~--installed~ repeats. A file
+is ~module -t avail~, ~module spider -t~, or ~Name/version~, and a
+directory is an Lmod tree, both read the same way as
+~stack gap --installed~. The version is the full module version,
+~1.3.1-GCCcore-15.2.0~, the spelling under ~modules/all~. A system
+toolchain contributes no toolchain segment. A listed module is a leaf:
+it stays out of the order, and so do the dependencies that were
+installed with it. A dependency the tree cannot resolve is still an
+error. The walk that remains uses the synthetic GCC-family rule
+~recipe hierarchy --export~ prints, so an unpinned dependency of a
+~GCC~ or ~GCCcore~ recipe stays in that family. ~--filter-deps~ is
+applied first, so a filtered dependency is not counted as a leaf. The
+line ~installed=<N>~ just before ~order=~ is how many distinct modules
+the walk stopped at. ~--oldest~ takes the oldest
 admissible version of an unpinned requirement, and the default is the
 newest. ~--out~ is one easyconfig path per line (default
 ~build-order.txt~). ~--easystack-out~ writes that same sequence as an
@@ -863,6 +877,9 @@ fallback, on each family ~--arch~ names, or on ~x86_64~, ~aarch64~,
 and ~riscv64~ with no ~--arch~. A source no probed family can fetch is
 ~unreachable~. A source another probed family can fetch is
 ~arch-missing~, so with one ~--arch~ a missing source is ~unreachable~.
+Two ~--arch~ values compare only that pair: a miss is ~arch-missing~
+when the other named family fetched the same source slot, and
+~unreachable~ when neither did.
 ~--probe-retries~ and ~--probe-timeout-s~ tune that network check.
 
 [[file:../howto/arch-unsupported.org][Refuse a plan an architecture cannot build]]
@@ -1751,7 +1768,8 @@ plus sandboxed recipe and easyblock tools:
   (easyblocks; ~eb_build_test~ only with ~EB_STACK_ALLOW_BUILD=1~);
 - ~eb_stack_solve~, ~eb_stack_sbom~, ~eb_stack_order~,
   ~eb_stack_easystack~, ~eb_stack_gap~, ~eb_stack_provided~,
-  ~eb_stack_batch~, ~eb_stack_shard~, ~eb_stack_arch~, ~eb_stack_files~,
+  ~eb_stack_shadow~, ~eb_stack_batch~, ~eb_stack_shard~,
+  ~eb_stack_arch~, ~eb_stack_files~,
   ~eb_stack_generation~, ~eb_stack_cuda_cc~, ~eb_stack_known_failures~,
   ~eb_stack_oom~, ~eb_stack_bot_classify~, ~eb_stack_sections~,
   ~eb_stack_from_commit~;
@@ -1792,8 +1810,12 @@ table and the derived-key rules. ~eb_recipe_hierarchy~ takes ~export~.
 The plain call prints the fixture generations. ~export~ true adds the
 synthetic GCC-family rule, the same split as ~recipe hierarchy --export~.
 ~eb_stack_order~ requires ~easyconfigs~ and ~root~, and takes ~out~,
-~oldest~, ~easystack_out~, ~hashes_out~, and ~filter_deps~.
+~oldest~, ~easystack_out~, ~hashes_out~, ~filter_deps~, and ~installed~.
 ~filter_deps~ drops the same dependencies ~--filter-deps~ drops.
+~installed~ is the module list or Lmod tree ~--installed~ reads. A
+module it names is left out of the order. The result field ~installed~
+is how many modules the walk stopped at, and is null when the argument
+is omitted.
 ~eb_stack_easystack~ requires ~lock~ and takes ~out~ and ~option~, each
 option a ~<file.eb>:<option>=<value>~ string, and ~eessi_version~,
 ~easybuild_version~, ~generation~, and ~out_dir~ for the software-layer
@@ -1809,13 +1831,16 @@ requires ~easystack~ and takes ~easyconfigs_repo~, ~easyblocks_repo~,
 ~licensed_file~, ~json~, ~format~, and ~strict~. A hit, an unparsed
 line, a wrong toolchain, a ~--hooks~ flag, or a family-lock name is a
 tool error. A licensed warning is not, unless ~strict~ is true. The
-text is the same report as ~stack provided~. ~eb_stack_arch~ requires
-~easystack~ and takes
+text is the same report as ~stack provided~. ~eb_stack_shadow~
+requires ~easyconfigs~ and ~base~, and takes ~json~. It returns the
+same report as ~stack shadow~. A shadow, or a recipe that does not
+parse, is a tool error. ~eb_stack_arch~ requires ~easystack~ and takes
 ~arch~, ~easyconfigs~, ~installed~, ~additional_arch~, ~unsupported~,
 ~probe_sources~, ~probe_retries~, and ~probe_timeout_s~. It returns the
 same report as ~stack arch~, with ~parse_failed~ and ~source_findings~,
 and a hit is a tool error. ~probe_sources~ probes the families ~arch~
-names, as ~--arch~ does. ~eb_stack_files~ requires ~easystack~ and takes
+names, as ~--arch~ does. Two names are compared only with each other.
+~eb_stack_files~ requires ~easystack~ and takes
 ~easyconfigs~, ~commit_tree~, ~easyconfigs_repo~, ~sourcepath~, and
 ~path_map~. It returns the same report as ~stack files~, and a missing
 file is a tool error. ~eb_stack_cuda_cc~ requires ~easystack~ and ~easyconfigs~,
diff --git a/docs/orgmode/reference/formats.org b/docs/orgmode/reference/formats.org
index 981d1ca5..eab763b6 100644
--- a/docs/orgmode/reference/formats.org
+++ b/docs/orgmode/reference/formats.org
@@ -219,8 +219,10 @@ solver selection, not a scan of installed software.
 
 One easyconfig path per line, in dependency order. A name EasyBuild
 installs twice lists both paths: another toolchain, a system bootstrap
-pair, or a build-only tool. ~--oldest~ changes which unpinned version is
-chosen; it does not change the file shape. When runtime requirements of
+pair, or a build-only tool. ~--installed~ leaves a listed module, and
+the dependencies that were installed with it, out of this file.
+~--oldest~ changes which unpinned version is chosen; it does not change
+the file shape. When runtime requirements of
 one name at one toolchain have no version that satisfies every one of
 them, the command writes no file and exits 1. Standard error names each
 requester and the version it resolved. The file is not a place where a
@@ -228,7 +230,8 @@ pin is rewritten.
 
 Stdout names a co-installable repeated build as
 ~multiple builds of <name>: <ver-tc>, ...~ and ends with
-~order=<path> builds=<N>~.
+~order=<path> builds=<N>~. When ~--installed~ is set, the line before
+that is ~installed=<N>~, how many listed modules the walk stopped at.
 
 * Input hashes (~--hashes-out~)
 
diff --git a/docs/orgmode/reference/mcp.org b/docs/orgmode/reference/mcp.org
index c4411e8d..6bf95858 100644
--- a/docs/orgmode/reference/mcp.org
+++ b/docs/orgmode/reference/mcp.org
@@ -88,7 +88,71 @@ absolute path there.
 
 * Tools
 
-~tools/list~ returns the workflows of ~package~, ~recipe~, ~stack~,
-~target~, ~campaign~, and ~repro~, plus ~pr-overlap~, ~rebuild-set~,
-~component-reach~, and ~easyblock-reach~. ~eb_build_test~ runs only
-when ~EB_STACK_ALLOW_BUILD=1~.
+The catalog has 51 tools. ~tools/list~ returns one tool for each CLI
+command in the table, and the recipe and easyblock tools that have no
+command. ~mcp~ publishes that catalog and has no tool of its own. Each
+command's tool calls the same runner as that command. The ~text~ field
+of a successful result is that command's stdout. Each argument is a
+name in the schema ~tools/list~ returns. The
+[[file:cli.org][CLI reference]] records the flags.
+
+| Command | Tool |
+|-
+| ~package inspect~ | ~eb_package_inspect~ |
+| ~package plan~ | ~eb_package_plan~ |
+| ~package bump~ | ~eb_package_bump~ |
+| ~package latest~ | ~eb_package_latest~ |
+| ~recipe easyblock~ | ~eb_recipe_easyblock~ |
+| ~recipe templates~ | ~eb_recipe_templates~ |
+| ~recipe hierarchy~ | ~eb_recipe_hierarchy~ |
+| ~recipe check~ | ~eb_recipe_check~ |
+| ~recipe lint~ | ~eb_recipe_lint~ |
+| ~recipe format~ | ~eb_recipe_format~ |
+| ~stack solve~ | ~eb_stack_solve~ |
+| ~stack sbom~ | ~eb_stack_sbom~ |
+| ~stack order~ | ~eb_stack_order~ |
+| ~stack gap~ | ~eb_stack_gap~ |
+| ~stack provided~ | ~eb_stack_provided~ |
+| ~stack shadow~ | ~eb_stack_shadow~ |
+| ~stack batch~ | ~eb_stack_batch~ |
+| ~stack shard~ | ~eb_stack_shard~ |
+| ~stack easystack~ | ~eb_stack_easystack~ |
+| ~stack sections~ | ~eb_stack_sections~ |
+| ~stack from-commit~ | ~eb_stack_from_commit~ |
+| ~stack arch~ | ~eb_stack_arch~ |
+| ~stack files~ | ~eb_stack_files~ |
+| ~stack generation~ | ~eb_stack_generation~ |
+| ~stack cuda-cc~ | ~eb_stack_cuda_cc~ |
+| ~stack known-failures~ | ~eb_stack_known_failures~ |
+| ~stack oom~ | ~eb_stack_oom~ |
+| ~stack bot-classify~ | ~eb_stack_bot_classify~ |
+| ~target list~ | ~eb_target_list~ |
+| ~target doctor~ | ~eb_target_doctor~ |
+| ~campaign run~ | ~eb_campaign_run~ |
+| ~campaign status~ | ~eb_campaign_status~ |
+| ~campaign finding claim~ | ~eb_campaign_finding_claim~ |
+| ~campaign finding resolve~ | ~eb_campaign_finding_resolve~ |
+| ~repro summary~ | ~eb_repro_summary~ |
+| ~easyblock-reach~ | ~eb_easyblock_reach~ |
+| ~pr-overlap~ | ~eb_pr_overlap~ |
+| ~rebuild-set~ | ~eb_rebuild_set~ |
+| ~component-reach~ | ~eb_component_reach~ |
+
+These tools edit files or run EasyBuild. They are not CLI commands.
+
+| Tool | Role |
+|-
+| ~eb_recipe_read~ | Read one UTF-8 file inside the workspace root |
+| ~eb_recipe_list~ | List one directory inside the workspace root |
+| ~eb_recipe_edit~ | Replace an exact string in a workspace file |
+| ~eb_recipe_apply_suggestion~ | Apply a review suggestion to the lines it is anchored on |
+| ~eb_recipe_diff~ | Show what changed in each recipe since the server first saw it |
+| ~eb_recipe_write~ | Create or overwrite a UTF-8 file inside the workspace root |
+| ~eb_recipe_grep~ | Search workspace files for a literal, or a regular expression |
+| ~eb_dep_versions~ | List easyconfig versions of one dependency in a local tree |
+| ~eb_module_lint~ | Check Python modules that ship with recipes |
+| ~eb_easyblock_dry_run~ | Run ~eb -x~ and return the commands the easyblock generates |
+| ~eb_build_log~ | Read an EasyBuild log by step |
+| ~eb_build_test~ | Run a build |
+
+~eb_build_test~ runs only when ~EB_STACK_ALLOW_BUILD=1~.
diff --git a/examples/easyconfigs-pr-overlap/fetch-prs.sh b/examples/easyconfigs-pr-overlap/fetch-prs.sh
index b50ab4f7..eaab28af 100755
--- a/examples/easyconfigs-pr-overlap/fetch-prs.sh
+++ b/examples/easyconfigs-pr-overlap/fetch-prs.sh
@@ -9,20 +9,56 @@
 # Run inside a clone of easybuild-easyconfigs whose `origin` is <owner/repo>.
 # The base text of a changed file is read from `develop`.
 set -euo pipefail
+# GitHub returns at most this many items on one page.
+page_size=100
+# GitHub lists at most this many changed files for one pull request.
+file_cap=3000
+# Pages of open pull requests read before the list is taken as unending.
+open_page_limit=1000
+# Pages of changed files read before the list is taken as unending.
+file_page_limit=40
 
 repo=$1
 out=${2:?usage: fetch-prs.sh <owner/repo> <out-dir>}
 # Rewrite outputs from scratch on every run, so closed pull requests do not
 # persist from stale raw/ and prs/ directories.
-rm -rf "$out/raw" "$out/prs"
-mkdir -p "$out/prs"
+rm -rf "$out/raw" "$out/prs" "$out/trunc"
+mkdir -p "$out/prs" "$out/trunc"
 rm -f "$out/refspecs"
 prefix="easybuild/easyconfigs/"
 
 git fetch --quiet --no-tags origin develop
-# Every open pull request, 100 per page, with no upper limit.
-gh api --method GET --paginate "repos/${repo}/pulls?state=open&per_page=100" \
-  --jq '.[] | {number, headRefOid: .head.sha, title}' >"$out/open.jsonl"
+# Every open pull request, 100 per page. Each page is requested on its own,
+# and a short page is the end. There is no stop at 500.
+: >"$out/open.jsonl"
+page=1
+while true; do
+  if ! chunk=$(gh api --method GET \
+      "repos/${repo}/pulls?state=open&per_page=${page_size}&page=${page}" \
+      --jq '.[] | {number, headRefOid: .head.sha, title}' 2>"$out/.gh-err"); then
+    cat "$out/.gh-err" >&2
+    echo "fetch-prs.sh: listing open pull requests failed on page ${page}" >&2
+    exit 1
+  fi
+  if [[ -z "${chunk//[$' \t\n']/}" ]]; then
+    break
+  fi
+  printf '%s\n' "$chunk" >>"$out/open.jsonl"
+  count=0
+  while IFS= read -r line; do
+    [[ -n "$line" ]] || continue
+    count=$((count + 1))
+  done <<<"$chunk"
+  if (( count < page_size )); then
+    break
+  fi
+  page=$((page + 1))
+  if (( page > open_page_limit )); then
+    echo "fetch-prs.sh: open pull request list did not end" >&2
+    exit 1
+  fi
+done
+rm -f "$out/.gh-err"
 python3 - "$out/open.jsonl" "$out/open.json" <<'PY'
 import json, sys
 rows = [json.loads(line) for line in open(sys.argv[1]) if line.strip()]
@@ -30,17 +66,88 @@ json.dump(rows, open(sys.argv[2], "w"))
 print("open pull requests:", len(rows))
 PY
 
+# Matching easyconfig paths for pull request $1, one per line.
+# Pages are 100 files. GitHub stops at 3000: a later page answers 422, or
+# another page is non-empty after 3000 names. The pull request is kept and
+# $out/trunc/$1 is created. Paths past that cap are not kept.
+pr_changed_files() {
+  local number=$1
+  local page=1
+  local total=0
+  local err="$out/.gh-err"
+  while true; do
+    if ! chunk=$(gh api --method GET \
+        "repos/${repo}/pulls/${number}/files?per_page=${page_size}&page=${page}" \
+        --jq '.[] | .filename' 2>"$err"); then
+      if (( page > 1 )) && grep -Eqi "${file_cap}|pagination is limited|maximum number of files|too many files" "$err"; then
+        : >"$out/trunc/${number}"
+        return 0
+      fi
+      cat "$err" >&2
+      echo "fetch-prs.sh: file list for pull request ${number} failed on page ${page}" >&2
+      return 1
+    fi
+    if [[ -z "${chunk//[$' \t\n']/}" ]]; then
+      return 0
+    fi
+    local count=0
+    local name
+    while IFS= read -r name; do
+      [[ -n "$name" ]] || continue
+      count=$((count + 1))
+      case "$name" in
+        "${prefix}"*.eb) printf '%s\n' "$name" ;;
+      esac
+    done <<<"$chunk"
+    total=$((total + count))
+    if (( count < page_size )); then
+      return 0
+    fi
+    if (( total >= file_cap )); then
+      page=$((page + 1))
+      if ! chunk=$(gh api --method GET \
+          "repos/${repo}/pulls/${number}/files?per_page=${page_size}&page=${page}" \
+          --jq '.[] | .filename' 2>"$err"); then
+        if grep -Eqi "${file_cap}|pagination is limited|maximum number of files|too many files" "$err"; then
+          : >"$out/trunc/${number}"
+          return 0
+        fi
+        cat "$err" >&2
+        echo "fetch-prs.sh: file list for pull request ${number} failed on page ${page}" >&2
+        return 1
+      fi
+      if [[ -n "${chunk//[$' \t\n']/}" ]]; then
+        : >"$out/trunc/${number}"
+      fi
+      return 0
+    fi
+    page=$((page + 1))
+    if (( page > file_page_limit )); then
+      echo "fetch-prs.sh: file list for pull request ${number} did not end" >&2
+      return 1
+    fi
+  done
+}
+
 python3 - "$out/open.json" <<'PY' | while read -r number sha; do
 import json, sys
 for pr in json.load(open(sys.argv[1])):
     print(pr["number"], pr["headRefOid"])
 PY
   # Changed files, from the API so no diff of fork history is needed.
-  mapfile -t files < <(gh api --paginate "repos/${repo}/pulls/${number}/files" \
-    --jq ".[] | select(.filename | startswith(\"${prefix}\")) | select(.filename | endswith(\".eb\")) | .filename")
-  [[ ${#files[@]} -eq 0 ]] && continue
   dir="$out/raw/${number}"
   mkdir -p "$dir"
+  if ! pr_changed_files "$number" >"$dir/names"; then
+    exit 1
+  fi
+  if [[ -f "$out/trunc/${number}" ]]; then
+    mv "$out/trunc/${number}" "$dir/truncated"
+  fi
+  mapfile -t files <"$dir/names"
+  if [[ ${#files[@]} -eq 0 && ! -f "$dir/truncated" ]]; then
+    rm -rf "$dir"
+    continue
+  fi
   i=0
   for f in "${files[@]}"; do
     printf '%s\n' "$f" >"$dir/${i}.path"
@@ -48,7 +155,9 @@ PY
   done
   printf '%s\n' "$sha" >"$dir/head_sha"
   # GitHub keeps every pull request head, fork or not, at refs/pull/N/head.
-  printf '+refs/pull/%s/head:refs/remotes/pr/%s\n' "$number" "$number" >>"$out/refspecs"
+  if [[ ${#files[@]} -gt 0 ]]; then
+    printf '+refs/pull/%s/head:refs/remotes/pr/%s\n' "$number" "$number" >>"$out/refspecs"
+  fi
 done
 
 # One shallow fetch for every head. A shallow fetch per pull request
@@ -101,6 +210,13 @@ for number in sorted(os.listdir(raw) if os.path.isdir(raw) else [], key=int):
         i += 1
     doc = {"number": int(number), "head_sha": read(f"{d}/head_sha").strip(),
            "title": titles.get(int(number)), "easyconfigs": easyconfigs}
+    if os.path.exists(f"{d}/truncated"):
+        doc["file_list_truncated"] = True
     json.dump(doc, open(f"{out}/prs/{number}.json", "w"), indent=1, sort_keys=True)
 PY
-ls "$out/prs" | wc -l | xargs echo "pull requests with easyconfig changes:"
+rm -rf "$out/trunc"
+rm -f "$out/.gh-err"
+shopt -s nullglob
+prs=("$out"/prs/*.json)
+shopt -u nullglob
+echo "pull requests with easyconfig changes: ${#prs[@]}"
diff --git a/examples/eessi-pr-overlap/README.md b/examples/eessi-pr-overlap/README.md
index 4d605188..3f6c73e0 100644
--- a/examples/eessi-pr-overlap/README.md
+++ b/examples/eessi-pr-overlap/README.md
@@ -153,9 +153,12 @@ eb-stack pr-overlap --pr in/prs/*.json \
   --out-dir out/
 ```
 
-`fetch-prs.sh` reads every open pull request, 100 per page with no upper
-limit, and writes `in/prs/<N>.json` for each one that changes a 2026.06
-easystack. On EESSI/software-layer on 2026-10-31 it printed:
+`fetch-prs.sh` reads every open pull request, 100 per page, and does not
+stop at 500. Changed files are read the same way, through GitHub's cap of
+3000. A pull request whose file list stops there is still written, with
+`file_list_truncated` set, and the record notes `truncated at GitHub's limit`.
+It writes `in/prs/<N>.json` for each one that changes a 2026.06 easystack.
+On EESSI/software-layer on 2026-10-31 it printed:
 
 ```
 open pull requests: 52
diff --git a/examples/eessi-pr-overlap/fetch-prs.sh b/examples/eessi-pr-overlap/fetch-prs.sh
index 2fc229a8..8dd8b42f 100755
--- a/examples/eessi-pr-overlap/fetch-prs.sh
+++ b/examples/eessi-pr-overlap/fetch-prs.sh
@@ -11,6 +11,14 @@
 # Needs: gh (authenticated with any read token), git, python3, curl.
 # Run inside a clone of the repository whose `origin` is <owner/repo>.
 set -euo pipefail
+# GitHub returns at most this many items on one page.
+page_size=100
+# GitHub lists at most this many changed files for one pull request.
+file_cap=3000
+# Pages of open pull requests read before the list is taken as unending.
+open_page_limit=1000
+# Pages of changed files read before the list is taken as unending.
+file_page_limit=40
 
 repo=$1
 version=$2
@@ -20,8 +28,8 @@ list=${4:-}
 # closed or stopped touching easystacks does not persist from a stale run,
 # and so does its refspecs line. commit-trees/ and easyblocks/ are caches
 # guarded by their marker files and survive reruns.
-rm -rf "$out/raw" "$out/prs"
-mkdir -p "$out/prs" "$out/commit-trees" "$out/easyblocks"
+rm -rf "$out/raw" "$out/prs" "$out/trunc"
+mkdir -p "$out/prs" "$out/commit-trees" "$out/easyblocks" "$out/trunc"
 rm -f "$out/refspecs"
 prefix="easystacks/software.eessi.io/${version}/"
 
@@ -48,9 +56,37 @@ for line in open(sys.argv[1]):
 json.dump(rows, open(sys.argv[2], "w"))
 PY
 else
-  # Every open pull request, 100 per page, with no upper limit.
-  gh api --method GET --paginate "repos/${repo}/pulls?state=open&per_page=100" \
-    --jq '.[] | {number, headRefOid: .head.sha, title}' >"$out/open.jsonl"
+  # Every open pull request, 100 per page. Each page is requested on its
+  # own, and a short page is the end. There is no stop at 500.
+  : >"$out/open.jsonl"
+  page=1
+  while true; do
+    if ! chunk=$(gh api --method GET \
+        "repos/${repo}/pulls?state=open&per_page=${page_size}&page=${page}" \
+        --jq '.[] | {number, headRefOid: .head.sha, title}' 2>"$out/.gh-err"); then
+      cat "$out/.gh-err" >&2
+      echo "fetch-prs.sh: listing open pull requests failed on page ${page}" >&2
+      exit 1
+    fi
+    if [[ -z "${chunk//[$' \t\n']/}" ]]; then
+      break
+    fi
+    printf '%s\n' "$chunk" >>"$out/open.jsonl"
+    count=0
+    while IFS= read -r line; do
+      [[ -n "$line" ]] || continue
+      count=$((count + 1))
+    done <<<"$chunk"
+    if (( count < page_size )); then
+      break
+    fi
+    page=$((page + 1))
+    if (( page > open_page_limit )); then
+      echo "fetch-prs.sh: open pull request list did not end" >&2
+      exit 1
+    fi
+  done
+  rm -f "$out/.gh-err"
   python3 - "$out/open.jsonl" "$out/open.json" <<'PY'
 import json, sys
 rows = [json.loads(line) for line in open(sys.argv[1]) if line.strip()]
@@ -59,22 +95,90 @@ print("open pull requests:", len(rows))
 PY
 fi
 
+# Matching easystack and easyconfig paths for pull request $1, one per line.
+# Pages are 100 files. GitHub stops at 3000: a later page answers 422, or
+# another page is non-empty after 3000 names. The pull request is kept and
+# $out/trunc/$1 is created. Paths past that cap are not kept.
+mkdir -p "$out/trunc"
+pr_changed_files() {
+  local number=$1
+  local page=1
+  local total=0
+  local err="$out/.gh-err"
+  while true; do
+    if ! chunk=$(gh api --method GET \
+        "repos/${repo}/pulls/${number}/files?per_page=${page_size}&page=${page}" \
+        --jq '.[] | .filename' 2>"$err"); then
+      if (( page > 1 )) && grep -Eqi "${file_cap}|pagination is limited|maximum number of files|too many files" "$err"; then
+        : >"$out/trunc/${number}"
+        return 0
+      fi
+      cat "$err" >&2
+      echo "fetch-prs.sh: file list for pull request ${number} failed on page ${page}" >&2
+      return 1
+    fi
+    if [[ -z "${chunk//[$' \t\n']/}" ]]; then
+      return 0
+    fi
+    local count=0
+    local name
+    while IFS= read -r name; do
+      [[ -n "$name" ]] || continue
+      count=$((count + 1))
+      case "$name" in
+        *.eb) printf '%s\n' "$name" ;;
+        "${prefix}"*.yml) printf '%s\n' "$name" ;;
+      esac
+    done <<<"$chunk"
+    total=$((total + count))
+    if (( count < page_size )); then
+      return 0
+    fi
+    if (( total >= file_cap )); then
+      page=$((page + 1))
+      if ! chunk=$(gh api --method GET \
+          "repos/${repo}/pulls/${number}/files?per_page=${page_size}&page=${page}" \
+          --jq '.[] | .filename' 2>"$err"); then
+        if grep -Eqi "${file_cap}|pagination is limited|maximum number of files|too many files" "$err"; then
+          : >"$out/trunc/${number}"
+          return 0
+        fi
+        cat "$err" >&2
+        echo "fetch-prs.sh: file list for pull request ${number} failed on page ${page}" >&2
+        return 1
+      fi
+      if [[ -n "${chunk//[$' \t\n']/}" ]]; then
+        : >"$out/trunc/${number}"
+      fi
+      return 0
+    fi
+    page=$((page + 1))
+    if (( page > file_page_limit )); then
+      echo "fetch-prs.sh: file list for pull request ${number} did not end" >&2
+      return 1
+    fi
+  done
+}
+
 python3 - "$out/open.json" <<'PY' | while read -r number sha; do
 import json, sys
 for pr in json.load(open(sys.argv[1])):
     print(pr["number"], pr["headRefOid"])
 PY
   # Changed files, from the API so no diff of fork history is needed.
-  mapfile -t files < <(gh api --method GET --paginate "repos/${repo}/pulls/${number}/files" \
-    --jq '.[] | .filename' | while IFS= read -r name; do
-      case "$name" in
-        *.eb) printf '%s\n' "$name" ;;
-        "${prefix}"*.yml) printf '%s\n' "$name" ;;
-      esac
-    done)
-  [[ ${#files[@]} -eq 0 ]] && continue
   dir="$out/raw/${number}"
   mkdir -p "$dir"
+  if ! pr_changed_files "$number" >"$dir/names"; then
+    exit 1
+  fi
+  if [[ -f "$out/trunc/${number}" ]]; then
+    mv "$out/trunc/${number}" "$dir/truncated"
+  fi
+  mapfile -t files <"$dir/names"
+  if [[ ${#files[@]} -eq 0 && ! -f "$dir/truncated" ]]; then
+    rm -rf "$dir"
+    continue
+  fi
   i=0
   for f in "${files[@]}"; do
     printf '%s\n' "$f" >"$dir/${i}.path"
@@ -82,7 +186,9 @@ PY
   done
   printf '%s\n' "$sha" >"$dir/head_sha"
   # GitHub keeps every pull request head, fork or not, at refs/pull/N/head.
-  printf '+refs/pull/%s/head:refs/remotes/pr/%s\n' "$number" "$number" >>"$out/refspecs"
+  if [[ ${#files[@]} -gt 0 ]]; then
+    printf '+refs/pull/%s/head:refs/remotes/pr/%s\n' "$number" "$number" >>"$out/refspecs"
+  fi
 done
 
 # One shallow fetch for every head. A shallow fetch per pull request
@@ -147,6 +253,8 @@ for number in sorted(os.listdir(raw) if os.path.isdir(raw) else [], key=int):
         i += 1
     doc = {"number": int(number), "head_sha": read(f"{d}/head_sha").strip(),
            "title": titles.get(int(number)), "easystacks": stacks, "files": extras}
+    if os.path.exists(f"{d}/truncated"):
+        doc["file_list_truncated"] = True
     json.dump(doc, open(f"{out}/prs/{number}.json", "w"), indent=1, sort_keys=True)
 PY
 
@@ -254,6 +362,8 @@ PY
       rm -f "$ball"
       : >"$dest/.touched-files"
     done
+rm -rf "$out/trunc"
+rm -f "$out/.gh-err"
 shopt -s nullglob
 prs=("$out"/prs/*.json)
 shopt -u nullglob
diff --git a/fixtures/stack_order_installed/installed.txt b/fixtures/stack_order_installed/installed.txt
new file mode 100644
index 00000000..0e9d4121
--- /dev/null
+++ b/fixtures/stack_order_installed/installed.txt
@@ -0,0 +1,2 @@
+# OpenBLAS is already installed. The version is the full module version.
+OpenBLAS/0.3.27-foss-2025b
diff --git a/llms-full.txt b/llms-full.txt
index 72c6afea..523e796d 100644
--- a/llms-full.txt
+++ b/llms-full.txt
@@ -1877,6 +1877,25 @@ eb-stack stack order \
 requirement. The hash file is one `<sha256>  <module>` line per build.
 See [the CLI reference](https://eb-stack.rgoswami.me/../reference/cli.html.md).
 
+`--installed` stops the walk at modules the site already has, the way
+the robot does. `--filter-deps` still drops dependencies before that
+walk. The two compose: a filtered dependency is gone, and a listed
+module is a leaf whose own dependencies are not ordered.
+
+```bash
+eb-stack stack order \
+  --easyconfigs fixtures/gromacs_2025_to_next/easyconfigs \
+  --root GROMACS \
+  --installed fixtures/stack_order_installed/installed.txt \
+  --filter-deps FFTW \
+  --out /tmp/build-order.txt
+```
+
+The order file has no `OpenBLAS` path and no `FFTW` path. `GROMACS` is
+still in it. Standard output ends with `installed=1` and then
+`order=/tmp/build-order.txt builds=`. `installed=1` is OpenBLAS. FFTW
+was filtered, so it is not a leaf the walk stopped at.
+
 # One lock per toolchain family
 
 A foss solve only sees the foss hierarchy.
@@ -2681,9 +2700,12 @@ EasyBuild version these easystacks name.
 differ from that version.
 `examples/eessi-pr-overlap/fetch-prs.sh` reads every open PR and writes
 one JSON file per PR that changes an easystack for that EESSI version.
-It pages through the GitHub pulls API 100 at a time with no upper
-limit, so a repository with more open PRs than one listing returns is
-still read in full. It fetches each PR head into the clone as
+It pages through the GitHub pulls API 100 at a time with no stop at
+500, so a repository with more open PRs than one listing returns is
+still read in full. Changed files are read 100 per page through
+GitHub's cap of 3000. A pull request whose file list stops there is
+still written, with `file_list_truncated` set, and the record notes
+`truncated at GitHub's limit`. It fetches each PR head into the clone as
 `refs/remotes/pr/N` and does not check it out. `--eessi-version`
 defaults to `2026.06`.
 
@@ -3009,7 +3031,11 @@ writes one JSON file per open PR that changes an easyconfig. Run it
 from a clone of easybuild-easyconfigs whose `origin` is that
 repository, with `gh` authenticated for public reads. Set
 `EB_STACK_CHECKOUT` to the eb-stack checkout. The script reads base
-text from `develop` and does not check a PR out.
+text from `develop` and does not check a PR out. Open pull requests
+are read 100 per page, with no stop at 500. Changed files are read
+100 per page through GitHub's cap of 3000. A pull request whose file
+list stops there is still written, with `file_list_truncated` set.
+`pr-overlap` notes `truncated at GitHub's limit`.
 
 ```bash
 : "${EB_STACK_CHECKOUT:?set this to an eb-stack checkout}"
@@ -3850,6 +3876,42 @@ same source slot resolves to a file that exists on another
 architecture. `--arch x86_64` on this fixture probes only the x86_64
 wheel, which the server has, and exits 0.
 
+## Two architectures
+
+What it does: `--arch x86_64 --arch aarch64 --probe-sources` probes
+those two families and no other. A target such as `x86_64/amd/zen4`
+is still the family before the slash. Naming a family and one of its
+targets, `--arch aarch64 --arch aarch64/neoverse_v1`, probes that
+family once. The order of the flags does not change the report.
+
+Why you'd use it: two bot targets failed the fetch and a third was
+not in the run. The comparison is between the families that were
+named. A family left off the command is not fetched, and it does not
+turn `arch-missing` into `unreachable` or the other way around.
+
+```bash
+eb-stack stack arch \
+  --arch x86_64 \
+  --arch aarch64 \
+  --easystack tests/source_probe_fixtures/easystacks/kaleido.yml \
+  --easyconfigs tests/source_probe_fixtures/easyconfigs \
+  --probe-sources
+```
+
+On the same copy and server it prints:
+
+```
+Kaleido-0.2.1-GCCcore-15.2.0.eb source kaleido-0.2.1-manylinux2014-aarch64.whl is arch-missing on aarch64: __BASE_URL__/kaleido-0.2.1-manylinux2014-aarch64.whl (attempt 1/3 HEAD=status:404 RANGE=status:404)
+parse_failed=0 unsupported=0 flagged=0 source_unreachable=0 source_arch_missing=1
+```
+
+How to read it: the x86_64 wheel is on the server, so the aarch64
+wheel is `arch-missing`. riscv64 is not named and is not probed. The
+same command with `--arch aarch64 --arch riscv64` prints both wheels
+as `unreachable`, with `source_unreachable=2` and
+`source_arch_missing=0`, because neither probed family fetched the
+source slot. The x86_64 wheel is not consulted.
+
 See [the command-line reference](https://eb-stack.rgoswami.me/../reference/cli.html.md).
 
 # Find a missing patch before the bot does
@@ -6534,6 +6596,7 @@ eb-stack stack order \
   --easyconfigs TREE [--easyconfigs OVERLAY]... \
   --root NAME [--root NAME==VERSION]... \
   [--filter-deps NAME,NAME...] \
+  [--installed LIST]... \
   [--out /tmp/build-order.txt] \
   [--oldest] \
   [--easystack-out /tmp/order.yml] \
@@ -6746,7 +6809,20 @@ not repin a recipe. See [Order every pinned build](https://eb-stack.rgoswami.me/
 `name==version` pins one build. `--filter-deps` drops each named
 dependency before that order is built, together with the subtree under
 it, using the same matching as `stack solve`; when the flag is absent
-the command reads `EASYBUILD_FILTER_DEPS`. `--oldest` takes the oldest
+the command reads `EASYBUILD_FILTER_DEPS`. `--installed` repeats. A file
+is `module -t avail`, `module spider -t`, or `Name/version`, and a
+directory is an Lmod tree, both read the same way as
+`stack gap --installed`. The version is the full module version,
+`1.3.1-GCCcore-15.2.0`, the spelling under `modules/all`. A system
+toolchain contributes no toolchain segment. A listed module is a leaf:
+it stays out of the order, and so do the dependencies that were
+installed with it. A dependency the tree cannot resolve is still an
+error. The walk that remains uses the synthetic GCC-family rule
+`recipe hierarchy --export` prints, so an unpinned dependency of a
+`GCC` or `GCCcore` recipe stays in that family. `--filter-deps` is
+applied first, so a filtered dependency is not counted as a leaf. The
+line `installed=<N>` just before `order=` is how many distinct modules
+the walk stopped at. `--oldest` takes the oldest
 admissible version of an unpinned requirement, and the default is the
 newest. `--out` is one easyconfig path per line (default
 `build-order.txt`). `--easystack-out` writes that same sequence as an
@@ -6965,6 +7041,9 @@ fallback, on each family `--arch` names, or on `x86_64`, `aarch64`,
 and `riscv64` with no `--arch`. A source no probed family can fetch is
 `unreachable`. A source another probed family can fetch is
 `arch-missing`, so with one `--arch` a missing source is `unreachable`.
+Two `--arch` values compare only that pair: a miss is `arch-missing`
+when the other named family fetched the same source slot, and
+`unreachable` when neither did.
 `--probe-retries` and `--probe-timeout-s` tune that network check.
 
 [Refuse a plan an architecture cannot build](https://eb-stack.rgoswami.me/../howto/arch-unsupported.html.md)
@@ -7853,7 +7932,8 @@ plus sandboxed recipe and easyblock tools:
   (easyblocks; `eb_build_test` only with `EB_STACK_ALLOW_BUILD=1`);
 - `eb_stack_solve`, `eb_stack_sbom`, `eb_stack_order`,
   `eb_stack_easystack`, `eb_stack_gap`, `eb_stack_provided`,
-  `eb_stack_batch`, `eb_stack_shard`, `eb_stack_arch`, `eb_stack_files`,
+  `eb_stack_shadow`, `eb_stack_batch`, `eb_stack_shard`,
+  `eb_stack_arch`, `eb_stack_files`,
   `eb_stack_generation`, `eb_stack_cuda_cc`, `eb_stack_known_failures`,
   `eb_stack_oom`, `eb_stack_bot_classify`, `eb_stack_sections`,
   `eb_stack_from_commit`;
@@ -7894,8 +7974,12 @@ table and the derived-key rules. `eb_recipe_hierarchy` takes `export`.
 The plain call prints the fixture generations. `export` true adds the
 synthetic GCC-family rule, the same split as `recipe hierarchy --export`.
 `eb_stack_order` requires `easyconfigs` and `root`, and takes `out`,
-`oldest`, `easystack_out`, `hashes_out`, and `filter_deps`.
+`oldest`, `easystack_out`, `hashes_out`, `filter_deps`, and `installed`.
 `filter_deps` drops the same dependencies `--filter-deps` drops.
+`installed` is the module list or Lmod tree `--installed` reads. A
+module it names is left out of the order. The result field `installed`
+is how many modules the walk stopped at, and is null when the argument
+is omitted.
 `eb_stack_easystack` requires `lock` and takes `out` and `option`, each
 option a `<file.eb>:<option>=<value>` string, and `eessi_version`,
 `easybuild_version`, `generation`, and `out_dir` for the software-layer
@@ -7911,13 +7995,16 @@ requires `easystack` and takes `easyconfigs_repo`, `easyblocks_repo`,
 `licensed_file`, `json`, `format`, and `strict`. A hit, an unparsed
 line, a wrong toolchain, a `--hooks` flag, or a family-lock name is a
 tool error. A licensed warning is not, unless `strict` is true. The
-text is the same report as `stack provided`. `eb_stack_arch` requires
-`easystack` and takes
+text is the same report as `stack provided`. `eb_stack_shadow`
+requires `easyconfigs` and `base`, and takes `json`. It returns the
+same report as `stack shadow`. A shadow, or a recipe that does not
+parse, is a tool error. `eb_stack_arch` requires `easystack` and takes
 `arch`, `easyconfigs`, `installed`, `additional_arch`, `unsupported`,
 `probe_sources`, `probe_retries`, and `probe_timeout_s`. It returns the
 same report as `stack arch`, with `parse_failed` and `source_findings`,
 and a hit is a tool error. `probe_sources` probes the families `arch`
-names, as `--arch` does. `eb_stack_files` requires `easystack` and takes
+names, as `--arch` does. Two names are compared only with each other.
+`eb_stack_files` requires `easystack` and takes
 `easyconfigs`, `commit_tree`, `easyconfigs_repo`, `sourcepath`, and
 `path_map`. It returns the same report as `stack files`, and a missing
 file is a tool error. `eb_stack_cuda_cc` requires `easystack` and `easyconfigs`,
@@ -8071,10 +8158,74 @@ absolute path there.
 
 # Tools
 
-`tools/list` returns the workflows of `package`, `recipe`, `stack`,
-`target`, `campaign`, and `repro`, plus `pr-overlap`, `rebuild-set`,
-`component-reach`, and `easyblock-reach`. `eb_build_test` runs only
-when `EB_STACK_ALLOW_BUILD=1`.
+The catalog has 51 tools. `tools/list` returns one tool for each CLI
+command in the table, and the recipe and easyblock tools that have no
+command. `mcp` publishes that catalog and has no tool of its own. Each
+command's tool calls the same runner as that command. The `text` field
+of a successful result is that command's stdout. Each argument is a
+name in the schema `tools/list` returns. The
+[CLI reference](https://eb-stack.rgoswami.me/cli.html.md) records the flags.
+
+| Command | Tool |
+| --- | --- |
+| `package inspect` | `eb_package_inspect` |
+| `package plan` | `eb_package_plan` |
+| `package bump` | `eb_package_bump` |
+| `package latest` | `eb_package_latest` |
+| `recipe easyblock` | `eb_recipe_easyblock` |
+| `recipe templates` | `eb_recipe_templates` |
+| `recipe hierarchy` | `eb_recipe_hierarchy` |
+| `recipe check` | `eb_recipe_check` |
+| `recipe lint` | `eb_recipe_lint` |
+| `recipe format` | `eb_recipe_format` |
+| `stack solve` | `eb_stack_solve` |
+| `stack sbom` | `eb_stack_sbom` |
+| `stack order` | `eb_stack_order` |
+| `stack gap` | `eb_stack_gap` |
+| `stack provided` | `eb_stack_provided` |
+| `stack shadow` | `eb_stack_shadow` |
+| `stack batch` | `eb_stack_batch` |
+| `stack shard` | `eb_stack_shard` |
+| `stack easystack` | `eb_stack_easystack` |
+| `stack sections` | `eb_stack_sections` |
+| `stack from-commit` | `eb_stack_from_commit` |
+| `stack arch` | `eb_stack_arch` |
+| `stack files` | `eb_stack_files` |
+| `stack generation` | `eb_stack_generation` |
+| `stack cuda-cc` | `eb_stack_cuda_cc` |
+| `stack known-failures` | `eb_stack_known_failures` |
+| `stack oom` | `eb_stack_oom` |
+| `stack bot-classify` | `eb_stack_bot_classify` |
+| `target list` | `eb_target_list` |
+| `target doctor` | `eb_target_doctor` |
+| `campaign run` | `eb_campaign_run` |
+| `campaign status` | `eb_campaign_status` |
+| `campaign finding claim` | `eb_campaign_finding_claim` |
+| `campaign finding resolve` | `eb_campaign_finding_resolve` |
+| `repro summary` | `eb_repro_summary` |
+| `easyblock-reach` | `eb_easyblock_reach` |
+| `pr-overlap` | `eb_pr_overlap` |
+| `rebuild-set` | `eb_rebuild_set` |
+| `component-reach` | `eb_component_reach` |
+
+These tools edit files or run EasyBuild. They are not CLI commands.
+
+| Tool | Role |
+| --- | --- |
+| `eb_recipe_read` | Read one UTF-8 file inside the workspace root |
+| `eb_recipe_list` | List one directory inside the workspace root |
+| `eb_recipe_edit` | Replace an exact string in a workspace file |
+| `eb_recipe_apply_suggestion` | Apply a review suggestion to the lines it is anchored on |
+| `eb_recipe_diff` | Show what changed in each recipe since the server first saw it |
+| `eb_recipe_write` | Create or overwrite a UTF-8 file inside the workspace root |
+| `eb_recipe_grep` | Search workspace files for a literal, or a regular expression |
+| `eb_dep_versions` | List easyconfig versions of one dependency in a local tree |
+| `eb_module_lint` | Check Python modules that ship with recipes |
+| `eb_easyblock_dry_run` | Run `eb -x` and return the commands the easyblock generates |
+| `eb_build_log` | Read an EasyBuild log by step |
+| `eb_build_test` | Run a build |
+
+`eb_build_test` runs only when `EB_STACK_ALLOW_BUILD=1`.
 
 # Package bundle reference
 
@@ -9239,8 +9390,10 @@ solver selection, not a scan of installed software.
 
 One easyconfig path per line, in dependency order. A name EasyBuild
 installs twice lists both paths: another toolchain, a system bootstrap
-pair, or a build-only tool. `--oldest` changes which unpinned version is
-chosen; it does not change the file shape. When runtime requirements of
+pair, or a build-only tool. `--installed` leaves a listed module, and
+the dependencies that were installed with it, out of this file.
+`--oldest` changes which unpinned version is chosen; it does not change
+the file shape. When runtime requirements of
 one name at one toolchain have no version that satisfies every one of
 them, the command writes no file and exits 1. Standard error names each
 requester and the version it resolved. The file is not a place where a
@@ -9248,7 +9401,8 @@ pin is rewritten.
 
 Stdout names a co-installable repeated build as
 `multiple builds of <name>: <ver-tc>, ...` and ends with
-`order=<path> builds=<N>`.
+`order=<path> builds=<N>`. When `--installed` is set, the line before
+that is `installed=<N>`, how many listed modules the walk stopped at.
 
 # Input hashes (`--hashes-out`)
 
diff --git a/skills/mcp/SKILL.md b/skills/mcp/SKILL.md
index 57829367..216551dc 100644
--- a/skills/mcp/SKILL.md
+++ b/skills/mcp/SKILL.md
@@ -73,6 +73,7 @@ PY
 `tools/list` returns the catalog.
 This page does not keep a count.
 Read the names from that response.
+`docs/orgmode/reference/mcp.org` lists one tool for each CLI command.
 The names that mirror the commands above are `eb_package_inspect`, `eb_package_plan`, `eb_package_bump`, `eb_stack_sbom`, and `eb_pr_overlap`.
 Each package tool's input schema requires `toolchain` as `name/version`.
 Inspect and plan also accept `toolchain_version` alone and default the name to `foss`.
diff --git a/src/build_order.rs b/src/build_order.rs
index d3e75a76..6eb8baa0 100644
--- a/src/build_order.rs
+++ b/src/build_order.rs
@@ -602,6 +602,22 @@ pub fn build_graph(
     roots: &[String],
     choice: Choice,
 ) -> Result<BuildGraph, OrderError> {
+    Ok(build_graph_against_installed(candidates, roots, choice, &|_| false)?.0)
+}
+
+/// The build graph of `roots`, stopping at modules `is_installed` names.
+///
+/// The graph is the one [`build_graph`] would build for everything that
+/// still has to be built. An installed module is not a node: the robot
+/// does not rebuild it, and it does not rebuild what was installed with
+/// it. The set is those modules, in key order.
+#[allow(clippy::result_large_err)]
+pub fn build_graph_against_installed(
+    candidates: &[Candidate],
+    roots: &[String],
+    choice: Choice,
+    is_installed: &dyn Fn(&ModuleKey) -> bool,
+) -> Result<(BuildGraph, BTreeSet<ModuleKey>), OrderError> {
     let mut starts: Vec<ModuleKey> = Vec::new();
     for root in roots {
         let (name, version_req) = match root.split_once("==") {
@@ -643,7 +659,7 @@ pub fn build_graph(
         };
         starts.push(ModuleKey::of(start));
     }
-    graph_from_keys(candidates, &starts, choice)
+    graph_from_keys_against_installed(candidates, &starts, choice, is_installed)
 }
 
 /// The build graph reachable from modules named by their full identity.
@@ -658,8 +674,24 @@ pub fn graph_from_keys(
     starts: &[ModuleKey],
     choice: Choice,
 ) -> Result<BuildGraph, OrderError> {
+    Ok(graph_from_keys_against_installed(candidates, starts, choice, &|_| false)?.0)
+}
+
+/// [`graph_from_keys`], stopping at modules `is_installed` names.
+///
+/// An installed module is not added, and nothing it depends on is walked.
+/// The set is those modules, in key order. A predicate that is never true
+/// builds the same graph as [`graph_from_keys`].
+#[allow(clippy::result_large_err)]
+pub fn graph_from_keys_against_installed(
+    candidates: &[Candidate],
+    starts: &[ModuleKey],
+    choice: Choice,
+    is_installed: &dyn Fn(&ModuleKey) -> bool,
+) -> Result<(BuildGraph, BTreeSet<ModuleKey>), OrderError> {
     let mut graph: BuildGraph = DiGraph::new();
     let mut index: HashMap<ModuleKey, NodeIndex> = HashMap::new();
+    let mut stopped: BTreeSet<ModuleKey> = BTreeSet::new();
     let by_key: BTreeMap<ModuleKey, &Candidate> =
         candidates.iter().map(|c| (ModuleKey::of(c), c)).collect();
     let by_name = index_by_name(candidates);
@@ -674,6 +706,10 @@ pub fn graph_from_keys(
     };
     let mut queue: Vec<ModuleKey> = Vec::new();
     for key in starts {
+        if is_installed(key) {
+            stopped.insert(key.clone());
+            continue;
+        }
         node_for(&mut graph, &mut index, key);
         queue.push(key.clone());
     }
@@ -699,9 +735,13 @@ pub fn graph_from_keys(
             }) {
                 let tc_key = ModuleKey::of(tc);
                 if tc_key != key {
-                    let node = node_for(&mut graph, &mut index, &tc_key);
-                    graph.add_edge(node, dependent, Edge::Toolchain);
-                    queue.push(tc_key);
+                    if is_installed(&tc_key) {
+                        stopped.insert(tc_key);
+                    } else {
+                        let node = node_for(&mut graph, &mut index, &tc_key);
+                        graph.add_edge(node, dependent, Edge::Toolchain);
+                        queue.push(tc_key);
+                    }
                 }
             }
         }
@@ -738,12 +778,16 @@ pub fn graph_from_keys(
                 });
             };
             let dep_key = ModuleKey::of(picked);
+            if is_installed(&dep_key) {
+                stopped.insert(dep_key);
+                continue;
+            }
             let node = node_for(&mut graph, &mut index, &dep_key);
             graph.add_edge(node, dependent, kind);
             queue.push(dep_key);
         }
     }
-    Ok(graph)
+    Ok((graph, stopped))
 }
 
 /// The build graph reachable from `starts`, including modules that are already
@@ -1240,9 +1284,42 @@ pub fn build_order(
     roots: &[String],
     choice: Choice,
 ) -> Result<Vec<Candidate>, OrderError> {
-    let graph = build_graph(candidates, roots, choice)?;
+    Ok(build_order_against_installed(candidates, roots, choice, &|_| false)?.order)
+}
+
+/// What still has to be built once modules already on the machine are leaves.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct OrderAgainstInstalled {
+    /// Modules that are not installed, dependencies first.
+    pub order: Vec<Candidate>,
+    /// Installed modules the walk stopped at, in key order.
+    ///
+    /// A module is here when a root or a dependency resolved to it and the
+    /// predicate said it was installed. Its own dependencies are not walked
+    /// and are not listed.
+    pub installed: Vec<ModuleKey>,
+}
+
+/// [`build_order`] against an installed module list.
+///
+/// `is_installed` is the robot's view of the machine: a module it names is
+/// left out of the order, and so is everything reachable only through it.
+/// Resolution is otherwise the same walk, including the synthetic GCC-family
+/// hierarchy and the refusal of two runtime versions in one toolchain.
+/// A predicate that is never true returns the same order as [`build_order`]
+/// and an empty `installed` list.
+#[allow(clippy::result_large_err)]
+pub fn build_order_against_installed(
+    candidates: &[Candidate],
+    roots: &[String],
+    choice: Choice,
+    is_installed: &dyn Fn(&ModuleKey) -> bool,
+) -> Result<OrderAgainstInstalled, OrderError> {
+    let (graph, stopped) = build_graph_against_installed(candidates, roots, choice, is_installed)?;
     // Refuse before sorting. A closure `stack solve` cannot install is not
-    // an order, even when the graph itself is acyclic.
+    // an order, even when the graph itself is acyclic. Installed modules
+    // are not in the graph, so a disagreement that lives only under one
+    // of them is not a disagreement about what this order builds.
     refuse_disjoint_runtime_versions(&graph, candidates, choice)?;
     let by_key: BTreeMap<ModuleKey, &Candidate> =
         candidates.iter().map(|c| (ModuleKey::of(c), c)).collect();
@@ -1258,10 +1335,13 @@ pub fn build_order(
         OrderError::Cycle(guilty.into_iter().map(|n| graph[n].clone()).collect())
     })?;
 
-    Ok(sorted
-        .into_iter()
-        .filter_map(|node| by_key.get(&graph[node]).map(|c| (*c).clone()))
-        .collect())
+    Ok(OrderAgainstInstalled {
+        order: sorted
+            .into_iter()
+            .filter_map(|node| by_key.get(&graph[node]).map(|c| (*c).clone()))
+            .collect(),
+        installed: stopped.into_iter().collect(),
+    })
 }
 
 /// Which edges would break the cycles in a graph, if any.
@@ -2149,4 +2229,109 @@ mod tests {
             .iter()
             .any(|item| item.requirement.contains("Missing")));
     }
+
+    /// `recipe hierarchy --export` describes this rule instead of enumerating
+    /// versions: GCC admits system and the same-version GCCcore, and no other
+    /// generation. A version that is not a fixture has to follow that rule or
+    /// the order either fails or pulls an unrelated build.
+    #[test]
+    fn a_gcc_recipe_uses_the_synthetic_gcc_family_hierarchy() {
+        let all = vec![
+            candidate("GCCcore", "9.9.9", tc("system", ""), vec![]),
+            candidate("GCC", "9.9.9", tc("GCCcore", "9.9.9"), vec![]),
+            candidate("Lib", "1.0", tc("GCCcore", "9.9.9"), vec![]),
+            candidate("Lib", "1.0", tc("GCCcore", "8.0.0"), vec![]),
+            candidate("Lib", "1.0", tc("foss", "2026.1"), vec![]),
+            candidate(
+                "App",
+                "1.0",
+                tc("GCC", "9.9.9"),
+                vec![dep("Lib", "==1.0", None)],
+            ),
+        ];
+        let order = build_order(&all, &["App".into()], Choice::Newest).expect("order");
+        let listed = names(&order);
+        assert!(
+            listed.iter().any(|name| name == "Lib-1.0-GCCcore-9.9.9"),
+            "{listed:?}"
+        );
+        assert!(
+            listed
+                .iter()
+                .all(|name| !name.contains("8.0.0") && !name.contains("foss-2026.1")),
+            "{listed:?}"
+        );
+        let at = |needle: &str| {
+            listed
+                .iter()
+                .position(|name| name == needle)
+                .unwrap_or_else(|| panic!("{needle} missing from {listed:?}"))
+        };
+        assert!(at("GCCcore-9.9.9-system") < at("GCC-9.9.9-GCCcore-9.9.9"));
+        assert!(at("GCC-9.9.9-GCCcore-9.9.9") < at("App-1.0-GCC-9.9.9"));
+        assert!(at("Lib-1.0-GCCcore-9.9.9") < at("App-1.0-GCC-9.9.9"));
+    }
+
+    #[test]
+    fn an_installed_module_is_a_leaf_and_its_dependencies_stay_out() {
+        let base = candidate("Base", "1.0", tc("foss", "2026.1"), vec![]);
+        let mid = candidate(
+            "Mid",
+            "1.0",
+            tc("foss", "2026.1"),
+            vec![dep("Base", "==1.0", None)],
+        );
+        let app = candidate(
+            "App",
+            "1.0",
+            tc("foss", "2026.1"),
+            vec![dep("Mid", "==1.0", None), dep("Side", "==1.0", None)],
+        );
+        let side = candidate("Side", "1.0", tc("foss", "2026.1"), vec![]);
+        let all = vec![base, mid, app, side];
+        let installed = |key: &ModuleKey| key.name == "Mid";
+        let report =
+            build_order_against_installed(&all, &["App".into()], Choice::Newest, &installed)
+                .expect("order");
+        let listed = names(&report.order);
+        assert!(
+            listed.iter().any(|name| name.starts_with("Side-"))
+                && listed.iter().any(|name| name.starts_with("App-")),
+            "{listed:?}"
+        );
+        assert!(
+            listed
+                .iter()
+                .all(|name| !name.starts_with("Mid-") && !name.starts_with("Base-")),
+            "{listed:?}"
+        );
+        let side = listed
+            .iter()
+            .position(|name| name.starts_with("Side-"))
+            .unwrap();
+        let app_at = listed
+            .iter()
+            .position(|name| name.starts_with("App-"))
+            .unwrap();
+        assert!(side < app_at, "{listed:?}");
+        assert_eq!(
+            report
+                .installed
+                .iter()
+                .map(|key| key.name.as_str())
+                .collect::<Vec<_>>(),
+            vec!["Mid"]
+        );
+
+        let root_installed = |key: &ModuleKey| key.name == "App";
+        let empty =
+            build_order_against_installed(&all, &["App".into()], Choice::Newest, &root_installed)
+                .expect("installed root");
+        assert!(empty.order.is_empty(), "{:?}", names(&empty.order));
+        assert_eq!(empty.installed.len(), 1);
+
+        let plain = build_order(&all, &["App".into()], Choice::Newest).expect("plain");
+        assert!(names(&plain).iter().any(|name| name.starts_with("Base-")));
+        assert!(names(&plain).iter().any(|name| name.starts_with("Mid-")));
+    }
 }
diff --git a/src/main.rs b/src/main.rs
index 98b67c84..6e0b1d52 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1140,6 +1140,13 @@ enum StackCommand {
         /// reads it.
         #[arg(long, value_delimiter = ',')]
         filter_deps: Vec<String>,
+        /// Installed modules. A file is `module -t avail`, `module spider -t`,
+        /// or `Name/version`. A directory is an Lmod tree, read the same way
+        /// as `stack gap --installed`. The version is the full module version
+        /// (`1.3.1-GCCcore-15.2.0`). A listed module is left out of the order,
+        /// and so are the dependencies that were installed with it. Repeatable.
+        #[arg(long = "installed")]
+        installed: Vec<PathBuf>,
     },
     /// What a site provides that a stack lacks, and the recipe that closes it.
     ///
@@ -1364,7 +1371,8 @@ enum StackCommand {
         /// ranged GET fallback) against every resolved source URL in the plan.
         /// A source no probed family can fetch is `unreachable`. A source
         /// another probed family can fetch is `arch-missing`, so one
-        /// `--arch` reports a missing source as `unreachable`.
+        /// `--arch` reports a missing source as `unreachable`. Two
+        /// `--arch` values compare only that pair.
         #[arg(long = "probe-sources")]
         probe_sources: bool,
         /// Extra attempts after the first source probe request.
@@ -2922,6 +2930,7 @@ fn run_stack(command: StackCommand) -> Result<()> {
             easystack_out,
             hashes_out,
             filter_deps,
+            installed,
         } => {
             let report =
                 eb_stack::workflows::stack_order(&eb_stack::workflows::StackOrderRequest {
@@ -2932,6 +2941,7 @@ fn run_stack(command: StackCommand) -> Result<()> {
                     easystack_out,
                     hashes_out,
                     filter_deps,
+                    installed,
                 })?;
             print!("{}", report.stdout);
             Ok(())
diff --git a/src/mcp.rs b/src/mcp.rs
index 8a7397d6..cc61f7c5 100644
--- a/src/mcp.rs
+++ b/src/mcp.rs
@@ -355,7 +355,7 @@ fn tool_catalog() -> Vec<Value> {
         ),
         tool_with_optional(
             "eb_stack_order",
-            "Order every pinned build a set of roots needs, and write the same order, easystack, and hash files as `stack order`.",
+            "Order every pinned build a set of roots needs, and write the same order, easystack, and hash files as `stack order`. filter_deps drops dependencies the way --filter-deps does. installed is a module list or an Lmod tree; a module it names is left out of the order, and so are the dependencies that were installed with it.",
             &[("easyconfigs", "array"), ("root", "array")],
             &[
                 ("out", "string"),
@@ -363,6 +363,7 @@ fn tool_catalog() -> Vec<Value> {
                 ("easystack_out", "string"),
                 ("hashes_out", "string"),
                 ("filter_deps", "array"),
+                ("installed", "array"),
             ],
         ),
         tool_with_optional(
@@ -475,7 +476,7 @@ fn tool_catalog() -> Vec<Value> {
         ),
         tool_with_optional(
             "eb_stack_arch",
-            "Refuse a plan an architecture cannot build, as `stack arch` does. Every easyconfig named in the plan is parsed per architecture, so an ARCH-conditional parse failure is reported before a build. An entry in the unsupported list fails the plan when the easystack names it or a dependency closes over it. With installed, an entry that architecture has never installed, and that is not in additional_arch, is flagged. With probe_sources, source_urls and sources are resolved on each arch family (x86_64, aarch64, and riscv64 when arch is absent) and probed by HEAD with ranged GET fallback. A source no probed family can fetch is unreachable; one another probed family can fetch is arch-missing.",
+            "Refuse a plan an architecture cannot build, as `stack arch` does. Every easyconfig named in the plan is parsed per architecture, so an ARCH-conditional parse failure is reported before a build. An entry in the unsupported list fails the plan when the easystack names it or a dependency closes over it. With installed, an entry that architecture has never installed, and that is not in additional_arch, is flagged. With probe_sources, source_urls and sources are resolved on each arch family (x86_64, aarch64, and riscv64 when arch is absent) and probed by HEAD with ranged GET fallback. A source no probed family can fetch is unreachable; one another probed family can fetch is arch-missing. Two arch values compare only that pair.",
             &[("easystack", "array_min1")],
             &[
                 ("arch", "array"),
@@ -2991,6 +2992,7 @@ fn stack_order_tool(arguments: &Value) -> Result<Value, String> {
         easystack_out: optional_path(arguments, "easystack_out"),
         hashes_out: optional_path(arguments, "hashes_out"),
         filter_deps: filter_dep_specs(arguments)?,
+        installed: optional_paths(arguments, "installed")?,
     })
     .map_err(workflow_error)?;
     let multiple = report
@@ -3012,6 +3014,7 @@ fn stack_order_tool(arguments: &Value) -> Result<Value, String> {
         "multiple": multiple,
         "easystack": report.easystack,
         "hashes": hashes,
+        "installed": report.installed_modules,
     }))
 }
 
diff --git a/src/workflows.rs b/src/workflows.rs
index 31bc411a..e712b841 100644
--- a/src/workflows.rs
+++ b/src/workflows.rs
@@ -17,7 +17,7 @@ use crate::{
 };
 use anyhow::{bail, Context, Result};
 use serde_json::Value;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
 
 /// Default `--out` for `stack order`.
@@ -126,6 +126,8 @@ pub struct StackOrderRequest {
     ///
     /// Empty means read `EASYBUILD_FILTER_DEPS`.
     pub filter_deps: Vec<String>,
+    /// Installed-module lists or Lmod trees. A module they name is a leaf.
+    pub installed: Vec<PathBuf>,
 }
 
 /// Hash file `stack order --hashes-out` wrote.
@@ -152,6 +154,10 @@ pub struct StackOrderReport {
     pub easystack: Option<PathBuf>,
     /// Hash-file summary when one was written.
     pub hashes: Option<StackOrderHashes>,
+    /// Installed modules the walk stopped at, when `--installed` was given.
+    ///
+    /// `None` when the command was not asked to read an installed list.
+    pub installed_modules: Option<usize>,
 }
 
 /// Order the builds `roots` need and write the files the CLI writes.
@@ -177,8 +183,25 @@ pub fn stack_order(request: &StackOrderRequest) -> Result<StackOrderReport> {
     let mut candidates = parsed.candidates;
     let specs = crate::dep_filter::specs_from_cli_or_env(&request.filter_deps);
     filter_deps(&mut candidates, &specs)?;
-    let order = build_order::build_order(&candidates, &request.roots, choice)
-        .map_err(|error| anyhow::anyhow!("{error}"))?;
+    // `--filter-deps` runs first, so a filtered dependency is gone before
+    // the installed list is consulted and is not counted as a leaf.
+    // The walk that remains uses the same hierarchy as `build_order`,
+    // including the synthetic GCC-family rule `recipe hierarchy --export`
+    // describes.
+    let installed_names = if request.installed.is_empty() {
+        None
+    } else {
+        Some(installed_module_names(&request.installed)?)
+    };
+    let stop = |key: &ModuleKey| {
+        installed_names
+            .as_ref()
+            .is_some_and(|names| names.contains(&build_order::module_name(key)))
+    };
+    let ordered =
+        build_order::build_order_against_installed(&candidates, &request.roots, choice, &stop)
+            .map_err(|error| anyhow::anyhow!("{error}"))?;
+    let order = ordered.order;
     std::fs::write(&request.out, build_order::format_order(&order))?;
     let multi = build_order::multi_build_names(&order);
     let multiple: Vec<(String, Vec<String>)> = multi
@@ -207,8 +230,9 @@ pub fn stack_order(request: &StackOrderRequest) -> Result<StackOrderReport> {
     }
 
     let hashes = if let Some(path) = request.hashes_out.as_deref() {
-        let graph = build_order::build_graph(&candidates, &request.roots, choice)
-            .map_err(|error| anyhow::anyhow!("{error}"))?;
+        let (graph, _) =
+            build_order::build_graph_against_installed(&candidates, &request.roots, choice, &stop)
+                .map_err(|error| anyhow::anyhow!("{error}"))?;
         let sequence: Vec<ModuleKey> = order.iter().map(ModuleKey::of).collect();
         let recipe_paths: BTreeMap<ModuleKey, String> = order
             .iter()
@@ -238,6 +262,9 @@ pub fn stack_order(request: &StackOrderRequest) -> Result<StackOrderReport> {
         None
     };
 
+    if installed_names.is_some() {
+        stdout.push_str(&format!("installed={}\n", ordered.installed.len()));
+    }
     stdout.push_str(&format!(
         "order={} builds={}\n",
         request.out.display(),
@@ -250,9 +277,28 @@ pub fn stack_order(request: &StackOrderRequest) -> Result<StackOrderReport> {
         multiple,
         easystack: request.easystack_out.clone(),
         hashes,
+        installed_modules: installed_names.as_ref().map(|_| ordered.installed.len()),
     })
 }
 
+/// Module strings an installed list or Lmod tree names, `Name/version`.
+///
+/// The version is the full module version. A bare name has no version and
+/// matches nothing: it does not mark every build of that name installed.
+fn installed_module_names(paths: &[PathBuf]) -> Result<BTreeSet<String>> {
+    let mut names = BTreeSet::new();
+    for path in paths {
+        let inventory = crate::gap::inventory_from_module_source(path)
+            .with_context(|| format!("--installed {}", path.display()))?;
+        for (name, versions) in inventory {
+            for version in versions {
+                names.insert(format!("{name}/{version}"));
+            }
+        }
+    }
+    Ok(names)
+}
+
 /// Arguments for `stack easystack`.
 pub struct StackEasystackRequest {
     /// Stack lock JSON written by `stack solve`.
diff --git a/tests/doc_walkthrough.rs b/tests/doc_walkthrough.rs
index bbccde07..6ab280fc 100644
--- a/tests/doc_walkthrough.rs
+++ b/tests/doc_walkthrough.rs
@@ -510,7 +510,7 @@ fn kaleido_server() -> (String, std::thread::JoinHandle<()>, std::net::SocketAdd
 
 /// `arch-unsupported.org` quotes the source-probe output with the server
 /// address written as the fixture's `__BASE_URL__`: first with no `--arch`,
-/// then with `--arch aarch64`.
+/// then with `--arch aarch64`, then with `--arch x86_64 --arch aarch64`.
 #[test]
 fn the_source_probe_howto_quotes_the_output_it_prints() {
     use std::io::Write;
@@ -554,6 +554,7 @@ fn the_source_probe_howto_quotes_the_output_it_prints() {
     };
     let every_arch = probe(&[]);
     let aarch64 = probe(&["aarch64"]);
+    let two = probe(&["x86_64", "aarch64"]);
     if let Ok(mut stop) = std::net::TcpStream::connect(addr) {
         let _ = stop.write_all(b"STOP / HTTP/1.1\r\n\r\n");
     }
@@ -569,12 +570,13 @@ fn the_source_probe_howto_quotes_the_output_it_prints() {
         "{section}"
     );
     assert!(section.contains("  --arch aarch64 \\\n"), "{section}");
+    assert!(section.contains("  --arch x86_64 \\\n"), "{section}");
     let quoted: Vec<&str> = section
         .split("#+begin_example\n")
         .skip(1)
         .filter_map(|rest| rest.split("#+end_example").next())
         .collect();
-    assert_eq!(quoted.len(), 2, "{section}");
+    assert_eq!(quoted.len(), 3, "{section}");
     assert_eq!(
         quoted[0], every_arch,
         "page:\n{}\nstdout:\n{every_arch}",
@@ -585,6 +587,7 @@ fn the_source_probe_howto_quotes_the_output_it_prints() {
         "page:\n{}\nstdout:\n{aarch64}",
         quoted[1]
     );
+    assert_eq!(quoted[2], two, "page:\n{}\nstdout:\n{two}", quoted[2]);
     assert!(quoted.iter().all(|text| !text.contains("127.0.0.1")));
 }
 
diff --git a/tests/fetch_prs_script.rs b/tests/fetch_prs_script.rs
index 39d0bb97..ba078389 100644
--- a/tests/fetch_prs_script.rs
+++ b/tests/fetch_prs_script.rs
@@ -1,8 +1,9 @@
 //! Regression checks for the fetch-prs.sh scripts under examples/.
 //!
 //! The easyconfigs script should rewrite outputs to only the currently open
-//! pull requests when rerun in the same output directory. The EESSI script
-//! should read every page of open pull requests, not stop at a fixed limit.
+//! pull requests when rerun in the same output directory. Both scripts should
+//! read every page of open pull requests, including a repository with more
+//! than 500, and page a changed-file list through GitHub's 3000-file cap.
 
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -165,16 +166,16 @@ for arg in "$@"; do
     repos/*) url="$arg" ;;
   esac
 done
+page=$(sed -n 's/.*[?&]page=\([0-9][0-9]*\).*/\1/p' <<<"$url")
+[[ -n "$page" ]] || page=1
 if [[ "$url" == *"/pulls?state=open&per_page=100"* ]]; then
-  cat "${MOCK_OPEN_JSONL:?}"
+  if [[ "$page" == 1 ]]; then cat "${MOCK_OPEN_JSONL:?}"; fi
   exit 0
 fi
-if [[ "$url" == *"/pulls/1/files"* ]]; then
-  printf '%s\n' "easybuild/easyconfigs/l/Lib/Lib-1.0.eb"
-  exit 0
-fi
-if [[ "$url" == *"/pulls/2/files"* ]]; then
-  printf '%s\n' "easybuild/easyconfigs/l/Lib/Lib-1.0.eb"
+if [[ "$url" == *"/pulls/1/files"* || "$url" == *"/pulls/2/files"* ]]; then
+  if [[ "$page" == 1 ]]; then
+    printf '%s\n' "easybuild/easyconfigs/l/Lib/Lib-1.0.eb"
+  fi
   exit 0
 fi
 echo "unexpected gh api request: $url" >&2
@@ -328,11 +329,11 @@ fn eessi_fetch_reads_every_page_of_open_pull_requests() {
     write(&page2, &pulls_page(101..=102, sha_of));
     let errors = root.join("gh-errors.log");
 
-    // A stand-in for gh: `api` only, one open-pulls URL, the files of pull
-    // requests 1 to 102, and the easyblocks commit PR 102 pins. The pages are GitHub's raw shape and --jq is
-    // applied per page, as gh does. Without --paginate it serves page 1
-    // only. Every refusal is also logged, because a gh call inside a
-    // process substitution cannot fail the script.
+    // A stand-in for gh: `api` only, one open-pulls page per request, the
+    // files of pull requests 1 and 102, and the easyblocks commit PR 102
+    // pins. The pages are GitHub's raw shape and --jq is applied per page,
+    // as gh does. A page the fixture does not have is an empty array.
+    // Every refusal is also logged.
     let mock_gh = mock_bin.join("gh");
     write_executable(
         &mock_gh,
@@ -355,24 +356,31 @@ while [[ $# -gt 0 ]]; do
   esac
   shift
 done
-pages=()
+page_n=$(sed -n 's/.*[?&]page=\([0-9][0-9]*\).*/\1/p' <<<"$url")
+[[ -n "$page_n" ]] || page_n=1
 case "$url" in
-  "repos/EESSI/software-layer/pulls?state=open&per_page=100")
-    pages=("${MOCK_PAGE1:?}")
-    [[ $paginate -eq 1 ]] && pages+=("${MOCK_PAGE2:?}")
-    for page in "${pages[@]}"; do
-      if [[ -n "$filter" ]]; then jq -c "$filter" "$page"; else cat "$page"; fi
-    done
+  *"/pulls?state=open&per_page=100"*)
+    file=""
+    case "$page_n" in
+      1) file="${MOCK_PAGE1:?}" ;;
+      2) file="${MOCK_PAGE2:-}" ;;
+    esac
+    if [[ -n "$file" && -f "$file" ]]; then
+      if [[ -n "$filter" ]]; then jq -c "$filter" "$file"; else cat "$file"; fi
+    else
+      if [[ -n "$filter" ]]; then echo '[]' | jq -c "$filter"; else echo '[]'; fi
+    fi
     ;;
-  repos/EESSI/software-layer/pulls/1/files|repos/EESSI/software-layer/pulls/102/files)
-    printf '%s\n' "${MOCK_STACK:?}"
+  repos/EESSI/software-layer/pulls/1/files*|repos/EESSI/software-layer/pulls/102/files*)
+    if [[ "$page_n" == 1 ]]; then printf '%s\n' "${MOCK_STACK:?}"; fi
     ;;
   repos/easybuilders/easybuild-easyblocks/commits/2222222222222222222222222222222222222222)
     printf '%s\n' easybuild/easyblocks/p/pkg.py
     ;;
-  repos/EESSI/software-layer/pulls/*/files)
+  repos/EESSI/software-layer/pulls/*/files*)
     number=${url#repos/EESSI/software-layer/pulls/}
-    number=${number%/files}
+    number=${number%%/*}
+    number=${number%%\?*}
     [[ "$number" =~ ^[0-9]+$ && $number -ge 2 && $number -le 101 ]] \
       || refuse "unexpected pull request: $url"
     ;;
@@ -535,13 +543,20 @@ while [[ $# -gt 0 ]]; do
   esac
   shift
 done
+page_n=$(sed -n 's/.*[?&]page=\([0-9][0-9]*\).*/\1/p' <<<"$url")
+[[ -n "$page_n" ]] || page_n=1
 case "$url" in
-  *"/pulls?state=open&per_page=100")
-    if [[ -n "$filter" ]]; then jq -c "$filter" "${MOCK_PAGE:?}"; else cat "${MOCK_PAGE:?}"; fi ;;
+  *"/pulls?state=open&per_page=100"*)
+    if [[ "$page_n" == 1 ]]; then
+      if [[ -n "$filter" ]]; then jq -c "$filter" "${MOCK_PAGE:?}"; else cat "${MOCK_PAGE:?}"; fi
+    else
+      if [[ -n "$filter" ]]; then echo '[]' | jq -c "$filter"; else echo '[]'; fi
+    fi
+    ;;
   repos/easybuilders/easybuild-easyblocks/commits/*)
     printf '%s\n' easybuild/easyblocks/p/pkg.py ;;
-  */pulls/*/files)
-    printf '%s\n' "${MOCK_STACK:?}" ;;
+  */pulls/*/files*)
+    if [[ "$page_n" == 1 ]]; then printf '%s\n' "${MOCK_STACK:?}"; fi ;;
   *) echo "unexpected url: $url" >&2; exit 1 ;;
 esac
 "#,
@@ -825,3 +840,459 @@ fn easyconfigs_fetch_refuses_an_empty_out_dir_before_deleting() {
         "stderr missing usage guard:\n{stderr}"
     );
 }
+
+fn write_open_pages(root: &Path, heads: &std::collections::BTreeMap<u64, String>, last: u64) {
+    let sha_of = |n: u64| {
+        heads
+            .get(&n)
+            .cloned()
+            .unwrap_or_else(|| format!("{n:040x}"))
+    };
+    let pages = last.div_ceil(100);
+    for page in 1..=pages {
+        let start = (page - 1) * 100 + 1;
+        let end = std::cmp::min(page * 100, last);
+        write(
+            &root.join(format!("page{page}.json")),
+            &pulls_page(start..=end, sha_of),
+        );
+    }
+}
+
+/// Open pull requests are served one page at a time from `$MOCK_ROOT/pageN.json`.
+/// Changed-file pages for `$MOCK_KEEP` print `$MOCK_PATH` on page 1 only.
+/// Every other pull request has an empty file list. A missing page is `[]`.
+fn write_paged_open_mock(mock_bin: &Path) {
+    write_executable(
+        &mock_bin.join("gh"),
+        r#"#!/usr/bin/env bash
+set -euo pipefail
+[[ "${1:-}" == api ]] || { echo "unexpected: gh $*" >&2; exit 1; }
+shift
+url="" filter=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --method) shift ;;
+    --paginate) ;;
+    --jq) shift; filter=$1 ;;
+    repos/*) url=$1 ;;
+    *) echo "unexpected arg: $1" >&2; exit 1 ;;
+  esac
+  shift
+done
+page_n=$(sed -n 's/.*[?&]page=\([0-9][0-9]*\).*/\1/p' <<<"$url")
+[[ -n "$page_n" ]] || page_n=1
+case "$url" in
+  *"/pulls?state=open&per_page=100"*)
+    file="${MOCK_ROOT:?}/page${page_n}.json"
+    if [[ -f "$file" ]]; then
+      if [[ -n "$filter" ]]; then jq -c "$filter" "$file"; else cat "$file"; fi
+    else
+      if [[ -n "$filter" ]]; then echo '[]' | jq -c "$filter"; else echo '[]'; fi
+    fi
+    ;;
+  */pulls/"${MOCK_KEEP:?}"/files*)
+    if [[ "$page_n" == 1 ]]; then printf '%s\n' "${MOCK_PATH:?}"; fi
+    ;;
+  */pulls/*/files*) ;;
+  *) echo "unexpected url: $url" >&2; exit 1 ;;
+esac
+"#,
+    )
+    .expect("write paged open mock");
+}
+
+/// 501 open pull requests, one per number. Only 501, on page 6, changes an
+/// easyconfig. A walk that stopped at 500 would leave `prs/` empty.
+#[test]
+fn easyconfigs_fetch_reads_open_pull_requests_past_five_hundred() {
+    let temp = tempfile::tempdir().expect("tempdir");
+    let root = temp.path();
+    let origin = root.join("origin.git");
+    let seed = root.join("seed");
+    let clone = root.join("clone");
+    let out = root.join("out");
+    let mock_bin = root.join("mock-bin");
+    fs::create_dir_all(&mock_bin).expect("mock bin");
+
+    assert_ok(
+        &run(
+            "git",
+            &["init", "--bare", origin.to_str().expect("origin utf-8")],
+            root,
+            &[],
+        ),
+        "init bare origin",
+    );
+    fs::create_dir_all(&seed).expect("seed dir");
+    assert_ok(&run("git", &["init"], &seed, &[]), "init seed");
+    git(&seed, &["config", "user.name", "Fixture"]);
+    git(&seed, &["config", "user.email", "fixture@example.invalid"]);
+    write(
+        &seed.join("easybuild/easyconfigs/l/Lib/Lib-1.0.eb"),
+        "name = 'Lib'\nversion = '1.0'\n",
+    );
+    git(&seed, &["add", "."]);
+    git(&seed, &["commit", "-m", "seed develop"]);
+    git(&seed, &["branch", "-M", "develop"]);
+    git(
+        &seed,
+        &[
+            "remote",
+            "add",
+            "origin",
+            origin.to_str().expect("origin utf-8"),
+        ],
+    );
+    git(&seed, &["push", "-u", "origin", "develop"]);
+    let sha = make_pr_head(
+        &seed,
+        "pr501",
+        501,
+        "name = 'Lib'\nversion = '1.0'\n# pr501\n",
+    );
+    git(&seed, &["checkout", "develop"]);
+    assert_ok(
+        &run(
+            "git",
+            &[
+                "clone",
+                origin.to_str().expect("origin utf-8"),
+                clone.to_str().expect("clone utf-8"),
+            ],
+            root,
+            &[],
+        ),
+        "clone fixture",
+    );
+    git(&clone, &["checkout", "develop"]);
+
+    let mut heads = std::collections::BTreeMap::new();
+    heads.insert(501, sha.clone());
+    write_open_pages(root, &heads, 501);
+    write_paged_open_mock(&mock_bin);
+    let path = format!(
+        "{}:{}",
+        mock_bin.display(),
+        std::env::var("PATH").expect("PATH")
+    );
+    let script = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("examples/easyconfigs-pr-overlap/fetch-prs.sh");
+    let ec = "easybuild/easyconfigs/l/Lib/Lib-1.0.eb";
+    let output = run(
+        "bash",
+        &[
+            script.to_str().expect("script utf-8"),
+            "acme/repo",
+            out.to_str().expect("out utf-8"),
+        ],
+        &clone,
+        &[
+            ("PATH", path.as_str()),
+            ("MOCK_ROOT", root.to_str().expect("root utf-8")),
+            ("MOCK_KEEP", "501"),
+            ("MOCK_PATH", ec),
+        ],
+    );
+    assert_ok(&output, "easyconfigs fetch past 500");
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(
+        stdout.lines().any(|line| line == "open pull requests: 501"),
+        "stdout:\n{stdout}"
+    );
+    assert_eq!(json_files(&out.join("prs")), ["501.json"]);
+    let doc: serde_json::Value =
+        serde_json::from_str(&fs::read_to_string(out.join("prs/501.json")).expect("read 501"))
+            .expect("501 json");
+    assert_eq!(doc["number"], 501);
+    assert_eq!(doc["head_sha"], sha);
+    assert_eq!(doc["easyconfigs"][0]["path"], ec);
+    assert!(doc["easyconfigs"][0]["head"]
+        .as_str()
+        .expect("head")
+        .contains("# pr501"));
+    assert!(doc.get("file_list_truncated").is_none());
+}
+
+/// 501 open pull requests. Only 501, on page 6, changes an easystack.
+#[test]
+fn eessi_fetch_reads_open_pull_requests_past_five_hundred() {
+    let temp = tempfile::tempdir().expect("tempdir");
+    let root = temp.path();
+    let clone = root.join("clone");
+    let out = root.join("out");
+    let mock_bin = root.join("mock-bin");
+    fs::create_dir_all(&mock_bin).expect("mock bin");
+    let body = "easyconfigs:\n  - zlib-1.3.1-GCCcore-15.2.0.eb\n  - Pkg501-1.0-GCCcore-15.2.0.eb\n";
+    let heads = eessi_seed_and_clone(root, &[(501, body.to_string())]);
+    write_open_pages(root, &heads, 501);
+    write_paged_open_mock(&mock_bin);
+    let path = format!(
+        "{}:{}",
+        mock_bin.display(),
+        std::env::var("PATH").expect("PATH")
+    );
+    let output = run(
+        "bash",
+        &[
+            eessi_script().to_str().expect("script utf-8"),
+            "EESSI/software-layer",
+            "2026.06",
+            out.to_str().expect("out utf-8"),
+        ],
+        &clone,
+        &[
+            ("PATH", path.as_str()),
+            ("MOCK_ROOT", root.to_str().expect("root utf-8")),
+            ("MOCK_KEEP", "501"),
+            ("MOCK_PATH", EESSI_STACK),
+        ],
+    );
+    assert_ok(&output, "eessi fetch past 500");
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(
+        stdout.lines().any(|line| line == "open pull requests: 501"),
+        "stdout:\n{stdout}"
+    );
+    assert_eq!(json_files(&out.join("prs")), ["501.json"]);
+    let doc: serde_json::Value =
+        serde_json::from_str(&fs::read_to_string(out.join("prs/501.json")).expect("read 501"))
+            .expect("501 json");
+    assert_eq!(doc["number"], 501);
+    assert_eq!(doc["head_sha"], heads[&501]);
+    assert_eq!(doc["easystacks"][0]["path"], EESSI_STACK);
+    assert!(doc["easystacks"][0]["head"]
+        .as_str()
+        .expect("head")
+        .contains("Pkg501-1.0-GCCcore-15.2.0.eb"));
+    assert!(doc.get("file_list_truncated").is_none());
+}
+
+/// Changed files are one page of 100 at a time.
+///
+/// Pull request 8's easyconfig is the 501st file (page 6). Pull request 9's
+/// list answers 422 on the page after 3000 files; the pull request is kept
+/// and `file_list_truncated` is set.
+fn write_file_page_mock(mock_bin: &Path, interesting: &str) {
+    let script = format!(
+        r#"#!/usr/bin/env bash
+set -euo pipefail
+[[ "${{1:-}}" == api ]] || {{ echo "unexpected: gh $*" >&2; exit 1; }}
+shift
+url="" filter=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --method) shift ;;
+    --paginate) ;;
+    --jq) shift; filter=$1 ;;
+    repos/*) url=$1 ;;
+    *) echo "unexpected arg: $1" >&2; exit 1 ;;
+  esac
+  shift
+done
+page_n=$(sed -n 's/.*[?&]page=\([0-9][0-9]*\).*/\1/p' <<<"$url")
+[[ -n "$page_n" ]] || page_n=1
+interesting={interesting:?}
+emit_fill() {{
+  local n=$1
+  local i
+  for ((i=0; i<n; i++)); do
+    printf '%s\n' "notes/p${{page_n}}-${{i}}.txt"
+  done
+}}
+case "$url" in
+  *"/pulls?state=open&per_page=100"*)
+    file="${{MOCK_ROOT:?}}/page${{page_n}}.json"
+    if [[ -f "$file" ]]; then
+      if [[ -n "$filter" ]]; then jq -c "$filter" "$file"; else cat "$file"; fi
+    else
+      if [[ -n "$filter" ]]; then echo '[]' | jq -c "$filter"; else echo '[]'; fi
+    fi
+    ;;
+  */pulls/8/files*)
+    if (( page_n >= 1 && page_n <= 5 )); then emit_fill 100
+    elif (( page_n == 6 )); then emit_fill 99; printf '%s\n' "$interesting"
+    fi
+    ;;
+  */pulls/9/files*)
+    if (( page_n == 1 )); then
+      printf '%s\n' "$interesting"
+      emit_fill 99
+    elif (( page_n >= 2 && page_n <= 30 )); then emit_fill 100
+    elif (( page_n == 31 )); then
+      echo "gh: pagination is limited for this resource. Responses include a maximum of 3000 files. (HTTP 422)" >&2
+      exit 1
+    fi
+    ;;
+  */pulls/*/files*) ;;
+  *) echo "unexpected url: $url" >&2; exit 1 ;;
+esac
+"#,
+        interesting = interesting,
+    );
+    write_executable(&mock_bin.join("gh"), &script).expect("write file page mock");
+}
+
+#[test]
+fn easyconfigs_fetch_pages_files_past_five_hundred_and_keeps_the_cap() {
+    let temp = tempfile::tempdir().expect("tempdir");
+    let root = temp.path();
+    let origin = root.join("origin.git");
+    let seed = root.join("seed");
+    let clone = root.join("clone");
+    let out = root.join("out");
+    let mock_bin = root.join("mock-bin");
+    fs::create_dir_all(&mock_bin).expect("mock bin");
+    let ec = "easybuild/easyconfigs/l/Lib/Lib-1.0.eb";
+
+    assert_ok(
+        &run(
+            "git",
+            &["init", "--bare", origin.to_str().expect("origin utf-8")],
+            root,
+            &[],
+        ),
+        "init bare origin",
+    );
+    fs::create_dir_all(&seed).expect("seed dir");
+    assert_ok(&run("git", &["init"], &seed, &[]), "init seed");
+    git(&seed, &["config", "user.name", "Fixture"]);
+    git(&seed, &["config", "user.email", "fixture@example.invalid"]);
+    write(&seed.join(ec), "name = 'Lib'\nversion = '1.0'\n");
+    git(&seed, &["add", "."]);
+    git(&seed, &["commit", "-m", "seed develop"]);
+    git(&seed, &["branch", "-M", "develop"]);
+    git(
+        &seed,
+        &[
+            "remote",
+            "add",
+            "origin",
+            origin.to_str().expect("origin utf-8"),
+        ],
+    );
+    git(&seed, &["push", "-u", "origin", "develop"]);
+    let sha8 = make_pr_head(&seed, "pr8", 8, "name = 'Lib'\nversion = '1.0'\n# page6\n");
+    let sha9 = make_pr_head(&seed, "pr9", 9, "name = 'Lib'\nversion = '1.0'\n# capped\n");
+    git(&seed, &["checkout", "develop"]);
+    assert_ok(
+        &run(
+            "git",
+            &[
+                "clone",
+                origin.to_str().expect("origin utf-8"),
+                clone.to_str().expect("clone utf-8"),
+            ],
+            root,
+            &[],
+        ),
+        "clone fixture",
+    );
+    git(&clone, &["checkout", "develop"]);
+
+    let mut heads = std::collections::BTreeMap::new();
+    heads.insert(8, sha8.clone());
+    heads.insert(9, sha9.clone());
+    write(
+        &root.join("page1.json"),
+        &pulls_page([8_u64, 9].into_iter(), |n| heads[&n].clone()),
+    );
+    write_file_page_mock(&mock_bin, ec);
+    let path = format!(
+        "{}:{}",
+        mock_bin.display(),
+        std::env::var("PATH").expect("PATH")
+    );
+    let script = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("examples/easyconfigs-pr-overlap/fetch-prs.sh");
+    let output = run(
+        "bash",
+        &[
+            script.to_str().expect("script utf-8"),
+            "acme/repo",
+            out.to_str().expect("out utf-8"),
+        ],
+        &clone,
+        &[
+            ("PATH", path.as_str()),
+            ("MOCK_ROOT", root.to_str().expect("root utf-8")),
+        ],
+    );
+    assert_ok(&output, "easyconfigs file pages");
+    assert_eq!(json_files(&out.join("prs")), ["8.json", "9.json"]);
+    let past: serde_json::Value =
+        serde_json::from_str(&fs::read_to_string(out.join("prs/8.json")).expect("read 8"))
+            .expect("8 json");
+    assert_eq!(past["easyconfigs"][0]["path"], ec);
+    assert!(past["easyconfigs"][0]["head"]
+        .as_str()
+        .expect("head")
+        .contains("# page6"));
+    assert!(past.get("file_list_truncated").is_none());
+    let capped: serde_json::Value =
+        serde_json::from_str(&fs::read_to_string(out.join("prs/9.json")).expect("read 9"))
+            .expect("9 json");
+    assert_eq!(capped["file_list_truncated"], true);
+    assert_eq!(capped["easyconfigs"][0]["path"], ec);
+    assert!(capped["easyconfigs"][0]["head"]
+        .as_str()
+        .expect("head")
+        .contains("# capped"));
+}
+
+#[test]
+fn eessi_fetch_pages_files_past_five_hundred_and_keeps_the_cap() {
+    let temp = tempfile::tempdir().expect("tempdir");
+    let root = temp.path();
+    let clone = root.join("clone");
+    let out = root.join("out");
+    let mock_bin = root.join("mock-bin");
+    fs::create_dir_all(&mock_bin).expect("mock bin");
+    let body8 = "easyconfigs:\n  - zlib-1.3.1-GCCcore-15.2.0.eb\n  - Pkg8-1.0-GCCcore-15.2.0.eb\n";
+    let body9 = "easyconfigs:\n  - zlib-1.3.1-GCCcore-15.2.0.eb\n  - Pkg9-1.0-GCCcore-15.2.0.eb\n";
+    let heads = eessi_seed_and_clone(root, &[(8, body8.to_string()), (9, body9.to_string())]);
+    write(
+        &root.join("page1.json"),
+        &pulls_page([8_u64, 9].into_iter(), |n| heads[&n].clone()),
+    );
+    write_file_page_mock(&mock_bin, EESSI_STACK);
+    let path = format!(
+        "{}:{}",
+        mock_bin.display(),
+        std::env::var("PATH").expect("PATH")
+    );
+    let output = run(
+        "bash",
+        &[
+            eessi_script().to_str().expect("script utf-8"),
+            "EESSI/software-layer",
+            "2026.06",
+            out.to_str().expect("out utf-8"),
+        ],
+        &clone,
+        &[
+            ("PATH", path.as_str()),
+            ("MOCK_ROOT", root.to_str().expect("root utf-8")),
+        ],
+    );
+    assert_ok(&output, "eessi file pages");
+    assert_eq!(json_files(&out.join("prs")), ["8.json", "9.json"]);
+    let past: serde_json::Value =
+        serde_json::from_str(&fs::read_to_string(out.join("prs/8.json")).expect("read 8"))
+            .expect("8 json");
+    assert_eq!(past["easystacks"][0]["path"], EESSI_STACK);
+    assert!(past["easystacks"][0]["head"]
+        .as_str()
+        .expect("head")
+        .contains("Pkg8-1.0-GCCcore-15.2.0.eb"));
+    assert!(past.get("file_list_truncated").is_none());
+    let capped: serde_json::Value =
+        serde_json::from_str(&fs::read_to_string(out.join("prs/9.json")).expect("read 9"))
+            .expect("9 json");
+    assert_eq!(capped["file_list_truncated"], true);
+    assert_eq!(capped["easystacks"][0]["path"], EESSI_STACK);
+    assert!(capped["easystacks"][0]["head"]
+        .as_str()
+        .expect("head")
+        .contains("Pkg9-1.0-GCCcore-15.2.0.eb"));
+}
diff --git a/tests/mcp_v1.rs b/tests/mcp_v1.rs
index 4bd8ff21..d6e8cf77 100644
--- a/tests/mcp_v1.rs
+++ b/tests/mcp_v1.rs
@@ -3263,6 +3263,7 @@ fn mcp_stack_order_matches_the_cli() {
             ("easystack_out", "string"),
             ("hashes_out", "string"),
             ("filter_deps", "array"),
+            ("installed", "array"),
         ],
     );
     let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
@@ -3412,6 +3413,53 @@ fn mcp_stack_order_matches_the_cli() {
     assert!(!filtered_text.contains("OpenBLAS-"), "{filtered_text}");
     assert!(filtered_text.contains("GROMACS-"), "{filtered_text}");
 
+    let installed = root.join("fixtures/stack_order_installed/installed.txt");
+    let installed = installed.to_str().expect("utf8");
+    let cli_installed = temp.path().join("cli-installed.txt");
+    let mcp_installed = temp.path().join("mcp-installed.txt");
+    let installed_stdout = cli_stdout(&[
+        "stack",
+        "order",
+        "--easyconfigs",
+        trees,
+        "--root",
+        "GROMACS",
+        "--installed",
+        installed,
+        "--filter-deps",
+        "FFTW",
+        "--out",
+        cli_installed.to_str().expect("utf8"),
+    ]);
+    let installed_body = mcp_tool(
+        135,
+        "eb_stack_order",
+        json!({
+            "easyconfigs": [trees],
+            "root": ["GROMACS"],
+            "installed": [installed],
+            "filter_deps": ["FFTW"],
+            "out": mcp_installed,
+        }),
+    );
+    assert_eq!(
+        swap_paths(
+            installed_body["text"].as_str().unwrap_or(""),
+            &mcp_installed,
+            "ORDER"
+        ),
+        swap_paths(&installed_stdout, &cli_installed, "ORDER")
+    );
+    assert_eq!(
+        std::fs::read(&cli_installed).unwrap(),
+        std::fs::read(&mcp_installed).unwrap()
+    );
+    assert_eq!(installed_body["installed"], 1);
+    let installed_text = std::fs::read_to_string(&mcp_installed).unwrap();
+    assert!(!installed_text.contains("OpenBLAS-"), "{installed_text}");
+    assert!(!installed_text.contains("FFTW-"), "{installed_text}");
+    assert!(installed_text.contains("GROMACS-"), "{installed_text}");
+
     let missing = mcp_error_text(
         133,
         "eb_stack_order",
@@ -3698,6 +3746,52 @@ fn mcp_repro_summary_matches_the_cli() {
     }
 }
 
+#[test]
+fn mcp_org_lists_a_tool_per_cli_command() {
+    let page = std::fs::read_to_string(
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("docs/orgmode/reference/mcp.org"),
+    )
+    .expect("read mcp.org");
+    let listed = handle_message(&json!({
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/list",
+        "params": {}
+    }))
+    .expect("tools/list");
+    let names = listed["result"]["tools"]
+        .as_array()
+        .expect("tools")
+        .iter()
+        .filter_map(|tool| tool["name"].as_str())
+        .collect::<Vec<_>>();
+    let mut commands = 0;
+    for leaf in cli_leaves() {
+        if leaf.as_slice() == ["mcp"] {
+            continue;
+        }
+        commands += 1;
+        let tool = format!("eb_{}", leaf.join("_").replace('-', "_"));
+        assert!(
+            names.contains(&tool.as_str()),
+            "CLI subcommand {} has no MCP tool",
+            leaf.join(" ")
+        );
+        assert!(
+            page.contains(&format!("~{tool}~")),
+            "docs/orgmode/reference/mcp.org does not list {tool} for {}",
+            leaf.join(" ")
+        );
+    }
+    assert!(commands > 0, "help listed no CLI commands");
+    for name in &names {
+        assert!(
+            page.contains(&format!("~{name}~")),
+            "docs/orgmode/reference/mcp.org does not list tool {name}"
+        );
+    }
+}
+
 #[test]
 fn every_cli_subcommand_has_an_mcp_tool() {
     let mapped = [
diff --git a/tests/source_probe.rs b/tests/source_probe.rs
index f344fe18..b66466b6 100644
--- a/tests/source_probe.rs
+++ b/tests/source_probe.rs
@@ -225,6 +225,96 @@ fn stack_arch_probes_aarch64_alone_and_names_the_missing_wheel() {
     assert_eq!(text(&target.stdout), stdout);
 }
 
+#[test]
+fn stack_arch_probe_with_two_arches_compares_only_that_pair() {
+    let server = FixtureServer::start();
+    let fixture = write_real_pr_1670_fixture(&server.base_url());
+
+    let paired = arch_probe(&["x86_64", "aarch64"], &fixture);
+    let stdout = text(&paired.stdout);
+    let stderr = text(&paired.stderr);
+    assert_eq!(paired.status.code(), Some(1), "{stdout}\n{stderr}");
+    let lines: Vec<&str> = stdout.lines().collect();
+    assert_eq!(lines.len(), 2, "{stdout}");
+    assert!(
+        lines[0].starts_with(&format!(
+            "Kaleido-0.2.1-GCCcore-15.2.0.eb source kaleido-0.2.1-manylinux2014-aarch64.whl is arch-missing on aarch64: {}/kaleido-0.2.1-manylinux2014-aarch64.whl (",
+            server.base_url()
+        )),
+        "{stdout}"
+    );
+    assert!(lines[0].contains("HEAD=status:404"), "{stdout}");
+    assert_eq!(
+        lines[1],
+        "parse_failed=0 unsupported=0 flagged=0 source_unreachable=0 source_arch_missing=1"
+    );
+    assert!(!stdout.contains("riscv64") && !stderr.contains("riscv64"));
+    assert!(stderr.contains("is arch-missing on aarch64"), "{stderr}");
+    assert_eq!(
+        text(&arch_probe(&["aarch64", "x86_64"], &fixture).stdout),
+        stdout
+    );
+    assert_eq!(
+        text(&arch_probe(&["x86_64/amd/zen4", "aarch64/neoverse_v1"], &fixture).stdout),
+        stdout
+    );
+
+    let neither = arch_probe(&["aarch64", "riscv64"], &fixture);
+    let neither_out = text(&neither.stdout);
+    let neither_err = text(&neither.stderr);
+    assert_eq!(
+        neither.status.code(),
+        Some(1),
+        "{neither_out}\n{neither_err}"
+    );
+    let neither_lines: Vec<&str> = neither_out.lines().collect();
+    assert_eq!(neither_lines.len(), 3, "{neither_out}");
+    assert!(
+        neither_lines[0].starts_with(&format!(
+            "Kaleido-0.2.1-GCCcore-15.2.0.eb source kaleido-0.2.1-manylinux2014-aarch64.whl is unreachable on aarch64: {}/kaleido-0.2.1-manylinux2014-aarch64.whl (",
+            server.base_url()
+        )),
+        "{neither_out}"
+    );
+    assert!(
+        neither_lines[1].starts_with(&format!(
+            "Kaleido-0.2.1-GCCcore-15.2.0.eb source kaleido-0.2.1-manylinux2014-riscv64.whl is unreachable on riscv64: {}/kaleido-0.2.1-manylinux2014-riscv64.whl (",
+            server.base_url()
+        )),
+        "{neither_out}"
+    );
+    assert!(
+        neither_lines[0].contains("HEAD=status:404"),
+        "{neither_out}"
+    );
+    assert!(
+        neither_lines[1].contains("HEAD=status:404"),
+        "{neither_out}"
+    );
+    assert_eq!(
+        neither_lines[2],
+        "parse_failed=0 unsupported=0 flagged=0 source_unreachable=2 source_arch_missing=0"
+    );
+    assert!(!neither_out.contains("x86_64") && !neither_err.contains("x86_64"));
+    assert!(!neither_out.contains("arch-missing"), "{neither_out}");
+    assert_eq!(
+        text(&arch_probe(&["aarch64", "aarch64/neoverse_v1"], &fixture).stdout),
+        text(&arch_probe(&["aarch64"], &fixture).stdout)
+    );
+
+    for arches in [&["x86_64", "aarch64"][..], &["aarch64", "riscv64"][..]] {
+        let cli = text(&arch_probe(arches, &fixture).stdout);
+        let cli_findings: Vec<&str> = cli
+            .lines()
+            .filter(|line| !line.starts_with("parse_failed="))
+            .collect();
+        let mcp = mcp_arch_probe(arches, &fixture);
+        assert_eq!(mcp["isError"], true, "{mcp}");
+        let mcp_text = mcp["content"][0]["text"].as_str().expect("error text");
+        assert_eq!(mcp_text.lines().collect::<Vec<_>>(), cli_findings);
+    }
+}
+
 #[test]
 fn stack_arch_does_not_probe_an_arch_it_did_not_parse() {
     let server = FixtureServer::start();
diff --git a/tests/stack_order_filter.rs b/tests/stack_order_filter.rs
index 65ca11b1..87e08dac 100644
--- a/tests/stack_order_filter.rs
+++ b/tests/stack_order_filter.rs
@@ -121,3 +121,123 @@ fn filter_deps_flag_and_env_drop_the_same_builds_solve_drops() {
         "the root stays in the solved build list:\n{solved_names:?}"
     );
 }
+
+#[test]
+fn installed_modules_are_leaves_and_filter_deps_still_drops_the_rest() {
+    let plain = order(&[], None);
+    let plain_names = names(&plain);
+    assert!(
+        plain_names.iter().any(|line| line.starts_with("OpenBLAS-")),
+        "{plain}"
+    );
+    assert!(
+        plain_names.iter().any(|line| line.starts_with("FFTW-")),
+        "{plain}"
+    );
+
+    let installed = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("fixtures/stack_order_installed/installed.txt");
+    let listed = order(
+        &[
+            "--installed",
+            installed.to_str().expect("utf8"),
+            "--filter-deps",
+            "FFTW",
+        ],
+        None,
+    );
+    let listed_names = names(&listed);
+    assert!(
+        listed_names
+            .iter()
+            .all(|line| !line.starts_with("OpenBLAS-")),
+        "an installed OpenBLAS is a leaf:\n{listed}"
+    );
+    assert!(
+        listed_names.iter().all(|line| !line.starts_with("FFTW-")),
+        "filter-deps still drops FFTW when an installed list is set:\n{listed}"
+    );
+    assert!(
+        listed_names.iter().any(|line| line.starts_with("GROMACS-")),
+        "the root stays:\n{listed}"
+    );
+    assert!(
+        listed_names.len() < plain_names.len(),
+        "plain {plain_names:?}\nlisted {listed_names:?}"
+    );
+
+    let tmp = tempfile::tempdir().expect("tempdir");
+    let out = tmp.path().join("order.txt");
+    let ran = Command::new(env!("CARGO_BIN_EXE_eb-stack"))
+        .args(["stack", "order", "--easyconfigs"])
+        .arg(easyconfigs())
+        .args(["--root", "GROMACS", "--installed"])
+        .arg(&installed)
+        .args(["--filter-deps", "FFTW", "--out"])
+        .arg(&out)
+        .env_remove("EASYBUILD_FILTER_DEPS")
+        .output()
+        .expect("run");
+    assert!(
+        ran.status.success(),
+        "{}",
+        String::from_utf8_lossy(&ran.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&ran.stdout);
+    assert!(
+        stdout.contains("installed=1\n"),
+        "OpenBLAS is the one leaf; FFTW was filtered:\n{stdout}"
+    );
+
+    let modules = tmp.path().join("modules/all/OpenBLAS");
+    std::fs::create_dir_all(&modules).expect("modules");
+    std::fs::write(modules.join("0.3.27-foss-2025b.lua"), "-- module\n").expect("lua");
+    let from_tree = order(
+        &[
+            "--installed",
+            tmp.path().join("modules").to_str().expect("utf8"),
+        ],
+        None,
+    );
+    assert!(
+        names(&from_tree)
+            .iter()
+            .all(|line| !line.starts_with("OpenBLAS-")),
+        "an Lmod modules/all tree is the same list:\n{from_tree}"
+    );
+    assert!(
+        names(&from_tree)
+            .iter()
+            .any(|line| line.starts_with("FFTW-")),
+        "the tree did not filter FFTW:\n{from_tree}"
+    );
+
+    let bare = tmp.path().join("bare.txt");
+    std::fs::write(&bare, "OpenBLAS\n").expect("bare");
+    let kept = order(&["--installed", bare.to_str().expect("utf8")], None);
+    assert!(
+        names(&kept)
+            .iter()
+            .any(|line| line.starts_with("OpenBLAS-")),
+        "a bare name is not every version:\n{kept}"
+    );
+
+    let missing = Command::new(env!("CARGO_BIN_EXE_eb-stack"))
+        .args(["stack", "order", "--easyconfigs"])
+        .arg(easyconfigs())
+        .args([
+            "--root",
+            "GROMACS",
+            "--installed",
+            "/tmp/no-such-installed-list-es6.txt",
+        ])
+        .env_remove("EASYBUILD_FILTER_DEPS")
+        .output()
+        .expect("run");
+    assert!(!missing.status.success());
+    let err = String::from_utf8_lossy(&missing.stderr);
+    assert!(
+        err.contains("--installed") && err.contains("no-such-installed-list-es6.txt"),
+        "{err}"
+    );
+}