@@ -1038,12 +1038,15 @@ def _load_db_setting(name: str) -> Optional[str]:
     find_frames,
     MODBUS_READ_HOLD,
 )
+from collector.capabilities import filter_holding_registers
+from collector.drivers.registry import DEFAULT_MODEL
 from collector.automation import _engineering_to_raw, _write_holding_register, AutomationEngine, AUTOMATION_TYPES, ALL_CONDITION_KINDS, SETTING_NAME_TO_REGISTER
 
 
 @app.get("/api/automation/registers")
 def api_automation_registers():
     """Return the list of writable holding registers (used by the schedule editor)."""
+    regs = _holding_registers_for_model()
     return {
         "registers": [
             {
@@ -1056,7 +1059,7 @@ def api_automation_registers():
                 "max": info.get("max"),
                 "desc": info["desc"],
             }
-            for reg, info in sorted(HOLDING_REGISTERS.items())
+            for reg, info in sorted(regs.items())
         ]
     }
 
@@ -1098,22 +1101,24 @@ def api_automation_conditions():
 @app.get("/api/automation/settings")
 def api_automation_settings():
     """Return the 50 SolarAssistant-style setting names with lux-mon register mapping."""
-    from collector.protocol import HOLDING_REGISTERS, HOLDING_BY_NAME
+    from collector.protocol import HOLDING_BY_NAME
+    regs = _holding_registers_for_model()
     settings = []
     for sa_name, reg_name in SETTING_NAME_TO_REGISTER.items():
         mapped = None
         if reg_name and reg_name in HOLDING_BY_NAME:
             reg_addr = HOLDING_BY_NAME[reg_name]
-            info = HOLDING_REGISTERS[reg_addr]
-            mapped = {
-                "name": reg_name,
-                "address": reg_addr,
-                "unit": info.get("unit"),
-                "scale": info.get("scale"),
-                "min": info.get("min"),
-                "max": info.get("max"),
-                "desc": info.get("desc"),
-            }
+            if reg_addr in regs:
+                info = regs[reg_addr]
+                mapped = {
+                    "name": reg_name,
+                    "address": reg_addr,
+                    "unit": info.get("unit"),
+                    "scale": info.get("scale"),
+                    "min": info.get("min"),
+                    "max": info.get("max"),
+                    "desc": info.get("desc"),
+                }
         settings.append({
             "name": sa_name,
             "label": sa_name.replace("_", " ").title(),
@@ -1300,6 +1305,16 @@ def _resolve_dongle() -> dict:
     }
 
 
+def _resolve_model() -> str:
+    """Resolve the active inverter model from env or DB settings."""
+    return os.getenv("LUX_INVERTER_MODEL") or _load_db_setting("inverter_model") or DEFAULT_MODEL
+
+
+def _holding_registers_for_model() -> Dict[int, dict]:
+    """Return the holding-register map filtered to the active model's capabilities."""
+    return filter_holding_registers(HOLDING_REGISTERS, _resolve_model())
+
+
 class QuickChargeBody(BaseModel):
     minutes: Optional[int] = None
     dry_run: bool = False
@@ -1360,9 +1375,9 @@ def _read_holding_block(
 
 
 def _read_all_holding_registers(dongle: dict) -> Dict[int, int]:
-    """Read holding registers 0-169 from the inverter in batches."""
+    """Read holding registers 0-261 from the inverter in batches."""
     raw: Dict[int, int] = {}
-    batches = [(0, 40), (40, 40), (80, 40), (120, 40), (160, 40)]
+    batches = [(0, 40), (40, 40), (80, 40), (120, 40), (160, 40), (200, 40), (240, 22)]
     for start, count in batches:
         ok, block, msg = _read_holding_block(
             dongle["dongle_host"],
@@ -1391,7 +1406,8 @@ def api_holding_list():
         raise HTTPException(400, "datalog_serial / inverter_serial not configured")
     raw = _read_all_holding_registers(dongle)
     result = {}
-    for reg, info in sorted(HOLDING_REGISTERS.items()):
+    regs = _holding_registers_for_model()
+    for reg, info in sorted(regs.items()):
         if reg in raw:
             result[info["name"]] = {
                 "address": reg,
@@ -1413,7 +1429,8 @@ def api_holding_controllable():
     entities without hardcoding a static list.
     """
     result = {}
-    for reg, info in sorted(HOLDING_REGISTERS.items()):
+    regs = _holding_registers_for_model()
+    for reg, info in sorted(regs.items()):
         name = info["name"]
         unit = info.get("unit", "")
         scale = info.get("scale", 1.0)
@@ -1449,10 +1466,12 @@ def api_holding_get(name: str):
     """Read a single named holding register from the inverter."""
     if name not in HOLDING_BY_NAME:
         raise HTTPException(404, f"Unknown holding register: {name}")
+    reg = HOLDING_BY_NAME[name]
+    if reg not in _holding_registers_for_model():
+        raise HTTPException(404, f"Register {name} not supported by this inverter model")
     dongle = _resolve_dongle()
     if not dongle["datalog_serial"] or not dongle["inverter_serial"]:
         raise HTTPException(400, "datalog_serial / inverter_serial not configured")
-    reg = HOLDING_BY_NAME[name]
     info = HOLDING_REGISTERS[reg]
     ok, raw_map, msg = _read_holding_block(
         dongle["dongle_host"],
@@ -1487,6 +1506,8 @@ def api_holding_put(name: str, body: HoldingUpdate):
     if name not in HOLDING_BY_NAME:
         raise HTTPException(404, f"Unknown holding register: {name}")
     reg = HOLDING_BY_NAME[name]
+    if reg not in _holding_registers_for_model():
+        raise HTTPException(404, f"Register {name} not supported by this inverter model")
     info = HOLDING_REGISTERS[reg]
     min_val = info.get("min")
     max_val = info.get("max")
 
@@ -61,6 +61,8 @@
     build_write_request,
     find_frames,
 )
+from .capabilities import filter_holding_registers
+from .drivers.registry import DEFAULT_MODEL
 
 logger = logging.getLogger("luxmon.automation")
 
@@ -669,6 +671,14 @@ def _set_setting(self, name: str, value: str) -> None:
         except Exception:
             logger.exception("Failed to write setting %s", name)
 
+    def _resolve_model(self) -> str:
+        """Resolve the active inverter model from the settings table."""
+        return self._get_setting("inverter_model", DEFAULT_MODEL)
+
+    def _register_supported(self, reg_addr: int) -> bool:
+        """Return True if the register is supported by the active model."""
+        return reg_addr in filter_holding_registers(HOLDING_REGISTERS, self._resolve_model())
+
     def load(self) -> List[Automation]:
         raw = self._get_setting(SETTING_AUTOMATIONS, "[]")
         try:
@@ -917,6 +927,11 @@ def _do_write(
                       f"Register '{reg_name}' not found in HOLDING_BY_NAME")
             return
 
+        if not self._register_supported(reg_addr):
+            self._log(automation_id, automation_name, setting_name, None, value, dry_run, False,
+                      f"Register '{reg_name}' not supported by this inverter model")
+            return
+
         meta = HOLDING_REGISTERS[reg_addr]
         clamped = _clamp_to_register(value, meta)
         raw = _engineering_to_raw(clamped, meta)
 
@@ -0,0 +1,160 @@
+"""Model capability layer for lux-mon.
+
+The LuxPower/EG4 family shares ONE register map — there is no per-model
+register table. An 18KPV and a 6000XP both *have* register 22 (PV start
+voltage), register 60 (active power %), etc. The difference is which
+registers are *meaningful/functional* on a given model.
+
+This module defines:
+
+  * CAPABILITIES — the set of feature flags a model may or may not support.
+  * MODEL_CAPABILITIES — maps each `inverter_model` setting value to the
+    capabilities its hardware actually has.
+  * filter_holding_registers() — filters the global holding-register map
+    down to the registers that apply to a given model.
+
+The model is identified at runtime by reading hold registers 7-8 (4 ASCII
+chars = firmware/model code) and register 16 (Device Type / DTC). The
+`inverter_model` setting is the user-facing alias for that detection.
+
+Capability flags are coarse feature groups, not per-register toggles. A
+register is tagged with the capability it requires; if the model lacks that
+capability, the register is hidden from the UI/API and never written.
+"""
+from __future__ import annotations
+
+from typing import Dict, FrozenSet, Set
+
+# ── Capability flags ────────────────────────────────────────────────
+#
+# Each flag names a hardware feature that some LuxPower/EG4 models have and
+# others do not. Registers are tagged with the flag(s) they require.
+
+# PV string count. The SNA family (6000XP, 6500EX, 3000EHV, 12000XP) has 2
+# MPPT inputs (PV1/PV2). The 12kPV has 3 (PV1-3). The 18KPV has up to 4-6.
+PV1 = "pv1"
+PV2 = "pv2"
+PV3 = "pv3"
+PV4 = "pv4"
+PV5 = "pv5"
+PV6 = "pv6"
+
+# Split-phase (120/240V) vs single-phase (120V) vs three-phase (208/400V).
+SINGLE_PHASE = "single_phase"
+SPLIT_PHASE = "split_phase"
+THREE_PHASE = "three_phase"
+
+# Feature groups.
+AFCI = "afci"                    # arc-fault circuit interrupter (18KPV)
+GENERATOR = "generator"          # generator input / generator charge
+SMART_LOAD = "smart_load"        # smart-load output port
+AC_COUPLE = "ac_couple"          # AC-coupled PV input
+WATTNODE = "wattnode"            # WattNode external CT meter
+GRID_PEAK_SHAVING = "grid_peak_shaving"
+VOLT_WATT = "volt_watt"          # Volt-Watt curve
+QV_CURVE = "qv_curve"            # Q(V) reactive power curve
+QP_CURVE = "qp_curve"            # cosphi(P) curve
+SEVEN_DAY_SCHEDULE = "seven_day_schedule"  # 7-day scheduling (regs 500-723)
+BATTERY_BMS = "battery_bms"      # per-battery BMS registers (5000+)
+
+# ── Model → capabilities ───────────────────────────────────────────
+
+# SNA family: 2-MPPT, single-phase, no AFCI/generator/smart-load/AC-couple.
+# This is the capture-validated reference family (6000XP and rebadges).
+_SNA_CAPS: FrozenSet[str] = frozenset({
+    PV1, PV2,
+    SINGLE_PHASE,
+    BATTERY_BMS,
+})
+
+# 18KPV family: 3+ MPPT, split-phase, AFCI, generator, smart load, AC couple.
+_18KPV_CAPS: FrozenSet[str] = frozenset({
+    PV1, PV2, PV3, PV4, PV5, PV6,
+    SPLIT_PHASE,
+    AFCI,
+    GENERATOR,
+    SMART_LOAD,
+    AC_COUPLE,
+    WATTNODE,
+    GRID_PEAK_SHAVING,
+    VOLT_WATT,
+    QV_CURVE,
+    QP_CURVE,
+    SEVEN_DAY_SCHEDULE,
+    BATTERY_BMS,
+})
+
+# 12kPV: 3 MPPT, split-phase, but no AFCI (it's a smaller 18KPV sibling).
+_12KPV_CAPS: FrozenSet[str] = frozenset({
+    PV1, PV2, PV3,
+    SPLIT_PHASE,
+    GENERATOR,
+    SMART_LOAD,
+    AC_COUPLE,
+    GRID_PEAK_SHAVING,
+    VOLT_WATT,
+    QV_CURVE,
+    QP_CURVE,
+    SEVEN_DAY_SCHEDULE,
+    BATTERY_BMS,
+})
+
+MODEL_CAPABILITIES: Dict[str, FrozenSet[str]] = {
+    # ── SNA family (2-MPPT single-phase) ──
+    "eg4_6000xp": _SNA_CAPS,
+    "luxpower_sna": _SNA_CAPS,
+    "eg4_12000xp": _SNA_CAPS,
+    "eg4_6500ex": _SNA_CAPS,
+    "eg4_3000ehv": _SNA_CAPS,
+    "lxp_6k": _SNA_CAPS,
+    "bigbattery_sna_6k": _SNA_CAPS,
+
+    # ── 18KPV family (3+ MPPT split-phase, AFCI) ──
+    "eg4_18kpv": _18KPV_CAPS,
+    "lxp_18k": _18KPV_CAPS,
+    "fortress_envy_12k": _18KPV_CAPS,
+
+    # ── 12kPV (3 MPPT split-phase, no AFCI) ──
+    "eg4_12kpv": _12KPV_CAPS,
+    "lxp_12k": _12KPV_CAPS,
+}
+
+# Default capabilities when the model is unknown (assume the most capable
+# family so nothing is hidden that might actually apply).
+DEFAULT_CAPABILITIES: FrozenSet[str] = _18KPV_CAPS
+
+
+def capabilities_for(model: str) -> FrozenSet[str]:
+    """Return the capability set for a model, defaulting to the full set."""
+    return MODEL_CAPABILITIES.get(model, DEFAULT_CAPABILITIES)
+
+
+def register_applies(
+    capabilities: FrozenSet[str],
+    required: Set[str] | FrozenSet[str] | None,
+) -> bool:
+    """Return True if a register's required capabilities are all present.
+
+    A register with no `required` capabilities applies to every model.
+    """
+    if not required:
+        return True
+    return required.issubset(capabilities)
+
+
+def filter_holding_registers(
+    holding_registers: Dict[int, dict],
+    model: str,
+) -> Dict[int, dict]:
+    """Filter a holding-register map down to the registers a model supports.
+
+    Registers without a `capabilities` key are always included (they are
+    shared across the whole family). Registers with a `capabilities` key are
+    included only if the model has every required capability.
+    """
+    caps = capabilities_for(model)
+    return {
+        reg: info
+        for reg, info in holding_registers.items()
+        if register_applies(caps, info.get("capabilities"))
+    }