feat(core): the data home, the lens texts, and --version naming both

process/ holds the procedure, the five lens texts, the templates and the
skill under process/skill/prepush/. A lens text's sha256 is part of every
reuse key and the texts are part of every prompt, so they carry no SPDX
header; --version prints the charter hashes: 1728bd4c, 148d5c4c,
c7ffef44 and 2b9a5f83 for the four charters.

Home() finds them: CRAFTER_REVIEW_HOME, natively only (a host setting
must not swap the Flatpak's texts for a checkout's), then
<exe>/../share/crafter-review, then the checkout the binary was built in.
Main() hands `__supervise` to the supervisor before anything else, then
decides the sandbox once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

implementations/Crafter.Review-Core.cpp

@@ -3,9 +3,45 @@
 
 module Crafter.Review:Core_impl;
 import :Core;
+import :Platform;
+import :Text;
+import :Crypto;
 import std;
 
+namespace fs = std::filesystem;
+
 namespace Crafter::Review {
+    namespace {
+        std::optional<fs::path>& HomeOverride() {
+            static std::optional<fs::path> home;
+            return home;
+        }
+
+        bool HoldsLenses(const fs::path& dir) {
+            std::error_code error;
+            return !dir.empty() && fs::is_directory(dir / "process" / "lenses", error);
+        }
+
+        fs::path FindHome() {
+            if (!Platform::InSandbox()) {
+                if (const std::optional<std::string> configured = Platform::GetEnv("CRAFTER_REVIEW_HOME"); configured && !configured->empty()) {
+                    if (HoldsLenses(*configured)) return *configured;
+                    throw std::runtime_error(std::format("CRAFTER_REVIEW_HOME={} holds no process/lenses", *configured));
+                }
+            }
+            const fs::path exe = Platform::SelfExe();
+            const fs::path installed = exe.parent_path().parent_path() / "share" / "crafter-review";
+            if (HoldsLenses(installed)) return installed;
+            // <checkout>/bin/crafter.review-exe-<variant>/crafter-review
+            const fs::path variant = exe.parent_path();
+            if (variant.filename().string().starts_with("crafter.review-exe-") && variant.parent_path().filename() == "bin") {
+                const fs::path checkout = variant.parent_path().parent_path();
+                if (HoldsLenses(checkout)) return checkout;
+            }
+            throw std::runtime_error(std::format("no process/lenses beside {} (neither {} nor a checkout's bin/): set CRAFTER_REVIEW_HOME", exe.string(), installed.string()));
+        }
+    }
+
     std::string_view Version() {
         return CRAFTER_REVIEW_VERSION;
     }
@@ -13,4 +49,28 @@ namespace Crafter::Review {
     std::string DriverLine() {
         return std::format("crafter-review {} (prompt v{})", Version(), PromptVersion);
     }
+
+    const fs::path& Home() {
+        if (!HomeOverride()) HomeOverride() = FindHome();
+        return *HomeOverride();
+    }
+
+    void SetHome(fs::path home) {
+        HomeOverride() = std::move(home);
+    }
+
+    fs::path LensDir() {
+        return Home() / "process" / "lenses";
+    }
+
+    std::vector<std::pair<std::string, std::string>> CharterHashes() {
+        std::vector<std::pair<std::string, std::string>> hashes;
+        std::error_code error;
+        for (const fs::directory_entry& entry : fs::directory_iterator(LensDir(), error)) {
+            if (entry.path().extension() != ".md") continue;
+            hashes.emplace_back(entry.path().filename().string(), Sha256Hex(Dyn::ReadText(entry.path())));
+        }
+        std::ranges::sort(hashes);
+        return hashes;
+    }
 }

implementations/Crafter.Review-Driver.cpp

@@ -4,6 +4,8 @@
 module Crafter.Review:Driver_impl;
 import :Driver;
 import :Core;
+import :Platform;
+import :Process;
 import std;
 
 namespace Crafter::Review {
@@ -15,14 +17,27 @@ R"(usage: crafter-review [--config FILE] {run,freeze,slots,config} ...
 
 The pre-push review pipeline: adversarial lenses, one claude process per
 inventory unit, against a frozen commit range.)";
+
+        std::int32_t PrintVersion() {
+            std::println("{}", DriverLine());
+            try {
+                std::println("home {}", Home().string());
+                for (const auto& [name, sha] : CharterHashes()) std::println("charter {} {}", name, sha);
+            } catch (const std::exception& e) {
+                std::println("home not found: {}", e.what());
+            }
+            return 0;
+        }
     }
 
     std::int32_t Main(std::span<const std::string_view> args) {
         const std::span<const std::string_view> rest = args.empty() ? args : args.subspan(1);
-        if (!rest.empty() && rest.front() == "--version") {
-            std::println("{}", DriverLine());
-            return 0;
-        }
+        // The supervisor first and alone: it is single-threaded and has to
+        // stay so, and it runs between the driver and claude, not as a
+        // command anyone types.
+        if (!rest.empty() && rest.front() == Process::SuperviseVerb) return Process::SuperviseMain(rest.subspan(1));
+        Platform::Init();
+        if (!rest.empty() && rest.front() == "--version") return PrintVersion();
         if (!rest.empty() && (rest.front() == "-h" || rest.front() == "--help")) {
             std::println("{}", Usage);
             return 0;