allow to (multi) select scrap

bin/app/data/config/buildings.toml

@@ -1,5 +1,6 @@
 [[building]]
 id = "belt"
+tooltip = "Transports items one tile at a time in the direction it faces."
 cost = 2
 player_placeable = true
 construction_time_seconds = 0.2
@@ -7,6 +8,7 @@ surface_mask = ["A>"]
 
 [[building]]
 id = "splitter"
+tooltip = "Splits an incoming item stream between two outputs, with optional per-output filters."
 cost = 3
 player_placeable = true
 construction_time_seconds = 0.5
@@ -14,6 +16,7 @@ surface_mask = ["<A>"]
 
 [[building]]
 id = "tunnel_entry"
+tooltip = "Sends items underground to a matching tunnel exit, letting belts cross."
 cost = 5
 player_placeable = true
 construction_time_seconds = 0.5
@@ -21,6 +24,7 @@ surface_mask = ["A>"]
 
 [[building]]
 id = "tunnel_exit"
+tooltip = "Receives items from a matching tunnel entry and pushes them onward."
 cost = 5
 player_placeable = true
 construction_time_seconds = 0.5
@@ -28,6 +32,7 @@ surface_mask = ["A>"]
 
 [[building]]
 id = "miner"
+tooltip = "Extracts a selected ore from the asteroid; every tile yields any ore."
 cost = 15
 player_placeable = true
 construction_time_seconds = 1
@@ -37,6 +42,7 @@ surface_mask = [
 
 [[building]]
 id = "smelter"
+tooltip = "Melts ore or scrap into basic materials. No recipe selection needed."
 cost = 20
 player_placeable = true
 construction_time_seconds = 1
@@ -47,6 +53,7 @@ surface_mask = [
 
 [[building]]
 id = "assembler"
+tooltip = "Crafts a selected recipe from the production tree into intermediate or final parts."
 cost = 35
 player_placeable = true
 construction_time_seconds = 1
@@ -57,6 +64,7 @@ surface_mask = [
 
 [[building]]
 id = "reprocessing_plant"
+tooltip = "Consumes scrap and yields one random higher-tier product per cycle."
 cost = 40
 player_placeable = true
 construction_time_seconds = 1
@@ -68,6 +76,7 @@ surface_mask = [
 
 [[building]]
 id = "shipyard"
+tooltip = "Builds autonomous combat ships from a selected schematic and module layout."
 cost = 60
 player_placeable = true
 construction_time_seconds = 1
@@ -78,6 +87,7 @@ surface_mask = [
 
 [[building]]
 id = "salvage_bay"
+tooltip = "Drop-off point where salvage ships unload collected scrap onto belts."
 cost = 25
 player_placeable = true
 construction_time_seconds = 1

bin/app/data/config/modules.toml

@@ -32,6 +32,7 @@
 
 [[module]]
 id = "railgun_s"
+tooltip = "Small railgun. Fast-firing, short range, low damage; fits any hull."
 unlock_at_station_level = -1
 surface_mask = ["O"]
 materials = [{item = "railgun_s_module", amount = 1}]
@@ -47,6 +48,7 @@ attack_rate_hz = 2.0
 
 [[module]]
 id = "railgun_m"
+tooltip = "Medium railgun. Higher damage at longer range; needs a 2x2 slot."
 unlock_at_station_level = 2
 surface_mask = [
     "OO",
@@ -64,6 +66,7 @@ attack_rate_hz = 1.5
 
 [[module]]
 id = "railgun_l"
+tooltip = "Large railgun. Heavy damage at long range; needs a 3x3 slot."
 unlock_at_station_level = 6
 unlock_requires = ["railgun_m"]
 surface_mask = [
@@ -86,6 +89,7 @@ attack_rate_hz = 0.8
 
 [[module]]
 id = "salvager"
+tooltip = "Collects scrap from wrecks and stores it in the ship's cargo hold."
 unlock_at_station_level = -1
 surface_mask = ["O"]
 materials = [{item = "salvager_module", amount = 1}]
@@ -101,6 +105,7 @@ collection_rate_hz = 0.5
 
 [[module]]
 id = "repair_tool"
+tooltip = "Repairs damaged friendly ships and defence stations within range."
 unlock_at_station_level = 0
 surface_mask = ["O"]
 materials = [{item = "repair_tool_module", amount = 1}]
@@ -119,6 +124,7 @@ repair_range_m = 80
 
 [[module]]
 id = "afterburner"
+tooltip = "Greatly boosts top speed and forward acceleration."
 unlock_at_station_level = 2
 surface_mask = ["OOO"]
 materials = [{item = "afterburner_module", amount = 1}]
@@ -133,6 +139,7 @@ added_main_acceleration_mpss = 60
 
 [[module]]
 id = "maneuvering_thrusters"
+tooltip = "Improves top speed and lateral/braking acceleration."
 unlock_at_station_level = 1
 surface_mask = ["OO"]
 materials = [{item = "maneuvering_thrusters_module", amount = 1}]
@@ -150,6 +157,7 @@ added_maneuvering_acceleration_mpss = 10
 
 [[module]]
 id = "armor_plates"
+tooltip = "Adds a large flat bonus to the ship's hit points."
 unlock_at_station_level = 0
 surface_mask = ["OO"]
 materials = [{item = "armor_plates_module", amount = 1}]
@@ -163,6 +171,7 @@ added_hp = 1200
 
 [[module]]
 id = "sensor_booster"
+tooltip = "Extends the ship's sensor range."
 unlock_at_station_level = 1
 surface_mask = ["OO"]
 materials = [{item = "sensor_booster_module", amount = 1}]
@@ -179,6 +188,7 @@ added_sensor_range_m = 50
 
 [[module]]
 id = "weapon_upgrade"
+tooltip = "Increases the damage of all weapons on the ship."
 unlock_at_station_level = 4
 surface_mask = [
     "OO",
@@ -195,6 +205,7 @@ multiplied_damage = 1.2
 
 [[module]]
 id = "weapon_primer"
+tooltip = "Increases the fire rate of all weapons on the ship."
 unlock_at_station_level = 4
 surface_mask = [
     "OO",
@@ -211,6 +222,7 @@ multiplied_attack_rate_hz = 1.2
 
 [[module]]
 id = "weapon_stabilizer"
+tooltip = "Extends weapon range at the cost of some fire rate."
 unlock_at_station_level = 3
 surface_mask = [
     "OO",
@@ -234,6 +246,7 @@ multiplied_attack_rate_hz = 0.8
 
 [[module]]
 id = "drone_bay"
+tooltip = "Drone launch bay (capability not yet implemented)."
 unlock_at_station_level = 5
 surface_mask = [
     "OO",
@@ -246,6 +259,7 @@ glyph = "Db"
 
 [[module]]
 id = "drone_hangar"
+tooltip = "Large drone hangar (capability not yet implemented)."
 unlock_at_station_level = 9
 surface_mask = [
     "OOOOOO",

bin/app/data/config/world.toml

@@ -10,6 +10,7 @@ tunnel_max_distance_tiles = 10
 departure_interval_seconds = 20
 orbit_factor = 0.8
 rally_orbit_radius_tiles = 5.0
+building_blocks_tooltip = "Building blocks are the currency for construction. Spend them to place buildings and to expand the asteroid. Produce building blocks in your factory and deliver them to the HQ on a belt to grow your stock."
 
 [regions]
 asteroid_width_tiles = 60

bin/test/data/config/buildings.toml

@@ -84,6 +84,7 @@ cost = 25
 player_placeable = true
 construction_time_seconds = 15
 output_buffer_capacity = 20
+tooltip = "Drop-off point for salvage ships."
 surface_mask = [
   "SAA",
   "SAA>",

bin/test/data/config/modules.toml

@@ -1,5 +1,6 @@
 [[module]]
 id = "armor_plate"
+tooltip = "Adds a large flat bonus to hit points."
 unlock_at_station_level = -1
 surface_mask = ["OO"]
 materials = [{item = "iron_ingot", amount = 2}]

bin/test/data/config/world.toml

@@ -10,6 +10,7 @@ tunnel_max_distance_tiles = 10
 departure_interval_seconds = 20
 orbit_factor = 0.8
 rally_orbit_radius_tiles = 5.0
+building_blocks_tooltip = "Spend building blocks to build; deliver them to the HQ to gain more."
 
 [regions]
 asteroid_width_tiles = 40

docs/requirements.md

@@ -4,11 +4,11 @@
 
 Config files use the TOML format. The following config files drive game parameters:
 
-- **world.toml** — world dimensions, region widths, expansion amounts, building refund percentage, wave timing, boss wave timing, belt speed, starting building blocks, departure interval, ship orbit factor, rally orbit radius, scrap-per-threat conversion, combat target-selection parameters (target score formula, overclaim penalty formula, target hysteresis), artifact chance formula, artifact win count, and view pan speeds (slow and fast horizontal pan speed and pan ramp band width).
-- **buildings.toml** — building block cost and construction time per building type.
+- **world.toml** — world dimensions, region widths, expansion amounts, building refund percentage, wave timing, boss wave timing, belt speed, starting building blocks, departure interval, ship orbit factor, rally orbit radius, scrap-per-threat conversion, combat target-selection parameters (target score formula, overclaim penalty formula, target hysteresis), artifact chance formula, artifact win count, view pan speeds (slow and fast horizontal pan speed and pan ramp band width), and an optional building blocks tooltip string (shown as the header bar's building blocks stock hover tooltip, REQ-UI-BLOCKS-TOOLTIP; omitted when unset).
+- **buildings.toml** — building block cost and construction time per building type, plus an optional tooltip description string per building type (shown as the build button's hover tooltip, REQ-UI-BUILD-TOOLTIP; omitted when unset).
 - **recipes.toml** — crafting recipes: inputs, outputs, quantities, durations, and reprocessing plant probabilities. Assembler recipe entries may optionally define `unlock_at_station_level` (integer): -1 means the recipe is explicitly unlocked at game start; a value ≥ 0 means the recipe starts locked and a schematic for it can be awarded via defence station destruction (see REQ-LOCK-EXPLICIT, REQ-DEF-SCHEMATIC-DROP). An assembler recipe schematic entry may also define an optional `unlock_requires` list of prerequisite schematic ids (REQ-LOCK-PREREQ).
 - **ships.toml** — per schematic: a human-readable display name (used in the UI), hull stats (HP, max linear speed, sensor range, main acceleration, maneuvering acceleration, angular acceleration, max rotation speed) as plain values, required build materials, the station level at which the schematic becomes available for unlock (`unlock_at_station_level`; -1 means the player starts with the schematic already unlocked), an optional `unlock_requires` prerequisite list (REQ-LOCK-PREREQ), a layout grid defining the ship's module slots, and a `default_modules` list used for enemy wave ships (see REQ-WAV-DEFAULT-MODULES).
-- **modules.toml** — per module type: id, surface mask, materials list, production time, fill color, glyph, the station level at which the schematic becomes available for unlock (`unlock_at_station_level`; -1 means the player starts with the module schematic already unlocked), an optional `unlock_requires` prerequisite list (REQ-LOCK-PREREQ), and an optional capability section and/or stat modifier formulas. A module with a capability section (`[module.weapon]`, `[module.salvage]`, or `[module.repair]`) containing base stat formulas is a **capability module** that grants the ship a weapon, salvage bay, or repair tool per instance (see REQ-MOD-CONFIG for the full list of formulas per capability type). A module with only `added_*`/`multiplied_*` formulas is a **passive module** that modifies stats on the ship or on capability module instances (see REQ-MOD-STAT-CALC).
+- **modules.toml** — per module type: id, surface mask, materials list, production time, fill color, glyph, an optional tooltip description string (shown as the module selection button's hover tooltip, REQ-MOD-UI-MODULE-TOOLTIP; omitted when unset), the station level at which the schematic becomes available for unlock (`unlock_at_station_level`; -1 means the player starts with the module schematic already unlocked), an optional `unlock_requires` prerequisite list (REQ-LOCK-PREREQ), and an optional capability section and/or stat modifier formulas. A module with a capability section (`[module.weapon]`, `[module.salvage]`, or `[module.repair]`) containing base stat formulas is a **capability module** that grants the ship a weapon, salvage bay, or repair tool per instance (see REQ-MOD-CONFIG for the full list of formulas per capability type). A module with only `added_*`/`multiplied_*` formulas is a **passive module** that modifies stats on the ship or on capability module instances (see REQ-MOD-STAT-CALC).
 - **stations.toml** — HP, damage, range, fire rate, and scrap drop for player and enemy defence stations, defined as formulas of station level.
 - **visuals.toml** — rendering-only config (not game parameters): fill and outline colors and glyphs for every building type, item type, ship schematic, and station type; a distinct beam color per tool type (weapon, repair, salvage) and beam width; overlay and toast colors. Loaded by the UI at startup; the simulation does not read it.
 - **ship_layouts.toml** — named layout blueprints per ship type; written and read by the application to persist the layout blueprint panel (REQ-MOD-UI-BLUEPRINT-PANEL through REQ-MOD-UI-BLUEPRINT-FILE-LOAD). Not a game parameter file; the simulation does not read it.
@@ -259,7 +259,7 @@ Modules in `modules.toml` define a `surface_mask` — a list of strings that des
 
 ### Module UI
 
-- REQ-MOD-UI-PREVIEW: When a schematic is selected in a shipyard's selected building panel, a small non-interactive **ship layout preview** widget is shown below the schematic selection button (REQ-UI-SELECT-BUTTON). The preview renders the ship's layout grid at a reduced scale: buildable cells without a module are shown as white, non-buildable cells are shown as black, and cells occupied by a module are shown in that module's `fill_color` with the module's `glyph` character. Below the preview, a "Configure" button is shown.
+- REQ-MOD-UI-PREVIEW: For a selected shipyard (operational building or construction site), the selected building panel always shows a small non-interactive **ship layout preview** widget below the schematic selection button (REQ-UI-SELECT-BUTTON) and a "Configure" button below the preview. Both are **disabled while no schematic is selected**, and enabled once one is; the preview then shows an empty placeholder in place of a layout grid. When a schematic is selected, the preview renders the ship's layout grid at a reduced scale: buildable cells without a module are shown as white, non-buildable cells are shown as black, and cells occupied by a module are shown in that module's `fill_color` with the module's `glyph` character. For non-shipyard buildings, neither the preview nor the "Configure" button is shown.
 - REQ-MOD-UI-DIALOG: Clicking the "Configure" button opens the **layout configuration dialog** as a modal. While the dialog is open, the game is paused (speed set to 0×). On close, the game speed is restored to what it was before the dialog was opened.
 
   The dialog contains:
@@ -269,6 +269,10 @@ Modules in `modules.toml` define a `surface_mask` — a list of strings that des
   - **Right** (below the grid): The layout blueprint panel (see REQ-MOD-UI-BLUEPRINT-PANEL through REQ-MOD-UI-BLUEPRINT-FILE-LOAD).
   - **Bottom**: A "Confirm" button and a "Cancel" button. Cancel discards all changes made in this dialog session and closes the dialog. Confirm applies the changes: the shipyard's configured layout is updated, the required materials and cycle time displayed in the selected building panel are recalculated, and the ship layout preview is refreshed.
 
+- REQ-MOD-UI-AUTO-DIALOG: When the player selects a schematic for a shipyard (operational building or construction site) through the schematic selection dialog (REQ-UI-SELECT-BUTTON), and the chosen schematic **differs** from the shipyard's current schematic, the layout configuration dialog (REQ-MOD-UI-DIALOG) opens automatically and immediately once the selection dialog closes — exactly as if the player had then clicked "Configure". Re-selecting the schematic already set does not reopen the dialog. This auto-open applies only to the manual schematic selection dialog; schematic changes applied via the copy-settings gesture (REQ-BLD-COPY-CONFIG) or blueprint placement (REQ-UI-BLUEPRINT-PLACE) do **not** auto-open the dialog. The player may still cancel the auto-opened dialog (REQ-MOD-UI-DIALOG), which leaves the newly selected schematic in place with its default empty layout; the "Configure" button (REQ-MOD-UI-PREVIEW) remains available to open the dialog again later.
+
+- REQ-MOD-UI-MODULE-TOOLTIP: Each module selection button in the layout configuration dialog (REQ-MOD-UI-DIALOG) shows a hover tooltip with the descriptive text defined for that module type in `modules.toml` (the optional per-module tooltip field). If a module type defines no tooltip text, its button shows no tooltip. The "Remove" button is not a module type and has no config-defined tooltip.
+
 - REQ-MOD-UI-STATS-PANEL: The **ship stats panel** in the layout configuration dialog shows the stats of the currently configured ship layout as they would be computed, incorporating all passive module modifiers per REQ-MOD-STAT-CALC. The panel updates in real time whenever modules are placed or removed in the layout grid.
 
   The panel always shows all hull stats as final computed values:
@@ -401,6 +405,7 @@ The screen is divided into two columns: a main column (75% width) containing the
 ```
 
 - REQ-UI-HEADER: The header bar spans the width of the game world column (75% of the screen width) and always shows the elapsed survival time, the current global building blocks stock, and the artifact count (REQ-WIN-ARTIFACT-COUNT) displayed as `Artifacts: x/y` (where `x` is the current artifact count and `y` is `world.toml [world].artifact_win_count`) on the left, the boss wave counter and boss countdown (REQ-UI-BOSS-STATUS) and an asteroid expansion button (REQ-UI-EXPAND-BUTTON) to the left of the speed buttons, and game speed controls on the right.
+- REQ-UI-BLOCKS-TOOLTIP: The header bar's building blocks stock display (REQ-UI-HEADER) shows a hover tooltip with the descriptive text defined in `world.toml [world].building_blocks_tooltip` — intended to tell the player what building blocks are used for and how to obtain them. If the field is unset, the stock display shows no tooltip. This tooltip is distinct from the build/module button tooltips (REQ-UI-BUILD-TOOLTIP, REQ-MOD-UI-MODULE-TOOLTIP).
 - REQ-UI-BOSS-STATUS: The header bar displays, to the left of the speed buttons, the current boss wave counter (REQ-WAV-BOSS-COUNTER) and the time remaining on the boss countdown (REQ-WAV-BOSS-COUNTDOWN). The boss wave counter is shown as `Boss Wave #<x>` and the countdown as `Next boss: <M:SS>`, where `<M:SS>` is the remaining seconds formatted as whole minutes and two-digit seconds. Both values update continuously as the simulation runs.
 - REQ-UI-SPEED: The game speed controls in the header bar are buttons for 0×, 0.5×, 1×, 2×, and 4× speed. The currently active speed is shown as selected. All game simulation (production, movement, threat accumulation, wave timing) scales with the selected speed. 0× pauses the game.
 - REQ-UI-EXPAND-BUTTON: The header bar shows an asteroid expansion button captioned `Expand: <x> Blocks`, where `<x>` is the current expansion cost computed from `world.toml [expansion].cost_building_blocks_formula` at the current number of purchased expansions (REQ-EXP-COST). Clicking the button unlocks the next asteroid expansion (REQ-EXP-UNLOCK, REQ-GW-ASTEROID-EXPAND), spending that many building blocks from the global stock. The button is disabled when the player cannot currently afford the cost (consistent with REQ-UI-BUILD-DISABLED). The caption updates as the cost changes with each purchased expansion.
@@ -454,25 +459,29 @@ The screen is divided into two columns: a main column (75% width) containing the
 
 ### Selected Building Panel
 
-- REQ-UI-EMPTY-SELECTION: When no building is selected, the panel is empty.
+- REQ-UI-EMPTY-SELECTION: When nothing is selected (no building, construction site, ship, defence station, or scrap pile), the panel is empty.
 - REQ-UI-SINGLE-SELECTION: When one building is selected, the panel shows: building name, current recipe or schematic selection, input buffer contents, and output buffer contents. Buffer counts are displayed as `a/b` where `a` is the current item count and `b` is the per-cycle amount (items consumed per run for inputs; items produced per run for outputs). For a selected construction site, the recipe/schematic selection (and, for a shipyard, the layout preview and "Configure" button) are shown but the buffer rows are omitted (REQ-BLD-SITE-CONFIG).
 - REQ-UI-PRODUCTION-PROGRESS: For buildings that produce items or ships (miner, smelter, assembler, reprocessing plant, shipyard), the selected building panel also shows: (a) the cycle time of the currently selected recipe or schematic in seconds, and (b) the completion percentage of the active production cycle as an integer (e.g. `42%`), or the text `idle` when no production cycle is active. When no recipe or schematic is selected, neither the cycle time nor the progress indicator is shown.
-- REQ-UI-MULTI-SELECT: The player selects multiple buildings by box-drag or by Ctrl+clicking individual buildings to add or remove them from the selection.
-- REQ-UI-MULTI-SELECTION: When multiple buildings are selected, the panel shows how many of each building type are selected. No per-building detail is shown.
+- REQ-UI-MULTI-SELECT: The player selects multiple buildings by box-drag or by Ctrl+clicking individual buildings to add or remove them from the selection. A box-drag that covers at least one building selects buildings (any scrap piles within the box are ignored); a box-drag that covers no buildings but does cover scrap piles selects those scrap piles instead (REQ-UI-SCRAP-MULTI-SELECT).
+- REQ-UI-MULTI-SELECTION: When multiple buildings are selected, the panel shows how many of each building type are selected. No per-building detail is shown. The panel additionally shows the **total building block cost** of the selection — the sum of each selected building's placement cost (`buildings.toml [[building]].cost`, per REQ-BLD-COST), counting only player-placeable buildings (buildings with a button in the build button grid); non-player-placeable buildings (the HQ and defence stations) are excluded from the total, consistent with the blueprint total (REQ-UI-BLUEPRINT-BUTTON). Construction sites count at their building type's full placement cost regardless of construction progress.
 - REQ-UI-CONFIG-INLINE: Recipe and schematic configuration for a selected building is shown within this panel. Recipe selection (miner, assembler) and schematic selection (shipyard) use the selection button and dialog (REQ-UI-SELECT-BUTTON) rather than an inline control. For shipyards, the panel additionally shows the ship layout preview and "Configure" button below the schematic selection button (REQ-MOD-UI-PREVIEW).
 - REQ-UI-SELECT-BUTTON: **Recipe and schematic selection control.** Recipe selection (Miner ore type, Assembler recipe) and schematic selection (Shipyard) are each presented in the selected building panel as a single **selection button** whose caption is the name of the currently selected recipe or schematic, or a placeholder ("Select recipe" / "Select schematic") when none is selected. Clicking the button opens a modal **selection dialog** that pauses the game (speed set to 0×; on close, the speed is restored to what it was before the dialog was opened). The dialog contains a grid of option buttons, one per selectable option — only options that are currently unlocked are shown (REQ-LOCK-UI-RECIPE for recipes, REQ-LOCK-UI-SCHEMATIC for schematics). Hovering an option button shows the selection info tooltip (REQ-UI-SELECT-TOOLTIP). Clicking an option button selects that recipe/schematic, closes the dialog, and updates the selection button's caption in the selected building panel. The dialog can be dismissed without changing the current selection (e.g. closing it without clicking an option). Selecting a new recipe or schematic has the same effects as before (REQ-MAT-INPUT-BUFFER, REQ-MAT-OUTPUT-BUFFER, REQ-BLD-SHIPYARD).
 - REQ-UI-SELECT-TOOLTIP: **Selection info tooltip.** Hovering an option button in the selection dialog (REQ-UI-SELECT-BUTTON), and hovering the selection button in the selected building panel when a selection is set, displays an info tooltip:
   - For a **recipe** (Miner or Assembler): the recipe name; the name and quantity of each input item (no inputs are listed for miner recipes, which consume nothing); the completion time (`duration_seconds`); and the name and quantity of the produced output item.
   - For a **ship schematic** (Shipyard): the ship's `display_name`; the name and quantity of each base required material (`[ship.schematic].materials`, excluding any module contributions); the base production time (`[ship.schematic].production_time_seconds`); and "Produces: 1 <ship display name>".
 - REQ-UI-BELT-CLEAR: When one or more belt, splitter, tunnel entry, or tunnel exit tiles are selected, the panel shows a "Clear" button that removes all items from the selected tiles. Clearing a tunnel entry or exit also discards all items currently in transit through that tunnel (REQ-BLD-TUNNEL-TRANSIT). This can be used to resolve stalled belts, splitters, and tunnels.
-- REQ-UI-ENTITY-CLICK-SELECT: The player can click any ship (player or enemy) or any defence station (player or enemy) in the game world to select it. Clicking a ship or defence station clears any existing selection and establishes a single-entity selection containing only that entity. Ships and defence stations cannot participate in multi-select together with buildings. Clicking empty world space (no building, ship, or defence station) clears the selection.
+- REQ-UI-ENTITY-CLICK-SELECT: The player can click any ship (player or enemy) or any defence station (player or enemy) in the game world to select it. Clicking a ship or defence station clears any existing selection and establishes a single-entity selection containing only that entity. Ships and defence stations cannot participate in multi-select together with buildings. Clicking a scrap pile instead establishes a scrap selection (REQ-UI-SCRAP-CLICK-SELECT). Clicking empty world space (no building, ship, defence station, or scrap pile) clears the selection.
 - REQ-UI-SHIP-STATS-PANEL: When a single ship is selected (REQ-UI-ENTITY-CLICK-SELECT), the selected building panel shows a **ship stats panel**. The panel structure mirrors REQ-MOD-UI-STATS-PANEL but reflects the ship's actual live state: stats are computed from its installed modules per REQ-MOD-STAT-CALC. The panel always shows all hull stats: HP (current / maximum), max linear speed, sensor range, main acceleration, maneuvering acceleration, angular acceleration, and max rotation speed. In addition, capability module summaries are shown conditioned on which module types are installed, using the same aggregation rules as REQ-MOD-UI-STATS-PANEL: weapons (combined DPS, maximum range), salvage (combined collection rate, maximum range), and repair (combined repair rate, maximum range), each section appearing only if at least one instance of that module type is installed. While debug draw mode is active (REQ-UI-DEBUG-DRAW), the panel additionally shows the ship's derived threat cost (REQ-MOD-THREAT).
 - REQ-UI-STATION-STATS-PANEL: When a single defence station is selected (REQ-UI-ENTITY-CLICK-SELECT), the selected building panel shows a **station stats panel** displaying the station's stats computed at its current level: HP (current / maximum), damage, range, and fire rate.
+- REQ-UI-SCRAP-CLICK-SELECT: The player can click any scrap pile (REQ-RES-SCRAP-DROP) in the game world to select it. Scrap forms its own selection category: clicking a scrap pile clears any existing selection and establishes a scrap selection containing only that pile. Scrap piles cannot participate in a selection together with buildings, ships, or defence stations. Hit-testing prioritizes actors over scrap: when a building, ship, or defence station lies under the cursor at the same point as a scrap pile, that object is selected in preference to the scrap; a scrap pile is selected only when no building, ship, or defence station is under the cursor. A selected scrap pile that despawns or is fully collected (REQ-RES-SCRAP-DROP) is removed from the selection; once the last selected pile is gone, the selection becomes empty (REQ-UI-EMPTY-SELECTION).
+- REQ-UI-SCRAP-MULTI-SELECT: Multiple scrap piles can be selected by box-drag or by Ctrl+clicking individual piles to add or remove them from the selection, mirroring building multi-select (REQ-UI-MULTI-SELECT). A scrap selection contains only scrap piles. Because scrap cannot mix with other object types (REQ-UI-SCRAP-CLICK-SELECT), Ctrl+clicking a scrap pile while a building, ship, or defence station selection is active first clears that selection and begins a scrap selection; conversely, selecting a building, ship, or defence station while a scrap selection is active clears the scrap selection. Box-drag disambiguation between buildings and scrap follows REQ-UI-MULTI-SELECT (a box covering any building selects buildings; a box covering scrap but no buildings selects the scrap).
+- REQ-UI-SCRAP-PANEL: When one or more scrap piles are selected, the selected building panel shows the **total remaining scrap amount** across all selected piles — the sum of the piles' current remaining amounts (REQ-RES-SCRAP-DROP), e.g. "Scrap: 47". The same summed-amount display is used whether one pile or many are selected; no per-pile detail and no pile count are shown. The displayed total updates as selected piles are partially collected or despawn (REQ-UI-SCRAP-CLICK-SELECT).
 
 ### Build Button Grid
 
 - REQ-UI-BUILD-GRID: All placeable building types are shown as a flat grid of buttons with no grouping.
 - REQ-UI-BUILD-COST: Each button caption shows the building name and its building block cost, e.g. "Belt: 2 Blocks".
+- REQ-UI-BUILD-TOOLTIP: Each building-type button shows a hover tooltip with the descriptive text defined for that building type in `buildings.toml` (the optional per-building tooltip field). This tooltip is distinct from the recipe/schematic selection tooltip (REQ-UI-SELECT-TOOLTIP). If a building type defines no tooltip text, its button shows no tooltip. The Demolish button (REQ-UI-DEMOLISH-BUTTON) is not a building type and has no config-defined tooltip.
 - REQ-UI-BUILD-DISABLED: Buttons for buildings the player cannot currently afford are shown as disabled.
 - REQ-UI-DEMOLISH-BUTTON: A dedicated **Demolish** button is shown in the build button grid. Clicking it toggles demolish mode on and off, equivalent to the Q demolish toggle (REQ-UI-HOTKEYS). The button is shown in a visually active/pressed state while demolish mode is active.
 
@@ -480,11 +489,11 @@ The screen is divided into two columns: a main column (75% width) containing the
 
 - REQ-UI-BLUEPRINT-PANEL: The blueprint panel is shown to the right of the build button grid. It contains, from top to bottom: a "Create Blueprint" button, and a list of blueprint entries (one per saved blueprint, in creation order). The panel has no Save or Load buttons; blueprints are persisted automatically (REQ-UI-BLUEPRINT-SAVE) and restored at startup (REQ-UI-BLUEPRINT-LOAD).
 
-- REQ-UI-BLUEPRINT-CREATE: The "Create Blueprint" button is enabled only when at least one player-placeable building (i.e. a building with a button in the build button grid) is currently selected; non-player-placeable buildings (HQ, defence stations) in the selection do not count toward this condition. When clicked, a modal dialog appears prompting the player to enter a name. The dialog has Confirm and Cancel buttons. Clicking Cancel closes the dialog with no effect. Clicking Confirm with a non-empty name creates a blueprint from the current selection, silently excluding any non-player-placeable buildings, and appends its button to the blueprint list.
+- REQ-UI-BLUEPRINT-CREATE: The "Create Blueprint" button is enabled only when at least one player-placeable building (i.e. a building with a button in the build button grid) is currently selected; non-player-placeable buildings (HQ, defence stations) in the selection do not count toward this condition. A selected player-placeable building may be either an operational building or a construction site (a building placed but not yet fully built, REQ-BLD-SITE-CONFIG); both count toward this condition and are captured identically (REQ-UI-BLUEPRINT-STORAGE). When clicked, a modal dialog appears prompting the player to enter a name. The dialog has Confirm and Cancel buttons. Clicking Cancel closes the dialog with no effect. Clicking Confirm with a non-empty name creates a blueprint from the current selection, silently excluding any non-player-placeable buildings, and appends its button to the blueprint list.
 
 - REQ-UI-BLUEPRINT-TEMP: Pressing the **T** key (REQ-UI-HOTKEYS) creates a **temporary blueprint** from the current selection and immediately enters blueprint placement mode for it, without opening the naming dialog. It has effect only when at least one player-placeable building is currently selected — the same condition as REQ-UI-BLUEPRINT-CREATE; pressing T with an empty selection, or a selection containing only non-player-placeable buildings (HQ, defence stations), does nothing. Entering this mode replaces any currently active build, blueprint placement, or demolish mode. The temporary blueprint is captured exactly as a saved blueprint (REQ-UI-BLUEPRINT-STORAGE), silently excluding any non-player-placeable buildings from the selection, but it is never named, never shown in the blueprint panel (REQ-UI-BLUEPRINT-PANEL), and never persisted to `blueprints.toml` (REQ-UI-BLUEPRINT-SAVE). Placement behaves identically to a saved blueprint's placement mode (REQ-UI-BLUEPRINT-MODE, REQ-UI-BLUEPRINT-PLACE): a ghost is rendered per building, R / Shift+R rotate the entire constellation, placement follows the same per-building validity and total-cost rules, and after a successful placement the mode stays active so the blueprint can be placed again. Right-clicking in the game world exits placement mode, at which point the temporary blueprint is discarded.
 
-- REQ-UI-BLUEPRINT-STORAGE: A blueprint stores its name and, for each building in the selection, the building type, its rotation, its tile offset (integer dx, dy) from the center of the bounding box of all selected buildings' footprints, and — where applicable — the selected recipe ID (miners and assemblers) or schematic ID (shipyards), and for splitters the two output filters (each a list of item types; an empty list means accept-all), at the time of capture. If no recipe or schematic was selected at capture time, none is stored; for a splitter with no filters set, no filter lists are stored. This structure maps directly to a TOML representation (e.g. one `[[building]]` array entry per constituent building, with the splitter filters as `filter_a`/`filter_b` arrays of item-type ids).
+- REQ-UI-BLUEPRINT-STORAGE: A blueprint stores its name and, for each building in the selection, the building type, its rotation, its tile offset (integer dx, dy) from the center of the bounding box of all selected buildings' footprints, and — where applicable — the selected recipe ID (miners and assemblers) or schematic ID (shipyards), and for splitters the two output filters (each a list of item types; an empty list means accept-all), at the time of capture. A source building may be either an operational building or a construction site (REQ-BLD-SITE-CONFIG); a construction site is captured identically, storing whatever configuration it currently holds and never any buffer or construction-progress state. If no recipe or schematic was selected at capture time, none is stored; for a splitter with no filters set, no filter lists are stored. This structure maps directly to a TOML representation (e.g. one `[[building]]` array entry per constituent building, with the splitter filters as `filter_a`/`filter_b` arrays of item-type ids).
 
 - REQ-UI-BLUEPRINT-BUTTON: Each blueprint entry consists of a blueprint button and a dedicated delete icon ("×") placed to the right of the button. The blueprint button displays the blueprint name and, below it, the total building block cost of the blueprint (sum of the individual costs of all constituent buildings). A blueprint button is disabled when the player cannot afford the total cost. Clicking an enabled blueprint button enters blueprint placement mode for that blueprint. The delete icon is always enabled regardless of whether the player can afford the blueprint.
 

src/lib/config/BuildingsConfig.h

@@ -23,9 +23,26 @@ struct BuildingDef
     // Output-buffer holding size for buildings without a recipe-driven buffer.
     // Only the Salvage Bay sets this (REQ-BLD-SALVAGE-BAY).
     std::optional<int> outputBufferCapacity;
+
+    // Optional hover-tooltip text for the build button (REQ-UI-BUILD-TOOLTIP).
+    std::optional<std::string> tooltip;
 };
 
 struct BuildingsConfig
 {
     std::vector<BuildingDef> buildings;
+
+    // Returns the definition for the given building type, or nullptr if the
+    // type has no entry in buildings.toml.
+    const BuildingDef* findBuildingDef(BuildingType type) const
+    {
+        for (const BuildingDef& def : buildings)
+        {
+            if (def.type == type)
+            {
+                return &def;
+            }
+        }
+        return nullptr;
+    }
 };

src/lib/config/ConfigLoader.cpp

@@ -273,6 +273,12 @@ WorldConfig ConfigLoader::loadWorld(const std::string& path)
     cfg.orbitFactor                = requireDouble(tbl["world"]["orbit_factor"], file, "world.orbit_factor");
     cfg.rallyOrbitRadius_tiles     = requireDouble(tbl["world"]["rally_orbit_radius_tiles"], file, "world.rally_orbit_radius_tiles");
 
+    if (const std::optional<std::string> tip =
+            tbl["world"]["building_blocks_tooltip"].value<std::string>())
+    {
+        cfg.buildingBlocksTooltip = *tip;
+    }
+
     cfg.regions.asteroidWidth_tiles     = static_cast<int>(requireInt(tbl["regions"]["asteroid_width_tiles"],      file, "regions.asteroid_width_tiles"));
     cfg.regions.playerBufferWidth_tiles = static_cast<int>(requireInt(tbl["regions"]["player_buffer_width_tiles"], file, "regions.player_buffer_width_tiles"));
     cfg.regions.contestZoneWidth_tiles  = static_cast<int>(requireInt(tbl["regions"]["contest_zone_width_tiles"],  file, "regions.contest_zone_width_tiles"));
@@ -343,6 +349,11 @@ BuildingsConfig ConfigLoader::loadBuildings(const std::string& path)
                 requireInt(mt["output_buffer_capacity"], file, elemPath + ".output_buffer_capacity"));
         }
 
+        if (mt.contains("tooltip"))
+        {
+            def.tooltip = requireString(mt["tooltip"], file, elemPath + ".tooltip");
+        }
+
         const std::optional<BuildingType> parsedType = parseBuildingType(def.id);
         if (!parsedType)
         {
@@ -603,6 +614,11 @@ ModulesConfig ConfigLoader::loadModules(const std::string& path)
         def.fillColor             = requireString(mt["fill_color"], file, elemPath + ".fill_color");
         def.glyph                 = requireString(mt["glyph"], file, elemPath + ".glyph");
 
+        if (mt.contains("tooltip"))
+        {
+            def.tooltip = requireString(mt["tooltip"], file, elemPath + ".tooltip");
+        }
+
         // Materials
         {
             const toml::array& materials = requireArray(mt["materials"], file, elemPath + ".materials");

src/lib/config/ModulesConfig.h

@@ -54,6 +54,10 @@ struct ModuleDef
     std::optional<ModuleWeaponCapability>  weaponCapability;
     std::optional<ModuleSalvageCapability> salvageCapability;
     std::optional<ModuleRepairCapability>  repairCapability;
+
+    // Optional hover-tooltip text for the module selection button
+    // (REQ-MOD-UI-MODULE-TOOLTIP).
+    std::optional<std::string> tooltip;
 };
 
 struct ModulesConfig

src/lib/config/WorldConfig.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <optional>
+#include <string>
+
 #include "Formula.h"
 
 // Region widths are in tiles (REQ-GW-REGIONS).
@@ -75,6 +78,10 @@ struct WorldConfig
     double orbitFactor;                 // REQ-SHP-ORBIT (multiplies tool range for orbit radius)
     double rallyOrbitRadius_tiles;      // REQ-SHP-ORBIT (fixed orbit radius around the rally point)
 
+    // Optional hover-tooltip for the header building blocks stock display
+    // (REQ-UI-BLOCKS-TOOLTIP). Presentation-only; the simulation ignores it.
+    std::optional<std::string> buildingBlocksTooltip;
+
     WorldRegions regions;
     WorldExpansion expansion;
     WorldPush push;

src/lib/ecs/system/ScrapSystem.cpp

@@ -69,9 +69,9 @@ std::vector<ScrapInfo> ScrapSystem::allScrapInfo() const
 {
     std::vector<ScrapInfo> result;
     m_admin.forEach<ScrapDataComponent>(
-        [&result, this](entt::entity e, const ScrapDataComponent& /*sd*/)
+        [&result, this](entt::entity e, const ScrapDataComponent& sd)
         {
-            result.push_back(ScrapInfo{e, m_admin.get<PositionComponent>(e).value});
+            result.push_back(ScrapInfo{e, m_admin.get<PositionComponent>(e).value, sd.amount});
         });
     return result;
 }

src/lib/ecs/system/ScrapSystem.h

@@ -15,6 +15,7 @@ struct ScrapInfo
 {
     entt::entity entity;
     QVector2D position;
+    int amount;
 };
 
 class ScrapSystem

src/lib/eventsystem/event/ScrapSelectionChangedEvent.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <vector>
+
+#include "entt/entity/entity.hpp"
+
+#include "Event.h"
+
+// The set of currently selected scrap piles (REQ-UI-SCRAP-CLICK-SELECT,
+// REQ-UI-SCRAP-MULTI-SELECT). An empty list means no scrap is selected. Scrap forms
+// its own selection category, mutually exclusive with buildings and entities.
+class ScrapSelectionChangedEvent : public Event
+{
+public:
+    explicit ScrapSelectionChangedEvent(std::vector<entt::entity> scrap)
+        : scrap(std::move(scrap)) {}
+    const std::vector<entt::entity> scrap;
+};

src/lib/sim/BuildingConfig.cpp

@@ -1,10 +1,55 @@
 #include "BuildingConfig.h"
 
+#include <algorithm>
+#include <climits>
+
 #include "BeltSystem.h"
 #include "Building.h"
 #include "BuildingSystem.h"
 #include "Simulation.h"
 
+namespace
+{
+// The blueprint-relevant geometry shared by operational buildings and construction
+// sites. Resolved from whichever of the two a selected id refers to.
+struct SelectedBuilding
+{
+    BuildingId                id;
+    BuildingType              type;
+    Rotation                  rotation;
+    QPoint                    anchor;
+    const std::vector<QPoint>* bodyCells;
+};
+
+// Resolves a selected id to a player-placeable building or construction site, if it
+// is one. Returns std::nullopt for an unknown id or a non-player-placeable building
+// (the HQ and defence stations, per REQ-UI-BLUEPRINT-CREATE).
+std::optional<SelectedBuilding> resolvePlaceable(const Simulation& sim, BuildingId id)
+{
+    const Building*         building = sim.buildings().findBuilding(id);
+    const ConstructionSite* site     = building ? nullptr : sim.buildings().findSite(id);
+    if (!building && !site)
+    {
+        return std::nullopt;
+    }
+
+    const BuildingType  type = building ? building->type : site->type;
+    const BuildingDef*  def  = sim.config().buildings.findBuildingDef(type);
+    if (!def || !def->playerPlaceable)
+    {
+        return std::nullopt;
+    }
+
+    SelectedBuilding resolved;
+    resolved.id        = id;
+    resolved.type      = type;
+    resolved.rotation  = building ? building->rotation : site->rotation;
+    resolved.anchor    = building ? building->anchor : site->anchor;
+    resolved.bodyCells = building ? &building->bodyCells : &site->bodyCells;
+    return resolved;
+}
+} // namespace
+
 std::optional<BuildingConfig> readBuildingConfig(const Simulation& sim, BuildingId id)
 {
     const Building*         building = sim.buildings().findBuilding(id);
@@ -49,3 +94,74 @@ std::optional<BuildingConfig> readBuildingConfig(const Simulation& sim, Building
 
     return config;
 }
+
+Blueprint captureBlueprintFromSelection(const Simulation&              sim,
+                                        const std::vector<BuildingId>& selectedIds)
+{
+    std::vector<SelectedBuilding> entries;
+    entries.reserve(selectedIds.size());
+    for (const BuildingId id : selectedIds)
+    {
+        const std::optional<SelectedBuilding> resolved = resolvePlaceable(sim, id);
+        if (resolved.has_value())
+        {
+            entries.push_back(*resolved);
+        }
+    }
+
+    if (entries.empty())
+    {
+        return Blueprint{};
+    }
+
+    int minX = INT_MAX, maxX = INT_MIN;
+    int minY = INT_MAX, maxY = INT_MIN;
+    for (const SelectedBuilding& e : entries)
+    {
+        for (const QPoint& cell : *e.bodyCells)
+        {
+            minX = std::min(minX, cell.x());
+            maxX = std::max(maxX, cell.x());
+            minY = std::min(minY, cell.y());
+            maxY = std::max(maxY, cell.y());
+        }
+    }
+
+    const QPoint center((minX + maxX) / 2, (minY + maxY) / 2);
+
+    Blueprint blueprint;
+    blueprint.buildings.reserve(entries.size());
+    for (const SelectedBuilding& e : entries)
+    {
+        BlueprintBuilding building;
+        building.type     = e.type;
+        building.rotation = e.rotation;
+        building.offset   = e.anchor - center;
+        // Recipe / schematic / layout / splitter-filter capture is shared with the
+        // copy-settings gesture (REQ-BLD-COPY-CONFIG) via readBuildingConfig, which
+        // handles operational buildings and construction sites alike.
+        const std::optional<BuildingConfig> config = readBuildingConfig(sim, e.id);
+        if (config.has_value())
+        {
+            building.recipeId        = config->recipeId.value_or(std::string());
+            building.shipLayout      = config->shipLayout;
+            building.splitterFilterA = config->splitterFilterA;
+            building.splitterFilterB = config->splitterFilterB;
+        }
+        blueprint.buildings.push_back(building);
+    }
+    return blueprint;
+}
+
+bool selectionHasPlaceableBuilding(const Simulation&              sim,
+                                   const std::vector<BuildingId>& selectedIds)
+{
+    for (const BuildingId id : selectedIds)
+    {
+        if (resolvePlaceable(sim, id).has_value())
+        {
+            return true;
+        }
+    }
+    return false;
+}

src/lib/sim/BuildingConfig.h

@@ -4,6 +4,7 @@
 #include <string>
 #include <vector>
 
+#include "Blueprint.h"
 #include "BuildingId.h"
 #include "BuildingType.h"
 #include "ItemType.h"
@@ -38,3 +39,16 @@ struct BuildingConfig
 // by id, handling operational buildings and sites alike. Returns std::nullopt if
 // no such building or site exists.
 std::optional<BuildingConfig> readBuildingConfig(const Simulation& sim, BuildingId id);
+
+// Captures a blueprint from a selection of building / construction-site ids, keeping
+// only player-placeable buildings and recording each one's type, rotation, offset
+// from the selection's bounding-box center, and configuration. Operational buildings
+// and construction sites are treated identically (REQ-UI-BLUEPRINT-CREATE,
+// REQ-UI-BLUEPRINT-STORAGE). The returned blueprint is unnamed.
+Blueprint captureBlueprintFromSelection(const Simulation&              sim,
+                                        const std::vector<BuildingId>& selectedIds);
+
+// True if any selected id refers to a player-placeable building or construction site
+// (the enable condition for the Create Blueprint button, REQ-UI-BLUEPRINT-CREATE).
+bool selectionHasPlaceableBuilding(const Simulation&              sim,
+                                   const std::vector<BuildingId>& selectedIds);

src/lib/sim/BuildingSystem.cpp

@@ -1,5 +1,6 @@
 #include "BuildingSystem.h"
 
+#include <algorithm>
 #include <cassert>
 #include <limits>
 #include <random>
@@ -9,6 +10,18 @@
 #include "SurfaceMask.h"
 #include "tracing.h"
 
+namespace
+{
+// Smelter and Reprocessing Plant have no player-selected recipe
+// (REQ-BLD-SMELTER, REQ-BLD-REPROCESSING). They auto-process whatever inputs
+// they receive, matching against every recipe of their building type.
+bool isAutoRecipeBuildingType(BuildingType type)
+{
+    return type == BuildingType::Smelter
+        || type == BuildingType::ReprocessingPlant;
+}
+}  // namespace
+
 BuildingSystem::BuildingSystem(const GameConfig& config,
                                BeltSystem& belts,
                                std::function<BuildingId()> allocateBuildingId,
@@ -118,6 +131,56 @@ void BuildingSystem::initBuffers(Building& b, const RecipeDef& recipe) const
     }
 }
 
+void BuildingSystem::initAutoBuffers(Building& b) const
+{
+    b.inputBuffer.counts.clear();
+    b.inputBuffer.caps.clear();
+
+    // Union the inputs of every recipe of this building type; the cap for each
+    // item is twice the largest per-cycle requirement across those recipes.
+    // Output capacity follows the same rules as initBuffers: the Reprocessing
+    // Plant holds one cycle's max output (REQ-MAT-OUTPUT-BUFFER-REPROCESSING),
+    // other auto buildings hold twice the largest per-cycle output.
+    int outputCapacity = 0;
+    for (const RecipeDef& recipe : m_config.recipes.recipes)
+    {
+        if (recipe.building != b.type)
+        {
+            continue;
+        }
+
+        for (const RecipeIngredient& ing : recipe.inputs)
+        {
+            const ItemType type{ing.item};
+            b.inputBuffer.counts[type] = 0;
+            b.inputBuffer.caps[type] =
+                std::max(b.inputBuffer.caps[type], 2 * ing.amount);
+        }
+
+        if (b.type == BuildingType::ReprocessingPlant)
+        {
+            int maxAmount = 0;
+            for (const RecipeOutput& out : recipe.outputs)
+            {
+                maxAmount = std::max(maxAmount, out.amount);
+            }
+            outputCapacity = std::max(outputCapacity, maxAmount);
+        }
+        else
+        {
+            int totalAmount = 0;
+            for (const RecipeOutput& out : recipe.outputs)
+            {
+                totalAmount += out.amount;
+            }
+            outputCapacity = std::max(outputCapacity, 2 * totalAmount);
+        }
+    }
+
+    b.outputBuffer.items.clear();
+    b.outputBuffer.capacity = outputCapacity;
+}
+
 void BuildingSystem::initShipyardBuffers(Building& b) const
 {
     b.inputBuffer.counts.clear();
@@ -419,6 +482,12 @@ void BuildingSystem::setRecipe(BuildingId id, const std::string& recipeId)
     {
         if (site.id == id)
         {
+            // Auto-recipe buildings have no player-selected recipe
+            // (REQ-BLD-SMELTER, REQ-BLD-REPROCESSING); ignore any attempt to set one.
+            if (isAutoRecipeBuildingType(site.type))
+            {
+                return;
+            }
             // No-op if the recipe is unchanged, so a redundant selection does
             // not wipe an already-configured ship layout.
             if (site.recipeId == recipeId)
@@ -436,6 +505,12 @@ void BuildingSystem::setRecipe(BuildingId id, const std::string& recipeId)
     {
         if (building.id == id)
         {
+            // Auto-recipe buildings have no player-selected recipe
+            // (REQ-BLD-SMELTER, REQ-BLD-REPROCESSING); ignore any attempt to set one.
+            if (isAutoRecipeBuildingType(building.type))
+            {
+                return;
+            }
             // No-op if the recipe is unchanged, so a redundant selection does
             // not wipe an already-configured ship layout or reset buffers.
             if (building.recipeId == recipeId)
@@ -603,6 +678,12 @@ void BuildingSystem::tickConstruction(Tick currentTick)
     {
         initSalvageBayBuffer(building);
     }
+    else if (isAutoRecipeBuildingType(building.type))
+    {
+        // Smelter/Reprocessing Plant need no recipe selection; buffers are set
+        // up from all recipes of the type (REQ-BLD-SMELTER, REQ-BLD-REPROCESSING).
+        initAutoBuffers(building);
+    }
     else if (!building.recipeId.empty())
     {
         if (building.type == BuildingType::Shipyard)
@@ -684,18 +765,24 @@ void BuildingSystem::tickBeltPull()
             continue;
         }
 
-        if (building.recipeId.empty())
+        // Auto-recipe buildings (Smelter, Reprocessing Plant) accept any item
+        // that is an input to one of their recipes; their caps already span the
+        // union of those inputs (initAutoBuffers), so no recipe lookup is needed.
+        if (!isAutoRecipeBuildingType(building.type))
         {
-            continue;
-        }
-
-        if (building.type != BuildingType::Shipyard)
-        {
-            const RecipeDef* recipe = findRecipe(building.recipeId, building.type);
-            if (!recipe || recipe->inputs.empty())
+            if (building.recipeId.empty())
             {
                 continue;
             }
+
+            if (building.type != BuildingType::Shipyard)
+            {
+                const RecipeDef* recipe = findRecipe(building.recipeId, building.type);
+                if (!recipe || recipe->inputs.empty())
+                {
+                    continue;
+                }
+            }
         }
 
         for (const Port& port : building.inputPorts)
@@ -752,18 +839,15 @@ void BuildingSystem::tickProduction(Tick currentTick)
             continue;
         }
 
-        if (building.recipeId.empty())
+        const bool autoRecipe = isAutoRecipeBuildingType(building.type);
+        if (!autoRecipe && building.recipeId.empty())
         {
             continue;
         }
 
-        const RecipeDef* recipe = findRecipe(building.recipeId, building.type);
-        if (!recipe)
-        {
-            continue;
-        }
-
-        // If a production cycle is active, check for completion.
+        // If a production cycle is active, check for completion. Completion only
+        // needs the already-decided outputs, so it does not depend on which
+        // recipe is selected or auto-chosen.
         if (building.production)
         {
             if (currentTick >= building.production->completesAt)
@@ -779,66 +863,93 @@ void BuildingSystem::tickProduction(Tick currentTick)
             continue;
         }
 
-        // Idle: check if a new cycle can start.
-
-        // 1. All required inputs present?
-        bool inputsOk = true;
-        for (const RecipeIngredient& ing : recipe->inputs)
+        // Idle: gather the candidate recipes to try. Auto-recipe buildings
+        // (Smelter, Reprocessing Plant) have no selected recipe and try every
+        // recipe of their type in config order, running the first whose inputs
+        // are satisfied (REQ-BLD-SMELTER, REQ-BLD-REPROCESSING). Other buildings
+        // try only their selected recipe.
+        std::vector<const RecipeDef*> candidates;
+        if (autoRecipe)
         {
-            const ItemType type{ing.item};
-            const std::map<ItemType, int>::const_iterator it =
-                building.inputBuffer.counts.find(type);
-            const int have = (it != building.inputBuffer.counts.end()) ? it->second : 0;
-            if (have < ing.amount)
+            for (const RecipeDef& r : m_config.recipes.recipes)
             {
-                inputsOk = false;
-                break;
-            }
-        }
-        if (!inputsOk)
-        {
-            continue;
-        }
-
-        // 2. Determine chosen outputs (roll for reprocessing).
-        std::vector<Item> chosen;
-        if (building.type == BuildingType::ReprocessingPlant)
-        {
-            chosen = rollReprocessingOutput(*recipe);
-            if (chosen.empty()) { continue; }
-        }
-        else
-        {
-            for (const RecipeOutput& out : recipe->outputs)
-            {
-                Item item;
-                item.type.id = out.item;
-                for (int i = 0; i < out.amount; ++i)
+                if (r.building == building.type && !r.inputs.empty())
                 {
-                    chosen.push_back(item);
+                    candidates.push_back(&r);
                 }
             }
         }
-
-        // 3. Output buffer has space for chosen outputs?
-        const int newSize = static_cast<int>(building.outputBuffer.items.size())
-                          + static_cast<int>(chosen.size());
-        if (newSize > building.outputBuffer.capacity)
+        else
         {
-            continue;
+            const RecipeDef* recipe = findRecipe(building.recipeId, building.type);
+            if (recipe)
+            {
+                candidates.push_back(recipe);
+            }
         }
 
-        // 4. Consume inputs and start cycle.
-        for (const RecipeIngredient& ing : recipe->inputs)
+        for (const RecipeDef* recipe : candidates)
         {
-            building.inputBuffer.counts[ItemType{ing.item}] -= ing.amount;
-        }
+            // 1. All required inputs present?
+            bool inputsOk = true;
+            for (const RecipeIngredient& ing : recipe->inputs)
+            {
+                const ItemType type{ing.item};
+                const std::map<ItemType, int>::const_iterator it =
+                    building.inputBuffer.counts.find(type);
+                const int have = (it != building.inputBuffer.counts.end()) ? it->second : 0;
+                if (have < ing.amount)
+                {
+                    inputsOk = false;
+                    break;
+                }
+            }
+            if (!inputsOk)
+            {
+                continue;
+            }
 
-        Production prod;
-        prod.recipeId     = building.recipeId;
-        prod.completesAt  = currentTick + secondsToTicks(recipe->durationSeconds);
-        prod.chosenOutputs = std::move(chosen);
-        building.production = std::move(prod);
+            // 2. Determine chosen outputs (roll for reprocessing).
+            std::vector<Item> chosen;
+            if (building.type == BuildingType::ReprocessingPlant)
+            {
+                chosen = rollReprocessingOutput(*recipe);
+                if (chosen.empty()) { continue; }
+            }
+            else
+            {
+                for (const RecipeOutput& out : recipe->outputs)
+                {
+                    Item item;
+                    item.type.id = out.item;
+                    for (int i = 0; i < out.amount; ++i)
+                    {
+                        chosen.push_back(item);
+                    }
+                }
+            }
+
+            // 3. Output buffer has space for chosen outputs?
+            const int newSize = static_cast<int>(building.outputBuffer.items.size())
+                              + static_cast<int>(chosen.size());
+            if (newSize > building.outputBuffer.capacity)
+            {
+                continue;
+            }
+
+            // 4. Consume inputs and start cycle.
+            for (const RecipeIngredient& ing : recipe->inputs)
+            {
+                building.inputBuffer.counts[ItemType{ing.item}] -= ing.amount;
+            }
+
+            Production prod;
+            prod.recipeId      = recipe->id;
+            prod.completesAt   = currentTick + secondsToTicks(recipe->durationSeconds);
+            prod.chosenOutputs = std::move(chosen);
+            building.production = std::move(prod);
+            break;  // At most one cycle starts per tick.
+        }
     }
 }
 

src/lib/sim/BuildingSystem.h

@@ -169,6 +169,10 @@ private:
     const ShipDef*      findShipDef(const std::string& id) const;
     const ModuleDef*    findModuleDef(const std::string& id) const;
     void                initBuffers(Building& b, const RecipeDef& recipe) const;
+    // Buffers for an auto-recipe building (Smelter, Reprocessing Plant): input
+    // caps span the union of every recipe of the building's type; no player
+    // recipe is selected (REQ-BLD-SMELTER, REQ-BLD-REPROCESSING).
+    void                initAutoBuffers(Building& b) const;
     void                initShipyardBuffers(Building& b) const;
     void                initSalvageBayBuffer(Building& b) const;
     std::vector<Port>   computeInputPorts(const Building& b) const;

src/lib/sim/EntityHitTest.cpp

@@ -1,9 +1,11 @@
 #include "EntityHitTest.h"
 
+#include <algorithm>
 #include <cmath>
 
 #include "EntityAdmin.h"
 #include "PositionComponent.h"
+#include "ScrapDataComponent.h"
 #include "StationBodyComponent.h"
 #include "HealthComponent.h"
 
@@ -54,3 +56,48 @@ entt::entity entityAtWorldPos(EntityAdmin& admin, QVector2D worldPos)
 
     return bestShip;
 }
+
+entt::entity scrapAtWorldPos(EntityAdmin& admin, QVector2D worldPos)
+{
+    // Slightly larger than the scrap's rendered radius (0.2 tiles) so small piles
+    // remain easy to click; tunable.
+    constexpr float kScrapHitRadiusSquared = 0.35f * 0.35f;
+    entt::entity bestScrap = entt::null;
+    float bestDistSquared = kScrapHitRadiusSquared;
+
+    admin.forEach<ScrapDataComponent, PositionComponent>(
+        [&](entt::entity entity, const ScrapDataComponent& /*sd*/, const PositionComponent& pos)
+        {
+            const float dx = pos.value.x() - worldPos.x();
+            const float dy = pos.value.y() - worldPos.y();
+            const float distSquared = dx * dx + dy * dy;
+            if (distSquared < bestDistSquared)
+            {
+                bestDistSquared = distSquared;
+                bestScrap = entity;
+            }
+        });
+
+    return bestScrap;
+}
+
+std::vector<entt::entity> scrapInBox(EntityAdmin& admin, QPoint tileA, QPoint tileB)
+{
+    const int minX = std::min(tileA.x(), tileB.x());
+    const int maxX = std::max(tileA.x(), tileB.x());
+    const int minY = std::min(tileA.y(), tileB.y());
+    const int maxY = std::max(tileA.y(), tileB.y());
+
+    std::vector<entt::entity> result;
+    admin.forEach<ScrapDataComponent, PositionComponent>(
+        [&](entt::entity entity, const ScrapDataComponent& /*sd*/, const PositionComponent& pos)
+        {
+            const int tileX = static_cast<int>(std::floor(pos.value.x()));
+            const int tileY = static_cast<int>(std::floor(pos.value.y()));
+            if (tileX >= minX && tileX <= maxX && tileY >= minY && tileY <= maxY)
+            {
+                result.push_back(entity);
+            }
+        });
+    return result;
+}

src/lib/sim/EntityHitTest.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <vector>
+
+#include <QPoint>
 #include <QVector2D>
 
 #include "entt/entity/entity.hpp"
@@ -7,3 +10,12 @@
 class EntityAdmin;
 
 entt::entity entityAtWorldPos(EntityAdmin& admin, QVector2D worldPos);
+
+// Returns the nearest scrap pile whose center is within the scrap pick radius of
+// worldPos, or entt::null if none (REQ-UI-SCRAP-CLICK-SELECT). Scrap is picked only
+// after actors: entityAtWorldPos never returns scrap (scrap has no HealthComponent).
+entt::entity scrapAtWorldPos(EntityAdmin& admin, QVector2D worldPos);
+
+// Returns every scrap pile whose position falls within the inclusive tile rectangle
+// spanned by tileA and tileB, in any corner order (REQ-UI-SCRAP-MULTI-SELECT).
+std::vector<entt::entity> scrapInBox(EntityAdmin& admin, QPoint tileA, QPoint tileB);

src/test/BlueprintTest.cpp

@@ -8,6 +8,7 @@
 
 #include "Blueprint.h"
 #include "Building.h"
+#include "BuildingConfig.h"
 #include "BuildingsConfig.h"
 #include "BuildingSystem.h"
 #include "BuildingType.h"
@@ -696,6 +697,92 @@ TEST_CASE("Blueprint placement: recipe transfers to building after construction
     REQUIRE(b->recipeId == "mine_copper_ore");
 }
 
+// ---------------------------------------------------------------------------
+// Blueprint capture from construction sites (REQ-UI-BLUEPRINT-CREATE,
+// REQ-UI-BLUEPRINT-STORAGE): a still-under-construction building is a valid
+// blueprint source, captured identically to an operational building.
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Blueprint creation: a construction site is captured", "[blueprint]")
+{
+    Simulation sim(loadConfig());
+
+    // Freshly placed → a ConstructionSite (not ticked to completion). A 1x1 belt keeps
+    // the body-cell bounding-box centered on the anchor, so a single site → zero offset.
+    const BuildingId id =
+        SimulationTestAccess::place(sim, BuildingType::Belt, QPoint(-2, 0), Rotation::East);
+    REQUIRE(id != kInvalidBuildingId);
+    REQUIRE(sim.buildings().findSite(id) != nullptr);
+    REQUIRE(sim.buildings().findBuilding(id) == nullptr);
+
+    const Blueprint bp = captureBlueprintFromSelection(sim, { id });
+
+    REQUIRE(bp.buildings.size() == 1);
+    REQUIRE(bp.buildings[0].type == BuildingType::Belt);
+    REQUIRE(bp.buildings[0].offset == QPoint(0, 0)); // single 1x1 building → zero offset
+}
+
+TEST_CASE("Blueprint creation: a construction site's recipe is captured", "[blueprint]")
+{
+    Simulation sim(loadConfig());
+
+    const BuildingId id =
+        SimulationTestAccess::place(sim, BuildingType::Miner, QPoint(-2, 0), Rotation::East);
+    REQUIRE(id != kInvalidBuildingId);
+    SimulationTestAccess::buildings(sim).setRecipe(id, "mine_iron_ore");
+
+    const Blueprint bp = captureBlueprintFromSelection(sim, { id });
+
+    REQUIRE(bp.buildings.size() == 1);
+    REQUIRE(bp.buildings[0].recipeId == "mine_iron_ore");
+}
+
+TEST_CASE("Blueprint creation: mixed operational building and construction site are both captured",
+          "[blueprint]")
+{
+    Simulation sim(loadConfig());
+
+    // Building A: place, configure, and tick to completion so it is operational.
+    const BuildingId idA =
+        SimulationTestAccess::place(sim, BuildingType::Miner, QPoint(-2, 0), Rotation::East);
+    REQUIRE(idA != kInvalidBuildingId);
+    SimulationTestAccess::buildings(sim).setRecipe(idA, "mine_iron_ore");
+    for (int i = 0; i <= static_cast<int>(secondsToTicks(10.0)); ++i) { sim.tick(); }
+    REQUIRE(sim.buildings().findBuilding(idA) != nullptr);
+
+    // Building B: place and configure, but leave as a construction site.
+    const BuildingId idB =
+        SimulationTestAccess::place(sim, BuildingType::Miner, QPoint(-6, 0), Rotation::East);
+    REQUIRE(idB != kInvalidBuildingId);
+    SimulationTestAccess::buildings(sim).setRecipe(idB, "mine_copper_ore");
+    REQUIRE(sim.buildings().findSite(idB) != nullptr);
+
+    const Blueprint bp = captureBlueprintFromSelection(sim, { idA, idB });
+
+    REQUIRE(bp.buildings.size() == 2);
+    REQUIRE(bp.buildings[0].type == BuildingType::Miner);
+    REQUIRE(bp.buildings[1].type == BuildingType::Miner);
+    // Both the operational building's and the site's configs come through.
+    std::vector<std::string> recipes = { bp.buildings[0].recipeId, bp.buildings[1].recipeId };
+    std::sort(recipes.begin(), recipes.end());
+    REQUIRE(recipes == std::vector<std::string>{ "mine_copper_ore", "mine_iron_ore" });
+    // Distinct anchors → distinct offsets.
+    REQUIRE(bp.buildings[0].offset != bp.buildings[1].offset);
+}
+
+TEST_CASE("Blueprint creation: selectionHasPlaceableBuilding sees a construction site", "[blueprint]")
+{
+    Simulation sim(loadConfig());
+
+    REQUIRE_FALSE(selectionHasPlaceableBuilding(sim, {}));
+
+    const BuildingId id =
+        SimulationTestAccess::place(sim, BuildingType::Miner, QPoint(-2, 0), Rotation::East);
+    REQUIRE(id != kInvalidBuildingId);
+    REQUIRE(sim.buildings().findSite(id) != nullptr);
+    REQUIRE(selectionHasPlaceableBuilding(sim, { id }));
+}
+
 TEST_CASE("Blueprint placement: interceptor schematic is unlocked at game start", "[blueprint]")
 {
     // "interceptor" has unlock_at_station_level = -1 in the test config.

src/test/BuildingTest.cpp

@@ -474,7 +474,8 @@ TEST_CASE("BuildingSystem: productionBuildingCount excludes construction sites",
     runTicks(bs, belts, static_cast<int>(secondsToTicks(15.0)), tick);
     REQUIRE(bs.productionBuildingCount() == 2);
 
-    // Neither has a recipe selected, so neither has an active cycle.
+    // Neither is producing yet: the miner has no recipe selected, and the
+    // smelter (auto-recipe, REQ-BLD-SMELTER) has no input feeding it.
     REQUIRE(bs.activeProductionBuildingCount() == 0);
 
     bs.setRecipe(minerId, "mine_iron_ore");
@@ -542,7 +543,8 @@ TEST_CASE("BuildingSystem: smelter input buffer fills from adjacent west-flowing
     // Smelter mask ["AA ","AA>"] → body (0,0),(1,0),(0,1),(1,1).
     // Output port (2,1) East.  Input port example: (2,0) West.
     const BuildingId sid = bs.place(BuildingType::Smelter, QPoint(0, 0), Rotation::East, 0);
-    bs.setRecipe(sid, "iron_ingot");
+    // Smelters have no recipe selection (REQ-BLD-SMELTER); they auto-accept any
+    // ore/scrap that is an input to a smelter recipe.
 
     // Complete construction (15s → tick 450+1 = 451 ticks).
     Tick tick = 0;
@@ -563,6 +565,105 @@ TEST_CASE("BuildingSystem: smelter input buffer fills from adjacent west-flowing
     REQUIRE(it->second >= 1);
 }
 
+// A smelter auto-selects the matching recipe for whatever it is fed, with no
+// player recipe selection (REQ-BLD-SMELTER).
+TEST_CASE("BuildingSystem: smelter auto-smelts ore without a recipe selection",
+          "[building]")
+{
+    const GameConfig cfg = loadConfig();
+    BeltSystem belts(static_cast<double>(kTickRateHz));
+    int stock = 0;
+    std::mt19937 rng(0);
+    BuildingId nextBuildingId = 1;
+    BuildingSystem bs(cfg, belts,
+                      [&nextBuildingId]() { return nextBuildingId++; },
+                      [&stock](int n) { stock += n; },
+                      [](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
+                      [](const std::string&) -> bool { return true; },
+                      rng);
+
+    const BuildingId sid = bs.place(BuildingType::Smelter, QPoint(0, 0), Rotation::East, 0);
+
+    Tick tick = 0;
+    runTicks(bs, belts, static_cast<int>(secondsToTicks(15.0)) + 1, tick);
+
+    // Feed 2 iron_ore (the test-config iron_ingot recipe needs 2) via a
+    // west-flowing belt at input port (2,0).
+    belts.placeBelt(QPoint(2, 0), Rotation::West);
+    for (int i = 0; i < 2; ++i)
+    {
+        belts.tryPutItem(QPoint(2, 0), makeItem("iron_ore"));
+        belts.tick();
+        bs.tickBeltPull();
+    }
+
+    // iron_ingot recipe cycle is 2s; run to completion.
+    runTicks(bs, belts, static_cast<int>(secondsToTicks(2.0)) + 2, tick);
+
+    const Building* b = bs.findBuilding(sid);
+    REQUIRE(b != nullptr);
+    bool hasIronIngot = false;
+    for (const Item& item : b->outputBuffer.items)
+    {
+        if (item.type.id == "iron_ingot") { hasIronIngot = true; }
+    }
+    REQUIRE(hasIronIngot);
+}
+
+// With mixed inputs, the smelter runs whichever recipe is currently satisfiable
+// and leaves an incomplete batch of another input waiting (see the union-of-
+// inputs caps in initAutoBuffers).
+TEST_CASE("BuildingSystem: smelter runs a satisfiable recipe while an incomplete batch waits",
+          "[building]")
+{
+    const GameConfig cfg = loadConfig();
+    BeltSystem belts(static_cast<double>(kTickRateHz));
+    int stock = 0;
+    std::mt19937 rng(0);
+    BuildingId nextBuildingId = 1;
+    BuildingSystem bs(cfg, belts,
+                      [&nextBuildingId]() { return nextBuildingId++; },
+                      [&stock](int n) { stock += n; },
+                      [](const std::string&, QVector2D, const std::optional<ShipLayoutConfig>&) {},
+                      [](const std::string&) -> bool { return true; },
+                      rng);
+
+    const BuildingId sid = bs.place(BuildingType::Smelter, QPoint(0, 0), Rotation::East, 0);
+
+    Tick tick = 0;
+    runTicks(bs, belts, static_cast<int>(secondsToTicks(15.0)) + 1, tick);
+
+    // Feed 1 iron_ore (iron_ingot needs 2 — incomplete) then 2 copper_ore
+    // (copper_ingot needs 2 — satisfiable) via the west-flowing input belt.
+    belts.placeBelt(QPoint(2, 0), Rotation::West);
+    const char* fed[] = { "iron_ore", "copper_ore", "copper_ore" };
+    for (const char* id : fed)
+    {
+        belts.tryPutItem(QPoint(2, 0), makeItem(id));
+        belts.tick();
+        bs.tickBeltPull();
+    }
+
+    // copper_ingot cycle is 2.5s; run to completion.
+    runTicks(bs, belts, static_cast<int>(secondsToTicks(2.5)) + 2, tick);
+
+    const Building* b = bs.findBuilding(sid);
+    REQUIRE(b != nullptr);
+
+    // Copper was smelted; the lone iron_ore still waits for a second unit.
+    bool hasCopperIngot = false;
+    for (const Item& item : b->outputBuffer.items)
+    {
+        if (item.type.id == "copper_ingot") { hasCopperIngot = true; }
+    }
+    REQUIRE(hasCopperIngot);
+
+    const std::map<ItemType, int>::const_iterator ironIt =
+        b->inputBuffer.counts.find(ItemType{"iron_ore"});
+    REQUIRE(ironIt != b->inputBuffer.counts.end());
+    REQUIRE(ironIt->second == 1);
+}
+
 // ---------------------------------------------------------------------------
 // Belt push → belt tile
 // ---------------------------------------------------------------------------
@@ -664,7 +765,8 @@ TEST_CASE("BuildingSystem: reprocessing plant output buffer capacity equals max
 
     const BuildingId id = bs.place(BuildingType::ReprocessingPlant,
                                   QPoint(0, 0), Rotation::East, 0);
-    bs.setRecipe(id, "reprocessing_cycle");
+    // Reprocessing plants have no recipe selection (REQ-BLD-REPROCESSING); the
+    // single reprocessing recipe is applied automatically on completion.
 
     // Complete construction (25s).
     Tick tick = 0;
@@ -695,7 +797,8 @@ TEST_CASE("BuildingSystem: reprocessing plant produces one cycle output then sta
 
     const BuildingId id = bs.place(BuildingType::ReprocessingPlant,
                                   QPoint(0, 0), Rotation::East, 0);
-    bs.setRecipe(id, "reprocessing_cycle");
+    // Reprocessing plants have no recipe selection (REQ-BLD-REPROCESSING); the
+    // single reprocessing recipe is applied automatically on completion.
 
     // Complete construction (25s).
     Tick tick = 0;

src/test/ConfigLoaderTest.cpp

@@ -83,6 +83,11 @@ TEST_CASE("ConfigLoader loads the committed bin/config/ configs end-to-end", "[c
     REQUIRE(cfg.world.rallyOrbitRadius_tiles == Approx(5.0));
     REQUIRE(cfg.world.scrapPerThreat == Approx(1.0));
 
+    // Optional header building blocks tooltip (REQ-UI-BLOCKS-TOOLTIP).
+    REQUIRE(cfg.world.buildingBlocksTooltip.has_value());
+    REQUIRE(*cfg.world.buildingBlocksTooltip ==
+            "Spend building blocks to build; deliver them to the HQ to gain more.");
+
     // Spot-check that a config-derived formula computes as expected.
     // threat_rate_formula = "x": evaluates to the input value.
     REQUIRE(cfg.world.waves.threatRateFormula.evaluate(1.0) == Approx(1.0));
@@ -113,6 +118,12 @@ TEST_CASE("ConfigLoader loads the committed bin/config/ configs end-to-end", "[c
     REQUIRE(salvageBayIt->outputBufferCapacity.has_value());
     REQUIRE(*salvageBayIt->outputBufferCapacity == 20);
 
+    // Optional per-building tooltip (REQ-UI-BUILD-TOOLTIP): the Salvage Bay
+    // defines one; the Miner leaves it unset.
+    REQUIRE(salvageBayIt->tooltip.has_value());
+    REQUIRE(*salvageBayIt->tooltip == "Drop-off point for salvage ships.");
+    REQUIRE_FALSE(minerIt->tooltip.has_value());
+
     // recipes.toml — reprocessing cycle has three weighted outputs.
     const auto reproIt = std::find_if(
         cfg.recipes.recipes.begin(), cfg.recipes.recipes.end(),
@@ -144,6 +155,21 @@ TEST_CASE("ConfigLoader loads the committed bin/config/ configs end-to-end", "[c
     REQUIRE(salvageShipIt != cfg.ships.ships.end());
     REQUIRE(salvageShipIt->defaultModules.empty());
 
+    // modules.toml — optional per-module tooltip (REQ-MOD-UI-MODULE-TOOLTIP):
+    // armor_plate defines one; salvager leaves it unset.
+    const auto armorPlateIt = std::find_if(
+        cfg.modules.modules.begin(), cfg.modules.modules.end(),
+        [](const ModuleDef& m) { return m.id == "armor_plate"; });
+    REQUIRE(armorPlateIt != cfg.modules.modules.end());
+    REQUIRE(armorPlateIt->tooltip.has_value());
+    REQUIRE(*armorPlateIt->tooltip == "Adds a large flat bonus to hit points.");
+
+    const auto salvagerModuleIt = std::find_if(
+        cfg.modules.modules.begin(), cfg.modules.modules.end(),
+        [](const ModuleDef& m) { return m.id == "salvager"; });
+    REQUIRE(salvagerModuleIt != cfg.modules.modules.end());
+    REQUIRE_FALSE(salvagerModuleIt->tooltip.has_value());
+
     // stations.toml
     REQUIRE(cfg.stations.playerStation.level == 5);
     REQUIRE(cfg.stations.playerStation.hpFormula.evaluate(5.0) == Approx(500.0));  // 300 + 40*5

src/test/ScrapTest.cpp

@@ -2,11 +2,22 @@
 
 #include <QVector2D>
 
+#include <algorithm>
+
 #include "DespawnAtComponent.h"
 #include "EntityAdmin.h"
+#include "EntityHitTest.h"
 #include "ScrapDataComponent.h"
 #include "ScrapSystem.h"
 
+namespace
+{
+bool contains(const std::vector<entt::entity>& v, entt::entity e)
+{
+    return std::find(v.begin(), v.end(), e) != v.end();
+}
+} // namespace
+
 // ---------------------------------------------------------------------------
 // Spawn
 // ---------------------------------------------------------------------------
@@ -140,3 +151,78 @@ TEST_CASE("ScrapSystem: allScrapInfo returns all spawned scrap", "[scrap]")
     const std::vector<ScrapInfo> info = ss.allScrapInfo();
     REQUIRE(info.size() == 2);
 }
+
+TEST_CASE("ScrapSystem: allScrapInfo reports each pile's remaining amount", "[scrap]")
+{
+    EntityAdmin admin;
+    ScrapSystem ss(admin);
+
+    const entt::entity a = ss.spawn(QVector2D(1.0f, 2.0f), 3, 100);
+    const entt::entity b = ss.spawn(QVector2D(4.0f, 5.0f), 6, 200);
+
+    const std::vector<ScrapInfo> info = ss.allScrapInfo();
+    REQUIRE(info.size() == 2);
+    for (const ScrapInfo& i : info)
+    {
+        if (i.entity == a) { REQUIRE(i.amount == 3); }
+        else if (i.entity == b) { REQUIRE(i.amount == 6); }
+        else { FAIL("unexpected scrap entity"); }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Selection hit-testing (REQ-UI-SCRAP-CLICK-SELECT, REQ-UI-SCRAP-MULTI-SELECT)
+// ---------------------------------------------------------------------------
+
+TEST_CASE("scrapAtWorldPos returns the pile near a point and null when far", "[scrap]")
+{
+    EntityAdmin admin;
+    ScrapSystem ss(admin);
+
+    const entt::entity e = ss.spawn(QVector2D(3.0f, 4.0f), 5, 100);
+
+    // Extra parens keep Catch from decomposing the comparison, which is ambiguous
+    // between Catch's expression templates and entt's entity operator==.
+    REQUIRE((scrapAtWorldPos(admin, QVector2D(3.1f, 4.0f)) == e));
+    REQUIRE((scrapAtWorldPos(admin, QVector2D(10.0f, 10.0f)) == entt::null));
+}
+
+TEST_CASE("scrapAtWorldPos returns the nearest of several piles", "[scrap]")
+{
+    EntityAdmin admin;
+    ScrapSystem ss(admin);
+
+    const entt::entity near = ss.spawn(QVector2D(2.0f, 2.0f), 1, 100);
+    ss.spawn(QVector2D(2.4f, 2.0f), 1, 100);
+
+    REQUIRE((scrapAtWorldPos(admin, QVector2D(2.05f, 2.0f)) == near));
+}
+
+TEST_CASE("entityAtWorldPos never returns a scrap pile", "[scrap]")
+{
+    EntityAdmin admin;
+    ScrapSystem ss(admin);
+
+    ss.spawn(QVector2D(3.0f, 4.0f), 5, 100);
+
+    // Scrap has no HealthComponent, so the actor hit-test ignores it entirely.
+    REQUIRE((entityAtWorldPos(admin, QVector2D(3.0f, 4.0f)) == entt::null));
+}
+
+TEST_CASE("scrapInBox returns exactly the piles inside the tile rectangle", "[scrap]")
+{
+    EntityAdmin admin;
+    ScrapSystem ss(admin);
+
+    const entt::entity inA  = ss.spawn(QVector2D(1.2f, 2.7f), 1, 100); // tile (1,2)
+    const entt::entity inB  = ss.spawn(QVector2D(4.9f, 5.1f), 1, 100); // tile (4,5)
+    const entt::entity outX = ss.spawn(QVector2D(10.0f, 10.0f), 1, 100);
+
+    // Box given in reversed corner order to confirm normalization.
+    const std::vector<entt::entity> hit = scrapInBox(admin, QPoint(5, 5), QPoint(0, 0));
+
+    REQUIRE(hit.size() == 2);
+    REQUIRE(contains(hit, inA));
+    REQUIRE(contains(hit, inB));
+    REQUIRE_FALSE(contains(hit, outX));
+}

src/ui/BlueprintPanel.cpp

@@ -146,66 +146,10 @@ void BlueprintPanel::onBlueprintButtonClicked(int index)
 
 Blueprint BlueprintPanel::createBlueprintFromSelection() const
 {
-    struct Entry
-    {
-        const Building* building;
-    };
-    std::vector<Entry> entries;
-    entries.reserve(m_selectedBuildingIds.size());
-
-    for (const BuildingId id : m_selectedBuildingIds)
-    {
-        const Building* b = m_sim->buildings().findBuilding(id);
-        if (!b) { continue; }
-        const bool placeable = [&]() {
-            for (const BuildingDef& def : m_config->buildings.buildings)
-            {
-                if (def.type == b->type) { return def.playerPlaceable; }
-            }
-            return false;
-        }();
-        if (placeable) { entries.push_back({ b }); }
-    }
-
-    if (entries.empty()) { return Blueprint{}; }
-
-    int minX = INT_MAX, maxX = INT_MIN;
-    int minY = INT_MAX, maxY = INT_MIN;
-    for (const Entry& e : entries)
-    {
-        for (const QPoint& cell : e.building->bodyCells)
-        {
-            minX = std::min(minX, cell.x());
-            maxX = std::max(maxX, cell.x());
-            minY = std::min(minY, cell.y());
-            maxY = std::max(maxY, cell.y());
-        }
-    }
-
-    const QPoint center((minX + maxX) / 2, (minY + maxY) / 2);
-
-    Blueprint bp;
-    bp.buildings.reserve(entries.size());
-    for (const Entry& e : entries)
-    {
-        BlueprintBuilding bb;
-        bb.type     = e.building->type;
-        bb.rotation = e.building->rotation;
-        bb.offset   = e.building->anchor - center;
-        // Recipe / schematic / layout / splitter-filter capture is shared with the
-        // copy-settings gesture (REQ-BLD-COPY-CONFIG) via readBuildingConfig.
-        const std::optional<BuildingConfig> config =
-            readBuildingConfig(*m_sim, e.building->id);
-        if (config.has_value())
-        {
-            bb.recipeId        = config->recipeId.value_or(std::string());
-            bb.shipLayout      = config->shipLayout;
-            bb.splitterFilterA = config->splitterFilterA;
-            bb.splitterFilterB = config->splitterFilterB;
-        }
-        bp.buildings.push_back(bb);
-    }
-    return bp;
+    // Capture is shared, testable logic in lib/sim: it resolves each selected id as an
+    // operational building or a construction site alike (REQ-UI-BLUEPRINT-CREATE,
+    // REQ-UI-BLUEPRINT-STORAGE).
+    return captureBlueprintFromSelection(*m_sim, m_selectedBuildingIds);
 }
 
 int BlueprintPanel::computeBlueprintCost(const Blueprint& bp) const
@@ -213,14 +157,8 @@ int BlueprintPanel::computeBlueprintCost(const Blueprint& bp) const
     int total = 0;
     for (const BlueprintBuilding& bb : bp.buildings)
     {
-        for (const BuildingDef& def : m_config->buildings.buildings)
-        {
-            if (def.type == bb.type)
-            {
-                total += def.cost;
-                break;
-            }
-        }
+        const BuildingDef* def = m_config->buildings.findBuildingDef(bb.type);
+        if (def) { total += def->cost; }
     }
     return total;
 }
@@ -239,7 +177,7 @@ void BlueprintPanel::rebuildButtons()
     {
         const Blueprint& bp   = m_blueprints[static_cast<std::size_t>(i)];
         const int        cost = computeBlueprintCost(bp);
-        const QString label   = bp.name + "\n" + tr("%1 Blocks").arg(cost);
+        const QString label   = bp.name + "\n" + tr("%1 Building Blocks").arg(cost);
 
         QWidget*     row       = new QWidget(m_buttonsContainer);
         QHBoxLayout* rowLayout = new QHBoxLayout(row);
@@ -307,19 +245,8 @@ void BlueprintPanel::loadFromDisk()
 
 void BlueprintPanel::refreshButtonStates()
 {
-    const bool anyPlaceable = [&]() {
-        for (const BuildingId id : m_selectedBuildingIds)
-        {
-            const Building* b = m_sim->buildings().findBuilding(id);
-            if (!b) { continue; }
-            for (const BuildingDef& def : m_config->buildings.buildings)
-            {
-                if (def.type == b->type) { return def.playerPlaceable; }
-            }
-        }
-        return false;
-    }();
-    m_createBtn->setEnabled(anyPlaceable);
+    // A construction site counts the same as an operational building (REQ-UI-BLUEPRINT-CREATE).
+    m_createBtn->setEnabled(selectionHasPlaceableBuilding(*m_sim, m_selectedBuildingIds));
 
     for (int i = 0; i < static_cast<int>(m_blueprintButtons.size()); ++i)
     {

src/ui/BuildButtonGrid.cpp

@@ -38,10 +38,14 @@ BuildButtonGrid::BuildButtonGrid(const GameConfig* config, QWidget* parent)
         m_costs[def.type] = def.cost;
 
         const QString label = QString::fromStdString(toDisplayName(def.id))
-            + "\n" + tr("%1 Blocks").arg(def.cost);
+            + "\n" + tr("%1 Building Blocks").arg(def.cost);
         QPushButton* btn = new QPushButton(label, this);
         btn->setCheckable(true);
         btn->setFixedHeight(48);
+        if (def.tooltip)
+        {
+            btn->setToolTip(QString::fromStdString(*def.tooltip));
+        }
         layout->addWidget(btn, row, col);
 
         const int idx = static_cast<int>(m_buttons.size());

src/ui/GameWorldView.cpp

@@ -43,6 +43,7 @@
 #include "PositionComponent.h"
 #include "RepairBehavior.h"
 #include "SalvageScrapBehavior.h"
+#include "ScrapSelectionChangedEvent.h"
 #include "ScrapSystem.h"
 #include "SelectionChangedEvent.h"
 #include "SensorRangeComponent.h"
@@ -271,6 +272,10 @@ void GameWorldView::onFrame()
         m_activeBeams = std::move(live);
     }
 
+    // Drop selected scrap piles that were collected or despawned this frame, so the
+    // panel stops counting them and the selection empties out (REQ-UI-SCRAP-CLICK-SELECT).
+    pruneDespawnedScrap();
+
     // Expire copy/paste flashes. Lifetime is wall-clock (the frame delta), so the
     // flash plays for a fixed real duration regardless of game speed, including
     // while the game is paused (REQ-BLD-COPY-CONFIG-FEEDBACK).
@@ -666,6 +671,36 @@ std::optional<QVector2D> GameWorldView::entityPosition(entt::entity entity) cons
     return m_sim->admin().get<PositionComponent>(entity).value;
 }
 
+void GameWorldView::clearScrapSelection()
+{
+    if (m_selectedScrap.empty()) { return; }
+    m_selectedScrap.clear();
+    EventManager::getInstance()->sendEventImmediately(
+        std::make_shared<ScrapSelectionChangedEvent>(m_selectedScrap));
+}
+
+void GameWorldView::pruneDespawnedScrap()
+{
+    if (m_selectedScrap.empty()) { return; }
+
+    std::vector<entt::entity> live;
+    for (const ScrapInfo& info : m_sim->scraps().allScrapInfo())
+    {
+        if (std::find(m_selectedScrap.begin(), m_selectedScrap.end(), info.entity)
+            != m_selectedScrap.end())
+        {
+            live.push_back(info.entity);
+        }
+    }
+
+    if (live.size() != m_selectedScrap.size())
+    {
+        m_selectedScrap = std::move(live);
+        EventManager::getInstance()->sendEventImmediately(
+            std::make_shared<ScrapSelectionChangedEvent>(m_selectedScrap));
+    }
+}
+
 void GameWorldView::stepSpeed(int delta)
 {
     const double kSpeeds[] = { 0.0, 0.5, 1.0, 2.0, 10.0 };
@@ -1048,6 +1083,19 @@ void GameWorldView::drawSelectionHighlights(QPainter& painter)
         // Outline sits 1px outside the footprint (into adjacent tiles).
         painter.drawRect(rect->adjusted(-1, -1, 1, 1));
     }
+
+    // A ring around each selected scrap pile, sitting just outside the pile's
+    // rendered circle (radius tilePx()*0.2, matching drawScrap) (REQ-UI-SCRAP-CLICK-SELECT).
+    if (!m_selectedScrap.empty())
+    {
+        const qreal outlineRadius = static_cast<qreal>(tilePx() * 0.2f) + 3.0;
+        for (const ScrapInfo& scrap : m_sim->scraps().allScrapInfo())
+        {
+            if (std::find(m_selectedScrap.begin(), m_selectedScrap.end(), scrap.entity)
+                == m_selectedScrap.end()) { continue; }
+            painter.drawEllipse(worldToWidget(scrap.position), outlineRadius, outlineRadius);
+        }
+    }
 }
 
 void GameWorldView::drawCopyConfigFeedback(QPainter& painter)
@@ -1752,6 +1800,8 @@ void GameWorldView::mousePressEvent(QMouseEvent* event)
 
         if (hitEntity != entt::null)
         {
+            // Actors (ship/station) win over scrap and buildings (REQ-UI-SCRAP-CLICK-SELECT).
+            clearScrapSelection();
             m_selectedBuildingIds.clear();
             EventManager::getInstance()->sendEventImmediately(
                 std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
@@ -1775,6 +1825,8 @@ void GameWorldView::mousePressEvent(QMouseEvent* event)
             }
             if (id != kInvalidBuildingId)
             {
+                // A building/construction site outranks scrap (REQ-UI-SCRAP-CLICK-SELECT).
+                clearScrapSelection();
                 if (event->modifiers() & Qt::ControlModifier)
                 {
                     bool found = false;
@@ -1794,6 +1846,36 @@ void GameWorldView::mousePressEvent(QMouseEvent* event)
                 EventManager::getInstance()->sendEventImmediately(
                 std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
             }
+            else if (const entt::entity scrapHit =
+                         scrapAtWorldPos(m_sim->admin(), worldPos); scrapHit != entt::null)
+            {
+                // Scrap forms its own selection category; picking it clears any
+                // building selection (REQ-UI-SCRAP-CLICK-SELECT, REQ-UI-SCRAP-MULTI-SELECT).
+                if (!m_selectedBuildingIds.empty())
+                {
+                    m_selectedBuildingIds.clear();
+                    EventManager::getInstance()->sendEventImmediately(
+                        std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
+                }
+                if (event->modifiers() & Qt::ControlModifier)
+                {
+                    bool found = false;
+                    std::vector<entt::entity> newSel;
+                    for (entt::entity sel : m_selectedScrap)
+                    {
+                        if (sel == scrapHit) { found = true; }
+                        else                 { newSel.push_back(sel); }
+                    }
+                    if (!found) { newSel.push_back(scrapHit); }
+                    m_selectedScrap = newSel;
+                }
+                else
+                {
+                    m_selectedScrap = { scrapHit };
+                }
+                EventManager::getInstance()->sendEventImmediately(
+                    std::make_shared<ScrapSelectionChangedEvent>(m_selectedScrap));
+            }
             else
             {
                 if (!(event->modifiers() & Qt::ControlModifier))
@@ -1801,6 +1883,7 @@ void GameWorldView::mousePressEvent(QMouseEvent* event)
                     m_selectedBuildingIds.clear();
                     EventManager::getInstance()->sendEventImmediately(
                 std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
+                    clearScrapSelection();
                 }
                 m_boxSelecting    = true;
                 m_boxStartTile    = tile;
@@ -1873,24 +1956,75 @@ void GameWorldView::mouseReleaseEvent(QMouseEvent* event)
             return;
         }
 
-        if (!(event->modifiers() & Qt::ControlModifier))
+        const bool ctrl = (event->modifiers() & Qt::ControlModifier) != 0;
+
+        if (!boxIds.empty())
         {
-            m_selectedBuildingIds = boxIds;
-        }
-        else
-        {
-            for (BuildingId id : boxIds)
+            // A box covering any building selects buildings; scrap in the box is
+            // ignored (REQ-UI-MULTI-SELECT, REQ-UI-SCRAP-MULTI-SELECT).
+            clearScrapSelection();
+            if (!ctrl)
             {
-                bool found = false;
-                for (BuildingId sel : m_selectedBuildingIds)
-                {
-                    if (sel == id) { found = true; break; }
-                }
-                if (!found) { m_selectedBuildingIds.push_back(id); }
+                m_selectedBuildingIds = boxIds;
             }
+            else
+            {
+                for (BuildingId id : boxIds)
+                {
+                    bool found = false;
+                    for (BuildingId sel : m_selectedBuildingIds)
+                    {
+                        if (sel == id) { found = true; break; }
+                    }
+                    if (!found) { m_selectedBuildingIds.push_back(id); }
+                }
+            }
+            EventManager::getInstance()->sendEventImmediately(
+                std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
+            return;
+        }
+
+        // No buildings in the box: a scrap-only box selects the scrap it covers
+        // (REQ-UI-SCRAP-MULTI-SELECT).
+        const std::vector<entt::entity> boxScrap =
+            scrapInBox(m_sim->admin(), m_boxStartTile, m_boxCurrentTile);
+        if (!boxScrap.empty())
+        {
+            if (!m_selectedBuildingIds.empty())
+            {
+                m_selectedBuildingIds.clear();
+                EventManager::getInstance()->sendEventImmediately(
+                    std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
+            }
+            if (!ctrl)
+            {
+                m_selectedScrap = boxScrap;
+            }
+            else
+            {
+                for (entt::entity e : boxScrap)
+                {
+                    bool found = false;
+                    for (entt::entity sel : m_selectedScrap)
+                    {
+                        if (sel == e) { found = true; break; }
+                    }
+                    if (!found) { m_selectedScrap.push_back(e); }
+                }
+            }
+            EventManager::getInstance()->sendEventImmediately(
+                std::make_shared<ScrapSelectionChangedEvent>(m_selectedScrap));
+            return;
+        }
+
+        // Empty box: a plain (non-additive) drag clears the current selection.
+        if (!ctrl)
+        {
+            m_selectedBuildingIds.clear();
+            EventManager::getInstance()->sendEventImmediately(
+                std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
+            clearScrapSelection();
         }
-        EventManager::getInstance()->sendEventImmediately(
-            std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
     }
 }
 

src/ui/GameWorldView.h

@@ -168,6 +168,13 @@ private:
     void     placeBlueprintAtTile(QPoint center);
 
     std::optional<QVector2D> entityPosition(entt::entity entity) const;
+    // Clears the scrap selection, emitting an empty ScrapSelectionChangedEvent when
+    // it was non-empty (REQ-UI-SCRAP-CLICK-SELECT). Used when another selection
+    // category takes over.
+    void                     clearScrapSelection();
+    // Drops despawned or fully-collected piles from the scrap selection and re-emits
+    // when it changed (REQ-UI-SCRAP-CLICK-SELECT). Called each frame from onFrame().
+    void                     pruneDespawnedScrap();
     void                     stepSpeed(int delta);
     void                     placeAtTile(QPoint tile);
 
@@ -249,6 +256,7 @@ private:
 
     std::vector<BuildingId> m_selectedBuildingIds;
     std::optional<entt::entity> m_selectedEntity;
+    std::vector<entt::entity> m_selectedScrap;
     bool                  m_boxSelecting;
     QPoint                m_boxStartTile;
     QPoint                m_boxCurrentTile;

src/ui/HeaderBar.cpp

@@ -17,7 +17,7 @@
 const double HeaderBar::kSpeeds[]   = { 0.0, 0.5, 1.0, 2.0, 10.0 };
 const int    HeaderBar::kSpeedCount = 5;
 
-HeaderBar::HeaderBar(QWidget* parent)
+HeaderBar::HeaderBar(const GameConfig* config, QWidget* parent)
     : QWidget(parent)
 {
     QHBoxLayout* layout = new QHBoxLayout(this);
@@ -25,7 +25,12 @@ HeaderBar::HeaderBar(QWidget* parent)
     layout->setSpacing(8);
 
     m_timeLabel      = new QLabel("00:00", this);
-    m_blocksLabel    = new QLabel(tr("Blocks: 0"), this);
+    m_blocksLabel    = new QLabel(tr("Building Blocks: 0"), this);
+    if (config->world.buildingBlocksTooltip)
+    {
+        m_blocksLabel->setToolTip(
+            QString::fromStdString(*config->world.buildingBlocksTooltip));
+    }
     m_artifactsLabel = new QLabel(tr("Artifacts: 0/?"), this);
     m_bossLabel      = new QLabel(tr("Boss Wave #1  Next boss: 5:00"), this);
     layout->addWidget(m_timeLabel);
@@ -81,7 +86,7 @@ void HeaderBar::handleEvent(std::shared_ptr<const TickAdvancedEvent> event)
 void HeaderBar::handleEvent(std::shared_ptr<const BuildingBlocksChangedEvent> event)
 {
     m_blocks = event->blocks;
-    m_blocksLabel->setText(tr("Blocks: %1").arg(event->blocks));
+    m_blocksLabel->setText(tr("Building Blocks: %1").arg(event->blocks));
     updateExpandButton();
 }
 
@@ -93,7 +98,7 @@ void HeaderBar::handleEvent(std::shared_ptr<const ExpansionCostChangedEvent> eve
 
 void HeaderBar::updateExpandButton()
 {
-    m_expandButton->setText(tr("Expand: %1 Blocks").arg(m_expansionCost));
+    m_expandButton->setText(tr("Expand: %1 Building Blocks").arg(m_expansionCost));
     m_expandButton->setEnabled(m_blocks >= m_expansionCost);
 }
 

src/ui/HeaderBar.h

@@ -9,6 +9,7 @@
 #include "BuildingBlocksChangedEvent.h"
 #include "EventHandler.h"
 #include "ExpansionCostChangedEvent.h"
+#include "GameConfig.h"
 #include "GameSpeedChangedEvent.h"
 #include "Tick.h"
 #include "TickAdvancedEvent.h"
@@ -27,7 +28,7 @@ class HeaderBar : public QWidget,
     Q_OBJECT
 
 public:
-    explicit HeaderBar(QWidget* parent = nullptr);
+    explicit HeaderBar(const GameConfig* config, QWidget* parent = nullptr);
     ~HeaderBar() override;
 
 private slots:

src/ui/MainWindow.cpp

@@ -42,15 +42,15 @@ MainWindow::MainWindow(Simulation* sim, const std::string& configDir,
     setWindowTitle(tr("Dota Factory"));
     resize(1280, 768);
 
-    m_headerBar = new HeaderBar(this);
+    m_headerBar = new HeaderBar(&sim->config(), this);
 
     m_gameWorldView = new GameWorldView(sim, &sim->config(), &m_visuals, m_configDir,
                                         m_replay.get(), this);
 
     m_sidePanel = new QWidget(this);
     QVBoxLayout* sideLayout = new QVBoxLayout(m_sidePanel);
-    sideLayout->setContentsMargins(0, 0, 0, 0);
-    sideLayout->setSpacing(0);
+    sideLayout->setContentsMargins(1, 1, 1, 1);
+    sideLayout->setSpacing(1);
 
     m_selectedBuildingPanel = new SelectedBuildingPanel(sim, &sim->config(), m_sidePanel);
     m_buildButtonGrid       = new BuildButtonGrid(&sim->config(), m_sidePanel);
@@ -60,6 +60,20 @@ MainWindow::MainWindow(Simulation* sim, const std::string& configDir,
     sideLayout->addWidget(m_buildButtonGrid,       1);
     sideLayout->addWidget(m_blueprintPanel,        1);
 
+    // Draw a thin border around each of the three side-panel sections. The class
+    // scoped selectors keep the border on the panels themselves rather than
+    // cascading onto their child widgets; WA_StyledBackground lets the plain
+    // QWidget subclasses honor the stylesheet box (border/background).
+    for (QWidget* panel : { static_cast<QWidget*>(m_selectedBuildingPanel),
+                            static_cast<QWidget*>(m_buildButtonGrid),
+                            static_cast<QWidget*>(m_blueprintPanel) })
+    {
+        panel->setAttribute(Qt::WA_StyledBackground, true);
+    }
+    m_sidePanel->setStyleSheet(QStringLiteral(
+        "SelectedBuildingPanel, BuildButtonGrid, BlueprintPanel {"
+        " border: 1px solid palette(mid); }"));
+
     m_gameWorldView->setFocus();
 
     connect(qApp, &QApplication::focusChanged, this, [this](QWidget*, QWidget* newWidget) {
@@ -206,33 +220,13 @@ void MainWindow::handleEvent(std::shared_ptr<const EscapeMenuRequestedEvent> /*e
     }
 }
 
-void MainWindow::handleEvent(std::shared_ptr<const LayoutDialogRequestedEvent> event)
+void MainWindow::openShipLayoutDialog(BuildingId shipyardId,
+                                      const std::string& schematicId,
+                                      const ShipLayoutConfig& currentLayout)
 {
     const double prevSpeed = m_gameWorldView->gameSpeed();
     m_gameWorldView->setGameSpeed(0.0);
 
-    // A construction site has no Building yet; fall back to its site record so
-    // the shipyard layout can be configured before it is built (REQ-BLD-SITE-CONFIG).
-    const Building* b = m_sim->buildings().findBuilding(event->shipyardId);
-    const ConstructionSite* s =
-        b ? nullptr : m_sim->buildings().findSite(event->shipyardId);
-    if (!b && !s)
-    {
-        m_gameWorldView->setGameSpeed(prevSpeed);
-        m_gameWorldView->resetFrameTimer();
-        return;
-    }
-
-    const std::string& schematicId = b ? b->recipeId : s->recipeId;
-    const std::optional<ShipLayoutConfig>& layoutOpt =
-        b ? b->shipLayout : s->shipLayout;
-
-    ShipLayoutConfig currentLayout;
-    if (layoutOpt.has_value())
-    {
-        currentLayout = *layoutOpt;
-    }
-
     std::set<std::string> unlockedModuleIds;
     for (const ModuleDef& def : m_sim->config().modules.modules)
     {
@@ -251,7 +245,7 @@ void MainWindow::handleEvent(std::shared_ptr<const LayoutDialogRequestedEvent> e
     {
         std::shared_ptr<SetShipLayoutCommand> command =
             std::make_shared<SetShipLayoutCommand>();
-        command->id     = event->shipyardId;
+        command->id     = shipyardId;
         command->layout = *dialog.result();
         EventManager::getInstance()->sendEventImmediately(
             std::make_shared<CommandRequestedEvent>(command));
@@ -261,6 +255,31 @@ void MainWindow::handleEvent(std::shared_ptr<const LayoutDialogRequestedEvent> e
     m_gameWorldView->resetFrameTimer();
 }
 
+void MainWindow::handleEvent(std::shared_ptr<const LayoutDialogRequestedEvent> event)
+{
+    // A construction site has no Building yet; fall back to its site record so
+    // the shipyard layout can be configured before it is built (REQ-BLD-SITE-CONFIG).
+    const Building* b = m_sim->buildings().findBuilding(event->shipyardId);
+    const ConstructionSite* s =
+        b ? nullptr : m_sim->buildings().findSite(event->shipyardId);
+    if (!b && !s)
+    {
+        return;
+    }
+
+    const std::string& schematicId = b ? b->recipeId : s->recipeId;
+    const std::optional<ShipLayoutConfig>& layoutOpt =
+        b ? b->shipLayout : s->shipLayout;
+
+    ShipLayoutConfig currentLayout;
+    if (layoutOpt.has_value())
+    {
+        currentLayout = *layoutOpt;
+    }
+
+    openShipLayoutDialog(event->shipyardId, schematicId, currentLayout);
+}
+
 void MainWindow::handleEvent(std::shared_ptr<const RecipeSelectionRequestedEvent> event)
 {
     const double prevSpeed = m_gameWorldView->gameSpeed();
@@ -279,12 +298,18 @@ void MainWindow::handleEvent(std::shared_ptr<const RecipeSelectionRequestedEvent
     }
 
     const BuildingType type = b ? b->type : s->type;
+    // Captured as a copy: a queued command may drain during the modal dialog's
+    // event loop and reallocate the building vectors, so b/s must not be
+    // dereferenced after dialog.exec() returns.
+    const std::string oldSchematic = b ? b->recipeId : s->recipeId;
     const std::vector<RecipeSelectionOption> options =
         buildRecipeSelectionOptions(type, *m_sim, m_sim->config());
     const QString title = (type == BuildingType::Shipyard)
         ? tr("Select Schematic")
         : tr("Select Recipe");
 
+    bool autoOpenLayout = false;
+    std::string chosenSchematic;
     RecipeSelectionDialog dialog(options, title, this);
     if (dialog.exec() == QDialog::Accepted && dialog.getChosenId().has_value())
     {
@@ -293,10 +318,27 @@ void MainWindow::handleEvent(std::shared_ptr<const RecipeSelectionRequestedEvent
         command->recipeId = *dialog.getChosenId();
         EventManager::getInstance()->sendEventImmediately(
             std::make_shared<CommandRequestedEvent>(command));
+
+        // REQ-MOD-UI-AUTO-DIALOG: picking a new schematic for a shipyard opens the
+        // layout configuration dialog immediately. Only on an actual change.
+        if (type == BuildingType::Shipyard && *dialog.getChosenId() != oldSchematic)
+        {
+            autoOpenLayout = true;
+            chosenSchematic = *dialog.getChosenId();
+        }
     }
 
     m_gameWorldView->setGameSpeed(prevSpeed);
     m_gameWorldView->resetFrameTimer();
+
+    // The SetRecipeCommand above is queued (drains on a later frame) and clears
+    // the shipyard's layout, so open the dialog with the chosen schematic and an
+    // empty layout rather than reading the not-yet-updated building state. Speed
+    // is already restored so the helper snapshots the real speed to restore.
+    if (autoOpenLayout)
+    {
+        openShipLayoutDialog(event->buildingId, chosenSchematic, ShipLayoutConfig{});
+    }
 }
 
 void MainWindow::handleEvent(std::shared_ptr<const GameOverEvent> /*event*/)

src/ui/MainWindow.h

@@ -15,6 +15,7 @@
 #include "WinEvent.h"
 #include "RecipeSelectionRequestedEvent.h"
 #include "SchematicChoicesAvailableEvent.h"
+#include "ShipLayout.h"
 #include "ShipLayoutBlueprint.h"
 #include "Tick.h"
 #include "VisualsConfig.h"
@@ -57,6 +58,12 @@ private:
     void handleEvent(std::shared_ptr<const EscapeMenuRequestedEvent> event) override;
     void handleEvent(std::shared_ptr<const LayoutDialogRequestedEvent> event) override;
     void handleEvent(std::shared_ptr<const RecipeSelectionRequestedEvent> event) override;
+
+    // Opens the shipyard layout configuration dialog for the given schematic and
+    // current layout, applying the result via SetShipLayoutCommand (REQ-MOD-UI-DIALOG).
+    void openShipLayoutDialog(BuildingId shipyardId,
+                              const std::string& schematicId,
+                              const ShipLayoutConfig& currentLayout);
     void layoutPanels();
 
 private:

src/ui/RecipeSelectionDialog.cpp

@@ -23,7 +23,7 @@ QString itemLine(const std::string& itemId, int amount)
 {
     return QStringLiteral("  ")
         + QString::fromStdString(toDisplayName(itemId))
-        + QStringLiteral(" ×") + QString::number(amount);
+        + QStringLiteral(" x ") + QString::number(amount);
 }
 
 QString shipTooltip(const ShipDef& def)

src/ui/RecipeTooltip.cpp

@@ -13,7 +13,7 @@ QString itemLine(const std::string& itemId, int amount)
 {
     return QStringLiteral("  ")
         + QString::fromStdString(toDisplayName(itemId))
-        + QStringLiteral(" ×") + QString::number(amount);
+        + QStringLiteral(" x ") + QString::number(amount);
 }
 
 }  // namespace

src/ui/SelectedBuildingPanel.cpp

@@ -37,6 +37,7 @@
 #include "RecipeSelectionDialog.h"
 #include "RecipeSelectionRequestedEvent.h"
 #include "Rotation.h"
+#include "ScrapSystem.h"
 #include "ShipLayoutPreview.h"
 #include "Simulation.h"
 #include "WeaponComponent.h"
@@ -78,6 +79,25 @@ bool isProductionBuilding(BuildingType type)
         || type == BuildingType::Shipyard;
 }
 
+// Buildings that expose a player recipe/schematic selection control
+// (REQ-UI-SELECT-BUTTON): Miner ore type, Assembler recipe, Shipyard schematic.
+// The Smelter and Reprocessing Plant auto-process and offer no selection
+// (REQ-BLD-SMELTER, REQ-BLD-REPROCESSING).
+bool hasRecipeSelection(BuildingType type)
+{
+    return type == BuildingType::Miner
+        || type == BuildingType::Assembler
+        || type == BuildingType::Shipyard;
+}
+
+// Auto-recipe buildings have no selected recipe; their production is driven by
+// whatever inputs they receive.
+bool isAutoRecipeBuilding(BuildingType type)
+{
+    return type == BuildingType::Smelter
+        || type == BuildingType::ReprocessingPlant;
+}
+
 bool isBeltLike(BuildingType type)
 {
     return type == BuildingType::Belt || type == BuildingType::Splitter
@@ -171,6 +191,10 @@ SelectedBuildingPanel::SelectedBuildingPanel(Simulation* sim,
     m_layout->addWidget(m_stationStatsLabel);
     m_stationStatsLabel->hide();
 
+    m_scrapLabel = new QLabel(this);
+    m_layout->addWidget(m_scrapLabel);
+    m_scrapLabel->hide();
+
     buildEmpty();
 
     registerForEvents();
@@ -187,6 +211,9 @@ void SelectedBuildingPanel::onSelectionChanged(const std::vector<BuildingId>& id
     if (!ids.empty())
     {
         clearEntityDisplay();
+        // A building selection supersedes any scrap selection (REQ-UI-SCRAP-CLICK-SELECT).
+        m_selectedScrap.clear();
+        m_scrapLabel->hide();
     }
     rebuild();
 }
@@ -219,6 +246,7 @@ void SelectedBuildingPanel::hideAllWidgets()
     m_filterBLabel->hide();
     m_filterBList->hide();
     m_buffersLabel->hide();
+    m_scrapLabel->hide();
 }
 
 void SelectedBuildingPanel::clearContent()
@@ -265,7 +293,7 @@ void SelectedBuildingPanel::buildSingle(BuildingId id)
     m_titleLabel->show();
     m_buffersLabel->show();
 
-    if (isProductionBuilding(type))
+    if (hasRecipeSelection(type))
     {
         const std::vector<RecipeSelectionOption> options =
             buildRecipeSelectionOptions(type, *m_sim, *m_config);
@@ -383,6 +411,21 @@ void SelectedBuildingPanel::refreshBuffers(const Building* b)
                                 ? findShipDef(b->recipeId)
                                 : nullptr;
 
+    // Auto-recipe buildings (Smelter, Reprocessing Plant) have no selected
+    // recipe; while a cycle runs, resolve the recipe actually in production so
+    // the cycle time and progress can be shown (REQ-UI-PRODUCTION-PROGRESS).
+    if (!recipe && isAutoRecipeBuilding(b->type) && b->production.has_value())
+    {
+        for (const RecipeDef& r : m_config->recipes.recipes)
+        {
+            if (r.id == b->production->recipeId && r.building == b->type)
+            {
+                recipe = &r;
+                break;
+            }
+        }
+    }
+
     QString bufText;
 
     if (!b->inputBuffer.counts.empty())
@@ -469,41 +512,51 @@ void SelectedBuildingPanel::refreshBuffers(const Building* b)
         }
     }
 
-    if (isProductionBuilding(b->type) && (recipe || shipDef))
+    if (isProductionBuilding(b->type)
+        && (recipe || shipDef || isAutoRecipeBuilding(b->type)))
     {
-        double durationSeconds = recipe
-            ? recipe->durationSeconds
-            : shipDef->schematic.productionTimeSeconds;
-
-        if (shipDef && b->shipLayout.has_value())
+        if (recipe || shipDef)
         {
-            for (const PlacedModule& pm : b->shipLayout->placedModules)
+            double durationSeconds = recipe
+                ? recipe->durationSeconds
+                : shipDef->schematic.productionTimeSeconds;
+
+            if (shipDef && b->shipLayout.has_value())
             {
-                for (const ModuleDef& modDef : m_config->modules.modules)
+                for (const PlacedModule& pm : b->shipLayout->placedModules)
                 {
-                    if (modDef.id == pm.moduleId)
+                    for (const ModuleDef& modDef : m_config->modules.modules)
                     {
-                        durationSeconds += modDef.productionTimeSeconds;
-                        break;
+                        if (modDef.id == pm.moduleId)
+                        {
+                            durationSeconds += modDef.productionTimeSeconds;
+                            break;
+                        }
                     }
                 }
             }
-        }
 
-        bufText += tr("Cycle: %1 s\n").arg(durationSeconds, 0, 'f', 1);
+            bufText += tr("Cycle: %1 s\n").arg(durationSeconds, 0, 'f', 1);
 
-        if (b->production.has_value())
-        {
-            const Tick cycleTicks  = secondsToTicks(durationSeconds);
-            const Tick completesAt = b->production->completesAt;
-            const Tick currentTick = m_sim->currentTick();
-            const Tick elapsed     = currentTick - (completesAt - cycleTicks);
-            const int  pct         = static_cast<int>(
-                std::max(Tick(0), std::min(cycleTicks, elapsed)) * 100 / cycleTicks);
-            bufText += tr("Progress: %1%\n").arg(pct);
+            if (b->production.has_value())
+            {
+                const Tick cycleTicks  = secondsToTicks(durationSeconds);
+                const Tick completesAt = b->production->completesAt;
+                const Tick currentTick = m_sim->currentTick();
+                const Tick elapsed     = currentTick - (completesAt - cycleTicks);
+                const int  pct         = static_cast<int>(
+                    std::max(Tick(0), std::min(cycleTicks, elapsed)) * 100 / cycleTicks);
+                bufText += tr("Progress: %1%\n").arg(pct);
+            }
+            else
+            {
+                bufText += tr("Progress: idle\n");
+            }
         }
         else
         {
+            // Auto-recipe building with no active cycle: no single recipe to
+            // show a cycle time for.
             bufText += tr("Progress: idle\n");
         }
     }
@@ -522,11 +575,21 @@ void SelectedBuildingPanel::updateShipyardLayoutWidgets(
     const std::string& recipeId,
     const std::optional<ShipLayoutConfig>& shipLayout)
 {
-    const ShipDef* shipDef = (type == BuildingType::Shipyard)
-        ? findShipDef(recipeId)
-        : nullptr;
+    // The preview and Configure button are shipyard-only controls; hide them
+    // entirely for other building types.
+    if (type != BuildingType::Shipyard)
+    {
+        m_layoutPreview->hide();
+        m_configureLayoutBtn->hide();
+        return;
+    }
 
-    if (shipDef && !shipDef->layout.empty())
+    const ShipDef* shipDef = findShipDef(recipeId);
+    const bool hasSchematic = shipDef && !shipDef->layout.empty();
+
+    // Always show the preview and Configure button for a shipyard; they are only
+    // enabled once a schematic is selected (REQ-MOD-UI-PREVIEW).
+    if (hasSchematic)
     {
         ShipLayoutConfig layout;
         if (shipLayout.has_value())
@@ -535,14 +598,16 @@ void SelectedBuildingPanel::updateShipyardLayoutWidgets(
         }
         m_layoutPreview->setShipAndLayout(
             shipDef->layout, layout, &m_config->modules.modules);
-        m_layoutPreview->show();
-        m_configureLayoutBtn->show();
     }
     else
     {
-        m_layoutPreview->hide();
-        m_configureLayoutBtn->hide();
+        m_layoutPreview->showPlaceholder();
     }
+
+    m_layoutPreview->setEnabled(hasSchematic);
+    m_configureLayoutBtn->setEnabled(hasSchematic);
+    m_layoutPreview->show();
+    m_configureLayoutBtn->show();
 }
 
 const RecipeDef* SelectedBuildingPanel::findRecipe(const Building* b) const
@@ -582,6 +647,13 @@ void SelectedBuildingPanel::handleEvent(
 
 void SelectedBuildingPanel::refreshSelectionDisplay(RefreshReason reason)
 {
+    if (!m_selectedScrap.empty())
+    {
+        // The total shrinks live as piles are collected or despawn (REQ-UI-SCRAP-PANEL).
+        refreshScrapTotal();
+        return;
+    }
+
     if (m_selectedEntity.has_value())
     {
         refreshEntityStats();
@@ -650,6 +722,7 @@ void SelectedBuildingPanel::buildMulti(const std::vector<BuildingId>& ids)
     }
 
     bool hasBelt = false;
+    int totalCost = 0;
     QString text;
     for (const std::pair<const BuildingType, int>& entry : counts)
     {
@@ -659,7 +732,15 @@ void SelectedBuildingPanel::buildMulti(const std::vector<BuildingId>& ids)
         {
             hasBelt = true;
         }
+        // Total placement cost counts only player-placeable buildings; the HQ
+        // and defence stations are excluded (REQ-UI-MULTI-SELECTION).
+        const BuildingDef* def = m_config->buildings.findBuildingDef(entry.first);
+        if (def && def->playerPlaceable)
+        {
+            totalCost += def->cost * entry.second;
+        }
     }
+    text += tr("Total: %1 Building Blocks").arg(totalCost);
     m_titleLabel->setText(text.trimmed());
     m_titleLabel->show();
 
@@ -820,6 +901,9 @@ void SelectedBuildingPanel::handleEvent(std::shared_ptr<const EntitySelectedEven
     {
         m_selectedEntity = event->entity;
         m_selectedBuildingIds.clear();
+        // An entity selection supersedes any scrap selection (REQ-UI-SCRAP-CLICK-SELECT).
+        m_selectedScrap.clear();
+        m_scrapLabel->hide();
         clearContent();
 
         EntityAdmin& admin = m_sim->admin();
@@ -957,6 +1041,54 @@ void SelectedBuildingPanel::handleEvent(std::shared_ptr<const SelectionChangedEv
     onSelectionChanged(event->ids);
 }
 
+void SelectedBuildingPanel::handleEvent(
+    std::shared_ptr<const ScrapSelectionChangedEvent> event)
+{
+    m_selectedScrap = event->scrap;
+    if (!m_selectedScrap.empty())
+    {
+        // Scrap is its own selection category, mutually exclusive with buildings and
+        // entities (REQ-UI-SCRAP-CLICK-SELECT).
+        m_selectedBuildingIds.clear();
+        clearContent();
+        clearEntityDisplay();
+        buildScrap();
+    }
+    else
+    {
+        m_scrapLabel->hide();
+        if (m_selectedBuildingIds.empty() && !m_selectedEntity.has_value())
+        {
+            buildEmpty();
+        }
+    }
+}
+
+void SelectedBuildingPanel::buildScrap()
+{
+    clearContent();
+    m_entityTitleLabel->hide();
+    m_entityStatsPanel->hide();
+    m_stationStatsLabel->hide();
+    refreshScrapTotal();
+    m_scrapLabel->show();
+}
+
+void SelectedBuildingPanel::refreshScrapTotal()
+{
+    // Sum the remaining amounts of the still-living selected piles (REQ-UI-SCRAP-PANEL).
+    int total = 0;
+    for (const ScrapInfo& info : m_sim->scraps().allScrapInfo())
+    {
+        if (std::find(m_selectedScrap.begin(), m_selectedScrap.end(), info.entity)
+            != m_selectedScrap.end())
+        {
+            total += info.amount;
+        }
+    }
+    m_scrapLabel->setText(tr("Scrap: %1").arg(total));
+}
+
 void SelectedBuildingPanel::handleEvent(std::shared_ptr<const DebugDrawToggledEvent> event)
 {
     m_debugDraw = event->active;

src/ui/SelectedBuildingPanel.h

@@ -18,6 +18,7 @@
 #include "GameConfig.h"
 #include "PlayerCommandsAppliedEvent.h"
 #include "RecipesConfig.h"
+#include "ScrapSelectionChangedEvent.h"
 #include "SelectionChangedEvent.h"
 #include "ShipLayout.h"
 #include "ShipsConfig.h"
@@ -37,6 +38,7 @@ class SelectedBuildingPanel : public QWidget,
                                                            PlayerCommandsAppliedEvent,
                                                            EntitySelectedEvent,
                                                            SelectionChangedEvent,
+                                                           ScrapSelectionChangedEvent,
                                                            DebugDrawToggledEvent>
 {
     Q_OBJECT
@@ -51,6 +53,7 @@ private:
     void handleEvent(std::shared_ptr<const PlayerCommandsAppliedEvent> event) override;
     void handleEvent(std::shared_ptr<const EntitySelectedEvent> event) override;
     void handleEvent(std::shared_ptr<const SelectionChangedEvent> event) override;
+    void handleEvent(std::shared_ptr<const ScrapSelectionChangedEvent> event) override;
     void handleEvent(std::shared_ptr<const DebugDrawToggledEvent> event) override;
 
 private slots:
@@ -77,6 +80,8 @@ private:
     void buildEmpty();
     void buildSingle(BuildingId id);
     void buildMulti(const std::vector<BuildingId>& ids);
+    void buildScrap();
+    void refreshScrapTotal();
     void refreshBuffers(const Building* b);
     void refreshSiteProgress(const ConstructionSite* s);
     void updateShipyardLayoutWidgets(BuildingType type,
@@ -115,6 +120,9 @@ private:
     QLabel*         m_entityTitleLabel;
     QLabel*         m_stationStatsLabel;
 
+    std::vector<entt::entity> m_selectedScrap;
+    QLabel*                   m_scrapLabel;
+
     void buildEntityShip(entt::entity entity);
     void buildEntityStation(entt::entity entity);
     void refreshEntityStats();

src/ui/ShipLayoutDialog.cpp

@@ -461,6 +461,10 @@ ShipLayoutDialog::ShipLayoutDialog(const GameConfig* config,
         QPushButton* btn = new QPushButton(label, this);
         btn->setCheckable(true);
         btn->setFixedHeight(48);
+        if (def.tooltip)
+        {
+            btn->setToolTip(QString::fromStdString(*def.tooltip));
+        }
         buttonGrid->addWidget(btn, row, col);
         m_moduleButtons.push_back(btn);
 

src/ui/ShipLayoutPreview.cpp

@@ -8,6 +8,10 @@ namespace
 
 const int kCellSize = 8;
 
+// Size of the empty placeholder box shown when no schematic is selected.
+const int kPlaceholderWidth  = 64;
+const int kPlaceholderHeight = 40;
+
 const ModuleDef* findModuleDef(const std::vector<ModuleDef>& modules,
                                const std::string& id)
 {
@@ -90,14 +94,28 @@ void ShipLayoutPreview::clear()
     m_modules = nullptr;
     m_rows = 0;
     m_cols = 0;
+    m_placeholder = false;
     setFixedSize(0, 0);
     update();
 }
 
+void ShipLayoutPreview::showPlaceholder()
+{
+    m_grid.clear();
+    m_placedModules.clear();
+    m_modules = nullptr;
+    m_rows = 0;
+    m_cols = 0;
+    m_placeholder = true;
+    setFixedSize(kPlaceholderWidth, kPlaceholderHeight);
+    update();
+}
+
 void ShipLayoutPreview::setShipAndLayout(const std::vector<std::string>& shipLayout,
                                          const ShipLayoutConfig& layout,
                                          const std::vector<ModuleDef>* modules)
 {
+    m_placeholder = false;
     m_modules = modules;
     m_placedModules = layout.placedModules;
     m_rows = static_cast<int>(shipLayout.size());
@@ -156,6 +174,18 @@ void ShipLayoutPreview::setShipAndLayout(const std::vector<std::string>& shipLay
 
 void ShipLayoutPreview::paintEvent(QPaintEvent* /*event*/)
 {
+    if (m_placeholder)
+    {
+        QPainter painter(this);
+        painter.setRenderHint(QPainter::Antialiasing, false);
+        const QRect box = rect().adjusted(0, 0, -1, -1);
+        painter.fillRect(box, QColor(40, 40, 40));
+        painter.setPen(QColor(128, 128, 128));
+        painter.drawRect(box);
+        painter.drawText(box, Qt::AlignCenter, tr("No schematic"));
+        return;
+    }
+
     if (m_rows == 0 || m_cols == 0)
     {
         return;

src/ui/ShipLayoutPreview.h

@@ -20,6 +20,10 @@ public:
                           const std::vector<ModuleDef>* modules);
     void clear();
 
+    // Shows an empty placeholder box (no ship layout) so the preview stays
+    // visible while no schematic is selected (REQ-MOD-UI-PREVIEW).
+    void showPlaceholder();
+
 protected:
     void paintEvent(QPaintEvent* event) override;
 
@@ -35,4 +39,5 @@ private:
     const std::vector<ModuleDef>* m_modules;
     int m_rows;
     int m_cols;
+    bool m_placeholder = false;
 };