Crafter.Review/implementations/Crafter.Review-Config.cpp

// SPDX-License-Identifier: AGPL-3.0-only
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®

module Crafter.Review:Config_impl;
import :Config;
import :Json;
import :Text;
import :Core;
import :Plan;
import :Tools;
import :PgWire;
import :Process;
import :Platform;
import :Prompt;
import std;

namespace fs = std::filesystem;

namespace Crafter::Review::Config {
    namespace {
        // Keys a consumer's config may still carry, with what replaced them.
        struct Retired {
            std::string_view section;
            std::string_view key;
            std::string why;
        };

        std::vector<Retired> RetiredKeys() {
            return {{
                "functional", "concurrency",
                std::format("passes run as many at once as free memory allows, each at its environment's measured cost, and a pass that drives "
                            "the application holds a stack of its own (2026-10-22); for more of them at once bring up more stacks "
                            "(slots.*, `{} slots`)", Invocation()),
            }};
        }

        std::string EnvironmentNames(std::string_view separator) {
            std::vector<std::string> names;
            for (const Plan::Environment& environment : Plan::Environments) names.emplace_back(environment.name);
            return Dyn::Join(names, separator);
        }

        Json EnvironmentTable() {
            Json table = Json::object();
            for (const Plan::Environment& environment : Plan::Environments) table[std::string(environment.name)] = true;
            return table;
        }

        bool AllStrings(const Json& list) {
            return list.is_array() && std::ranges::all_of(list, [](const Json& item) { return item.is_string(); });
        }

        // ^(Bash\([^()]+:\*\)|mcp__[A-Za-z0-9_-]+(__[A-Za-z0-9_-]+)?)$; `$`
        // also matches before a final newline.
        bool IsToolEntry(std::string_view tool) {
            std::string_view body = tool;
            if (body.ends_with('\n')) body.remove_suffix(1);
            if (body.starts_with("Bash(") && body.ends_with(":*)") && body.size() > 8) {
                const std::string_view prefix = body.substr(5, body.size() - 8);
                return !prefix.contains('(') && !prefix.contains(')');
            }
            if (body.starts_with("mcp__") && body.size() > 5) {
                return std::ranges::all_of(body.substr(5), [](char c) {
                    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_' || c == '-';
                });
            }
            return false;
        }

        // re.match(r'^https?://', text)
        bool IsHttpUrl(std::string_view text) {
            return text.starts_with("http://") || text.starts_with("https://");
        }

        // An integer or a float, not a bool.
        bool IsRealNumber(const Json& value) {
            return value.is_number();
        }

        bool Positive(const Json& value) {
            return value.is_number_float() ? value.get<double>() > 0.0 : (value.is_number_unsigned() ? value.get<std::uint64_t>() > 0 : value.get<std::int64_t>() > 0);
        }

        // A mode's defaults: its kind (null for a name that is no kind - the
        // config says which), no lens, the kind's effort.
        Json ModeDefaults(std::string_view kind) {
            return {{"kind", kind.empty() ? Json() : Json(std::string(kind))}, {"lenses", Json::array()}, {"effort", nullptr}};
        }

        std::vector<std::string> Merge(Json& destination, const Json& source, const std::string& path) {
            std::vector<std::string> problems;
            for (auto it = source.begin(); it != source.end(); ++it) {
                const std::string& key = it.key();
                if (!Dyn::Has(destination, key)) {
                    // A mode of the repository's own name: its defaults, then
                    // the config's values over them.
                    if (path == "modes.") {
                        destination[key] = ModeDefaults("");
                    } else {
                        problems.push_back(std::format("unknown key {}{}", path, key));
                        continue;
                    }
                }
                Json& target = destination[key];
                if (target.is_object() && it.value().is_object()) {
                    std::ranges::move(Merge(target, it.value(), std::format("{}{}.", path, key)), std::back_inserter(problems));
                } else {
                    target = it.value();
                }
            }
            return problems;
        }

        // The config's entry for the lens, else its default one.
        const Json& LensEntry(const Json& config, std::string_view lensFile) {
            static const Json defaults = Defaults()["lenses"];
            const Json& lenses = Dyn::Get(config, "lenses");
            const std::string name = Plan::LensName(lensFile);
            const Json* entry = lenses.is_object() ? &Dyn::Get(lenses, name) : nullptr;
            return entry && entry->is_object() ? *entry : defaults.at(name);
        }

        // A config or a slot file as JSON: the value, or the text that goes
        // into the "not JSON (...)" problem.
        std::variant<Json, std::string> LoadJson(const fs::path& path) {
            try {
                return Dyn::LoadJsonFile(path);
            } catch (const std::exception& error) {
                return std::string(error.what());
            }
        }
    }

    Json Defaults() {
        // Each lens's environment, and its section: a file of the repository's
        // own appended to its shipped charter (null: none). Which lenses run is
        // the modes'.
        Json lenses = Json::object();
        for (const Plan::Lens& lens : Plan::Lenses) lenses[Plan::LensName(lens.file)] = {{"environment", lens.env}, {"section", nullptr}};
        // Every lens is off until a mode lists it (2026-10-31, Jorijn: "all
        // lenses off by default and opt in only"): the three artifact kinds
        // are modes of their own name with no lens; a mode of any name is a
        // kind, the lenses it runs and the effort it runs at (2026-11-01).
        Json modes = Json::object();
        for (const std::string_view kind : Plan::Kinds) modes[std::string(kind)] = ModeDefaults(kind);
        return {
            // The integration branch a range is measured against (e.g.
            // origin/dev): merge-base HEAD <base>.
            {"base", nullptr},
            // upstream: the push delta @{upstream}..HEAD, the base branch only
            // when HEAD tracks nothing; base: always merge-base HEAD
            // <base>..HEAD, the whole pull request.
            {"rangeFrom", "upstream"},
            // Author and committer emails the freeze accepts; null: the
            // repository's `git config user.email`.
            {"authors", nullptr},
            // forbid | allow: Assisted-by / Co-Authored-By trailers in the
            // range.
            {"aiTrailers", "forbid"},
            // An unsigned commit fails the freeze (else a warning).
            {"requireSigned", false},
            // The modes: {<name>: {kind, lenses, effort}}.
            {"modes", modes},
            // Tracked paths the local stack rewrites in place while the lenses
            // run.
            {"allowDirty", Json::array()},
            // The commands Gate 0 runs by hand, in order (documentation for the
            // skill; the driver runs none of them).
            {"gate0", Json::array()},
            // Per lens: its environment (Plan::Environments); which lenses
            // run is the modes'.
            {"lenses", lenses},
            // The database under test, for every lens whose environment
            // reaches it. The URL reaches a db pass's broker, never a prompt,
            // and the dump and the log show it with the password masked.
            {"supabase", {{"dbUrl", "postgresql://postgres:postgres@127.0.0.1:54322/postgres"}, {"start", nullptr}, {"stop", nullptr}, {"notes", ""}}},
            // Stacks side by side (2026-10-22): a pass that drives an
            // application holds one of its own.
            {"slots", {{"dir", nullptr}, {"start", nullptr}, {"stop", nullptr}, {"memMb", nullptr}, {"startMb", nullptr}}},
            // The application under test, for every lens whose environment
            // reaches one.
            {"functional", {
                {"appUrl", "http://localhost:8080"},
                {"readyPath", "/"},
                {"apiUrls", Json::array()},
                {"start", nullptr},
                {"stop", nullptr},
                {"login", {{"fixtures", Json::array()}, {"notes", ""}}},
                {"exclude", Json::array()},
                {"extraTools", Json::array()},
                {"mcp", {{"command", "npx"}, {"args", nullptr}}},
                {"notes", ""},
            }},
        };
    }

    Loaded Load(const fs::path& repo, const fs::path& path) {
        Loaded loaded{Defaults(), {}};
        Json& config = loaded.config;
        const fs::path p = path.empty() ? repo / ConfigFile : path;
        std::vector<std::string> warnings;
        if (fs::exists(p)) {
            std::variant<Json, std::string> read = LoadJson(p);
            if (std::holds_alternative<std::string>(read)) {
                loaded.problems.push_back(std::format("{}: not JSON ({})", p.string(), std::get<std::string>(read)));
                return loaded;
            }
            Json data = std::move(std::get<Json>(read));
            if (!data.is_object()) {
                loaded.problems.push_back(std::format("{}: the top level must be an object", p.string()));
                return loaded;
            }
            for (const Retired& retired : RetiredKeys()) {
                const Json& section = Dyn::Get(data, retired.section);
                if (section.is_object() && Dyn::Has(section, retired.key)) {
                    warnings.push_back(std::format("{}.{} is no longer read - remove it from {}: {}", retired.section, retired.key, p.filename().string(), retired.why));
                    data[std::string(retired.section)].erase(std::string(retired.key));
                }
            }
            // lenses.<name>.run is retired (2026-11-01): a mode lists what runs.
            if (const Json& given = Dyn::Get(data, "lenses"); given.is_object()) {
                std::vector<std::string> retiredRuns;
                for (auto it = given.begin(); it != given.end(); ++it) {
                    if (it.value().is_object() && Dyn::Has(it.value(), "run")) retiredRuns.push_back(it.key());
                }
                for (const std::string& name : retiredRuns) {
                    warnings.push_back(std::format("lenses.{}.run is no longer read - remove it from {}: a mode lists the lenses it runs (modes.<mode>.lenses)", name, p.filename().string()));
                    data["lenses"][name].erase("run");
                }
            }
            loaded.problems = Merge(config, data, "");
        } else if (!path.empty()) {
            loaded.problems.push_back(std::format("{}: no such file", p.string()));
        }
        config["_path"] = fs::exists(p) ? Json(p.string()) : Json();
        Json warningList = Json::array();
        for (const std::string& warning : warnings) warningList.push_back(warning);
        config["_warnings"] = std::move(warningList);
        std::ranges::move(Validate(config), std::back_inserter(loaded.problems));
        std::ranges::move(SectionProblems(config, repo), std::back_inserter(loaded.problems));
        return loaded;
    }

    namespace {
        // A path setting resolved against the repository root (slots.dir,
        // lenses.<name>.section): a relative path that stays inside it - not
        // blank, no leading `/`, no `..` part (2026-11-01: one check, so the
        // settings cannot drift apart).
        bool InsideRepository(const Json& value) {
            if (!value.is_string()) return false;
            const std::string& dir = value.get_ref<const std::string&>();
            const std::vector<std::string> parts = Dyn::Split(Dyn::Replace(dir, "\\", "/"), "/");
            return !Dyn::Strip(dir).empty() && !dir.starts_with('/') && !std::ranges::contains(parts, std::string(".."));
        }
    }

    std::vector<std::string> Validate(const Json& config) {
        std::vector<std::string> out;
        const Json& trailers = Dyn::At(config, "aiTrailers");
        if (trailers != "forbid" && trailers != "allow") out.emplace_back("aiTrailers must be 'forbid' or 'allow'");
        const Json& rangeFrom = Dyn::At(config, "rangeFrom");
        if (rangeFrom != "upstream" && rangeFrom != "base") out.emplace_back("rangeFrom must be 'upstream' or 'base'");
        if (rangeFrom == "base" && !Dyn::Truthy(Dyn::At(config, "base"))) out.emplace_back("rangeFrom 'base' needs a base branch");
        const Json& authors = Dyn::At(config, "authors");
        if (!authors.is_null() && (!authors.is_array() || !std::ranges::all_of(authors, [](const Json& a) {
                return a.is_string() && a.get_ref<const std::string&>().contains('@');
            }))) {
            out.emplace_back("authors must be null or a list of email addresses");
        }
        for (const std::string_view key : {"allowDirty", "gate0"}) {
            if (!AllStrings(Dyn::At(config, key))) out.push_back(std::format("{} must be a list of strings", key));
        }
        const Json environments = EnvironmentTable();
        Json lenses = Dyn::At(config, "lenses");
        if (!lenses.is_object()) {
            out.push_back(std::format("lenses must be an object: {{<lens name>: {{environment: {}}}}}", EnvironmentNames("|")));
            lenses = Json::object();
        }
        for (auto it = lenses.begin(); it != lenses.end(); ++it) {
            const Json& entry = it.value();
            if (!entry.is_object()) {
                out.push_back(std::format("lenses.{} must be an object {{environment: {}}}", it.key(), EnvironmentNames("|")));
                continue;
            }
            if (!Dyn::In(Dyn::Get(entry, "environment"), environments)) out.push_back(std::format("lenses.{}.environment must be one of {}", it.key(), EnvironmentNames(", ")));
            const Json& section = Dyn::Get(entry, "section");
            if (!section.is_null() && !InsideRepository(section)) out.push_back(std::format("lenses.{}.section must be null or a file inside the repository (a relative path)", it.key()));
        }
        // The modes (2026-11-01): each an artifact kind and the lenses it
        // runs, at an effort of its own when set. Every lens is off until a
        // mode lists it.
        auto joined = [](std::span<const std::string_view> items, std::string_view separator) {
            std::vector<std::string> strings(items.begin(), items.end());
            return Dyn::Join(strings, separator);
        };
        std::set<std::string> listed;
        const Json& modes = Dyn::At(config, "modes");
        if (!modes.is_object()) {
            out.push_back(std::format("modes must be an object: {{<mode name>: {{kind: {}, lenses: [<lens name>, ...], effort: {}|null}}}}", joined(Plan::Kinds, "|"), joined(Plan::Efforts, "|")));
        } else {
            for (auto it = modes.begin(); it != modes.end(); ++it) {
                const std::string& name = it.key();
                const Json& mode = it.value();
                if (!mode.is_object()) {
                    out.push_back(std::format("modes.{} must be an object {{kind, lenses, effort}}", name));
                    continue;
                }
                const Json& kindValue = Dyn::Get(mode, "kind");
                std::string kind;
                if (std::ranges::contains(Plan::Kinds, std::string_view(name))) {
                    if (!kindValue.is_null() && kindValue != name) out.push_back(std::format("modes.{}.kind must be {} (the mode of a kind's name is that kind) or null", name, name));
                    kind = name;
                } else if (kindValue.is_string() && std::ranges::contains(Plan::Kinds, std::string_view(kindValue.get_ref<const std::string&>()))) {
                    kind = kindValue.get<std::string>();
                } else {
                    out.push_back(std::format("modes.{}.kind must name the artifact kind the mode reviews ({})", name, joined(Plan::Kinds, ", ")));
                }
                const Json& lensList = Dyn::Get(mode, "lenses");
                if (!AllStrings(lensList)) {
                    out.push_back(std::format("modes.{}.lenses must be a list of lens names", name));
                } else if (!kind.empty()) {
                    const std::vector<std::string> ofKind = Plan::KindLenses(kind);
                    std::vector<std::string> ofKindNames;
                    for (const std::string& lf : ofKind) ofKindNames.push_back(Plan::LensName(lf));
                    std::set<std::string> seen;
                    for (const Json& item : lensList) {
                        const std::string lf = std::format("{}.md", item.get<std::string>());
                        if (!std::ranges::contains(ofKind, lf)) {
                            out.push_back(std::format("modes.{}: {} is no lens of a {} ({})", name, Dyn::Str(item), kind, Dyn::Join(ofKindNames, ", ")));
                        } else if (!seen.insert(lf).second) {
                            out.push_back(std::format("modes.{}: {} is listed twice", name, Dyn::Str(item)));
                        } else {
                            listed.insert(lf);
                        }
                    }
                }
                const Json& effort = Dyn::Get(mode, "effort");
                if (!effort.is_null() && !(effort.is_string() && std::ranges::contains(Plan::Efforts, std::string_view(effort.get_ref<const std::string&>())))) {
                    out.push_back(std::format("modes.{}.effort must be one of {} or null (the kind's default: {} for a reply or a series, {} for a commit range)", name, joined(Plan::Efforts, ", "),
                                              Plan::KernelEffort, Plan::Effort));
                }
            }
            if (listed.empty()) {
                std::vector<std::string> names;
                for (const Plan::Lens& lens : Plan::Lenses) names.push_back(Plan::LensName(lens.file));
                out.push_back(std::format("modes: no mode lists a lens - every lens is off until a mode lists it in modes.<mode>.lenses ({})", Dyn::Join(names, ", ")));
            }
        }
        auto runs = [&](std::string_view lensFile) { return listed.contains(std::string(lensFile)); };
        for (const Plan::Lens& lens : Plan::Lenses) {
            if (!lens.empirical || !runs(lens.file)) continue;
            const Json& entry = Dyn::Get(lenses, Plan::LensName(lens.file));
            if (!entry.is_object()) continue;
            const Json& name = Dyn::Get(entry, "environment");
            if (!Dyn::In(name, environments)) continue;
            if (!Plan::FindEnvironment(name.get_ref<const std::string&>())->app) {
                std::vector<std::string> withApp;
                for (const Plan::Environment& environment : Plan::Environments) {
                    if (environment.app) withApp.emplace_back(environment.name);
                }
                out.push_back(std::format("lenses.{}: an empirical lens needs an environment with an application under test ({}) - or no mode lists it", Plan::LensName(lens.file),
                                          Dyn::Join(withApp, ", ")));
            }
        }
        const Json& supabase = Dyn::At(config, "supabase");
        if (!supabase.is_object()) {
            out.emplace_back("supabase must be an object {dbUrl, start, stop, notes}");
        } else {
            if (const std::optional<std::string> problem = PgWire::CheckUrl(Dyn::Get(supabase, "dbUrl"))) out.push_back(std::format("supabase.dbUrl: {}", *problem));
            for (const std::string_view key : {"start", "stop"}) {
                const Json& value = Dyn::Get(supabase, key);
                if (!value.is_null() && !value.is_string()) out.push_back(std::format("supabase.{} must be null or a command line", key));
            }
            if (!Dyn::Get(supabase, "notes").is_string()) out.emplace_back("supabase.notes must be text");
        }
        const Json& functional = Dyn::At(config, "functional");
        if (!functional.is_object()) {
            out.emplace_back("functional must be an object");
            return out;
        }
        // The application's URL matters only to a lens that drives it.
        const bool drivesApp = std::ranges::any_of(Plan::Lenses, [&](const Plan::Lens& lens) {
            if (!runs(lens.file)) return false;
            const Json& entry = Dyn::Get(lenses, Plan::LensName(lens.file));
            if (!entry.is_object()) return false;
            const Json& name = Dyn::Get(entry, "environment");
            if (name.is_array() || name.is_object()) throw Dyn::Error("TypeError", std::format("unhashable type: '{}'", Dyn::TypeName(name)));
            const Plan::Environment* environment = name.is_string() ? Plan::FindEnvironment(name.get_ref<const std::string&>()) : nullptr;
            return environment && environment->app;
        });
        if (drivesApp && !IsHttpUrl(Dyn::StrOr(Dyn::At(functional, "appUrl"), ""))) out.emplace_back("functional.appUrl must be an http(s) URL");
        if (!AllStrings(Dyn::At(functional, "exclude"))) out.emplace_back("functional.exclude must be a list of globs");
        const Json& extraTools = Dyn::At(functional, "extraTools");
        if (!extraTools.is_array() || !std::ranges::all_of(extraTools, [](const Json& x) { return x.is_string() && IsToolEntry(x.get_ref<const std::string&>()); })) {
            out.emplace_back("functional.extraTools entries must be Bash(<prefix>:*) or mcp__<server>[__<tool>]");
        } else {
            std::vector<std::string> dead;
            for (const Json& tool : extraTools) {
                if (Tools::Denied(tool.get_ref<const std::string&>())) dead.push_back(tool.get<std::string>());
            }
            if (!dead.empty()) {
                out.push_back(std::format("functional.extraTools: {} - denied to every pass (pool.DENY wins over an allowlist); "
                                          "a lens reaches the database through the supabase environment, every call rolled back", Dyn::Join(dead, ", ")));
            }
        }
        const Json& login = Dyn::At(functional, "login");
        if (!login.is_object() || !(Dyn::Has(login, "fixtures") ? Dyn::At(login, "fixtures").is_array() : true)) out.emplace_back("functional.login must be {fixtures: [paths], notes: text}");
        const Json& slots = Dyn::At(config, "slots");
        if (!slots.is_object()) {
            out.emplace_back("slots must be an object {dir, start, stop, memMb, startMb}");
        } else if (!Dyn::Get(slots, "dir").is_null()) {
            if (!InsideRepository(Dyn::At(slots, "dir"))) out.emplace_back("slots.dir must be null or a directory inside the repository (a relative path)");
            for (const std::string_view key : {"start", "stop"}) {
                const Json& value = Dyn::Get(slots, key);
                if (!value.is_null() && (!value.is_string() || !value.get_ref<const std::string&>().contains("{n}"))) {
                    out.push_back(std::format("slots.{} must be null or a command line with {{n}}, the slot number", key));
                }
            }
            const Json& memMb = Dyn::Get(slots, "memMb");
            if (!IsRealNumber(memMb) || !Positive(memMb)) {
                out.push_back(std::format("slots.memMb must be the measured memory of one slot in MB (a number > 0): `{} slots` sizes the slots by it", Invocation()));
            }
            const Json& startMb = Dyn::Get(slots, "startMb");
            if (!startMb.is_null() && (!IsRealNumber(startMb) || !Positive(startMb))) {
                out.emplace_back("slots.startMb must be null or the measured peak of one slot coming up in MB (a number > 0)");
            }
        }
        const Json& args = Dyn::Get(Dyn::At(functional, "mcp"), "args");
        if (!args.is_null() && !AllStrings(args)) out.emplace_back("functional.mcp.args must be null or a list of strings");
        // A path found on the host, such as /usr/bin/npx, is not there inside
        // the Flatpak, whose /usr is the Sdk's.
        const Json& command = Dyn::Get(Dyn::At(functional, "mcp"), "command");
        if (command.is_string() && command.get<std::string>().starts_with('/')) {
            std::error_code error;
            const fs::path file(command.get<std::string>());
            const bool executable = fs::is_regular_file(file, error) && (fs::status(file, error).permissions() & (fs::perms::owner_exec | fs::perms::group_exec | fs::perms::others_exec)) != fs::perms::none;
            if (!executable) {
                out.emplace_back(std::format("functional.mcp.command {} is no program here{}", Dyn::Repr(command.get<std::string>()),
                                             Platform::InSandbox() ? " (inside the Flatpak /usr is the Sdk's: name it `npx`, the bundled one)" : ""));
            }
        }
        return out;
    }

    Json Redacted(const Json& config) {
        Json copy = Json::object();
        for (auto it = config.begin(); it != config.end(); ++it) {
            if (!it.key().starts_with('_')) copy[it.key()] = it.value();
        }
        if (Dyn::Get(copy, "supabase").is_object() && Dyn::Get(copy["supabase"], "dbUrl").is_string()) {
            copy["supabase"]["dbUrl"] = PgWire::Redact(copy["supabase"]["dbUrl"].get<std::string>());
        }
        return copy;
    }

    std::string GitUserEmail(const fs::path& repo) {
        const Process::Captured run = Process::Run({"git", "-C", repo.string(), "config", "user.email"});
        return run.returnCode == 0 ? Dyn::Strip(Dyn::UniversalNewlines(Dyn::DecodeReplace(run.out))) : std::string();
    }

    std::vector<std::string> Authors(const Json& config, const fs::path& repo) {
        const Json& authors = Dyn::Get(config, "authors");
        if (Dyn::Truthy(authors)) {
            std::vector<std::string> out;
            for (const Json& author : authors) out.push_back(Dyn::Str(author));
            return out;
        }
        const std::string email = GitUserEmail(repo);
        if (email.empty()) return {};
        return {email};
    }

    std::map<std::string, fs::path> LensSectionsOf(const Json& config, const fs::path& repo) {
        // Only a file inside the repository, by the rule Validate refuses the
        // rest by: fs::path's `/` would let an absolute one replace the root.
        std::map<std::string, fs::path> out;
        for (const Plan::Lens& lens : Plan::Lenses) {
            const Json& section = Dyn::Get(LensEntry(config, lens.file), "section");
            if (InsideRepository(section)) out.emplace(std::string(lens.file), repo / section.get<std::string>());
        }
        return out;
    }

    std::vector<std::string> SectionProblems(const Json& config, const fs::path& repo) {
        // Through the reader the run itself uses (Prompt::ReadSection): a
        // section the run could not use is a problem here, never a section
        // left out in silence or an error in the run's Gate 0.
        std::vector<std::string> out;
        for (const auto& [lensFile, file] : LensSectionsOf(config, repo)) {
            const std::string where = std::format("lenses.{}.section: {}", Plan::LensName(lensFile), Dyn::Str(Dyn::Get(LensEntry(config, lensFile), "section")));
            const Prompt::Section section = Prompt::ReadSection(file);
            if (!section.problem.empty()) out.push_back(std::format("{} {}", where, section.problem));
            else if (!section.present) out.push_back(std::format("{} does not exist", where));
        }
        return out;
    }

    std::optional<Mode> ModeOf(const Json& config, std::string_view name) {
        const Json& modes = Dyn::Get(config, "modes");
        if (!modes.is_object() || !Dyn::Has(modes, name)) return std::nullopt;
        const Json& mode = Dyn::At(modes, name);
        if (!mode.is_object()) return std::nullopt;
        Mode out{std::string(name), {}, {}, std::nullopt};
        const Json& kind = Dyn::Get(mode, "kind");
        if (std::ranges::contains(Plan::Kinds, name)) {
            out.kind = std::string(name);
        } else if (kind.is_string() && std::ranges::contains(Plan::Kinds, std::string_view(kind.get_ref<const std::string&>()))) {
            out.kind = kind.get<std::string>();
        } else {
            return std::nullopt;
        }
        const Json& list = Dyn::Get(mode, "lenses");
        if (!AllStrings(list)) return std::nullopt;
        std::set<std::string> wanted;
        for (const Json& item : list) wanted.insert(std::format("{}.md", item.get<std::string>()));
        for (const std::string& lf : Plan::KindLenses(out.kind)) {
            if (wanted.contains(lf)) out.lensFiles.push_back(lf);
        }
        const Json& effort = Dyn::Get(mode, "effort");
        if (effort.is_string() && !effort.get_ref<const std::string&>().empty()) out.effort = effort.get<std::string>();
        return out;
    }

    std::vector<std::string> ModeNames(const Json& config) {
        std::vector<std::string> out;
        const Json& modes = Dyn::Get(config, "modes");
        if (!modes.is_object()) return out;
        for (auto it = modes.begin(); it != modes.end(); ++it) out.push_back(it.key());
        return out;
    }

    std::vector<std::string> LensesOff(const Json& config) {
        std::set<std::string> listed;
        for (const std::string& name : ModeNames(config)) {
            if (const std::optional<Mode> mode = ModeOf(config, name)) listed.insert(mode->lensFiles.begin(), mode->lensFiles.end());
        }
        std::vector<std::string> out;
        for (const Plan::Lens& lens : Plan::Lenses) {
            if (!listed.contains(std::string(lens.file))) out.emplace_back(lens.file);
        }
        return out;
    }

    std::vector<std::string> LensesOff(const Json& config, std::string_view modeName) {
        std::vector<std::string> out;
        const std::optional<Mode> mode = ModeOf(config, modeName);
        if (!mode) return out;
        for (const std::string& lf : Plan::KindLenses(mode->kind)) {
            if (!std::ranges::contains(mode->lensFiles, lf)) out.push_back(lf);
        }
        return out;
    }

    Json Environments(const Json& config) {
        Json out = Json::object();
        for (const Plan::Lens& lens : Plan::Lenses) {
            const Json& entry = LensEntry(config, lens.file);
            out[std::string(lens.file)] = Dyn::Has(entry, "environment") ? Dyn::At(entry, "environment") : Json("none");
        }
        return out;
    }

    Slots SlotStacks(const Json& config, const fs::path& repo) {
        Slots slots;
        const Json& dir = Dyn::Get(Dyn::Or(Dyn::Get(config, "slots"), Dyn::EmptyDict()), "dir");
        if (!Dyn::Truthy(dir) || !fs::is_directory(repo / dir.get<std::string>())) return slots;
        const std::string d = dir.get<std::string>();
        std::vector<std::string> names;
        for (const fs::directory_entry& entry : fs::directory_iterator(repo / d)) names.push_back(entry.path().filename().string());
        std::ranges::stable_sort(names, {}, [](const std::string& name) { return Dyn::Natural(name); });
        for (const std::string& n : names) {
            const fs::path file = repo / d / n / SlotFile;
            if (!fs::is_regular_file(file)) continue;
            const std::string rel = Dyn::JoinPath(Dyn::JoinPath(d, n), SlotFile);
            std::variant<Json, std::string> read = LoadJson(file);
            if (std::holds_alternative<std::string>(read)) {
                slots.problems.push_back(std::format("{}: not JSON ({})", rel, std::get<std::string>(read)));
                continue;
            }
            const Json& s = std::get<Json>(read);
            if (!s.is_object() || !IsHttpUrl(Dyn::StrOr(Dyn::Get(s, "appUrl"), ""))) {
                slots.problems.push_back(std::format("{}: no appUrl", rel));
                continue;
            }
            const Json& api = Dyn::Or(Dyn::Get(s, "apiUrls"), Dyn::EmptyList());
            if (!AllStrings(api)) {
                slots.problems.push_back(std::format("{}: apiUrls must be a list of URLs", rel));
                continue;
            }
            const Json& db = Dyn::Get(s, "dbUrl");
            if (!db.is_null()) {
                if (const std::optional<std::string> problem = PgWire::CheckUrl(db)) {
                    slots.problems.push_back(std::format("{}: dbUrl: {}", rel, *problem));
                    continue;
                }
            }
            const Json& login = Dyn::Get(s, "login");
            if (!login.is_null() && (!login.is_string() || !fs::exists(repo / login.get<std::string>()))) {
                slots.problems.push_back(std::format("{}: login {} is not a file", rel, Dyn::ReprValue(login)));
                continue;
            }
            slots.stacks.push_back({
                {"id", std::format("slot {}", n)},
                {"appUrl", Dyn::RStrip(Dyn::At(s, "appUrl").get<std::string>(), "/")},
                {"apiUrls", api},
                {"dbUrl", db},
                {"login", login},
                {"slot", true},
            });
        }
        return slots;
    }

    std::vector<std::string> SlotCommands(const Json& config, std::string_view which, std::span<const std::int64_t> slots) {
        const Json& command = Dyn::Get(Dyn::Or(Dyn::Get(config, "slots"), Dyn::EmptyDict()), which);
        if (!Dyn::Truthy(command)) return {};
        std::vector<std::string> out;
        for (const std::int64_t n : slots) out.push_back(Dyn::Replace(command.get<std::string>(), "{n}", std::to_string(n)));
        return out;
    }

    std::optional<std::string> LoginFixture(const Json& config, const fs::path& repo) {
        const Json& login = Dyn::Or(Dyn::Get(Dyn::At(config, "functional"), "login"), Dyn::EmptyDict());
        for (const Json& fixture : Dyn::Or(Dyn::Get(login, "fixtures"), Dyn::EmptyList())) {
            if (fs::exists(repo / fixture.get<std::string>())) return fixture.get<std::string>();
        }
        return std::nullopt;
    }

    Json Example() {
        Json example = Defaults();
        example["base"] = "origin/main";
        example["authors"] = {"you@example.com"};
        example["aiTrailers"] = "forbid";
        example["gate0"] = {"make check"};
        // The three kinds as modes, each with every lens of its kind at the
        // kind's effort: trim each to what the repository runs.
        for (const std::string_view kind : Plan::Kinds) {
            Json names = Json::array();
            for (const std::string& lf : Plan::KindLenses(kind)) names.push_back(Plan::LensName(lf));
            example["modes"][std::string(kind)]["lenses"] = names;
            example["modes"][std::string(kind)]["effort"] = std::string(Plan::DefaultEffort(kind));
        }
        Json& functional = example["functional"];
        functional["appUrl"] = "http://localhost:8080";
        functional["start"] = "make run";
        functional["stop"] = "make stop";
        functional["login"] = {{"fixtures", {".local-stack/test-user.json"}}, {"notes", "the fixture holds a TOTP-verified login"}};
        functional["exclude"] = {"**/*.test.*", "**/*.spec.*", "docs/**", ".github/**", "*.md"};
        return example;
    }

    std::int32_t Main(const fs::path& repo, const fs::path& path) {
        const Loaded loaded = Load(repo, path);
        Json shown = Redacted(loaded.config);
        // The database password masked, as in the dump.
        shown["_path"] = Dyn::Get(loaded.config, "_path");
        std::println("{}", DumpFile(shown));
        for (const Json& warning : Dyn::Or(Dyn::Get(loaded.config, "_warnings"), Dyn::EmptyList())) std::println("warning: {}", Dyn::Str(warning));
        for (const std::string& problem : loaded.problems) std::println("problem: {}", problem);
        return loaded.problems.empty() ? 0 : 1;
    }
}