stage --list: generic spellings, and a refusal that names its entries; two prepare steps split under the size gate (#734)

- The placement list is written with forward slashes on every host, which is
  its stated format; on Windows the unit test read `bin\msvcp140.dll`.
- A refusal from `mcpp stage --list` names the failing group's entries as the
  list writes them. With one edge for the whole list, ninja's echo of the
  command no longer shows which files were involved (e2e 646 on Windows).
- step13_serve_workspace_members (E1) and host_module_units are split out of
  step13_dependency_cache and step6_host_module_registration, which the
  function-size gate reported over 400 lines. `workspace_member_of` is one
  function shared by E1 and W3.
- The design record states three further plugin departures.

Author: speak-agent

.agents/docs/2026-09-28-build-cost-foreign-toolsets-and-library-surface-design.md

@@ -1262,5 +1262,23 @@ Departures from §6:
    check reads it.
 5. **Each deps-cmake toolset statement has its own build directory,** because
    CMake refuses a cache made with another generator or instance.
+6. **The Linux GCC row keeps the foreign system's detection under `resolved`.**
+   §6.2 named every non-MSVC toolset through `chain`. The plugins' CI measured
+   that the GCC payload's driver is not a complete handover: mcpp runs it with a
+   sysroot, a binutils directory and a link model that only its own command
+   lines carry, and vcpkg's compiler detection failed with the driver alone.
+   The clang payloads are complete through their `.cfg` files. On the GCC row
+   the host compiler's libstdc++ is the program's C++ library, so
+   `mcpp.plugins.toolset` answers `detected` there and states why.
+7. **The MSBuild refusal matches the call stack.** A read inside a function
+   reports the caller's list file to a `variable_watch` callback, so a match on
+   the current file never fired (measured on the masked row: MSBuild failed
+   with "no such file or directory" and no reason). The stack names the
+   helper's defining file.
+8. **E2 has no "tool flags" accessor.** Deviation 6 is where one would be
+   read. The engine states `toolchain_sysroot()` and
+   `toolchain_binutils_dir()` already, but not the link model; handing a
+   foreign system the GCC payload completely is left to a later design with its
+   own criterion (a port that builds and runs a host tool).
 
 **mcpp-index, validation.** Recorded below as they land.

src/build/ninja_backend.cppm

@@ -3045,7 +3045,7 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements) {
             outs += " " + escape_ninja_path(d.dest);
             for (auto const& s : d.sources) {
                 ins += " " + escape_ninja_path(s);
-                list += std::format("{}\t{}\n", s.string(), d.dest.string());
+                list += std::format("{}\t{}\n", s.generic_string(), d.dest.generic_string());
             }
         }
         append(std::format("build{} : stage_list{} | placements.list\n  count = {}\n",

src/build/prepare/features.cpp

@@ -911,25 +911,10 @@ static void step11_public_module_check(PrepareState& state) {
     // A member of the root's own workspace is built from source together with
     // the root, whichever form it is published in, so the packed-form
     // consequence W3 states does not arise for it (SPEC-008 §4).
-    auto sameWorkspace = [&](const std::filesystem::path& root) {
-        if (!state.wsManifest || state.runtimeWorkspaceRoot.empty()) return false;
-        const auto rel = root.lexically_normal()
-                             .lexically_relative(state.runtimeWorkspaceRoot.lexically_normal())
-                             .generic_string();
-        if (rel.empty() || rel == "." || rel.starts_with("..")) return false;
-        for (auto const& m : state.wsManifest->workspace.members) {
-            if (m == rel) return true;
-            if (m.ends_with("/*") && rel.starts_with(m.substr(0, m.size() - 1))
-                && rel.find('/', m.size() - 1) == std::string::npos)
-                return true;
-        }
-        return false;
-    };
-
     std::map<std::string, std::set<std::string>> publicOf;
     for (std::size_t i = 1; i < state.packages.size(); ++i) {
         auto const& pr = state.packages[i];
-        if (sameWorkspace(pr.root)) continue;
+        if (!workspace_member_of(state, pr.root).empty()) continue;
         const auto rootFile = (pr.root / mcpp::manifest::resolve_lib_root_path(pr.manifest, pr.root))
                                   .lexically_normal();
         std::error_code ec;

src/build/prepare/plan.cpp

@@ -502,6 +502,10 @@ struct PrepareState {
 // static would give each definition internal linkage, invisible outside
 // its own file.
 std::expected<void, std::string> phase0_manifest_and_workspace(PrepareState& state);
+
+// plan.cpp: the member path of a package root within the workspace this build
+// runs in, or empty (#734 E1, W3).
+std::string workspace_member_of(const PrepareState& state, const std::filesystem::path& root);
 std::expected<void, std::string> phase1_toolchain_spec_and_axes(PrepareState& state);
 std::expected<void, std::string> phase2_define_toolchain_resolver(PrepareState& state);
 std::expected<void, std::string> phase3_xlings_before_graph(PrepareState& state);

src/build/prepare/scan.cpp

@@ -978,6 +978,7 @@ export int cmd_stage(const mcpplibs::cmdline::ParsedArgs& parsed) {
             return 1;
         }
         std::vector<std::pair<std::string, std::vector<std::filesystem::path>>> groups;
+        std::vector<std::vector<std::string>> spelled;   // each group's sources as the list writes them
         std::map<std::string, std::size_t> index;
         std::string line;
         while (std::getline(in, line)) {
@@ -990,15 +991,22 @@ export int cmd_stage(const mcpplibs::cmdline::ParsedArgs& parsed) {
             }
             std::string src = line.substr(0, tab), dst = line.substr(tab + 1);
             auto [it, fresh] = index.emplace(dst, groups.size());
-            if (fresh) groups.push_back({dst, {}});
+            if (fresh) { groups.push_back({dst, {}}); spelled.emplace_back(); }
             groups[it->second].second.push_back(
                 mcpp::platform::fs::extended_length(std::filesystem::path{src}));
+            spelled[it->second].push_back(src);
         }
-        for (auto const& [dst, srcs] : groups) {
+        for (std::size_t g = 0; g < groups.size(); ++g) {
+            auto const& [dst, srcs] = groups[g];
             auto r = mcpp::build::stage::stage_files(
                 srcs, mcpp::platform::fs::extended_length(std::filesystem::path{dst}), opts);
             if (!r) {
+                // One edge places the whole list, so ninja's echo of the
+                // command no longer shows which files were involved; the
+                // entries are named here as the list writes them.
                 std::println(stderr, "error: {}", r.error().message);
+                std::println(stderr, "  placement list entries ({}):", listFile);
+                for (auto const& src : spelled[g]) std::println(stderr, "    {} -> {}", src, dst);
                 return 1;
             }
         }