chore(observability): expose 7 silent broad-except fallbacks (Wave Agent 7)

[Ghenghis]

Summary

Wave Agent 7 (Remaining/Skipped Wave 2026-05-09) flagged 7 silent broad-except sites that returned an empty default with no log. Tighten observability without changing behavior.

Sites cleaned up

Site	Level	Special handling
module_runtime.py:_private_runtime_env	warning	runs through redact_text (env-import exceptions can carry token fragments)
design.py:module_version_lookup	debug
update_center.py:read proof_events insert	warning
system.py:metrics psutil fallback	debug
repair_agent.py:extract_json fallback	debug	uses pre-existing log symbol
auto_recovery.py:printer_state_poll_soft	debug	uses pre-existing log symbol
auto_recovery.py:firmware_restart	debug	uses pre-existing log symbol

All sites preserve silent-fallback semantics; only observability is added. Each site marked # noqa: BLE001 so future linting doesn't re-flag.

Tests added (8, all green)

• 7 parameterized tests pin each site's log-marker substring
• 1 test confirms module_runtime imports redact_text for safe exception logging

Test plan

• py_compile: OK
• Focused tests: 8/8 pass
• Pre-push hook: passed
• CI on PR

Scope

• Observability only. Zero behavior change. No new dependencies.

Swarm provenance

Wave Agent 7 of the 10-agent Remaining/Skipped Blocker Wave enumerated 10 candidate sites; 3 were already using LOG.exception or specific exceptions; the remaining 7 are cleaned up here.

🤖 Generated with Claude Code

[gemini-code-assist]

Code Review

This pull request replaces several silent pass statements in broad exception handlers with logging calls to improve observability across various modules, including design, system, and update center routes. It also introduces a new test suite to verify the presence of these logging markers. The review feedback suggests removing redundant nested try...except blocks around the new logging calls, moving imports to the top level to follow PEP 8, and using a more robust method for locating source files in the tests to avoid brittle path dependencies.

[gemini-code-assist]

The nested try...except Exception: pass block around the logging call is redundant and adds unnecessary complexity. In a pull request specifically aimed at cleaning up silent broad-except fallbacks, adding a new one for the logger is contradictory. If the concern is that logging might fail (e.g., during interpreter shutdown), it is better to import logging at the top level to ensure it is available in sys.modules and remove the inner try block.

        import logging
        logging.getLogger(__name__).debug(
            "design.module_version_lookup: metadata.version(%r) failed: %s: %s",
            module_name, type(exc).__name__, exc,
        )

[gemini-code-assist]

The nested try...except Exception: pass block around the logging call is redundant. Additionally, import logging should ideally be moved to the top level of the module to follow PEP 8 and avoid repeated imports during exception handling.

        import logging
        logging.getLogger(__name__).debug(
            "system.metrics: psutil unavailable; cpu/ram default to 0: %s: %s",
            type(exc).__name__, exc,
        )

[gemini-code-assist]

The nested try...except Exception: pass block around the logging call is redundant. Moving import logging to the top level of the module is recommended to adhere to standard practices and improve efficiency.

        import logging
        logging.getLogger(__name__).warning(
            "update_center.read: proof_events insert failed: %s: %s",
            type(exc).__name__, exc,
        )

[gemini-code-assist]

The nested try...except block and lazy imports inside the exception handler should be avoided. Furthermore, there is an inconsistency in the use of redaction: this block imports redact_text from hermes3d.gateways.redaction, while a local _redact_text function already exists in this module (line 3240). If the external redact_text is preferred for its more robust masking, it should be imported at the top level to maintain consistency and avoid circular dependency risks during lazy loading.

        import logging

        from hermes3d.gateways.redaction import redact_text

        logging.getLogger(__name__).warning(
            "_private_runtime_env: private_env import/load failed: %s",
            redact_text(f"{type(exc).__name__}: {exc}")[:200],
        )

[gemini-code-assist]

The hardcoded path depth (parents[3]) in _read_source is brittle and may cause tests to fail if run from a different environment or if the repository structure changes. Using importlib.util.find_spec is a more robust way to locate the source file for a given module regardless of the current working directory or test execution context.

Suggested change

	def _read_source(dotted: str) -> str:
	"""Read a Python source file under hermes3d by dotted module name."""
	parts = dotted.split(".")
	from pathlib import Path
	src_root = Path(__file__).resolve().parents[3] / "03_implementation" / "src"
	file_path = src_root / Path(*parts).with_suffix(".py")
	return file_path.read_text(encoding="utf-8")
	def _read_source(dotted: str) -> str:
	"""Read a Python source file under hermes3d by dotted module name."""
	import importlib.util
	from pathlib import Path
	spec = importlib.util.find_spec(dotted)
	if spec is None or spec.origin is None:
	raise ImportError(f"Could not find source for {dotted}")
	return Path(spec.origin).read_text(encoding="utf-8")