story: DGR-037 Bind llama.cpp to the standalone worker

packages/node/native/worker/shard_worker_main.cpp

@@ -64,8 +64,50 @@ meshnet::worker::FlowLimits LimitsFromEnv() {
   return limits;
 }
 
+bool IdentityFromEnv(meshnet::worker::WorkerIdentity* identity, std::string* error) {
+  const auto required = [&](const char* name, std::string* out) -> bool {
+    const char* value = std::getenv(name);
+    if (!value || !*value) { *error = std::string("missing required ") + name; return false; }
+    *out = value;
+    return true;
+  };
+  if (!required("MESHNET_MODEL_ARTIFACT", &identity->artifact_path) ||
+      !required("MESHNET_MODEL_ARTIFACT_DIGEST", &identity->artifact_digest) ||
+      !required("MESHNET_RUNTIME_RECIPE_DIGEST", &identity->recipe_digest) ||
+      !required("MESHNET_RECIPE_ID", &identity->recipe_id) ||
+      !required("MESHNET_RECIPE_VERSION", &identity->recipe_version) ||
+      !required("MESHNET_CATALOGUE_VERSION", &identity->catalogue_version)) return false;
+  const auto layer = [&](const char* name, uint32_t* out) -> bool {
+    const char* value = std::getenv(name); char* end = nullptr;
+    const unsigned long parsed = value ? std::strtoul(value, &end, 10) : 0;
+    if (!value || end == value || *end != '\0' || parsed > UINT32_MAX) {
+      *error = std::string("invalid required ") + name; return false;
+    }
+    *out = static_cast<uint32_t>(parsed); return true;
+  };
+  if (!layer("MESHNET_SHARD_START_LAYER", &identity->start_layer) ||
+      !layer("MESHNET_SHARD_END_LAYER", &identity->end_layer) ||
+      identity->end_layer <= identity->start_layer) {
+    if (error->empty()) *error = "MESHNET_SHARD_END_LAYER must exceed MESHNET_SHARD_START_LAYER";
+    return false;
+  }
+  if (const char* value = std::getenv("MESHNET_INJECT_PROCESS_DEATH_AFTER_EXECUTIONS")) {
+    char* end = nullptr;
+    const unsigned long parsed = std::strtoul(value, &end, 10);
+    if (end == value || *end != '\0' || parsed == 0 || parsed > UINT32_MAX) {
+      *error = "invalid MESHNET_INJECT_PROCESS_DEATH_AFTER_EXECUTIONS";
+      return false;
+    }
+    identity->injected_death_after_executions = static_cast<uint32_t>(parsed);
+  }
+  return true;
+}
+
 int RunSelfTest() {
-  meshnet::worker::ShardRuntimeServiceImpl service(LimitsFromEnv());
+  std::cerr << "selftest requires an opt-in real GGUF artifact; use the native worker integration harness\n";
+  return 2;
+  // A model-free selftest would reintroduce the fake execution path DGR-037 removes.
+#if 0
   int selected_port = 0;
   grpc::ServerBuilder builder;
   builder.AddListeningPort("127.0.0.1:0", grpc::InsecureServerCredentials(), &selected_port);
@@ -225,6 +267,8 @@ int RunSelfTest() {
   std::cerr << "selftest: " << failures << " check(s) failed\n";
   return 1;
 }
+#endif
+}
 
 }  // namespace
 
@@ -245,8 +289,20 @@ int main(int argc, char** argv) {
     listen_addr = argv[1];
   }
 
+  meshnet::worker::WorkerIdentity identity;
+  std::string load_error;
+  if (!IdentityFromEnv(&identity, &load_error)) {
+    std::cerr << "worker configuration error: " << load_error << "\n";
+    return 2;
+  }
+  std::unique_ptr<meshnet::worker::ShardEngine> engine =
+      meshnet::worker::MakeLlamaShardEngine(std::move(identity));
+  if (!engine->Load(&load_error)) {
+    std::cerr << "worker load error: " << load_error << "\n";
+    return 2;
+  }
   meshnet::worker::FlowLimits limits = LimitsFromEnv();
-  meshnet::worker::ShardRuntimeServiceImpl service(limits);
+  meshnet::worker::ShardRuntimeServiceImpl service(limits, *engine);
 
   grpc::ServerBuilder builder;
   int selected_port = 0;
@@ -294,6 +350,7 @@ int main(int argc, char** argv) {
   std::cout << "ShardRuntime worker listening on " << listen_addr << std::endl;
 
   server->Wait();
+  engine->Shutdown();
   drain.join();
   ::close(pipe_fds[0]);
   ::close(pipe_fds[1]);