diff --git a/CHANGELOG.md b/CHANGELOG.md
index c3894758..e37aad15 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -29,6 +29,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 +283,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/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/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..0fcba673 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.
@@ -3850,6 +3869,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 +6589,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 +6802,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 +7034,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 +7925,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 +7967,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 +7988,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 +8151,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 +9383,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 +9394,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/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}"
+    );
+}