@@ -1652,7 +1652,7 @@ def validate_config(self):
                                 if spec.get("scalar_value_dict", False):
                                     for key, sub_value in item.items():
                                         if not isinstance(sub_value, str):
-                                            self.log("Warn: Validation of apps.yaml found configuration item '{}' entry '{}' value {} is not a string - quote it to ensure it is matched".format(name, key, sub_value))
+                                            self.log("Warn: Validation of apps.yaml found configuration item '{}' entry '{}' value {} is not a string - quote it to keep its exact formatting (e.g. a leading zero)".format(name, key, sub_value))
                     elif expected_type == "int_float_dict":
                         if spec.get("or_auto", False) and value == "auto":
                             matches = True
 
@@ -323,6 +323,27 @@ def test_collect_log_secret_values():
         print("ERROR: a boolean secrets.yaml value should not be collected, got {}".format(bool_found))
         failed = True
 
+    # An unquoted numeric MPAN in the bare redact_strings list form (not just the labelled dict
+    # form) loads from YAML as an int and must still be collected, coerced to string - the same
+    # gap as the labelled form, just missed on the first pass (#5053 review).
+    numeric_bare_found = collect_log_secret_values({}, {}, [1234567890123], None)
+    if "1234567890123" not in numeric_bare_found or numeric_bare_found["1234567890123"] != "redact_strings":
+        print("ERROR: a numeric redact_strings (bare list) value should be collected as a string, got {}".format(numeric_bare_found))
+        failed = True
+
+    # A non-string dict key (an integer key in a nested mapping, reached at the true top level of
+    # args) must not crash the traversal - log() runs on the very first startup line, before
+    # validation has had any chance to report the malformed input (#5053 review).
+    try:
+        non_string_key_found = collect_log_secret_values({123: "some_value"}, {})
+    except AttributeError as e:
+        print("ERROR: a non-string dict key crashed the traversal instead of being tolerated: {}".format(e))
+        failed = True
+        non_string_key_found = {}
+    if non_string_key_found:
+        print("ERROR: a non-secret-flagged non-string key should not itself be collected, got {}".format(non_string_key_found))
+        failed = True
+
     if not failed:
         print("**** test_collect_log_secret_values PASSED ****")
     return failed
@@ -388,15 +409,25 @@ def test_compile_log_secret_pattern_and_redact_log_line():
     if "sec1" in diff_position_redacted or "c123x" in diff_position_redacted:
         print("ERROR: an overlapping secret value survived redaction: {}".format(diff_position_redacted))
         failed = True
+    # The merged span itself is not a key in `labels` (it is neither secret value alone), so a
+    # naive labels.get(merged_value, SECRET_MASK) falls back to the generic mask - losing the
+    # "which credential" guarantee a labelled mask exists to provide, even though nothing leaks
+    # (Copilot review on #5053). Both contributing labels must survive, joined together.
+    if "<short_secret+long_secret>" not in diff_position_redacted:
+        print("ERROR: an overlapping match should keep both labels, got {}".format(diff_position_redacted))
+        failed = True
 
     # A three-way overlap chain (v1/1v2/v2345 all present in "v1v2345") must extend through
-    # every overlap, not just the first one found.
+    # every overlap, not just the first one found - and keep every contributing label.
     chain_found = {"v1": "l1", "1v2": "l2", "v2345": "l3"}
     chain_pattern = compile_log_secret_pattern(chain_found)
     chain_redacted = redact_log_line("value v1v2345 end", chain_pattern)
     if "v1v2345" in chain_redacted or "2345" in chain_redacted or "v2345" in chain_redacted:
         print("ERROR: a chained overlap was not fully covered: {}".format(chain_redacted))
         failed = True
+    if "<l1+l2+l3>" not in chain_redacted:
+        print("ERROR: a chained overlap should keep every contributing label, got {}".format(chain_redacted))
+        failed = True
 
     # A line with nothing secret in it must come back byte-identical.
     clean_line = "Info: battery_size is 9.5 today"
 
@@ -53,7 +53,12 @@ def _run(my_predbat, extra_args, extra_states=None, expect_errors=(), expect_cle
         for name in expect_clean:
             assert name not in my_predbat.arg_errors, f"Unexpected validation error for '{name}': {my_predbat.arg_errors.get(name)}"
     finally:
-        my_predbat.args = saved_args
+        # In place, not my_predbat.args = saved_args - a ComponentBase aliases self.args = base.args
+        # at construction time (component_base.py), so reassigning here would leave any component
+        # already holding that reference still pointing at the old, now-extra_args-mutated dict
+        # even though my_predbat.args itself looks restored (#5053 review).
+        my_predbat.args.clear()
+        my_predbat.args.update(saved_args)
         my_predbat.ha_interface.dummy_items = saved_states
 
 
@@ -213,7 +218,9 @@ def test_validate_config(my_predbat):
         assert "redact_strings_labelled" not in my_predbat.arg_errors, "a numeric redact_strings_labelled value should warn, not error: {}".format(my_predbat.arg_errors.get("redact_strings_labelled"))
         assert any("my_mpan" in msg and "not a string" in msg for msg in captured), "expected a 'not a string' warning naming my_mpan, got {}".format(captured)
     finally:
-        my_predbat.args = saved_args
+        # In place, not reassignment - see _run()'s equivalent comment above (#5053 review).
+        my_predbat.args.clear()
+        my_predbat.args.update(saved_args)
         my_predbat.log = saved_log
 
     # ==========================================================================
 
@@ -256,7 +256,11 @@ def _collect_secret_values(value, found, label_prefix=""):
             # the more specific one redact_strings_labelled would have given it (#5053 review).
             # Only exempt the true top-level keys (label_prefix empty) - an unrelated nested key
             # that happens to share the name is not these denylists and should still collect.
-            if not label_prefix and key.lower() in SECRET_KEY_EXPLICIT_NAMES:
+            # str(key) first: apps.yaml keys are always strings in practice, but is_secret_key()
+            # below already tolerates a non-string key the same way, and log() runs on the very
+            # first startup line - an unguarded .lower() here would crash before validation ever
+            # gets a chance to report the malformed input (#5053 review).
+            if not label_prefix and str(key).lower() in SECRET_KEY_EXPLICIT_NAMES:
                 continue
             if is_secret_key(key):
                 key_label = (label_prefix + "." + key) if label_prefix else key
@@ -350,8 +354,10 @@ def collect_log_secret_values(args, secrets, redact_strings=None, redact_strings
                     found[value] = str(label)
     if isinstance(redact_strings, list):
         for value in redact_strings:
-            if isinstance(value, str) and value and value not in found:
-                found[value] = "redact_strings"
+            if isinstance(value, (str, int, float)) and not isinstance(value, bool):
+                value = str(value)
+                if value and value not in found:
+                    found[value] = "redact_strings"
     return found
 
 
@@ -399,7 +405,10 @@ def redact_log_line(line, secret_pattern):
     matches at the earliest position ("sec1"), then resumes scanning after it, so it never
     considers "c123x" starting one character in and leaves "23x" exposed. Extend each match to
     the longest secret that starts anywhere inside it before emitting the mask, so a longer
-    secret overlapping a shorter one is always fully covered.
+    secret overlapping a shorter one is always fully covered. Every secret that contributed to an
+    extended span keeps its own label in the mask (joined with "+"), rather than falling back to
+    the generic mask just because the merged span itself is not a single known value (#5053
+    review) - the point of a labelled mask is telling an operator which credential to check.
     """
     if secret_pattern is None or not line:
         return line
@@ -411,7 +420,13 @@ def redact_log_line(line, secret_pattern):
         if start < pos:
             # Already covered by the extended span of a previous match.
             continue
-        value = match.group(0)
+        # Collect the label of every secret found to contribute to the (possibly extended) span,
+        # in the order encountered, rather than looking up labels[line[start:end]] once at the
+        # end - a merged span covering more than one overlapping secret is not itself a key in
+        # labels, so that lookup would silently fall back to the generic mask and the line would
+        # read no differently from an unrecognised value, losing the "which credential" guarantee
+        # this feature exists to provide (#5053 review).
+        span_labels = [labels.get(match.group(0), SECRET_MASK)]
         # Look for a longer secret starting at each position within this match's span and extend
         # to cover it - finditer() itself won't report an overlapping match once it has already
         # consumed the earlier one, so each candidate start position must be probed directly with
@@ -423,10 +438,12 @@ def redact_log_line(line, secret_pattern):
                 rescan = pattern.match(line, probe)
                 if rescan and rescan.end() > end:
                     end = rescan.end()
-                    value = line[start:end]
+                    rescan_label = labels.get(rescan.group(0), SECRET_MASK)
+                    if rescan_label not in span_labels:
+                        span_labels.append(rescan_label)
                     extended = True
         out.append(line[pos:start])
-        out.append("<{}>".format(labels.get(value, SECRET_MASK)))
+        out.append("<{}>".format("+".join(span_labels)))
         pos = end
     out.append(line[pos:])
     return "".join(out)