Cleanup user and brewery generation exception logic

docs/pipeline/ETHICS-AND-KNOWN-ISSUES.md

@@ -13,6 +13,7 @@ low-resource language failures.
 - [Model Bias and Language Quality](#model-bias-and-language-quality)
 - [Western and Eurocentric Lens](#western-and-eurocentric-lens)
 - [Wikipedia Enrichment](#wikipedia-enrichment)
+- [Names-by-Country Dataset](#names-by-country-dataset)
 - [The "Avoid AI Phrases" Prompt Instruction](#the-avoid-ai-phrases-prompt-instruction)
 - [Known Issues](#known-issues)
   - [Hallucinated Brewing Techniques](#hallucinated-brewing-techniques)
@@ -91,6 +92,33 @@ generated descriptions.
 
 ---
 
+## Names-by-Country Dataset
+
+`tooling/pipeline/forenames-by-country.json` and `surnames-by-country.json`
+(used to sample a `Name` per ISO 3166-1 country code for user generation) are
+vendored verbatim, unmodified, from
+[sigpwned/popular-names-by-country-dataset](https://github.com/sigpwned/popular-names-by-country-dataset)
+(the `common-forenames-by-country.json` / `common-surnames-by-country.json`
+release assets), released under **CC0** (public domain). That dataset's own
+forename/surname lists are pulled from Wikipedia's "Lists of most common
+surnames" and "List of most popular given names" as of the week of
+2023-07-08 — see that project's README for full provenance. Names are not
+LLM-generated; this is curated fixture data per ROADMAP.md §2. Per-forename
+gender from the source data is preserved through to the sampled `Name`
+(rather than discarded during loading) so it's available for gender-aware
+persona/bio generation later.
+
+The full multinational dataset is kept as-is (106 countries for forenames,
+75 for surnames) rather than trimmed to `locations.json`'s current country
+list, so it doesn't need re-sourcing if more countries are added later.
+`NamesByCountry::SampleName()` returns no result for a country present in
+neither file; of the countries in `locations.json`, that's currently `KE`,
+`SE`, `SG`, `TH`, `VN`, and `ZA` — `GenerateUsers` skips cities in those
+countries the same way brewery generation skips cities whose enrichment
+lookup fails.
+
+---
+
 ## The "Avoid AI Phrases" Prompt Instruction
 
 The system prompt instructs the model to avoid common AI-generated phrasing

docs/pipeline/ROADMAP.md

@@ -33,28 +33,60 @@ architecture needs.
 - [ ] Add `BeerResult`, `CheckinResult`, `RatingResult` result payloads.
 - [ ] Add `GenerationMetadata` (`generation_id`, `generated_time`,
       `context_provided`, `generated_with`).
-- [ ] Add `activity_weight` to `UserResult` (currently just `username`,
-      `bio`).
+- [x] Add `first_name`, `last_name`, `gender`, and `activity_weight` to
+      `UserResult` (currently just `username`, `bio`). `first_name`/
+      `last_name`/`gender` are copied from the sampled `Name` (see below),
+      not LLM-invented.
+- [x] Add `Name` (`first_name`, `last_name`, `gender`) — the sampled result
+      handed to `DataGenerator::GenerateUser`. Add `ForenameEntry` (`name`,
+      `gender`) and a `NamesByCountry` class (not a bare typedef) that owns
+      two maps — `std::unordered_map<std::string, std::vector<ForenameEntry>>`
+      and `std::unordered_map<std::string, std::vector<std::string>>`, both
+      keyed by ISO 3166-1 code — and exposes `SampleName(iso3166_1, rng)`.
+      Pairing a forename with a surname happens at sample time so gender
+      (present per-forename in the source data) is never discarded the way a
+      pre-flattened `{first_name, last_name}` list would lose it; see
+      `LoadNamesByCountry()` below.
 - [ ] Extend `GeneratedBrewery` with `brewery_id`, `context_completeness`,
       `metadata` (currently just `{location, brewery}`).
-- [ ] Add `GeneratedBeer`, `GeneratedUser`, `GeneratedCheckin`,
-      `GeneratedRating`, `GeneratedFollow` aggregate structs.
-- [ ] Add `UserPersona` (`name`, `description`, `style_affinities`).
+- [ ] Add `GeneratedBeer`, `GeneratedCheckin`, `GeneratedRating`,
+      `GeneratedFollow` aggregate structs.
+- [x] Add `GeneratedUser` aggregate struct. Carries `email`, `date_of_birth`,
+      and `password` — programmatically generated by the orchestrator, never
+      LLM-authored — so a downstream auth-account seeding consumer (outside
+      this repo tree's docs) can register real accounts from the pipeline's
+      SQLite export. Skips `user_id`/`metadata` for now, matching
+      `GeneratedBrewery`'s current (pre-`brewery_id`/`metadata`) shape. Not
+      yet wired into `IExportService`/`SqliteExportService` — `GenerateUsers`
+      currently only logs and holds `generated_users_` in memory; no `users`
+      table exists in the SQLite export yet (see §5).
+- [x] Add `UserPersona` (`name`, `description`, `style_affinities`).
 
 ## 2. Data Preloading
 
 `tooling/pipeline/includes/json_handling/`, fixture files.
 
-- [ ] Extract a `DataPreloader` interface; have `JsonLoader` implement it
-      instead of exposing only a static `LoadLocations()`.
+- [ ] Extract a `DataPreloader` interface; have `JsonLoader` implement it.
+      `JsonLoader` now also exposes static `LoadPersonas()` and
+      `LoadNamesByCountry()` (see below), but as additional static methods,
+      not yet behind a formal interface.
 - [ ] Add `LoadBeerStyles()`. `beer-styles.json` already exists in the repo
       and is already copied into the Docker image
       (`runpod/Dockerfile`), but no loader reads it yet, and the native
       CMake build doesn't copy it into `build/` at all — `CMakeLists.txt`'s
       "Runtime Assets" step only copies `locations.json` and `prompts/`.
-- [ ] Add `LoadPersonas()` and author `personas.json` (doesn't exist yet).
-- [ ] Add `LoadNamesByCountry()` and author `names-by-country.json` (doesn't
-      exist yet).
+- [x] Add `LoadPersonas()` and author `personas.json` (doesn't exist yet).
+- [x] Add `LoadNamesByCountry(forenames_filepath, surnames_filepath)`,
+      parsing `tooling/pipeline/forenames-by-country.json` and
+      `surnames-by-country.json` into a `NamesByCountry`. Both files are
+      vendored verbatim (unmodified, full multinational coverage) from
+      `sigpwned/popular-names-by-country-dataset` (CC0) — see
+      ETHICS-AND-KNOWN-ISSUES.md's Names-by-Country Dataset section for
+      provenance. Deliberately not pre-paired or filtered down to just the
+      countries in `locations.json`: keeping the source shape (including
+      per-forename gender) intact means the loader can support more
+      countries later, or gender-aware persona/bio generation, without
+      re-sourcing data.
 
 ## 3. Policy / Strategy Layer
 
@@ -83,10 +115,14 @@ Entirely new — no `includes/policy/` (or equivalent) directory exists today.
 - [ ] Extend the `DataGenerator` interface with `GenerateBeer`,
       `GenerateCheckin`, `GenerateRating` (today: only `GenerateBrewery` and
       `GenerateUser`).
-- [ ] Implement `LlamaGenerator::GenerateUser` for real. It currently
-      returns a hardcoded `{"test_user", "This is a test user profile from
-    {locale}."}` regardless of input — see the `// TODO` at the top of
-      `src/data_generation/llama/generate_user.cc`.
+- [x] Implement `LlamaGenerator::GenerateUser` for real, with a retry loop
+      mirroring `GenerateBrewery` (GBNF grammar, `ValidateUserJson`, up to 3
+      attempts with corrective feedback) and a new
+      `prompts/USER_GENERATION.md`. Changed the `DataGenerator::GenerateUser`
+      signature to
+      `(city : const EnrichedCity&, persona : const UserPersona&, name : const Name&) : UserResult`,
+      matching what the activity diagram actually passes. `MockGenerator::GenerateUser`
+      updated to match the new signature too.
 - [ ] Implement `MockGenerator::GenerateBeer` / `GenerateCheckin` /
       `GenerateRating`.
 - [ ] Add `IPromptFormatter::ExpectedArchitecture()` and

docs/pipeline/diagrams/planned/activity.puml

@@ -43,7 +43,7 @@ fork again
   :EnrichmentService::PreWarmLocationCache(sampled_locations);
 end fork
 fork
-  :JsonLoader::LoadNamesByCountry("names-by-country.json");
+  :JsonLoader::LoadNamesByCountry(\n  "forenames-by-country.json",\n  "surnames-by-country.json");
 fork again
   :JsonLoader::LoadPersonas("personas.json");
 end fork

docs/pipeline/diagrams/planned/class.puml

@@ -67,11 +67,47 @@ package "Domain: Models" {
   }
 
   class UserResult {
+    + first_name : std::string
+    + last_name : std::string
+    + gender : std::string
     + username : std::string
     + bio : std::string
     + activity_weight : float
   }
 
+  class Name {
+    + first_name : std::string
+    + last_name : std::string
+    + gender : std::string
+  }
+
+  class ForenameEntry {
+    + name : std::string
+    + gender : std::string
+  }
+
+  class NamesByCountry {
+    - forenames_by_country_ : std::unordered_map<std::string, std::vector<ForenameEntry>>
+    - surnames_by_country_ : std::unordered_map<std::string, std::vector<std::string>>
+    + SampleName(iso3166_1 : const std::string&,\n  rng : std::mt19937&) : std::optional<Name>
+  }
+
+  note right of NamesByCountry
+    Backed by two source-shaped maps,
+    keyed by ISO 3166-1 country code,
+    sourced from popular-names-by-country-dataset
+    (CC0) -- see ETHICS-AND-KNOWN-ISSUES.md.
+    Gender is preserved per forename so it can
+    be threaded through to persona/bio generation
+    later; surnames carry no gender in the source
+    data. Pairing happens at sample time, not at
+    fixture-authoring time, so no information from
+    the source dataset is discarded up front.
+  end note
+
+  NamesByCountry *-- "0..*" ForenameEntry
+  NamesByCountry ..> Name : produces
+
   class CheckinResult {
     + checked_in_at : std::string
     + note : std::string
@@ -110,9 +146,20 @@ package "Domain: Models" {
     + user_id : uint64_t
     + location : Location
     + user : UserResult
+    + email : std::string
+    + date_of_birth : std::string
+    + password : std::string
     + metadata : GenerationMetadata
   }
 
+  note right of GeneratedUser
+    email, date_of_birth, and password are
+    programmatically generated by the orchestrator
+    (not LLM-authored) so a downstream auth-account
+    seeding consumer can register real accounts from
+    this export. See ROADMAP.md §1.
+  end note
+
   class GeneratedCheckin {
     + checkin_id : uint64_t
     + user_id : uint64_t
@@ -321,15 +368,15 @@ package "Infrastructure: Data Preloading" {
   interface DataPreloader <<interface>> {
     + LoadLocations(filepath : const std::filesystem::path&) : std::vector<Location>
     + LoadBeerStyles(filepath : const std::filesystem::path&) : std::vector<BeerStyle>
-    + LoadPersonas(filepath : const std::filesystem::path&) : std::vector<Persona>
-    + LoadNamesByCountry(filepath : const std::filesystem::path&) : NamesByCountry
+    + LoadPersonas(filepath : const std::filesystem::path&) : std::vector<UserPersona>
+    + LoadNamesByCountry(forenames_filepath : const std::filesystem::path&,\n  surnames_filepath : const std::filesystem::path&) : NamesByCountry
   }
 
   class JsonLoader {
     + LoadLocations(filepath : const std::filesystem::path&) : std::vector<Location>
     + LoadBeerStyles(filepath : const std::filesystem::path&) : std::vector<BeerStyle>
-    + LoadPersonas(filepath : const std::filesystem::path&) : std::vector<Persona>
-    + LoadNamesByCountry(filepath : const std::filesystem::path&) : NamesByCountry
+    + LoadPersonas(filepath : const std::filesystem::path&) : std::vector<UserPersona>
+    + LoadNamesByCountry(forenames_filepath : const std::filesystem::path&,\n  surnames_filepath : const std::filesystem::path&) : NamesByCountry
   }
 
 }
@@ -380,7 +427,7 @@ package "Infrastructure: Data Generation" {
   interface DataGenerator <<interface>> {
     + GenerateBrewery(location : const Location&,\n  context : const LocationContext&) : BreweryResult
     + GenerateBeer(brewery_id : uint64_t,\n  location : const Location&,\n  context : const LocationContext&,\n  style : const BeerStyle&) : BeerResult
-    + GenerateUser(location : const Location&) : UserResult
+    + GenerateUser(city : const EnrichedCity&,\n  persona : const UserPersona&,\n  name : const Name&) : UserResult
     + GenerateCheckin(user : const GeneratedUser&,\n  brewery : const GeneratedBrewery&,\n  timestamp : const std::string&) : CheckinResult
     + GenerateRating(user : const GeneratedUser&,\n  beer : const GeneratedBeer&,\n  checkin_id : uint64_t) : RatingResult
   }

tooling/pipeline/CMakeLists.txt

@@ -151,6 +151,11 @@ target_sources(${PROJECT_NAME} PRIVATE
         src/json_handling/json_loader.cc
 )
 
+# --- data_model ---
+target_sources(${PROJECT_NAME} PRIVATE
+        src/data_model/names_by_country.cc
+)
+
 # --- application_options ---
 target_sources(${PROJECT_NAME} PRIVATE
         src/application_options/parse_arguments.cc
@@ -161,6 +166,7 @@ target_sources(${PROJECT_NAME} PRIVATE
         src/biergarten_pipeline_orchestrator/log_results.cc
         src/biergarten_pipeline_orchestrator/biergarten_pipeline_orchestrator.cc
         src/biergarten_pipeline_orchestrator/generate_breweries.cc
+        src/biergarten_pipeline_orchestrator/generate_users.cc
         src/biergarten_pipeline_orchestrator/run.cc
         src/biergarten_pipeline_orchestrator/query_cities_with_countries.cc
 )
@@ -204,6 +210,7 @@ target_sources(${PROJECT_NAME} PRIVATE
 # --- services: sqlite ---
 target_sources(${PROJECT_NAME} PRIVATE
 	src/services/sqlite/process_record.cc
+	src/services/sqlite/process_user_record.cc
 	src/services/sqlite/sqlite_export_service.cc
 	src/services/sqlite/finalize.cc
 	src/services/sqlite/initialize.cc
@@ -260,6 +267,21 @@ configure_file(
         ${CMAKE_BINARY_DIR}/locations.json
         COPYONLY
 )
+configure_file(
+        ${CMAKE_SOURCE_DIR}/personas.json
+        ${CMAKE_BINARY_DIR}/personas.json
+        COPYONLY
+)
+configure_file(
+        ${CMAKE_SOURCE_DIR}/forenames-by-country.json
+        ${CMAKE_BINARY_DIR}/forenames-by-country.json
+        COPYONLY
+)
+configure_file(
+        ${CMAKE_SOURCE_DIR}/surnames-by-country.json
+        ${CMAKE_BINARY_DIR}/surnames-by-country.json
+        COPYONLY
+)
 add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
         COMMAND ${CMAKE_COMMAND} -E copy_directory
         ${CMAKE_SOURCE_DIR}/prompts

tooling/pipeline/includes/biergarten_pipeline_orchestrator.h

@@ -17,7 +17,6 @@
 #include "data_model/generated_models.h"
 #include "services/database/export_service.h"
 #include "services/enrichment/enrichment_service.h"
-
 #include "services/logging/logger.h"
 
 /**
@@ -28,14 +27,15 @@
  */
 class BiergartenPipelineOrchestrator {
  public:
-/**
- * @brief Constructs the orchestrator with injected pipeline dependencies.
- *
- * @param context_service Provides regional context for locations.
- * @param generator Implementation (Llama or Mock) for brewery/user generation.
- * @param exporter Database backend for persisting generated records.
- * @param application_options CLI configuration and paths.
- */
+  /**
+   * @brief Constructs the orchestrator with injected pipeline dependencies.
+   *
+   * @param context_service Provides regional context for locations.
+   * @param generator Implementation (Llama or Mock) for brewery/user
+   * generation.
+   * @param exporter Database backend for persisting generated records.
+   * @param application_options CLI configuration and paths.
+   */
   BiergartenPipelineOrchestrator(
       std::shared_ptr<ILogger> logger,
       std::unique_ptr<IEnrichmentService> context_service,
@@ -52,10 +52,11 @@ class BiergartenPipelineOrchestrator {
    * 3. Generate brewery data for sampled cities
    *
    * @note STRUCTURAL CONCURRENCY REQUIREMENT:
-   * When transitioned to a multithreaded design, this method MUST structurally
-   * enforce that all deployed worker threads are joined before returning (e.g.
-   * by using std::jthread or a structured concurrency primitive). This ensures
-   * workers do not attempt to log to a closed channel during application teardown.
+   * When transitioned to a multithreaded design, this method MUST
+   * structurally enforce that all deployed worker threads are joined before
+   * returning (e.g. by using std::jthread or a structured concurrency
+   * primitive). This ensures workers do not attempt to log to a closed
+   * channel during application teardown.
    *
    * @return true if successful, false if not
    */
@@ -71,11 +72,11 @@ class BiergartenPipelineOrchestrator {
   /// @brief Generator dependency selected in the composition root.
   std::unique_ptr<DataGenerator> generator_;
 
-   /// @brief Storage backend for generated brewery records.
-   std::unique_ptr<IExportService> exporter_;
+  /// @brief Storage backend for generated brewery records.
+  std::unique_ptr<IExportService> exporter_;
 
-   /// @brief CLI configuration: paths, model settings, generation parameters.
-   ApplicationOptions application_options_;
+  /// @brief CLI configuration: paths, model settings, generation parameters.
+  ApplicationOptions application_options_;
 
   /**
    * @brief Load locations from JSON and sample cities.
@@ -91,12 +92,27 @@ class BiergartenPipelineOrchestrator {
    */
   void GenerateBreweries(std::span<const EnrichedCity> cities);
 
+  /**
+   * @brief Generate users grounded in sampled names and personas for
+   * enriched cities.
+   *
+   * Loads personas.json / forenames-by-country.json /
+   * surnames-by-country.json itself, mirroring how QueryCitiesWithCountries()
+   * owns its own locations.json load.
+   *
+   * @param cities Span of enriched city data.
+   */
+  void GenerateUsers(std::span<const EnrichedCity> cities);
+
   /**
    * @brief Log the generated brewery results.
    */
   void LogResults() const;
 
   /// @brief Stores generated brewery data.
-  std::vector<GeneratedBrewery> generated_breweries_;
+  std::vector<BreweryRecord> generated_breweries_;
+
+  /// @brief Stores generated user data.
+  std::vector<UserRecord> generated_users_;
 };
 #endif  // BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_DATA_GENERATOR_H_

tooling/pipeline/includes/concurrency/bounded_channel.h

@@ -9,10 +9,12 @@
 
 /**
  * @file bounded_channel.h
- * @brief Thread-safe, bounded multi-producer/multi-consumer synchronous channel.
+ * @brief Thread-safe, bounded multi-producer/multi-consumer synchronous
+ * channel.
  *
  * Intent: Enables asynchronous inter-thread communication with backpressure.
- * Models a synchronous channel where producers/consumers block on capacity limits.
+ * Models a synchronous channel where producers/consumers block on capacity
+ * limits.
  */
 
 /**

tooling/pipeline/includes/data_generation/data_generator.h

@@ -28,12 +28,16 @@ class DataGenerator {
                                         const std::string& region_context) = 0;
 
   /**
-   * @brief Generates a user profile for a locale.
+   * @brief Generates a user profile grounded in a sampled name and persona.
    *
-   * @param locale Locale hint used by generator.
+   * @param city Enriched city the user is associated with.
+   * @param persona Persona archetype grounding the generated bio.
+   * @param name Sampled first/last name (and gender) -- not LLM-invented.
    * @return User generation result.
    */
-  virtual UserResult GenerateUser(const std::string& locale) = 0;
+  virtual UserResult GenerateUser(const EnrichedCity& city,
+                                  const UserPersona& persona,
+                                  const Name& name) = 0;
 };
 
 #endif  // BIERGARTEN_PIPELINE_INCLUDES_DATA_GENERATION_DATA_GENERATOR_H_

tooling/pipeline/includes/data_generation/llama_generator.h

@@ -65,12 +65,15 @@ class LlamaGenerator final : public DataGenerator {
                                 const std::string& region_context) override;
 
   /**
-   * @brief Generates a user profile for the provided locale.
+   * @brief Generates a user profile grounded in a sampled name and persona.
    *
-   * @param locale Locale hint.
+   * @param city Enriched city the user is associated with.
+   * @param persona Persona archetype grounding the generated bio.
+   * @param name Sampled first/last name -- not LLM-invented.
    * @return Generated user profile.
    */
-  UserResult GenerateUser(const std::string& locale) override;
+  UserResult GenerateUser(const EnrichedCity& city, const UserPersona& persona,
+                          const Name& name) override;
 
  private:
   static constexpr int32_t kDefaultMaxTokens = 10000;

tooling/pipeline/includes/data_generation/llama_generator_helpers.h

@@ -47,4 +47,18 @@ void AppendTokenPiece(const llama_vocab* vocab, llama_token token,
 std::optional<std::string> ValidateBreweryJson(const std::string& raw,
                                                BreweryResult& brewery_out);
 
+/**
+ * @brief Validates and parses user JSON output.
+ *
+ * Only populates `username`, `bio`, and `activity_weight` -- `first_name`
+ * and `last_name` are not LLM-authored and are set separately from the
+ * sampled Name.
+ *
+ * @param raw Raw model output.
+ * @param user_out Parsed user payload.
+ * @return Validation error message if invalid, or std::nullopt on success.
+ */
+std::optional<std::string> ValidateUserJson(const std::string& raw,
+                                            UserResult& user_out);
+
 #endif  // BIERGARTEN_PIPELINE_INCLUDES_DATA_GENERATION_LLAMA_GENERATOR_HELPERS_H_

tooling/pipeline/includes/data_generation/mock_generator.h

@@ -28,12 +28,16 @@ class MockGenerator final : public DataGenerator {
                                 const std::string& region_context) override;
 
   /**
-   * @brief Generates deterministic user data for a locale.
+   * @brief Generates deterministic user data grounded in a sampled name and
+   * persona.
    *
-   * @param locale Locale hint.
+   * @param city Enriched city the user is associated with.
+   * @param persona Persona archetype.
+   * @param name Sampled first/last name, copied directly into the result.
    * @return Generated user result.
    */
-  UserResult GenerateUser(const std::string& locale) override;
+  UserResult GenerateUser(const EnrichedCity& city, const UserPersona& persona,
+                          const Name& name) override;
 
  private:
   /**
@@ -44,12 +48,25 @@ class MockGenerator final : public DataGenerator {
    */
   static size_t DeterministicHash(const Location& location);
 
+  /**
+   * @brief Combines city, persona, and name into a stable hash value.
+   *
+   * @param location City and country names.
+   * @param persona Persona archetype.
+   * @param name Sampled first/last name.
+   * @return Deterministic hash value.
+   */
+  static size_t DeterministicHash(const Location& location,
+                                  const UserPersona& persona, const Name& name);
+
   // Hash stride constants for deterministic distribution across fixed-size
   // arrays. These coprime strides spread hash values uniformly without
   // clustering, ensuring diverse output across different hash inputs.
   static constexpr size_t kNounHashStride = 7;
   static constexpr size_t kDescriptionHashStride = 13;
   static constexpr size_t kBioHashStride = 11;
+  static constexpr size_t kActivityWeightHashStride = 17;
+  static constexpr size_t kActivityWeightHashRange = 1000;
 
   static constexpr std::array<std::string_view, 18> kBreweryAdjectives = {
       "Craft",      "Heritage", "Local",  "Artisan",  "Pioneer",    "Golden",
@@ -124,7 +141,8 @@ class MockGenerator final : public DataGenerator {
       "Visits breweries for the stories, stays for the flagship pours.",
       "Craft beer fan mapping tasting notes and favorite brew routes.",
       "Always ready to trade recommendations for underrated local breweries.",
-      "Keeping a running list of must-try collab releases and tap takeovers."};
+      "Keeping a running list of must-try collab releases and tap "
+      "takeovers."};
 };
 
 #endif  // BIERGARTEN_PIPELINE_INCLUDES_DATA_GENERATION_MOCK_GENERATOR_H_

tooling/pipeline/includes/data_model/generated_models.h

@@ -3,8 +3,8 @@
 
 /**
  * @file data_model/generated_models.h
- * @brief Generated output models from the pipeline: brewery/user results, enriched data,
- * and complete generation results.
+ * @brief Generated output models from the pipeline: brewery/user results,
+ * enriched data, and complete generation results.
  */
 
 #include <string>
@@ -36,11 +36,27 @@ struct BreweryResult {
  * @brief Generated user profile payload.
  */
 struct UserResult {
+  /// @brief First (given) name, copied from the sampled Name -- not
+  /// LLM-invented.
+  std::string first_name{};
+
+  /// @brief Last (family) name, copied from the sampled Name -- not
+  /// LLM-invented.
+  std::string last_name{};
+
+  /// @brief Gender associated with the sampled first name, copied from the
+  /// sampled Name -- not LLM-invented.
+  std::string gender{};
+
   /// @brief Username handle.
   std::string username{};
 
   /// @brief Short user biography.
   std::string bio{};
+
+  /// @brief Relative check-in/activity weight for this user, used to drive
+  /// a J-curve activity profile in later pipeline phases.
+  float activity_weight{};
 };
 
 // ============================================================================
@@ -58,9 +74,24 @@ struct EnrichedCity {
 /**
  * @brief Helper struct to store generated brewery data.
  */
-struct GeneratedBrewery {
+struct BreweryRecord {
   Location location;
   BreweryResult brewery;
 };
 
+/**
+ * @brief Helper struct to store generated user data.
+ *
+ * `email`, `date_of_birth`, and `password` are programmatically generated by
+ * the orchestrator (never LLM-authored) so a downstream auth-account seeding
+ * consumer can register real accounts from the pipeline's SQLite export.
+ */
+struct UserRecord {
+  Location location;
+  UserResult user;
+  std::string email{};
+  std::string date_of_birth{};
+  std::string password{};
+};
+
 #endif  // BIERGARTEN_PIPELINE_INCLUDES_DATA_MODEL_GENERATED_MODELS_H_

tooling/pipeline/includes/data_model/models.h

@@ -53,15 +53,51 @@ struct Location {
   double longitude{};
 };
 
-/**
- * @brief Non-owning brewery location input.
- */
-struct BreweryLocation {
-  /// @brief City name.
-  std::string_view city_name;
+// ============================================================================
+// Name / Persona Models
+// ============================================================================
 
-  /// @brief Country name.
-  std::string_view country_name;
+/**
+ * @brief A sampled first/last name pair, with the source forename's gender.
+ *
+ * Produced by NamesByCountry::SampleName();
+ */
+struct Name {
+  /// @brief First (given) name.
+  std::string first_name{};
+
+  /// @brief Last (family) name.
+  std::string last_name{};
+
+  /// @brief Gender associated with the sampled forename (e.g. "M", "F"), as
+  /// reported by the source dataset.
+  std::string gender{};
+};
+
+/**
+ * @brief A single forename entry from the names-by-country fixture data.
+ */
+struct ForenameEntry {
+  /// @brief Romanized forename.
+  std::string name{};
+
+  /// @brief Gender associated with this forename, as reported by the source
+  /// dataset (e.g. "M", "F").
+  std::string gender{};
+};
+
+/**
+ * @brief A persona archetype used to ground LLM-generated user bios.
+ */
+struct UserPersona {
+  /// @brief Persona display name (e.g. "Hophead Explorer").
+  std::string name{};
+
+  /// @brief Short description of the persona's interests and voice.
+  std::string description{};
+
+  /// @brief Beer styles this persona gravitates toward.
+  std::vector<std::string> style_affinities{};
 };
 
 // ============================================================================
@@ -72,7 +108,7 @@ struct BreweryLocation {
  * @brief LLM sampling parameters.
  */
 struct SamplingOptions {
-  /// @brief LLM sampling temperature (0.0 to 1.0, higher = more random).
+  /// @brief LLM sampling temperature (higher = more random).
   float temperature = 1.0F;
 
   /// @brief LLM nucleus sampling top-p parameter.
@@ -101,8 +137,6 @@ struct GeneratorOptions {
   /// @brief Use mocked generator instead of actual LLM inference.
   bool use_mocked = false;
 
-
-
   /// @brief Specific sampling parameters for this generator.
   /// If nullopt, the application should use global defaults.
   std::optional<SamplingOptions> sampling;
@@ -139,7 +173,7 @@ struct ApplicationOptions {
 // Function Declarations
 // ============================================================================
 
-std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
-                                                std::shared_ptr<ILogger> logger = nullptr);
+std::optional<ApplicationOptions> ParseArguments(
+    const int argc, char** argv, std::shared_ptr<ILogger> logger = nullptr);
 
 #endif  // BIERGARTEN_PIPELINE_INCLUDES_DATA_MODEL_MODELS_H_

tooling/pipeline/includes/data_model/names_by_country.h

@@ -0,0 +1,51 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_DATA_MODEL_NAMES_BY_COUNTRY_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_DATA_MODEL_NAMES_BY_COUNTRY_H_
+
+/**
+ * @file data_model/names_by_country.h
+ * @brief Sampling over the names-by-country fixture data.
+ */
+
+#include <optional>
+#include <random>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "data_model/models.h"
+
+/**
+ * @brief Samples locale-appropriate names from curated forename/surname
+ * fixture data, keyed by ISO 3166-1 country code.
+ *
+ * Forenames and surnames are kept in separate maps (mirroring the source
+ * dataset's own shape) so per-forename gender is preserved; pairing happens
+ * at sample time rather than being precomputed, so no information from the
+ * source dataset is discarded up front.
+ */
+class NamesByCountry {
+ public:
+  NamesByCountry(std::unordered_map<std::string, std::vector<ForenameEntry>>
+                     forenames_by_country,
+                 std::unordered_map<std::string, std::vector<std::string>>
+                     surnames_by_country);
+
+  /**
+   * @brief Samples a first/last name pair for the given country.
+   *
+   * @param iso3166_1 ISO 3166-1 country code to sample for.
+   * @param rng Random source used for sampling.
+   * @return A sampled Name, or std::nullopt if the country has no forename
+   * or no surname entries.
+   */
+  [[nodiscard]] std::optional<Name> SampleName(const std::string& iso3166_1,
+                                               std::mt19937& rng) const;
+
+ private:
+  std::unordered_map<std::string, std::vector<ForenameEntry>>
+      forenames_by_country_;
+  std::unordered_map<std::string, std::vector<std::string>>
+      surnames_by_country_;
+};
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_DATA_MODEL_NAMES_BY_COUNTRY_H_

tooling/pipeline/includes/json_handling/json_loader.h

@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "data_model/models.h"
+#include "data_model/names_by_country.h"
 #include "services/logging/logger.h"
 
 /// @brief Loads curated world locations from a JSON file into memory.
@@ -20,6 +21,23 @@ class JsonLoader {
   static std::vector<Location> LoadLocations(
       const std::filesystem::path& filepath,
       std::shared_ptr<ILogger> logger = nullptr);
+
+  /// @brief Parses a JSON array file and returns all persona records.
+  static std::vector<UserPersona> LoadPersonas(
+      const std::filesystem::path& filepath,
+      std::shared_ptr<ILogger> logger = nullptr);
+
+  /**
+   * @brief Parses the names-by-country fixture pair into a sampling-capable
+   * NamesByCountry.
+   *
+   * @param forenames_filepath Path to forenames-by-country.json.
+   * @param surnames_filepath Path to surnames-by-country.json.
+   */
+  static NamesByCountry LoadNamesByCountry(
+      const std::filesystem::path& forenames_filepath,
+      const std::filesystem::path& surnames_filepath,
+      std::shared_ptr<ILogger> logger = nullptr);
 };
 
 #endif  // BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_JSON_LOADER_H_

tooling/pipeline/includes/services/database/export_service.h

@@ -33,7 +33,14 @@ class IExportService {
    *
    * @param brewery Generated brewery payload to store.
    */
-  virtual uint64_t ProcessRecord(const GeneratedBrewery& brewery) = 0;
+  virtual uint64_t ProcessRecord(const BreweryRecord& brewery) = 0;
+
+  /**
+   * @brief Persists one generated user record.
+   *
+   * @param user Generated user payload to store.
+   */
+  virtual uint64_t ProcessRecord(const UserRecord& user) = 0;
 
   /// @brief Finalizes the export destination.
   virtual void Finalize() = 0;

tooling/pipeline/includes/services/database/sqlite_export_service.h

@@ -11,8 +11,8 @@
 #include <string>
 #include <unordered_map>
 
-#include "data_model/models.h"
 #include "../datetime/date_time_provider.h"
+#include "data_model/models.h"
 #include "export_service.h"
 #include "sqlite_export_service_helpers.h"
 
@@ -30,7 +30,8 @@ class SqliteExportService final : public IExportService {
   SqliteExportService& operator=(SqliteExportService&&) = delete;
 
   void Initialize() override;
-  uint64_t ProcessRecord(const GeneratedBrewery& brewery) override;
+  uint64_t ProcessRecord(const BreweryRecord& brewery) override;
+  uint64_t ProcessRecord(const UserRecord& user) override;
   void Finalize() override;
 
  private:
@@ -46,6 +47,15 @@ class SqliteExportService final : public IExportService {
   [[nodiscard]] std::filesystem::path BuildDatabasePath() const;
   [[nodiscard]] static std::string BuildLocationKey(const Location& location);
 
+  /**
+   * @brief Returns the row id for @p location, inserting it first if it has
+   * not already been seen during this run.
+   *
+   * Shared by both ProcessRecord() overloads so breweries and users
+   * referencing the same location resolve to the same row.
+   */
+  [[nodiscard]] sqlite3_int64 ResolveLocationId(const Location& location);
+
   std::unique_ptr<IDateTimeProvider> date_time_provider_;
   std::filesystem::path output_path_;
   std::string run_timestamp_utc_;
@@ -53,6 +63,7 @@ class SqliteExportService final : public IExportService {
   SqliteDatabaseHandle db_handle_;
   SqliteStatementHandle insert_location_stmt_;
   SqliteStatementHandle insert_brewery_stmt_;
+  SqliteStatementHandle insert_user_stmt_;
   bool transaction_open_ = false;
   std::unordered_map<std::string, sqlite3_int64> location_cache_;
 };

tooling/pipeline/includes/services/database/sqlite_statement_helpers.h

@@ -50,6 +50,27 @@ CREATE INDEX IF NOT EXISTS idx_breweries_location_id ON breweries(location_id);
 
 )sql";
 
+inline constexpr std::string_view kCreateUsersTableSql = R"sql(
+
+CREATE TABLE IF NOT EXISTS users (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  location_id INTEGER NOT NULL,
+  first_name TEXT NOT NULL,
+  last_name TEXT NOT NULL,
+  gender TEXT NOT NULL,
+  username TEXT NOT NULL,
+  bio TEXT NOT NULL,
+  activity_weight REAL NOT NULL,
+  email TEXT NOT NULL UNIQUE,
+  date_of_birth TEXT NOT NULL,
+  password TEXT NOT NULL,
+  FOREIGN KEY(location_id) REFERENCES locations(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_users_location_id ON users(location_id);
+
+)sql";
+
 inline constexpr std::string_view kInsertLocationSql = R"sql(
 INSERT INTO locations (
   city,
@@ -73,6 +94,21 @@ INSERT INTO breweries (
 ) VALUES (?, ?, ?, ?, ?);
 )sql";
 
+inline constexpr std::string_view kInsertUserSql = R"sql(
+INSERT INTO users (
+  location_id,
+  first_name,
+  last_name,
+  gender,
+  username,
+  bio,
+  activity_weight,
+  email,
+  date_of_birth,
+  password
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
+)sql";
+
 inline constexpr int kLocationCityBindIndex = 1;
 inline constexpr int kLocationStateProvinceBindIndex = 2;
 inline constexpr int kLocationIso31662BindIndex = 3;
@@ -88,6 +124,17 @@ inline constexpr int kBreweryEnglishDescriptionBindIndex = 3;
 inline constexpr int kBreweryLocalNameBindIndex = 4;
 inline constexpr int kBreweryLocalDescriptionBindIndex = 5;
 
+inline constexpr int kUserLocationIdBindIndex = 1;
+inline constexpr int kUserFirstNameBindIndex = 2;
+inline constexpr int kUserLastNameBindIndex = 3;
+inline constexpr int kUserGenderBindIndex = 4;
+inline constexpr int kUserUsernameBindIndex = 5;
+inline constexpr int kUserBioBindIndex = 6;
+inline constexpr int kUserActivityWeightBindIndex = 7;
+inline constexpr int kUserEmailBindIndex = 8;
+inline constexpr int kUserDateOfBirthBindIndex = 9;
+inline constexpr int kUserPasswordBindIndex = 10;
+
 SqliteStatementHandle PrepareStatement(const SqliteDatabaseHandle& db_handle,
                                        std::string_view sql,
                                        const char* action);

tooling/pipeline/includes/services/logging/log_entry.h

@@ -34,8 +34,9 @@ enum class LogLevel {
  * pipeline that emitted it.
  */
 enum class PipelinePhase {
-  Startup,                   ///< Initialization and validation.
-  UserGeneration,            ///< User profile generation.
+  Startup,         ///< Initialization and validation.
+  Enrichment,      ///< Location/context enrichment (e.g. Wikipedia lookups).
+  UserGeneration,  ///< User profile generation.
   BreweryAndBeerGeneration,  ///< Brewery and beer data generation.
   CheckinGeneration,         ///< Checkin (visit) record generation.
   RatingGeneration,          ///< Rating and review generation.
@@ -45,7 +46,8 @@ enum class PipelinePhase {
 
 /**
  * @struct LogDTO
- * @brief User-provided subset of log fields. Used to capture call-site info transparently.
+ * @brief User-provided subset of log fields. Used to capture call-site info
+ * transparently.
  */
 struct LogDTO {
   LogLevel level;
@@ -73,7 +75,6 @@ struct LogEntry {
   /// @brief Thread responsible for emitting the log.
   std::thread::id thread_id{};
 
-
   /// @brief Severity level of this entry.
   LogLevel level;
 
@@ -82,7 +83,6 @@ struct LogEntry {
 
   /// @brief Log message text.
   std::string message;
-
 };
 
 #endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_

tooling/pipeline/includes/services/logging/logger.h

@@ -39,7 +39,8 @@ class ILogger {
    */
   void Log(LogDTO payload,
            std::source_location origin = std::source_location::current(),
-           std::chrono::system_clock::time_point timestamp = std::chrono::system_clock::now(),
+           std::chrono::system_clock::time_point timestamp =
+               std::chrono::system_clock::now(),
            std::thread::id thread_id = std::this_thread::get_id()) {
     LogEntry entry;
     entry.timestamp = timestamp;

tooling/pipeline/includes/web_client/http_web_client.h

@@ -1,19 +1,18 @@
 /**
-* @file web_client/http_web_client.h
-* @brief cpp-httplib implementation of the WebClient interface.
-*/
+ * @file web_client/http_web_client.h
+ * @brief cpp-httplib implementation of the WebClient interface.
+ */
 
 #ifndef BIERGARTEN_PIPELINE_INCLUDES_WEB_CLIENT_HTTP_WEB_CLIENT_H_
 #define BIERGARTEN_PIPELINE_INCLUDES_WEB_CLIENT_HTTP_WEB_CLIENT_H_
 
-
-#include "web_client/web_client.h"
-#include "services/logging/logger.h"
-
 #include <memory>
 #include <string>
 #include <utility>
 
+#include "services/logging/logger.h"
+#include "web_client/web_client.h"
+
 /**
  * @brief WebClient implementation backed by cpp-httplib.
  *
@@ -26,7 +25,7 @@
  * bound to a single origin at construction time.
  */
 class HttpWebClient final : public WebClient {
-public:
+ public:
   explicit HttpWebClient(std::shared_ptr<ILogger> logger)
       : logger_(std::move(logger)) {}
   ~HttpWebClient() override = default;
@@ -34,7 +33,8 @@ public:
   /**
    * @brief Executes a blocking HTTP/HTTPS GET request against a full URL.
    *
-   * @param url Fully-qualified URL, e.g. "https://en.wikipedia.org/api/rest_v1/page/summary/Berlin"
+   * @param url Fully-qualified URL, e.g.
+   * "https://en.wikipedia.org/api/rest_v1/page/summary/Berlin"
    * @return Response body on HTTP 2xx; throws std::runtime_error otherwise.
    */
   std::string Get(const std::string& url) override;
@@ -52,5 +52,4 @@ public:
   std::shared_ptr<ILogger> logger_;
 };
 
-
 #endif

tooling/pipeline/personas.json

@@ -0,0 +1,42 @@
+[
+  {
+    "name": "Hophead Explorer",
+    "description": "Chases the newest hop varieties and double-digit IBUs, tracking hazy releases and limited tap takeovers across town.",
+    "style_affinities": ["American IPA", "Double IPA", "New England IPA", "Black IPA"]
+  },
+  {
+    "name": "Malt & Tradition Loyalist",
+    "description": "Prefers clean, balanced lagers brewed the way their region has brewed them for generations, and is quick to defend a well-made Helles.",
+    "style_affinities": ["Munich Helles", "Vienna Lager", "Märzen", "Festbier"]
+  },
+  {
+    "name": "Dark & Roasty Devotee",
+    "description": "Orders the darkest beer on the board year-round, drawn to roasted malt, coffee, and chocolate notes over carbonated lightness.",
+    "style_affinities": ["Imperial Stout", "Robust Porter", "Baltic Porter", "Oatmeal Stout"]
+  },
+  {
+    "name": "Sour & Wild Forager",
+    "description": "Seeks out barrel-aged, spontaneously fermented, and funky beers, and will travel for a fresh bottling of something wild.",
+    "style_affinities": ["Lambic", "Gueuze", "Flanders Red Ale", "Wild Ale"]
+  },
+  {
+    "name": "Session Sipper",
+    "description": "Values an easy-drinking pint that holds up over a long afternoon at the taproom more than raw intensity or novelty.",
+    "style_affinities": ["Session IPA", "Ordinary Bitter", "Cream Ale", "Blonde Ale"]
+  },
+  {
+    "name": "Belgian Abbey Pilgrim",
+    "description": "Collects abbey and trappist releases, drawn to the dried-fruit esters and warming strength of classic Belgian ales.",
+    "style_affinities": ["Belgian Tripel", "Belgian Dubbel", "Belgian Quadrupel", "Trappist Single"]
+  },
+  {
+    "name": "Wheat & Citrus Casual",
+    "description": "Reaches for something light, cloudy, and refreshing, usually with a citrus or coriander note, especially on a patio in summer.",
+    "style_affinities": ["Hefeweizen", "Witbier", "American Wheat Beer", "Berliner Weisse"]
+  },
+  {
+    "name": "Big & Boozy Connoisseur",
+    "description": "Sips slowly from a snifter, seeking out high-ABV releases meant for aging and savoring rather than quick refreshment.",
+    "style_affinities": ["English Barleywine", "Wee Heavy", "Doppelbock", "Old Ale"]
+  }
+]

tooling/pipeline/prompts/USER_GENERATION.md

@@ -0,0 +1,122 @@
+# FULL SYSTEM PROMPT
+
+You are a craft beer community profile writer. You write short, first-person
+biographies for fictional users of a brewery-discovery app, grounded in the
+exact name, locale, and persona provided. You do not invent the user's name --
+it is given to you and must not be altered, translated, or abbreviated beyond
+forming a username.
+
+You will receive the inputs like this:
+
+## NAME:
+
+[First name] [Last name]
+
+## GENDER:
+
+[Gender associated with the given first name]
+
+## CITY:
+
+[City Name]
+
+## COUNTRY:
+
+[Country Name]
+
+## PERSONA:
+
+[Persona archetype name]
+
+## PERSONA DESCRIPTION:
+
+[What this persona cares about and how they talk about beer]
+
+## STYLE AFFINITIES:
+
+[Comma-separated beer styles this persona favors]
+
+## CRITICAL OUTPUT FORMAT (READ CAREFULLY):
+
+ABSOLUTELY NO MARKDOWN FORMATTING. Do NOT wrap your response in json or ```
+blocks.
+
+Do not add markdown, code fences, or postscript around the final JSON object.
+Do not say "Here is the JSON" or "Enjoy!".
+
+The JSON must contain exactly three keys ("username", "bio",
+"activity_weight") in that order. Do not rename or add any other keys.
+
+ESCAPE ALL QUOTES inside the bio field using \", or use single quotes (' ')
+instead.
+
+DO NOT use actual line breaks (\n) inside any string. Keep the bio as one
+continuous string.
+
+The bio must be between 25 and 60 words, written in first person, and must
+read as something this specific person would write about themselves -- not a
+generic profile blurb.
+
+`activity_weight` is a number between 0 and 1 (inclusive) representing how
+often this persona checks in at breweries relative to other users. Persona
+archetypes implying frequent, habitual brewery visits should skew higher;
+casual or occasional-visitor personas should skew lower. Do not default to
+0.5 -- vary it meaningfully based on the persona description.
+
+Expected JSON format:
+
+```json
+{
+  "username": "a handle derived from the given name",
+  "bio": "The first-person bio goes here.",
+  "activity_weight": 0.62
+}
+```
+
+## CONTENT RULES AND CONSTRAINTS:
+
+### THE USERNAME:
+
+Derive the username from the given first and/or last name (e.g. lowercase,
+abbreviated, or combined with a short word or number tied to the persona's
+style affinities). Do not invent an unrelated handle. Do not include spaces.
+
+### THE BIO:
+
+Ground the bio in the supplied persona description and style affinities --
+mention at least one specific beer style from the style affinities list, in a
+way that sounds like a personal preference rather than a list. Reference the
+city or country naturally if it fits, but do not force it.
+
+### VOICE & PERSPECTIVE:
+
+Write in the first person ("I"/"my"). The tone should match the persona:
+an enthusiastic explorer sounds different from a relaxed, easy-drinking
+regular. Do not write in second or third person.
+
+### THE BLOCKLIST (FORBIDDEN CONCEPTS):
+
+You absolutely cannot use the following words and phrases. Make sure your
+final output doesn't have any of these:
+
+- "hidden gem"
+- "passion"
+- "authentic"
+- "craft beer enthusiast"
+- "beer connoisseur"
+- "journey"
+
+#### FORBIDDEN WRITING PATTERNS
+
+The following patterns are common AI writing pitfalls and must not appear in
+the bio:
+
+- Negative parallelism constructions: "It's not X, it's Y"
+- Inflated significance phrases: "stands as a testament," "plays a vital
+  role," "deeply rooted"
+- Superficial trailing analyses: sentences ending in -ing words that add
+  opinion without content
+- Promotional travel-copy tone: "breathtaking," "must-visit," "vibrant"
+- Overused conjunctive transitions used as sentence openers: "Moreover,"
+  "Furthermore," "In addition"
+- Rule of three: do not consistently organise ideas or examples in triplets

tooling/pipeline/src/application_options/parse_arguments.cc

@@ -15,8 +15,6 @@ std::optional<ApplicationOptions> ParseArguments(
 
   opt("help,h", "Produce help message");
 
-  // Defaults sourced from SamplingOptions{} so the CLI and LlamaGenerator
-  // share a single source of truth — changing the struct updates both.
   auto add_sampling_options = [&]() -> void {
     const SamplingOptions sampling_defaults{};
     opt("temperature",
@@ -53,7 +51,8 @@ std::optional<ApplicationOptions> ParseArguments(
         prog_opts::value<std::string>()->default_value("pipeline.log"),
         "Path for application logs");
     opt("prompt-dir", prog_opts::value<std::string>()->default_value(""),
-        "Directory containing named prompt files (e.g. BREWERY_GENERATION.md)."
+        "Directory containing named prompt files (e.g. "
+        "BREWERY_GENERATION.md)."
         " Required when not using --mocked.");
     opt("location-count", prog_opts::value<uint32_t>()->default_value(10));
   };
@@ -72,11 +71,11 @@ std::optional<ApplicationOptions> ParseArguments(
     })();
     if (logger) {
       logger->Log(LogDTO{.level = LogLevel::Info,
-                   .phase = PipelinePhase::Startup,
-                   .message = title});
+                         .phase = PipelinePhase::Startup,
+                         .message = title});
       logger->Log(LogDTO{.level = LogLevel::Info,
-                   .phase = PipelinePhase::Startup,
-                   .message = usage});
+                         .phase = PipelinePhase::Startup,
+                         .message = usage});
     }
     return std::nullopt;
   }
@@ -91,8 +90,8 @@ std::optional<ApplicationOptions> ParseArguments(
       help_stream << "\n" << desc;
       if (logger) {
         logger->Log(LogDTO{.level = LogLevel::Info,
-                     .phase = PipelinePhase::Startup,
-                     .message = help_stream.str()});
+                           .phase = PipelinePhase::Startup,
+                           .message = help_stream.str()});
       }
       return std::nullopt;
     }
@@ -108,14 +107,16 @@ std::optional<ApplicationOptions> ParseArguments(
     const std::string model_path = var_map["model"].as<std::string>();
     const int n_gpu_layers = var_map["n-gpu-layers"].as<int>();
 
-    // Enforce mutual exclusivity before any further configuration is applied.
+    // Enforce mutual exclusivity before any further configuration is
+    // applied.
     if (use_mocked && !model_path.empty()) {
       const std::string msg =
-          "Invalid arguments: --mocked and --model are mutually exclusive";
+          "Invalid arguments: --mocked and --model are mutually "
+          "exclusive";
       if (logger) {
         logger->Log(LogDTO{.level = LogLevel::Error,
-                     .phase = PipelinePhase::Startup,
-                     .message = msg});
+                           .phase = PipelinePhase::Startup,
+                           .message = msg});
       } else {
         std::cerr << msg << std::endl;
       }
@@ -124,11 +125,12 @@ std::optional<ApplicationOptions> ParseArguments(
 
     if (!use_mocked && model_path.empty()) {
       const std::string msg =
-          "Invalid arguments: either --mocked or --model must be specified";
+          "Invalid arguments: either --mocked or --model must be "
+          "specified";
       if (logger) {
         logger->Log(LogDTO{.level = LogLevel::Error,
-                     .phase = PipelinePhase::Startup,
-                     .message = msg});
+                           .phase = PipelinePhase::Startup,
+                           .message = msg});
       } else {
         std::cerr << msg << std::endl;
       }
@@ -139,7 +141,8 @@ std::optional<ApplicationOptions> ParseArguments(
     // generator has no use for it and should not require it to be present.
     if (!use_mocked && options.pipeline.prompt_dir.empty()) {
       const std::string msg =
-          "Invalid arguments: --prompt-dir is required when not using --mocked";
+          "Invalid arguments: --prompt-dir is required when not using "
+          "--mocked";
       if (logger) {
         logger->Log({.level = LogLevel::Error,
                      .phase = PipelinePhase::Startup,
@@ -152,7 +155,6 @@ std::optional<ApplicationOptions> ParseArguments(
 
     options.generator.use_mocked = use_mocked;
     options.generator.model_path = model_path;
-    // options.generator.n_gpu_layers = n_gpu_layers;
 
     // Only populate sampling config when the user explicitly overrides at
     // least one value. Leaving it as std::nullopt lets LlamaGenerator fall
@@ -171,8 +173,8 @@ std::optional<ApplicationOptions> ParseArguments(
             "Sampling parameters are ignored when using --mocked";
         if (logger) {
           logger->Log(LogDTO{.level = LogLevel::Warn,
-                       .phase = PipelinePhase::Startup,
-                       .message = msg});
+                             .phase = PipelinePhase::Startup,
+                             .message = msg});
         } else {
           std::cerr << msg << std::endl;
         }
@@ -197,8 +199,8 @@ std::optional<ApplicationOptions> ParseArguments(
         exception.what();
     if (logger) {
       logger->Log(LogDTO{.level = LogLevel::Error,
-                   .phase = PipelinePhase::Startup,
-                   .message = msg});
+                         .phase = PipelinePhase::Startup,
+                         .message = msg});
     }
     return std::nullopt;
   } catch (...) {
@@ -206,8 +208,8 @@ std::optional<ApplicationOptions> ParseArguments(
         "Failed to parse command-line arguments: unknown error";
     if (logger) {
       logger->Log(LogDTO{.level = LogLevel::Error,
-                   .phase = PipelinePhase::Startup,
-                   .message = msg});
+                         .phase = PipelinePhase::Startup,
+                         .message = msg});
     }
     return std::nullopt;
   }

tooling/pipeline/src/biergarten_pipeline_orchestrator/biergarten_pipeline_orchestrator.cc

@@ -12,7 +12,7 @@ BiergartenPipelineOrchestrator::BiergartenPipelineOrchestrator(
     std::unique_ptr<IEnrichmentService> context_service,
     std::unique_ptr<DataGenerator> generator,
     std::unique_ptr<IExportService> exporter,
-    const ApplicationOptions &app_options)
+    const ApplicationOptions& app_options)
     : logger_(std::move(logger)),
       context_service_(std::move(context_service)),
       generator_(std::move(generator)),

tooling/pipeline/src/biergarten_pipeline_orchestrator/generate_breweries.cc

@@ -5,6 +5,7 @@
 
 #include <chrono>
 #include <format>
+#include <optional>
 
 #include "biergarten_pipeline_orchestrator.h"
 #include "services/logging/logger.h"
@@ -19,50 +20,69 @@ void BiergartenPipelineOrchestrator::GenerateBreweries(
   size_t skipped_count = 0;
   size_t export_failed_count = 0;
 
-  for (const auto& [location, region_context] : cities) {
+  const auto generate_record =
+      [this, &skipped_count](
+          const Location& location,
+          const std::string& region_context) -> std::optional<BreweryRecord> {
     try {
       const BreweryResult brewery =
           generator_->GenerateBrewery(location, region_context);
-
-      const GeneratedBrewery gen{.location = location, .brewery = brewery};
-
-      generated_breweries_.push_back(gen);
-
-      try {
-        exporter_->ProcessRecord(gen);
-      } catch (const std::exception& export_exception) {
-        ++export_failed_count;
-
-        logger_->Log(
-            {.level = LogLevel::Warn,
-             .phase = PipelinePhase::BreweryAndBeerGeneration,
-             .message =
-                 std::format("[Pipeline] Generated brewery for '{}' ({}) but SQLite export failed: {}",
-                 location.city, location.country, export_exception.what())});
-      }
+      return BreweryRecord{.location = location, .brewery = brewery};
     } catch (const std::exception& e) {
       ++skipped_count;
 
-      logger_->Log({.level = LogLevel::Warn,
-                    .phase = PipelinePhase::BreweryAndBeerGeneration,
-                    .message = std::format("[Pipeline] Skipping city '{}' ({}): brewery generation failed: {}",
-                               location.city, location.country, e.what())});
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::BreweryAndBeerGeneration,
+           .message = std::format("[Pipeline] Skipping city '{}' ({}): brewery "
+                                  "generation failed: {}",
+                                  location.city, location.country, e.what())});
+      return std::nullopt;
     }
+  };
+
+  const auto export_record = [this, &export_failed_count](
+                                 const BreweryRecord& record) {
+    try {
+      exporter_->ProcessRecord(record);
+    } catch (const std::exception& export_exception) {
+      ++export_failed_count;
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::BreweryAndBeerGeneration,
+           .message = std::format("[Pipeline] Generated brewery for '{}' ({}) "
+                                  "but SQLite export failed: {}",
+                                  record.location.city, record.location.country,
+                                  export_exception.what())});
+    }
+  };
+
+  for (const auto& [location, region_context] : cities) {
+    const std::optional<BreweryRecord> record =
+        generate_record(location, region_context);
+    if (!record.has_value()) {
+      continue;
+    }
+
+    generated_breweries_.push_back(*record);
+    export_record(*record);
   }
 
   if (skipped_count > 0) {
-    logger_->Log({.level = LogLevel::Warn,
-                  .phase = PipelinePhase::BreweryAndBeerGeneration,
-                  .message = std::format(
-                      "[Pipeline] Skipped {} city/cities due to generation errors",
-                      skipped_count)});
+    logger_->Log(
+        {.level = LogLevel::Warn,
+         .phase = PipelinePhase::BreweryAndBeerGeneration,
+         .message = std::format(
+             "[Pipeline] Skipped {} city/cities due to generation errors",
+             skipped_count)});
   }
 
   if (export_failed_count > 0) {
-    logger_->Log({.level = LogLevel::Warn,
-                  .phase = PipelinePhase::Teardown,
-                  .message = std::format(
-                      "[Pipeline] Failed to export {} generated brewery/breweries to SQLite",
-                      export_failed_count)});
+    logger_->Log(
+        {.level = LogLevel::Warn,
+         .phase = PipelinePhase::Teardown,
+         .message = std::format("[Pipeline] Failed to export {} generated "
+                                "brewery/breweries to SQLite",
+                                export_failed_count)});
   }
 }

tooling/pipeline/src/biergarten_pipeline_orchestrator/generate_users.cc

@@ -0,0 +1,205 @@
+/**
+ * @file biergarten_pipeline_orchestrator/generate_users.cc
+ * @brief BiergartenDataGenerator::GenerateUsers() implementation.
+ */
+
+#include <cctype>
+#include <chrono>
+#include <format>
+#include <optional>
+#include <random>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <unordered_set>
+
+#include "biergarten_pipeline_orchestrator.h"
+#include "json_handling/json_loader.h"
+#include "services/logging/logger.h"
+
+namespace {
+
+std::string Sanitize(std::string_view value) {
+  std::string out;
+  out.reserve(value.size());
+  for (const char character : value) {
+    if (std::isalnum(static_cast<unsigned char>(character)) != 0) {
+      out.push_back(static_cast<char>(
+          std::tolower(static_cast<unsigned char>(character))));
+    }
+  }
+  return out;
+}
+
+std::string BuildEmail(const Name& name,
+                       std::unordered_set<std::string>& used_local_parts) {
+  const std::string base =
+      std::format("{}.{}", Sanitize(name.first_name), Sanitize(name.last_name));
+
+  std::string local_part = base;
+  uint32_t suffix = 1;
+
+  while (used_local_parts.contains(local_part)) {
+    local_part = std::format("{}{}", base, suffix);
+    ++suffix;
+  }
+
+  used_local_parts.insert(local_part);
+
+  return std::format("{}@thebiergarten.app", local_part);
+}
+
+std::string GenerateDateOfBirth(std::mt19937& rng) {
+  using namespace std::chrono;
+
+  constexpr int kMinAge = 19;
+  constexpr int kMaxAge = 48;
+  constexpr int kMaxDayOffset = 364;
+
+  std::uniform_int_distribution<int> age_dist(kMinAge, kMaxAge);
+  std::uniform_int_distribution<int> day_offset_dist(0, kMaxDayOffset);
+
+  const year_month_day today{floor<days>(system_clock::now())};
+  const year_month_day birth_year_anchor{today.year() - years{age_dist(rng)},
+                                         today.month(), today.day()};
+  const sys_days birth_date =
+      sys_days{birth_year_anchor} - days{day_offset_dist(rng)};
+  const year_month_day birth_ymd{birth_date};
+
+  return std::format("{:04}-{:02}-{:02}", static_cast<int>(birth_ymd.year()),
+                     static_cast<unsigned>(birth_ymd.month()),
+                     static_cast<unsigned>(birth_ymd.day()));
+}
+
+std::string GenerateRandomPassword(std::mt19937& rng) {
+  constexpr size_t k_password_length = 32;
+  constexpr std::string_view k_charset =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&"
+      "*";
+
+  std::uniform_int_distribution<size_t> char_dist(0, k_charset.size() - 1);
+
+  std::string password;
+  password.reserve(k_password_length);
+  for (size_t i = 0; i < k_password_length; ++i) {
+    password.push_back(k_charset[char_dist(rng)]);
+  }
+  return password;
+}
+
+}  // namespace
+
+void BiergartenPipelineOrchestrator::GenerateUsers(
+    std::span<const EnrichedCity> cities) {
+  logger_->Log({.level = LogLevel::Info,
+                .phase = PipelinePhase::UserGeneration,
+                .message = "=== SAMPLE USER GENERATION ==="});
+
+  const std::vector<UserPersona> personas =
+      JsonLoader::LoadPersonas("personas.json", logger_);
+
+  if (personas.empty()) {
+    throw std::runtime_error(
+        "No personas available in personas.json for user generation");
+  }
+
+  const NamesByCountry names_by_country = JsonLoader::LoadNamesByCountry(
+      "forenames-by-country.json", "surnames-by-country.json", logger_);
+
+  std::mt19937 rng(std::random_device{}());
+  std::uniform_int_distribution<size_t> persona_dist(0, personas.size() - 1);
+
+  generated_users_.clear();
+  std::unordered_set<std::string> used_email_local_parts;
+  size_t skipped_count = 0;
+  size_t export_failed_count = 0;
+
+  const auto generate_record =
+      [this, &rng, &used_email_local_parts, &skipped_count](
+          const EnrichedCity& city, const UserPersona& persona,
+          const Name& sampled_name) -> std::optional<UserRecord> {
+    try {
+      const UserResult user =
+          generator_->GenerateUser(city, persona, sampled_name);
+
+      return UserRecord{
+          .location = city.location,
+          .user = user,
+          .email = BuildEmail(sampled_name, used_email_local_parts),
+          .date_of_birth = GenerateDateOfBirth(rng),
+          .password = GenerateRandomPassword(rng),
+      };
+    } catch (const std::exception& e) {
+      ++skipped_count;
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::UserGeneration,
+                    .message = std::format(
+                        "[Pipeline] Skipping city '{}' ({}): "
+                        "user generation failed: {}",
+                        city.location.city, city.location.country, e.what())});
+      return std::nullopt;
+    }
+  };
+
+  const auto export_record = [this,
+                              &export_failed_count](const UserRecord& record) {
+    try {
+      exporter_->ProcessRecord(record);
+    } catch (const std::exception& export_exception) {
+      ++export_failed_count;
+
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::UserGeneration,
+           .message = std::format("[Pipeline] Generated user for '{}' ({}) but "
+                                  "SQLite export failed: {}",
+                                  record.location.city, record.location.country,
+                                  export_exception.what())});
+    }
+  };
+
+  for (const auto& city : cities) {
+    const std::optional<Name> sampled_name =
+        names_by_country.SampleName(city.location.iso3166_1, rng);
+
+    if (!sampled_name.has_value()) {
+      ++skipped_count;
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::UserGeneration,
+                    .message = std::format(
+                        "[Pipeline] Skipping city '{}' ({}): no names "
+                        "available for country '{}'",
+                        city.location.city, city.location.country,
+                        city.location.iso3166_1)});
+      continue;
+    }
+
+    const UserPersona& persona = personas[persona_dist(rng)];
+
+    const std::optional<UserRecord> record =
+        generate_record(city, persona, *sampled_name);
+    if (!record.has_value()) {
+      continue;
+    }
+
+    generated_users_.push_back(*record);
+    export_record(*record);
+  }
+
+  if (skipped_count > 0) {
+    logger_->Log(
+        {.level = LogLevel::Warn,
+         .phase = PipelinePhase::UserGeneration,
+         .message = std::format(
+             "[Pipeline] Skipped {} city/cities during user generation",
+             skipped_count)});
+  }
+
+  if (export_failed_count > 0) {
+    logger_->Log({.level = LogLevel::Warn,
+                  .phase = PipelinePhase::Teardown,
+                  .message = std::format("[Pipeline] Failed to export {} "
+                                         "generated user/users to SQLite",
+                                         export_failed_count)});
+  }
+}

tooling/pipeline/src/biergarten_pipeline_orchestrator/log_results.cc

@@ -10,11 +10,12 @@
 #include "../../includes/json_handling/pretty_print.h"
 #include "biergarten_pipeline_orchestrator.h"
 #include "services/logging/logger.h"
+
 void BiergartenPipelineOrchestrator::LogResults() const {
-  boost::json::array output;
+  boost::json::array brewery_output;
 
   for (const auto& [location, brewery] : generated_breweries_) {
-    output.push_back(boost::json::object{
+    brewery_output.push_back(boost::json::object{
         {"name_en", brewery.name_en},
         {"description_en", brewery.description_en},
         {"name_local", brewery.name_local},
@@ -29,9 +30,30 @@ void BiergartenPipelineOrchestrator::LogResults() const {
                      }}});
   }
 
-  std::ostringstream oss;
-  PrettyPrint(oss, output);
+  std::ostringstream brewery_oss;
+  PrettyPrint(brewery_oss, brewery_output);
   logger_->Log({.level = LogLevel::Info,
                 .phase = PipelinePhase::Teardown,
-                .message = oss.str()});
+                .message = brewery_oss.str()});
+
+  boost::json::array user_output;
+
+  for (const auto& generated_user : generated_users_) {
+    user_output.push_back(boost::json::object{
+        {"first_name", generated_user.user.first_name},
+        {"last_name", generated_user.user.last_name},
+        {"gender", generated_user.user.gender},
+        {"username", generated_user.user.username},
+        {"bio", generated_user.user.bio},
+        {"activity_weight", generated_user.user.activity_weight},
+        {"email", generated_user.email},
+        {"date_of_birth", generated_user.date_of_birth},
+    });
+  }
+
+  std::ostringstream user_oss;
+  PrettyPrint(user_oss, user_output);
+  logger_->Log({.level = LogLevel::Info,
+                .phase = PipelinePhase::Teardown,
+                .message = user_oss.str()});
 }

tooling/pipeline/src/biergarten_pipeline_orchestrator/run.cc

@@ -22,42 +22,40 @@ bool BiergartenPipelineOrchestrator::Run() {
     for (auto& city : cities) {
       try {
         std::string region_context = context_service_->GetLocationContext(city);
-        // logger_->Log(LogLevel::Debug, PipelinePhase::UserGeneration,
-        //              "[Pipeline] Context for '" + city.city + "' (" +
-        //              city.iso3166_2 + ") gathered:\n" + region_context);
 
         enriched.push_back(
             EnrichedCity{.location = std::move(city),
                          .region_context = std::move(region_context)});
       } catch (const std::exception& exception) {
         ++skipped_count;
-        logger_->Log(
-            {.level = LogLevel::Warn,
-             .phase = PipelinePhase::UserGeneration,
-             .message = std::format(
-                 "[Pipeline] Skipping city '{}' ({}): context lookup failed: {}",
-                 city.city, city.country, exception.what())});
+        logger_->Log({.level = LogLevel::Warn,
+                      .phase = PipelinePhase::Enrichment,
+                      .message = std::format(
+                          "[Pipeline] Skipping city '{}' ({}): context "
+                          "lookup failed: {}",
+                          city.city, city.country, exception.what())});
       }
     }
 
     if (skipped_count > 0) {
-      logger_->Log({.level = LogLevel::Warn,
-                    .phase = PipelinePhase::UserGeneration,
-                    .message = std::format(
-                        "[Pipeline] Skipped {} city/cities due to context lookup errors",
-                        skipped_count)});
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::Enrichment,
+           .message = std::format("[Pipeline] Skipped {} city/cities due "
+                                  "to context lookup errors",
+                                  skipped_count)});
     }
 
+    this->GenerateUsers(enriched);
     this->GenerateBreweries(enriched);
     exporter_->Finalize();
     this->LogResults();
     return true;
   } catch (const std::exception& e) {
-    logger_->Log(
-        {.level = LogLevel::Error,
-         .phase = PipelinePhase::Teardown,
-         .message =
-             std::format("Pipeline execution failed with error: {}", e.what())});
+    logger_->Log({.level = LogLevel::Error,
+                  .phase = PipelinePhase::Teardown,
+                  .message = std::format(
+                      "Pipeline execution failed with error: {}", e.what())});
     return false;
   }
 }

tooling/pipeline/src/data_generation/llama/generate_brewery.cc

@@ -83,15 +83,14 @@ BreweryResult LlamaGenerator::GenerateBrewery(
 
   /**
    * RETRY LOOP with validation and error correction
-   * Attempts to generate valid brewery data up to 3 times, with feedback-based
-   * refinement
+   * Attempts to generate valid brewery data up to 3 times, with
+   * feedback-based refinement
    */
   constexpr int max_attempts = 3;
   std::string raw;
   std::string last_error;
 
   // Token budget: too small risks truncating valid JSON mid-string.
-  // Start conservatively but allow adaptive increases on truncation.
   int max_tokens = kBreweryInitialMaxTokens;
 
   // Limit output length to keep it concise and focused
@@ -104,7 +103,7 @@ BreweryResult LlamaGenerator::GenerateBrewery(
           {.level = LogLevel::Debug,
            .phase = PipelinePhase::BreweryAndBeerGeneration,
            .message = std::format("LlamaGenerator: raw output (attempt {}): {}",
-                      attempt + 1, raw)});
+                                  attempt + 1, raw)});
     }
 
     // Validate output: parse JSON and check required fields
@@ -120,8 +119,9 @@ BreweryResult LlamaGenerator::GenerateBrewery(
         logger_->Log(
             {.level = LogLevel::Info,
              .phase = PipelinePhase::BreweryAndBeerGeneration,
-             .message = std::format("LlamaGenerator: successfully generated brewery data on attempt {}",
-                        attempt + 1)});
+             .message = std::format("LlamaGenerator: successfully generated "
+                                    "brewery data on attempt {}",
+                                    attempt + 1)});
       }
 
       return brewery;
@@ -134,33 +134,38 @@ BreweryResult LlamaGenerator::GenerateBrewery(
       logger_->Log(
           {.level = LogLevel::Warn,
            .phase = PipelinePhase::BreweryAndBeerGeneration,
-           .message =
-               std::format("LlamaGenerator: malformed brewery JSON (attempt {}): {}",
+           .message = std::format(
+               "LlamaGenerator: malformed brewery JSON (attempt {}): {}",
                attempt + 1, *validation_error)});
     }
 
     // Update prompt with error details to guide LLM toward correct output.
     user_prompt = std::format(
         "Your previous response was invalid. Error: {}\nReturn the thought "
-        "process before the JSON if needed, then return ONLY valid JSON with "
-        "exactly these keys, in this exact order: {{\"name_en\": \"<English "
+        "process before the JSON if needed, then return ONLY valid JSON "
+        "with "
+        "exactly these keys, in this exact order: {{\"name_en\": "
+        "\"<English "
         "brewery name>\", \"description_en\": \"<English single-paragraph "
-        "description>\", \"name_local\": \"<local-language brewery name>\", "
+        "description>\", \"name_local\": \"<local-language brewery "
+        "name>\", "
         "\"description_local\": \"<local-language single-paragraph "
-        "description>\"}}.\nDo not include markdown, comments, extra keys, or "
-        "literal placeholder values.\n\nKeep the JSON strings concise enough "
+        "description>\"}}.\nDo not include markdown, comments, extra keys, "
+        "or "
+        "literal placeholder values.\n\nKeep the JSON strings concise "
+        "enough "
         "to fit within the token budget.\n\n{}",
         *validation_error, retry_location);
   }
 
   // All retry attempts exhausted: log failure and throw exception
   if (logger_) {
-    logger_->Log(
-        {.level = LogLevel::Error,
-         .phase = PipelinePhase::BreweryAndBeerGeneration,
-       .message = std::format(
-         "LlamaGenerator: malformed brewery response after {} attempts: {}",
-         max_attempts, last_error.empty() ? raw : last_error)});
+    logger_->Log({.level = LogLevel::Error,
+                  .phase = PipelinePhase::BreweryAndBeerGeneration,
+                  .message = std::format(
+                      "LlamaGenerator: malformed brewery "
+                      "response after {} attempts: {}",
+                      max_attempts, last_error.empty() ? raw : last_error)});
   }
   throw std::runtime_error("LlamaGenerator: malformed brewery response");
 }

tooling/pipeline/src/data_generation/llama/generate_user.cc

@@ -1,24 +1,123 @@
 /**
  * @file data_generation/llama/generate_user.cc
- * @brief Generates locale-aware user profiles with strict two-line formatting,
- * retry handling, and output sanitization for downstream parsing.
+ * @brief Builds persona/name-grounded user prompts, performs retry-based
+ * inference, and validates structured JSON output for user records.
  */
 
-
 #include <format>
+#include <optional>
+#include <stdexcept>
 #include <string>
+#include <string_view>
 
 #include "data_generation/llama_generator.h"
 #include "data_generation/llama_generator_helpers.h"
 
-// TODO: Implement locale-aware user profile generation.
-// Current implementation returns a hardcoded test value and ignores the
-// locale parameter. Future implementation should:
-// 1. Load a USER_GENERATION.md prompt template with locale context
-// 2. Perform LLM inference with locale-specific username/bio generation
-// 3. Parse and validate JSON output with retry handling (similar to brewery)
-// 4. Return locale-aware username and biography
-UserResult LlamaGenerator::GenerateUser(const std::string& locale) {
-  return {.username = "test_user",
-          .bio = std::format("This is a test user profile from {}.", locale)};
+// GBNF grammar for structured user JSON output.
+static constexpr std::string_view kUserJsonGrammar = R"json_user(
+root ::= thought-block "{" ws "\"username\"" ws ":" ws string ws "," ws "\"bio\"" ws ":" ws string ws "," ws "\"activity_weight\"" ws ":" ws number ws "}" ws
+thought-block ::= [^{]*
+ws ::= [ \t\n\r]*
+string ::= "\"" char+ "\""
+char ::= [^"\\\x7F\x00-\x1F] | [\\] escape
+escape ::= ["\\/bfnrt] | "u" hex hex hex hex
+hex ::= [0-9a-fA-F]
+number ::= "-"? ("0" | [1-9] [0-9]*) ("." [0-9]+)?
+)json_user";
+
+static constexpr int kUserInitialMaxTokens = 1200;
+
+UserResult LlamaGenerator::GenerateUser(const EnrichedCity& city,
+                                        const UserPersona& persona,
+                                        const Name& name) {
+  std::string style_affinities;
+  for (const std::string& style : persona.style_affinities) {
+    if (!style_affinities.empty()) {
+      style_affinities += ", ";
+    }
+    style_affinities += style;
+  }
+
+  const std::string system_prompt = prompt_directory_->Load("USER_GENERATION");
+
+  std::string user_prompt = std::format(
+      "## NAME:\n{} {}\n\n## GENDER:\n{}\n\n## CITY:\n{}\n\n## "
+      "COUNTRY:\n{}\n\n"
+      "## PERSONA:\n{}\n\n## PERSONA DESCRIPTION:\n{}\n\n## STYLE "
+      "AFFINITIES:\n{}",
+      name.first_name, name.last_name, name.gender, city.location.city,
+      city.location.country, persona.name, persona.description,
+      style_affinities);
+
+  const std::string retry_context = std::format(
+      "Name: {} {}\nCity: {}, {}\nPersona: {}", name.first_name, name.last_name,
+      city.location.city, city.location.country, persona.name);
+
+  constexpr int max_attempts = 3;
+  std::string raw;
+  std::string last_error;
+  int max_tokens = kUserInitialMaxTokens;
+
+  for (int attempt = 0; attempt < max_attempts; ++attempt) {
+    raw = this->Infer(system_prompt, user_prompt, max_tokens, kUserJsonGrammar);
+    if (logger_) {
+      logger_->Log(
+          {.level = LogLevel::Debug,
+           .phase = PipelinePhase::UserGeneration,
+           .message = std::format("LlamaGenerator: raw output (attempt {}): {}",
+                                  attempt + 1, raw)});
+    }
+
+    UserResult user;
+    const std::optional<std::string> validation_error =
+        ValidateUserJson(raw, user);
+
+    if (!validation_error.has_value()) {
+      if (logger_) {
+        logger_->Log(
+            {.level = LogLevel::Info,
+             .phase = PipelinePhase::UserGeneration,
+             .message = std::format("LlamaGenerator: successfully "
+                                    "generated user data on attempt {}",
+                                    attempt + 1)});
+      }
+
+      user.first_name = name.first_name;
+      user.last_name = name.last_name;
+      user.gender = name.gender;
+      return user;
+    }
+
+    last_error = *validation_error;
+    if (logger_) {
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::UserGeneration,
+                    .message = std::format(
+                        "LlamaGenerator: malformed user JSON (attempt {}): {}",
+                        attempt + 1, *validation_error)});
+    }
+
+    user_prompt = std::format(
+        "Your previous response was invalid. Error: {}\nReturn the thought "
+        "process before the JSON if needed, then return ONLY valid JSON "
+        "with "
+        "exactly these keys, in this exact order: {{\"username\": "
+        "\"<handle "
+        "derived from the given name>\", \"bio\": \"<first-person bio "
+        "grounded in the persona>\", \"activity_weight\": <number between "
+        "0 "
+        "and 1>}}.\nDo not include markdown, comments, extra keys, or "
+        "literal placeholder values.\n\n{}",
+        *validation_error, retry_context);
+  }
+
+  if (logger_) {
+    logger_->Log({.level = LogLevel::Error,
+                  .phase = PipelinePhase::UserGeneration,
+                  .message = std::format(
+                      "LlamaGenerator: malformed user response "
+                      "after {} attempts: {}",
+                      max_attempts, last_error.empty() ? raw : last_error)});
+  }
+  throw std::runtime_error("LlamaGenerator: malformed user response");
 }

tooling/pipeline/src/data_generation/llama/helpers.cc

@@ -9,6 +9,7 @@
 #include <boost/json.hpp>
 #include <cctype>
 #include <optional>
+#include <span>
 #include <stdexcept>
 #include <string>
 #include <string_view>
@@ -76,7 +77,7 @@ bool ReadRequiredTrimmedStringField(const boost::json::object& obj,
   return !out.empty();
 }
 
-bool HasSchemaPlaceholder(const std::array<std::string*, 4>& values) {
+bool HasSchemaPlaceholder(std::span<std::string* const> values) {
   for (const std::string* value : values) {
     std::string lowered = *value;
     std::ranges::transform(lowered, lowered.begin(),
@@ -207,3 +208,58 @@ std::optional<std::string> ValidateBreweryJson(const std::string& raw,
 
   return std::nullopt;
 }
+
+std::optional<std::string> ValidateUserJson(const std::string& raw,
+                                            UserResult& user_out) {
+  boost::system::error_code error_code;
+  const std::string_view raw_view(raw);
+  const size_t opening_brace = raw_view.find('{');
+  if (opening_brace == std::string_view::npos) {
+    return "JSON parse error: missing opening brace '{'";
+  }
+
+  const std::string_view json_payload = raw_view.substr(opening_brace);
+  boost::json::value json_value = boost::json::parse(json_payload, error_code);
+  if (error_code) {
+    return "JSON parse error: " + error_code.message();
+  }
+
+  if (!json_value.is_object()) {
+    return "JSON root must be an object";
+  }
+
+  const auto& obj = json_value.get_object();
+  if (obj.size() != 3) {
+    return "JSON object must contain exactly three keys";
+  }
+
+  std::string validation_error;
+  if (!ReadRequiredTrimmedStringField(obj, "username", user_out.username,
+                                      &validation_error)) {
+    return validation_error;
+  }
+
+  if (!ReadRequiredTrimmedStringField(obj, "bio", user_out.bio,
+                                      &validation_error)) {
+    return validation_error;
+  }
+
+  const boost::json::value* activity_weight_field =
+      obj.if_contains("activity_weight");
+  if (activity_weight_field == nullptr || !activity_weight_field->is_number()) {
+    return "Missing or invalid numeric field: activity_weight";
+  }
+
+  const double activity_weight = activity_weight_field->to_number<double>();
+  if (activity_weight < 0.0 || activity_weight > 1.0) {
+    return "activity_weight must be between 0 and 1";
+  }
+  user_out.activity_weight = static_cast<float>(activity_weight);
+
+  const std::array schema_placeholders = {&user_out.username, &user_out.bio};
+  if (HasSchemaPlaceholder(schema_placeholders)) {
+    return "JSON appears to be a schema placeholder, not content";
+  }
+
+  return std::nullopt;
+}

tooling/pipeline/src/data_generation/mock/deterministic_hash.cc

@@ -14,3 +14,13 @@ size_t MockGenerator::DeterministicHash(const Location& location) {
   boost::hash_combine(seed, location.country);
   return seed;
 }
+
+size_t MockGenerator::DeterministicHash(const Location& location,
+                                        const UserPersona& persona,
+                                        const Name& name) {
+  size_t seed = DeterministicHash(location);
+  boost::hash_combine(seed, persona.name);
+  boost::hash_combine(seed, name.first_name);
+  boost::hash_combine(seed, name.last_name);
+  return seed;
+}

tooling/pipeline/src/data_generation/mock/generate_user.cc

@@ -1,22 +1,31 @@
 /**
  * @file data_generation/mock/generate_user.cc
- * @brief Generates deterministic mock user profiles by hashing locale values
- * into predefined username and bio collections.
+ * @brief Generates deterministic mock user profiles by hashing city, persona,
+ * and sampled name into predefined username and bio collections.
  */
 
-#include <functional>
-#include <string>
 #include <string_view>
 
 #include "data_generation/mock_generator.h"
 
-UserResult MockGenerator::GenerateUser(const std::string& locale) {
-  const size_t hash = std::hash<std::string>{}(locale);
+UserResult MockGenerator::GenerateUser(const EnrichedCity& city,
+                                       const UserPersona& persona,
+                                       const Name& name) {
+  const size_t hash = DeterministicHash(city.location, persona, name);
 
-  UserResult result;
   const std::string_view username = kUsernames[hash % kUsernames.size()];
   const std::string_view bio = kBios[hash / kBioHashStride % kBios.size()];
-  result.username = username;
-  result.bio = bio;
-  return result;
+  const float activity_weight =
+      static_cast<float>(hash / kActivityWeightHashStride %
+                         kActivityWeightHashRange) /
+      static_cast<float>(kActivityWeightHashRange);
+
+  return {
+      .first_name = name.first_name,
+      .last_name = name.last_name,
+      .gender = name.gender,
+      .username = std::string(username),
+      .bio = std::string(bio),
+      .activity_weight = activity_weight,
+  };
 }

tooling/pipeline/src/data_model/names_by_country.cc

@@ -0,0 +1,40 @@
+/**
+ * @file data_model/names_by_country.cc
+ * @brief NamesByCountry::SampleName() implementation.
+ */
+
+#include "data_model/names_by_country.h"
+
+#include <utility>
+
+NamesByCountry::NamesByCountry(
+    std::unordered_map<std::string, std::vector<ForenameEntry>>
+        forenames_by_country,
+    std::unordered_map<std::string, std::vector<std::string>>
+        surnames_by_country)
+    : forenames_by_country_(std::move(forenames_by_country)),
+      surnames_by_country_(std::move(surnames_by_country)) {}
+
+std::optional<Name> NamesByCountry::SampleName(const std::string& iso3166_1,
+                                               std::mt19937& rng) const {
+  const auto forenames_it = forenames_by_country_.find(iso3166_1);
+  const auto surnames_it = surnames_by_country_.find(iso3166_1);
+
+  if (forenames_it == forenames_by_country_.end() ||
+      surnames_it == surnames_by_country_.end() ||
+      forenames_it->second.empty() || surnames_it->second.empty()) {
+    return std::nullopt;
+  }
+
+  const std::vector<ForenameEntry>& forenames = forenames_it->second;
+  const std::vector<std::string>& surnames = surnames_it->second;
+
+  std::uniform_int_distribution<size_t> forename_dist(0, forenames.size() - 1);
+  std::uniform_int_distribution<size_t> surname_dist(0, surnames.size() - 1);
+
+  const ForenameEntry& forename = forenames[forename_dist(rng)];
+
+  return Name{.first_name = forename.name,
+              .last_name = surnames[surname_dist(rng)],
+              .gender = forename.gender};
+}

tooling/pipeline/src/json_handling/json_loader.cc

@@ -6,16 +6,18 @@
 
 #include "json_handling/json_loader.h"
 
-#include <format>
-#include "services/logging/logger.h"
-#include <iostream>
-
 #include <boost/json.hpp>
+#include <format>
 #include <fstream>
+#include <iostream>
 #include <sstream>
 #include <stdexcept>
 #include <string>
 #include <string_view>
+#include <unordered_map>
+#include <utility>
+
+#include "services/logging/logger.h"
 
 static std::string ReadRequiredString(const boost::json::object& object,
                                       const char* key) {
@@ -43,7 +45,7 @@ static std::vector<std::string> ReadRequiredStringArray(
   const boost::json::value* value = object.if_contains(key);
   if (value == nullptr || !value->is_array()) {
     throw std::runtime_error(
-      std::format("Missing or invalid string array field: {}", key));
+        std::format("Missing or invalid string array field: {}", key));
   }
 
   const auto& array = value->as_array();
@@ -59,24 +61,52 @@ static std::vector<std::string> ReadRequiredStringArray(
   return items;
 }
 
-std::vector<Location> JsonLoader::LoadLocations(
-    const std::filesystem::path& filepath, std::shared_ptr<ILogger> logger) {
+namespace {
+
+boost::json::value ParseJsonFile(const std::filesystem::path& filepath,
+                                 const char* what) {
   std::ifstream input(filepath);
   if (!input.is_open()) {
-    throw std::runtime_error("Failed to open locations file: " +
-                             filepath.string());
+    throw std::runtime_error(
+        std::format("Failed to open {} file: {}", what, filepath.string()));
   }
 
   std::stringstream buffer;
   buffer << input.rdbuf();
-  const std::string content = buffer.str();
 
   boost::system::error_code error;
-  boost::json::value root = boost::json::parse(content, error);
+  boost::json::value root = boost::json::parse(buffer.str(), error);
   if (error) {
-    throw std::runtime_error("Failed to parse locations JSON: " +
-                             error.message());
+    throw std::runtime_error(
+        std::format("Failed to parse {} JSON: {}", what, error.message()));
   }
+  return root;
+}
+
+/// @brief Returns the first element of a string array field, falling back to
+/// `fallback_key` if `key` is missing/empty (some source entries only have a
+/// "localized" form and no "romanized" form).
+std::string ReadFirstOfStringArray(const boost::json::object& object,
+                                   const char* key, const char* fallback_key) {
+  for (const char* candidate_key : {key, fallback_key}) {
+    const boost::json::value* value = object.if_contains(candidate_key);
+    if (value == nullptr || !value->is_array()) {
+      continue;
+    }
+    const auto& array = value->as_array();
+    if (!array.empty() && array.front().is_string()) {
+      return std::string(array.front().as_string());
+    }
+  }
+  throw std::runtime_error(
+      std::format("Missing or invalid string array field: {}", key));
+}
+
+}  // namespace
+
+std::vector<Location> JsonLoader::LoadLocations(
+    const std::filesystem::path& filepath, std::shared_ptr<ILogger> logger) {
+  const boost::json::value root = ParseJsonFile(filepath, "locations");
 
   if (!root.is_array()) {
     throw std::runtime_error(
@@ -108,3 +138,98 @@ std::vector<Location> JsonLoader::LoadLocations(
 
   return locations;
 }
+
+std::vector<UserPersona> JsonLoader::LoadPersonas(
+    const std::filesystem::path& filepath, std::shared_ptr<ILogger> logger) {
+  const boost::json::value root = ParseJsonFile(filepath, "personas");
+
+  if (!root.is_array()) {
+    throw std::runtime_error(
+        "Invalid personas JSON: root element must be an array");
+  }
+
+  std::vector<UserPersona> personas;
+  const auto& items = root.as_array();
+  personas.reserve(items.size());
+
+  for (const auto& item : items) {
+    if (!item.is_object()) {
+      throw std::runtime_error(
+          "Invalid personas JSON: each entry must be an object");
+    }
+
+    const auto& object = item.as_object();
+    personas.push_back(UserPersona{
+        .name = ReadRequiredString(object, "name"),
+        .description = ReadRequiredString(object, "description"),
+        .style_affinities = ReadRequiredStringArray(object, "style_affinities"),
+    });
+  }
+
+  return personas;
+}
+
+NamesByCountry JsonLoader::LoadNamesByCountry(
+    const std::filesystem::path& forenames_filepath,
+    const std::filesystem::path& surnames_filepath,
+    std::shared_ptr<ILogger> logger) {
+  const boost::json::value forenames_root =
+      ParseJsonFile(forenames_filepath, "forenames-by-country");
+  const boost::json::value surnames_root =
+      ParseJsonFile(surnames_filepath, "surnames-by-country");
+
+  if (!forenames_root.is_object() || !surnames_root.is_object()) {
+    throw std::runtime_error(
+        "Invalid names-by-country JSON: root element must be an object "
+        "keyed by ISO 3166-1 country code");
+  }
+
+  std::unordered_map<std::string, std::vector<ForenameEntry>>
+      forenames_by_country;
+  for (const auto& [country_code, regions] : forenames_root.as_object()) {
+    if (!regions.is_array()) {
+      continue;
+    }
+    std::vector<ForenameEntry> entries;
+    for (const auto& region : regions.as_array()) {
+      if (!region.is_object()) {
+        continue;
+      }
+      const boost::json::value* names = region.as_object().if_contains("names");
+      if (names == nullptr || !names->is_array()) {
+        continue;
+      }
+      for (const auto& name_value : names->as_array()) {
+        if (!name_value.is_object()) {
+          continue;
+        }
+        const auto& name_object = name_value.as_object();
+        entries.push_back(ForenameEntry{
+            .name =
+                ReadFirstOfStringArray(name_object, "romanized", "localized"),
+            .gender = ReadRequiredString(name_object, "gender"),
+        });
+      }
+    }
+    forenames_by_country.emplace(country_code, std::move(entries));
+  }
+
+  std::unordered_map<std::string, std::vector<std::string>> surnames_by_country;
+  for (const auto& [country_code, name_entries] : surnames_root.as_object()) {
+    if (!name_entries.is_array()) {
+      continue;
+    }
+    std::vector<std::string> surnames;
+    for (const auto& name_value : name_entries.as_array()) {
+      if (!name_value.is_object()) {
+        continue;
+      }
+      surnames.push_back(ReadFirstOfStringArray(name_value.as_object(),
+                                                "romanized", "localized"));
+    }
+    surnames_by_country.emplace(country_code, std::move(surnames));
+  }
+
+  return NamesByCountry(std::move(forenames_by_country),
+                        std::move(surnames_by_country));
+}

tooling/pipeline/src/main.cc

@@ -53,6 +53,7 @@ int main(const int argc, char** argv) {
       std::make_shared<LogProducer>(log_channel);
 
   std::thread log_thread([&log_dispatcher] { log_dispatcher->Run(); });
+
   auto shutdown = [&](const int exit_code) {
     log_channel.Close();
     log_thread.join();
@@ -66,8 +67,8 @@ int main(const int argc, char** argv) {
     const LlamaBackendState llama_backend_state;
 #endif
 
-    log_producer->Log({.level   = LogLevel::Info,
-                       .phase   = PipelinePhase::Startup,
+    log_producer->Log({.level = LogLevel::Info,
+                       .phase = PipelinePhase::Startup,
                        .message = "STARTING PIPELINE"});
 
     const std::optional<ApplicationOptions> parsed_options =
@@ -89,8 +90,8 @@ int main(const int argc, char** argv) {
         prompt_directory = std::make_unique<PromptDirectory>(
             options.pipeline.prompt_dir, log_producer);
       } catch (const std::exception& dir_error) {
-        log_producer->Log({.level   = LogLevel::Error,
-                           .phase   = PipelinePhase::Startup,
+        log_producer->Log({.level = LogLevel::Error,
+                           .phase = PipelinePhase::Startup,
                            .message = std::format("Invalid --prompt-dir: {}",
                                                   dir_error.what())});
 
@@ -108,7 +109,7 @@ int main(const int argc, char** argv) {
             {
               log_producer->Log(
                   {.level = LogLevel::Info,
-                   .phase   = PipelinePhase::Startup,
+                   .phase = PipelinePhase::Startup,
                    .message = "Prompt formatter: none (mock mode)"});
             }
             return std::unique_ptr<IPromptFormatter>(nullptr);
@@ -116,7 +117,7 @@ int main(const int argc, char** argv) {
           {
             log_producer->Log(
                 {.level = LogLevel::Info,
-                 .phase   = PipelinePhase::Startup,
+                 .phase = PipelinePhase::Startup,
                  .message = "Prompt formatter: Gemma4JinjaPromptFormatter"});
           }
           return std::unique_ptr<IPromptFormatter>(
@@ -125,15 +126,15 @@ int main(const int argc, char** argv) {
         di::bind<WebClient>().to([options, log_producer] {
           if (options.generator.use_mocked) {
             {
-              log_producer->Log({.level   = LogLevel::Info,
-                                 .phase   = PipelinePhase::Startup,
+              log_producer->Log({.level = LogLevel::Info,
+                                 .phase = PipelinePhase::Startup,
                                  .message = "Web client: none (mock mode)"});
             }
             return std::unique_ptr<WebClient>(nullptr);
           }
           {
-            log_producer->Log({.level   = LogLevel::Info,
-                               .phase   = PipelinePhase::Startup,
+            log_producer->Log({.level = LogLevel::Info,
+                               .phase = PipelinePhase::Startup,
                                .message = "Web client: HttpWebClient"});
           }
           return std::unique_ptr<WebClient>(
@@ -144,15 +145,15 @@ int main(const int argc, char** argv) {
                 const auto& inj) -> std::unique_ptr<IEnrichmentService> {
               if (options.generator.use_mocked) {
                 {
-                  log_producer->Log({.level   = LogLevel::Info,
-                                     .phase   = PipelinePhase::Startup,
+                  log_producer->Log({.level = LogLevel::Info,
+                                     .phase = PipelinePhase::Startup,
                                      .message = "Enrichment: mock"});
                 }
                 return std::make_unique<MockEnrichmentService>();
               }
               {
-                log_producer->Log({.level   = LogLevel::Info,
-                                   .phase   = PipelinePhase::Startup,
+                log_producer->Log({.level = LogLevel::Info,
+                                   .phase = PipelinePhase::Startup,
                                    .message = "Enrichment: Wikipedia"});
               }
               return std::make_unique<WikipediaEnrichmentService>(
@@ -164,8 +165,8 @@ int main(const int argc, char** argv) {
              &log_producer](const auto& inj) -> std::unique_ptr<DataGenerator> {
               if (options.generator.use_mocked) {
                 {
-                  log_producer->Log({.level   = LogLevel::Info,
-                                     .phase   = PipelinePhase::Startup,
+                  log_producer->Log({.level = LogLevel::Info,
+                                     .phase = PipelinePhase::Startup,
                                      .message = "Generator: mock"});
                 }
                 return std::make_unique<MockGenerator>();
@@ -173,9 +174,10 @@ int main(const int argc, char** argv) {
               {
                 log_producer->Log(
                     {.level = LogLevel::Info,
-                     .phase   = PipelinePhase::Startup,
+                     .phase = PipelinePhase::Startup,
                      .message = std::format(
-                         "Generator: LlamaGenerator | model={} | temp={:.2f} "
+                         "Generator: LlamaGenerator | model={} | "
+                         "temp={:.2f} "
                          "top_p={:.2f} top_k={} n_ctx={} seed={}",
                          model_path, sampling.temperature, sampling.top_p,
                          sampling.top_k, sampling.n_ctx, sampling.seed)});
@@ -190,14 +192,14 @@ int main(const int argc, char** argv) {
         injector.create<std::unique_ptr<BiergartenPipelineOrchestrator>>();
 
     if (!orchestrator->Run()) {
-      log_producer->Log({.level   = LogLevel::Error,
-                         .phase   = PipelinePhase::Teardown,
+      log_producer->Log({.level = LogLevel::Error,
+                         .phase = PipelinePhase::Teardown,
                          .message = "Pipeline execution failed"});
       return shutdown(EXIT_FAILURE);
     }
 
-    log_producer->Log({.level   = LogLevel::Info,
-                       .phase   = PipelinePhase::Teardown,
+    log_producer->Log({.level = LogLevel::Info,
+                       .phase = PipelinePhase::Teardown,
                        .message = std::format("Pipeline complete in {} ms",
                                               timer.Elapsed())});
 
@@ -205,8 +207,8 @@ int main(const int argc, char** argv) {
 
   } catch (const std::exception& exception) {
     const LogDTO log_entry{.level = LogLevel::Error,
-                               .phase   = PipelinePhase::Teardown,
-                               .message = exception.what()};
+                           .phase = PipelinePhase::Teardown,
+                           .message = exception.what()};
     if (log_producer) {
       log_producer->Log(log_entry);
     } else {

tooling/pipeline/src/services/enrichment/wikipedia/fetch_extract.cc

@@ -20,9 +20,10 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   if (const auto cache_it = this->extract_cache_.find(cache_key);
       cache_it != this->extract_cache_.end()) {
     if (logger_) {
-      logger_->Log({.level = LogLevel::Debug,
-                    .phase = PipelinePhase::UserGeneration,
-                    .message = std::format("Wikipedia: Cache hit for {}!", cache_key)});
+      logger_->Log(
+          {.level = LogLevel::Debug,
+           .phase = PipelinePhase::Enrichment,
+           .message = std::format("Wikipedia: Cache hit for {}!", cache_key)});
     }
     return cache_it->second;
   }
@@ -30,7 +31,8 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   const std::string encoded = this->client_->EncodeURL(cache_key);
   const std::string url = std::format(
       "https://en.wikipedia.org/w/"
-      "api.php?action=query&titles={}&prop=extracts&explaintext=1&format=json",
+      "api.php?action=query&titles={}&prop=extracts&explaintext=1&format="
+      "json",
       encoded);
 
   const std::string body = this->client_->Get(url);
@@ -45,11 +47,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (ec) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message = std::format("WikipediaService: JSON parse error for '{}': {}",
-                      std::string(query), ec.message())});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: JSON parse error for '{}': {}",
+                        std::string(query), ec.message())});
     }
     return {};
   }
@@ -58,12 +60,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   const json::object* obj = doc.if_object();
   if (obj == nullptr) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message =
-               std::format("WikipediaService: Expected root object for '{}'",
-               std::string(query))});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: Expected root object for '{}'",
+                        std::string(query))});
     }
     return {};
   }
@@ -76,12 +77,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if ((pages_ptr == nullptr) || !pages_ptr->is_object()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message =
-               std::format("WikipediaService: Missing query.pages for '{}'",
-               std::string(query))});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: Missing query.pages for '{}'",
+                        std::string(query))});
     }
     return {};
   }
@@ -90,11 +90,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (pages.empty()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message = std::format("WikipediaService: No pages returned for '{}'",
-                      std::string(query))});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: No pages returned for '{}'",
+                        std::string(query))});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -106,12 +106,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (!page_val.is_object()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message =
-               std::format("WikipediaService: Unexpected page format for '{}'",
-               std::string(query))});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: Unexpected page format for '{}'",
+                        std::string(query))});
     }
     return {};
   }
@@ -121,10 +120,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   // Handle 404/Missing status
   if (page.contains("missing")) {
     if (logger_) {
-      logger_->Log({.level = LogLevel::Warn,
-                    .phase = PipelinePhase::UserGeneration,
-                    .message = std::format("WikipediaService: Page '{}' does not exist",
-                               std::string(query))});
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::Enrichment,
+           .message = std::format("WikipediaService: Page '{}' does not exist",
+                                  std::string(query))});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -134,12 +134,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if ((extract_ptr == nullptr) || !extract_ptr->is_string()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message =
-               std::format("WikipediaService: No extract string found for '{}'",
-               std::string(query))});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: No extract string found for '{}'",
+                        std::string(query))});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -148,10 +147,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   // 4. Success
   std::string extract(extract_ptr->as_string());
   if (logger_) {
-    logger_->Log({.level = LogLevel::Info,
-                  .phase = PipelinePhase::UserGeneration,
-                  .message = std::format("WikipediaService: Fetched {} chars for '{}'",
-                             extract.size(), std::string(query))});
+    logger_->Log(
+        {.level = LogLevel::Info,
+         .phase = PipelinePhase::Enrichment,
+         .message = std::format("WikipediaService: Fetched {} chars for '{}'",
+                                extract.size(), std::string(query))});
   }
 
   this->extract_cache_.insert_or_assign(cache_key, extract);

tooling/pipeline/src/services/enrichment/wikipedia/get_summary.cc

@@ -16,7 +16,7 @@ std::string WikipediaEnrichmentService::GetLocationContext(
   if (!this->client_) {
     if (logger_) {
       logger_->Log({.level = LogLevel::Warn,
-                    .phase = PipelinePhase::UserGeneration,
+                    .phase = PipelinePhase::Enrichment,
                     .message = "Wikipedia client is nullptr."});
     }
     return {};
@@ -24,13 +24,6 @@ std::string WikipediaEnrichmentService::GetLocationContext(
 
   std::string result;
 
-  // std::string region_query(loc.city);
-  // if (!loc.country.empty()) {
-  //   region_query += loc.state_province,
-  //   region_query += ", ";
-  //   region_query += loc.country;
-  // }
-
   constexpr std::string_view brewing_query = "brewing";
   const std::string location_query =
       std::format("{}, {}", loc.city, loc.iso3166_2);
@@ -51,9 +44,10 @@ std::string WikipediaEnrichmentService::GetLocationContext(
     append_extract(FetchExtract(beer_query));
     if (logger_) {
       logger_->Log({.level = LogLevel::Info,
-                    .phase = PipelinePhase::UserGeneration,
-                    .message = std::format("Done fetching for {}. Sleeping for 10 seconds.",
-                               location_query)});
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "Done fetching for {}. Sleeping for 10 seconds.",
+                        location_query)});
     }
     std::this_thread::sleep_for(10s);
 
@@ -61,9 +55,9 @@ std::string WikipediaEnrichmentService::GetLocationContext(
     if (logger_) {
       logger_->Log(
           {.level = LogLevel::Debug,
-           .phase = PipelinePhase::UserGeneration,
+           .phase = PipelinePhase::Enrichment,
            .message = std::format("WikipediaService lookup failed for '{}': {}",
-                      location_query, e.what())});
+                                  location_query, e.what())});
     }
   }
   return result;

tooling/pipeline/src/services/logging/log_dispatcher.cc

@@ -19,6 +19,8 @@ namespace {
   switch (phase) {
     case PipelinePhase::Startup:
       return "Startup";
+    case PipelinePhase::Enrichment:
+      return "Enrichment";
     case PipelinePhase::UserGeneration:
       return "User Generation";
     case PipelinePhase::BreweryAndBeerGeneration:

tooling/pipeline/src/services/prompt_directory.cc

@@ -44,8 +44,8 @@ PromptDirectory::PromptDirectory(const std::filesystem::path& prompt_dir,
   // Scenario 4: directory must be readable (probe with directory_iterator).
   std::filesystem::directory_iterator probe(prompt_dir_, ec);
   if (ec) {
-    throw std::runtime_error(
-        std::format("PromptDirectory: prompt directory is not readable: {} ({})",
+    throw std::runtime_error(std::format(
+        "PromptDirectory: prompt directory is not readable: {} ({})",
         prompt_dir_.string(), ec.message()));
   }
 
@@ -76,7 +76,7 @@ std::string PromptDirectory::Load(std::string_view key) {
   if (!file.is_open()) {
     throw std::runtime_error(
         std::format("PromptDirectory: prompt file not found for key '{}': {}",
-        key_str, file_path.string()));
+                    key_str, file_path.string()));
   }
 
   std::string content((std::istreambuf_iterator<char>(file)),
@@ -84,15 +84,18 @@ std::string PromptDirectory::Load(std::string_view key) {
   file.close();
 
   if (content.empty()) {
-    throw std::runtime_error(std::format("PromptDirectory: prompt file for key '{}' is empty: {}",
-                             key_str, file_path.string()));
+    throw std::runtime_error(
+        std::format("PromptDirectory: prompt file for key '{}' is empty: {}",
+                    key_str, file_path.string()));
   }
 
   if (logger_) {
-    logger_->Log({.level = LogLevel::Info,
-                  .phase = PipelinePhase::Startup,
-                  .message = std::format("[PromptDirectory] Loaded prompt '{}' from '{}' ({} chars)",
-                             key_str, file_path.string(), content.size())});
+    logger_->Log(
+        {.level = LogLevel::Info,
+         .phase = PipelinePhase::Startup,
+         .message = std::format(
+             "[PromptDirectory] Loaded prompt '{}' from '{}' ({} chars)",
+             key_str, file_path.string(), content.size())});
   }
 
   cache_.emplace(key_str, content);

tooling/pipeline/src/services/sqlite/finalize.cc

@@ -14,6 +14,7 @@ void SqliteExportService::Finalize() {
   }
 
   try {
+    insert_user_stmt_.reset();
     insert_brewery_stmt_.reset();
     insert_location_stmt_.reset();
     if (transaction_open_) {

tooling/pipeline/src/services/sqlite/initialize.cc

@@ -18,9 +18,9 @@ std::filesystem::path SqliteExportService::BuildDatabasePath() const {
   std::filesystem::path candidate = output_path_ / base_filename;
 
   for (int suffix = 1; std::filesystem::exists(candidate); ++suffix) {
-    candidate = output_path_ /
-                std::filesystem::path(std::format("biergarten_seed_{}-{}.sqlite",
-                                      run_timestamp_utc_, suffix));
+    candidate = output_path_ / std::filesystem::path(
+                                   std::format("biergarten_seed_{}-{}.sqlite",
+                                               run_timestamp_utc_, suffix));
   }
 
   return candidate;
@@ -33,6 +33,9 @@ void SqliteExportService::InitializeSchema() const {
   sqlite_export_service_internal::ExecSql(
       db_handle_, sqlite_export_service_internal::kCreateBreweriesTableSql,
       "Failed to create SQLite breweries table");
+  sqlite_export_service_internal::ExecSql(
+      db_handle_, sqlite_export_service_internal::kCreateUsersTableSql,
+      "Failed to create SQLite users table");
 }
 
 void SqliteExportService::PrepareStatements() {
@@ -42,6 +45,9 @@ void SqliteExportService::PrepareStatements() {
   insert_brewery_stmt_ = sqlite_export_service_internal::PrepareStatement(
       db_handle_, sqlite_export_service_internal::kInsertBrewerySql,
       "Failed to prepare SQLite brewery insert statement");
+  insert_user_stmt_ = sqlite_export_service_internal::PrepareStatement(
+      db_handle_, sqlite_export_service_internal::kInsertUserSql,
+      "Failed to prepare SQLite user insert statement");
 }
 
 void SqliteExportService::RollbackAndCloseNoThrow() noexcept {
@@ -54,6 +60,7 @@ void SqliteExportService::RollbackAndCloseNoThrow() noexcept {
     transaction_open_ = false;
   }
 
+  insert_user_stmt_.reset();
   insert_brewery_stmt_.reset();
   insert_location_stmt_.reset();
   db_handle_.reset();

tooling/pipeline/src/services/sqlite/process_record.cc

@@ -1,6 +1,7 @@
 /**
  * @file services/sqlite/process_record.cc
- * @brief SqliteExportService::ProcessRecord() implementation.
+ * @brief SqliteExportService::ProcessRecord() implementation
+ * and the shared location-resolution helper.
  */
 
 #include <iomanip>
@@ -29,82 +30,84 @@ std::string SqliteExportService::BuildLocationKey(const Location& location) {
   return key_stream.str();
 }
 
-uint64_t SqliteExportService::ProcessRecord(const GeneratedBrewery& brewery) {
+sqlite3_int64 SqliteExportService::ResolveLocationId(const Location& location) {
+  const std::string location_key = BuildLocationKey(location);
+  const auto cached_location = location_cache_.find(location_key);
+  if (cached_location != location_cache_.end()) {
+    return cached_location->second;
+  }
+
+  const std::string local_languages_json =
+      sqlite_export_service_internal::SerializeVector(location.local_languages);
+
+  sqlite_export_service_internal::Bind(
+      insert_location_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kLocationCityBindIndex,
+          .value = location.city,
+          .action = "Failed to bind SQLite location city"});
+  sqlite_export_service_internal::Bind(
+      insert_location_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index =
+              sqlite_export_service_internal::kLocationStateProvinceBindIndex,
+          .value = location.state_province,
+          .action = "Failed to bind SQLite location state/province"});
+  sqlite_export_service_internal::Bind(
+      insert_location_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kLocationIso31662BindIndex,
+          .value = location.iso3166_2,
+          .action = "Failed to bind SQLite location ISO 3166-2 code"});
+  sqlite_export_service_internal::Bind(
+      insert_location_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kLocationCountryBindIndex,
+          .value = location.country,
+          .action = "Failed to bind SQLite location country"});
+  sqlite_export_service_internal::Bind(
+      insert_location_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kLocationIso31661BindIndex,
+          .value = location.iso3166_1,
+          .action = "Failed to bind SQLite location ISO 3166-1 code"});
+  sqlite_export_service_internal::Bind(
+      insert_location_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kLocationLanguagesBindIndex,
+          .value = local_languages_json,
+          .action = "Failed to bind SQLite location languages"});
+  sqlite_export_service_internal::Bind(
+      insert_location_stmt_,
+      sqlite_export_service_internal::BindParam{
+          .index = sqlite_export_service_internal::kLocationLatitudeBindIndex,
+          .value = location.latitude,
+          .action = "Failed to bind SQLite location latitude"});
+  sqlite_export_service_internal::Bind(
+      insert_location_stmt_,
+      sqlite_export_service_internal::BindParam{
+          .index = sqlite_export_service_internal::kLocationLongitudeBindIndex,
+          .value = location.longitude,
+          .action = "Failed to bind SQLite location longitude"});
+
+  sqlite_export_service_internal::StepStatement(
+      db_handle_, insert_location_stmt_,
+      "Failed to insert SQLite location row");
+
+  const sqlite3_int64 location_id =
+      sqlite_export_service_internal::LastInsertRowId(db_handle_);
+  location_cache_.emplace(location_key, location_id);
+  sqlite_export_service_internal::ResetStatement(insert_location_stmt_);
+
+  return location_id;
+}
+
+uint64_t SqliteExportService::ProcessRecord(const BreweryRecord& brewery) {
   if (db_handle_ == nullptr || !transaction_open_) {
     throw std::runtime_error("SQLite export service is not initialized");
   }
 
-  const std::string location_key = BuildLocationKey(brewery.location);
-  const auto cached_location = location_cache_.find(location_key);
-  sqlite3_int64 location_id = 0;
-
-  if (cached_location != location_cache_.end()) {
-    location_id = cached_location->second;
-  } else {
-    const std::string local_languages_json =
-        sqlite_export_service_internal::SerializeVector(
-            brewery.location.local_languages);
-
-    sqlite_export_service_internal::Bind(
-        insert_location_stmt_,
-        sqlite_export_service_internal::BindParam<std::string_view>{
-            .index = sqlite_export_service_internal::kLocationCityBindIndex,
-            .value = brewery.location.city,
-            .action = "Failed to bind SQLite location city"});
-    sqlite_export_service_internal::Bind(
-        insert_location_stmt_,
-        sqlite_export_service_internal::BindParam<std::string_view>{
-            .index =
-                sqlite_export_service_internal::kLocationStateProvinceBindIndex,
-            .value = brewery.location.state_province,
-            .action = "Failed to bind SQLite location state/province"});
-    sqlite_export_service_internal::Bind(
-        insert_location_stmt_,
-        sqlite_export_service_internal::BindParam<std::string_view>{
-            .index = sqlite_export_service_internal::kLocationIso31662BindIndex,
-            .value = brewery.location.iso3166_2,
-            .action = "Failed to bind SQLite location ISO 3166-2 code"});
-    sqlite_export_service_internal::Bind(
-        insert_location_stmt_,
-        sqlite_export_service_internal::BindParam<std::string_view>{
-            .index = sqlite_export_service_internal::kLocationCountryBindIndex,
-            .value = brewery.location.country,
-            .action = "Failed to bind SQLite location country"});
-    sqlite_export_service_internal::Bind(
-        insert_location_stmt_,
-        sqlite_export_service_internal::BindParam<std::string_view>{
-            .index = sqlite_export_service_internal::kLocationIso31661BindIndex,
-            .value = brewery.location.iso3166_1,
-            .action = "Failed to bind SQLite location ISO 3166-1 code"});
-    sqlite_export_service_internal::Bind(
-        insert_location_stmt_,
-        sqlite_export_service_internal::BindParam<std::string_view>{
-            .index =
-                sqlite_export_service_internal::kLocationLanguagesBindIndex,
-            .value = local_languages_json,
-            .action = "Failed to bind SQLite location languages"});
-    sqlite_export_service_internal::Bind(
-        insert_location_stmt_,
-        sqlite_export_service_internal::BindParam{
-            .index = sqlite_export_service_internal::kLocationLatitudeBindIndex,
-            .value = brewery.location.latitude,
-            .action = "Failed to bind SQLite location latitude"});
-    sqlite_export_service_internal::Bind(
-        insert_location_stmt_,
-        sqlite_export_service_internal::BindParam{
-            .index =
-                sqlite_export_service_internal::kLocationLongitudeBindIndex,
-            .value = brewery.location.longitude,
-            .action = "Failed to bind SQLite location longitude"});
-
-    sqlite_export_service_internal::StepStatement(
-        db_handle_, insert_location_stmt_,
-        "Failed to insert SQLite location row");
-
-    location_id = sqlite_export_service_internal::LastInsertRowId(db_handle_);
-    location_cache_.emplace(location_key, location_id);
-    sqlite_export_service_internal::ResetStatement(insert_location_stmt_);
-  }
+  const sqlite3_int64 location_id = ResolveLocationId(brewery.location);
 
   sqlite_export_service_internal::Bind(
       insert_brewery_stmt_,
@@ -112,12 +115,14 @@ uint64_t SqliteExportService::ProcessRecord(const GeneratedBrewery& brewery) {
           .index = sqlite_export_service_internal::kBreweryLocationIdBindIndex,
           .value = location_id,
           .action = "Failed to bind SQLite brewery location id"});
+
   sqlite_export_service_internal::Bind(
       insert_brewery_stmt_,
       sqlite_export_service_internal::BindParam<std::string_view>{
           .index = sqlite_export_service_internal::kBreweryEnglishNameBindIndex,
           .value = brewery.brewery.name_en,
           .action = "Failed to bind SQLite brewery English name"});
+
   sqlite_export_service_internal::Bind(
       insert_brewery_stmt_,
       sqlite_export_service_internal::BindParam<std::string_view>{
@@ -125,12 +130,14 @@ uint64_t SqliteExportService::ProcessRecord(const GeneratedBrewery& brewery) {
               kBreweryEnglishDescriptionBindIndex,
           .value = brewery.brewery.description_en,
           .action = "Failed to bind SQLite brewery English description"});
+
   sqlite_export_service_internal::Bind(
       insert_brewery_stmt_,
       sqlite_export_service_internal::BindParam<std::string_view>{
           .index = sqlite_export_service_internal::kBreweryLocalNameBindIndex,
           .value = brewery.brewery.name_local,
           .action = "Failed to bind SQLite brewery local name"});
+
   sqlite_export_service_internal::Bind(
       insert_brewery_stmt_,
       sqlite_export_service_internal::BindParam<std::string_view>{

tooling/pipeline/src/services/sqlite/process_user_record.cc

@@ -0,0 +1,85 @@
+/**
+ * @file services/sqlite/process_user_record.cc
+ * @brief SqliteExportService::ProcessRecord(UserRecord) implementation.
+ */
+
+#include <stdexcept>
+
+#include "services/database/sqlite_export_service.h"
+#include "services/database/sqlite_export_service_helpers.h"
+
+uint64_t SqliteExportService::ProcessRecord(const UserRecord& user) {
+  if (db_handle_ == nullptr || !transaction_open_) {
+    throw std::runtime_error("SQLite export service is not initialized");
+  }
+
+  const sqlite3_int64 location_id = ResolveLocationId(user.location);
+
+  sqlite_export_service_internal::Bind(
+      insert_user_stmt_,
+      sqlite_export_service_internal::BindParam<sqlite3_int64>{
+          .index = sqlite_export_service_internal::kUserLocationIdBindIndex,
+          .value = location_id,
+          .action = "Failed to bind SQLite user location id"});
+  sqlite_export_service_internal::Bind(
+      insert_user_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kUserFirstNameBindIndex,
+          .value = user.user.first_name,
+          .action = "Failed to bind SQLite user first name"});
+  sqlite_export_service_internal::Bind(
+      insert_user_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kUserLastNameBindIndex,
+          .value = user.user.last_name,
+          .action = "Failed to bind SQLite user last name"});
+  sqlite_export_service_internal::Bind(
+      insert_user_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kUserGenderBindIndex,
+          .value = user.user.gender,
+          .action = "Failed to bind SQLite user gender"});
+  sqlite_export_service_internal::Bind(
+      insert_user_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kUserUsernameBindIndex,
+          .value = user.user.username,
+          .action = "Failed to bind SQLite user username"});
+  sqlite_export_service_internal::Bind(
+      insert_user_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kUserBioBindIndex,
+          .value = user.user.bio,
+          .action = "Failed to bind SQLite user bio"});
+  sqlite_export_service_internal::Bind(
+      insert_user_stmt_,
+      sqlite_export_service_internal::BindParam<double>{
+          .index = sqlite_export_service_internal::kUserActivityWeightBindIndex,
+          .value = static_cast<double>(user.user.activity_weight),
+          .action = "Failed to bind SQLite user activity weight"});
+  sqlite_export_service_internal::Bind(
+      insert_user_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kUserEmailBindIndex,
+          .value = user.email,
+          .action = "Failed to bind SQLite user email"});
+  sqlite_export_service_internal::Bind(
+      insert_user_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kUserDateOfBirthBindIndex,
+          .value = user.date_of_birth,
+          .action = "Failed to bind SQLite user date of birth"});
+  sqlite_export_service_internal::Bind(
+      insert_user_stmt_,
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kUserPasswordBindIndex,
+          .value = user.password,
+          .action = "Failed to bind SQLite user password"});
+
+  sqlite_export_service_internal::StepStatement(
+      db_handle_, insert_user_stmt_, "Failed to insert SQLite user row");
+
+  sqlite_export_service_internal::ResetStatement(insert_user_stmt_);
+
+  return sqlite_export_service_internal::LastInsertRowId(db_handle_);
+}

tooling/pipeline/src/web_client/http_web_client.cc

@@ -48,21 +48,20 @@ std::string HttpWebClient::Get(const std::string& url) {
   const httplib::Result result = client.Get(path);
 
   if (!result) {
-    throw std::runtime_error(std::format(
-        "[HttpWebClient] Request failed for URL: {} — {}", url,
-        httplib::to_string(result.error())));
+    throw std::runtime_error(
+        std::format("[HttpWebClient] Request failed for URL: {} — {}", url,
+                    httplib::to_string(result.error())));
   }
 
   if (result->status < kSuccessMin || result->status >= kSuccessMax) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Error,
-           .phase = PipelinePhase::UserGeneration,
-         .message =
-           std::format("[HttpWebClient] Request failed for URL: {}", url)});
+      logger_->Log({.level = LogLevel::Error,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "[HttpWebClient] Request failed for URL: {}", url)});
     }
     throw std::runtime_error(std::format("[HttpWebClient] HTTP {} for URL: {}",
-                       result->status, url));
+                                         result->status, url));
   }
 
   return result->body;