Use + to concatenate the values in each parameter to get NULL when the column has the value NULL instead. NULLIF can be used to change "empty" (I assume zero length strings ( '' ) to NULL as well. Also, I recommend using CONCAT_WS too:

CONCAT_WS(', ',
          'Sub-título: ' + NULLIF(p.[config_metadata subtitle],''),
          'Descrição: ' + NULLIF(p.[last_timeline descricao],''),
          'Fwd_descrição: ' + NULLIF(p.[last_timeline forwardingDescription],''),
          'Justificativa: ' + NULLIF(p.[last_version Justificativa],''),
          'Motivo: ' + NULLIF(p.[last_version motivo],''),
          'Área propriedade: ' + NULLIF(p.[last_version areapropriedade],''),
          'Endereço: ' + NULLIF(p.[last_version endereco],''),
          'Atividade: ' + NULLIF(p.[last_version atividade],''),
          'Atividade empreendida: ' + NULLIF(p.[last_version atividadeempreend],''),
          'Descreva finalidade: ' + NULLIF(p.[last_version descrevafinalidade],''),
          'Nome: ' + NULLIF(p.[last_version nome],''),
          'Nome empreendimento: ' + [last_version nomeempreendimento],''),
          'Quantidade: ' + [last_version quantidade],''),
          'Outros: ' + [last_version outros],''),
          'Data finalizado: ' + NULLIF(p.[finalizado date],''))

This assumes that all your columns are a string based value. If a column isn't, you'll need to explicitly CAST / CONVERT the value to a (n)varchar of an appropriate length (and style if wanted/needed).

A minimal reproducible example is not provided.

Please try the following conceptual solution. It will work starting from SQL Server 2017 onwards.

SQL

-- DDL and sample data population, start
DECLARE @tbl TABLE (ID INT IDENTITY PRIMARY KEY, col1 VARCHAR(10), col2 VARCHAR(10));
INSERT @tbl (col1, col2) VALUES
('Miami', NULL),
('Orlando', 'Florida'),
(NULL, 'Florida'),
(NULL, NULL);
-- DDL and sample data population, end

SELECT * 
    , result = CONCAT_WS(', ', 'City: ' + NULLIF(col1,''), 'State: ' + NULLIF(col2,''))
FROM @tbl;

Output

If you had something like an EAV table with lots of columns and data normalization was not an option, you can take advantage of XML (and potentially JSON) methods to dynamically retrieve column names. This way, if the column names are updated or more are added "horizontally" to the table (for example you have no control over the data design, but you are still required to query it), the query will continue to "work". While PIVOT/UNPIVOT operations are possible as well, these have to have a 'hardcoded' list of values that would need to be maintained or utilize dynamic multi-statement SQL.

While the above example from the OP shows generating a concatenation where the "label" portion is different than the column name specifically, the following example of the query technique could be adapted to join to a "Lookup" table to match a column name to a description needed for the runtime query. The basic premise is to :

1. Generate an automatic XML representation of the field data (potentially utilizing COLUMN_SET for SPARSE columns)
2. Filter the representation's nodes() as needed for the query (for example, non empty, equals value, etc.)
3. Use APPLY statements in combination with local-name(.) to get the field name associated with the filtered value. (applying any 'formatting' to the name)
4. Aggregate the filtered information as needed.

In this example, both COLUMN_SET / SPARSE as well as 'filter out the non-field columns' techniques are shown to dynamically summarize BIT fields that are set to 'true' for a record (tested in SQL2022 LocalDB):

/* Option 1: Use "Sparse" columns and COLUMN_SET with xml 'local-name(.)' query
, to generate an XML already filtered for field columns to be queried.
See SQL Documentation for considerations of SPARSE and COLUMN_SET */
CREATE TABLE SparsePropertyList
(
  CLID     INT IDENTITY(1,1)    NOT NULL CONSTRAINT CX_SPL UNIQUE      CLUSTERED
, SerialNo       VARCHAR(42)    NOT NULL CONSTRAINT PK_SPL PRIMARY KEY NONCLUSTERED
, FieldInfo              XML             COLUMN_SET FOR ALL_SPARSE_COLUMNS
, Has_FieldA             BIT SPARSE NULL 
, Has_FieldB             BIT SPARSE NULL 
, Has_FieldC             BIT SPARSE NULL 
)

INSERT INTO dbo.SparsePropertyList ( SerialNo
                                   , Has_FieldA
                                   , Has_FieldB
                                   , Has_FieldC )
VALUES ( 'ABC',1,1,1),('AB',1,1,0),('BC',0,1,1),('C',NULL,NULL,1)

SELECT 
SPL.CLID,
SPL.SerialNo,
f1.HasFields
FROM
SparsePropertyList SPL
CROSS APPLY ( SELECT STRING_AGG(x3.p1,',') WITHIN GROUP (ORDER BY x3.p1 ASC) HasFields FROM SPL.FieldInfo.nodes('/*[text()[1] eq 1]') x1(p1)
                     CROSS APPLY ( SELECT x1.p1.query('local-name(.)').value('.','varchar(100)')) x2(p1)
                     CROSS APPLY ( SELECT CASE WHEN x2.p1 LIKE 'Has_%' THEN SUBSTRING(x2.p1,LEN('Has_!'),LEN(x2.p1)) ELSE x2.p1 END ) x3(p1)
                     WHERE x2.p1 LIKE 'Has_%' ) f1

/* Option 2: Self reference APPLY to FOR XML ELEMENTS 'local-name(.)' query
, to generate an XML node that will need to be filtered to field columns */
CREATE TABLE NonsparsePropertyList
(
  CLID     INT IDENTITY(1,1)    NOT NULL CONSTRAINT CX_NPL UNIQUE      CLUSTERED
, SerialNo       VARCHAR(42)    NOT NULL CONSTRAINT PK_NPL PRIMARY KEY NONCLUSTERED
, Has_FieldA             BIT        NULL 
, Has_FieldB             BIT        NULL 
, Has_FieldC             BIT        NULL 
)

INSERT INTO dbo.NonsparsePropertyList ( SerialNo
                                   , Has_FieldA
                                   , Has_FieldB
                                   , Has_FieldC )
VALUES ( 'ABC',1,1,1),('AB',1,1,0),('BC',0,1,1),('C',NULL,NULL,1)

SELECT NPLx.* FROM dbo.NonsparsePropertyList NPLx WHERE NPLx.CLID = 2 FOR XML AUTO,ELEMENTS

SELECT 
NPL.CLID,
NPL.SerialNo,
f1.HasFields
FROM
NonsparsePropertyList NPL
CROSS APPLY ( SELECT CAST((SELECT NPLx.* FROM dbo.NonsparsePropertyList NPLx WHERE NPLx.CLID = NPL.CLID FOR XML AUTO,ELEMENTS) AS XML) ) XPL(FieldInfo)
CROSS APPLY ( SELECT STRING_AGG(x3.p1,',') WITHIN GROUP (ORDER BY x3.p1 ASC) HasFields FROM XPL.FieldInfo.nodes('/NPLx/*[text()[1] eq 1]') x1(p1)
                     CROSS APPLY ( SELECT x1.p1.query('local-name(.)').value('.','varchar(100)')) x2(p1)
                     CROSS APPLY ( SELECT CASE WHEN x2.p1 LIKE 'Has_%' THEN SUBSTRING(x2.p1,LEN('Has_!'),LEN(x2.p1)) ELSE x2.p1 END ) x3(p1)
                     WHERE x2.p1 NOT IN ('CLID','SerialNo') AND x2.p1 LIKE 'Has_%' ) f1

/* Option 3: Use a similar method, but with FOR JSON and OPENJSON 
, to get key names to be filtered and queried. Out of scope for this example */

The results in either method include : | SerialNo | HasFields | |----------|------------| | AB | FieldA,FieldB | | ABC | FieldA,FieldB,FieldC | | BC | FieldB,FieldC | | C | FieldC |

The key point here (😉), is that the source tables could be expanded to any number of columns, and the query would not need to change to select them specifically. (As is the case in CONCAT / CONCAT_WS or PIVOT based methods)