wup 0.2.64__tar.gz → 0.2.65__tar.gz

{wup-0.2.64/wup.egg-info → wup-0.2.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wup
-Version: 0.2.64
+Version: 0.2.65
 Summary: WUP (What's Up) - Intelligent file watcher for regression testing in large projects
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -31,17 +31,17 @@ Dynamic: license-file
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.64-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$3.49-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-31.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.65-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$3.50-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-33.2h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $3.4940 (76 commits)
-- 👤 **Human dev:** ~$3168 (31.7h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $3.4955 (77 commits)
+- 👤 **Human dev:** ~$3318 (33.2h @ $100/h, 30min dedup)
 
-Generated on 2026-05-27 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-06-03 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.64-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.65-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 

{wup-0.2.64 → wup-0.2.65}/README.md

@@ -3,17 +3,17 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.64-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$3.49-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-31.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.65-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$3.50-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-33.2h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $3.4940 (76 commits)
-- 👤 **Human dev:** ~$3168 (31.7h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $3.4955 (77 commits)
+- 👤 **Human dev:** ~$3318 (33.2h @ $100/h, 30min dedup)
 
-Generated on 2026-05-27 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-06-03 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.64-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.65-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 

{wup-0.2.64 → wup-0.2.65}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wup"
-version = "0.2.64"
+version = "0.2.65"
 description = "WUP (What's Up) - Intelligent file watcher for regression testing in large projects"
 readme = "README.md"
 requires-python = ">=3.9"

{wup-0.2.64 → wup-0.2.65}/tests/test_testql_monitor.py

@@ -34,11 +34,48 @@ API[1]{method, endpoint, expected_status}:
     assert is_monitoring_probe(probes[0])
 
 
-def test_firmware_plugin_health_on_8202_not_live_probe():
+def test_hardware_identify_and_peripheral_status_are_live_probes():
+    assert is_monitoring_probe(
+        ProbeTarget(url="http://localhost:8202/api/v1/hardware/identify")
+    )
+    assert is_monitoring_probe(
+        ProbeTarget(url="http://localhost:8096/api/v3/hardware/peripheral-status/modbus-io")
+    )
+
+
+def test_firmware_plugin_health_catalog_not_periodic_live_probe():
+    """Plugin health is listed for detail TestQL; live watch uses identify + peripheral-status."""
     probe = ProbeTarget(url="http://localhost:8202/api/v1/plugins/modbus-io/health")
-    assert not is_monitoring_probe(probe)
-    direct = ProbeTarget(url="http://localhost:8202/health")
-    assert is_monitoring_probe(direct)
+    assert is_monitoring_probe(probe)
+    with tempfile.TemporaryDirectory() as tmpdir:
+        root = Path(tmpdir)
+        cfg = WupConfig(
+            project=ProjectConfig(name="demo"),
+            services=[
+                ServiceConfig(name="firmware", paths=["backend/firmware/**"]),
+                ServiceConfig(name="connect-scenario", paths=["connect-scenario/**"]),
+            ],
+            watch=WatchConfig(),
+            testql=TestQLConfig(
+                hardware_usb_modules={
+                    "oqlos_url": "http://localhost:8202",
+                    "proxy_url": "http://localhost:8096",
+                    "module_ids": ["modbus-io", "modbus-adc"],
+                },
+            ),
+        )
+        monitor = TestQLMonitor(root, cfg)
+        firmware = {p.url for p in monitor.probes_for_service("firmware")}
+        scenario = {p.url for p in monitor.probes_for_service("connect-scenario")}
+    assert "http://localhost:8202/api/v1/hardware/identify" in firmware
+    assert "http://localhost:8202/api/v1/plugins/modbus-io/health" not in firmware
+    assert "http://localhost:8096/api/v3/hardware/identify" in scenario
+    assert (
+        "http://localhost:8096/api/v3/hardware/peripheral-status/modbus-io" in scenario
+    )
+    assert (
+        "http://localhost:8096/api/v3/hardware/peripheral-status/modbus-adc" in scenario
+    )
 
 
 def test_connect_api_paths_on_8100_are_not_monitoring_probes():
@@ -108,8 +145,18 @@ def test_monitor_merges_config_and_service_map():
         probes = monitor.probes_for_service("firmware")
         urls = {p.url for p in probes}
         assert "http://localhost:8100/firmware/api/v1/health" in urls
-        assert "http://localhost:8100/firmware/api/v1/execution/status" in urls
-        assert "http://localhost:8100/firmware/api/v1/execution/logs" in urls
+        # Execution telemetry is for fleet TestQL, not WUP live liveness probes.
+        assert "http://localhost:8100/firmware/api/v1/execution/status" not in urls
+        assert "http://localhost:8100/firmware/api/v1/execution/logs" not in urls
+
+
+def test_firmware_live_probe_prefers_oqlos_8202():
+    probes = [
+        ProbeTarget(url="http://localhost:8100/firmware/api/v1/health"),
+        ProbeTarget(url="http://localhost:8202/health"),
+    ]
+    ordered = TestQLMonitor._sort_probes_for_live(probes, service="firmware")
+    assert ordered[0].url == "http://localhost:8202/health"
 
 
 def test_probes_for_service_ignores_non_health_extra_paths():

{wup-0.2.64 → wup-0.2.65}/tests/test_wup.py

@@ -1790,6 +1790,37 @@ class TestTestQLWatcherConfig:
             scenarios = watcher._select_scenarios_for_service("users")
             # Should be limited by config when no matching scenarios found
             assert len(scenarios) <= 2
+
+    def test_testql_watcher_select_scenarios_uses_pinned_scenario(self):
+        """Pinned quick_tests.scenario wins over auto-api scoring."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            scenarios_dir = Path(tmpdir) / "testql-scenarios"
+            scenarios_dir.mkdir()
+            (scenarios_dir / "auto-api-connect-workshop.testql.toon.yaml").write_text("# workshop")
+            pinned = scenarios_dir / "connect-scenario-wup-quick-fast.testql.toon.yaml"
+            pinned.write_text("# sentinel")
+
+            service = ServiceConfig(
+                name="connect-scenario",
+                type="web",
+                paths=["connect-scenario/**"],
+                quick_tests=ServiceTestConfig(
+                    scope="all",
+                    max_endpoints=1,
+                    scenario="connect-scenario-wup-quick-fast.testql.toon.yaml",
+                ),
+            )
+            config = WupConfig(
+                project=ProjectConfig(name="test"),
+                watch=WatchConfig(),
+                services=[service],
+                test_strategy=TestStrategyConfig(),
+                testql=TestQLConfig(),
+            )
+
+            watcher = TestQLWatcher(tmpdir, scenarios_dir="testql-scenarios", config=config)
+            selected = watcher._select_scenarios_for_service("connect-scenario")
+            assert selected == [pinned]
     
     def test_testql_watcher_uses_config_timeout(self):
         """Test that TestQLWatcher uses config timeout settings."""

{wup-0.2.64 → wup-0.2.65}/wup/__init__.py

@@ -7,7 +7,7 @@ WUP monitors file changes and runs intelligent regression tests using a 3-layer
 3. Detail Layer: Full tests with blame reports (only on failure)
 """
 
-__version__ = "0.2.64"
+__version__ = "0.2.65"
 __author__ = "Tom Sapletta"
 
 from .config import load_config, save_config, get_default_config

{wup-0.2.64 → wup-0.2.65}/wup/config.py

@@ -139,11 +139,13 @@ def _parse_services_config(raw: dict) -> List[ServiceConfig]:
             type=svc_raw.get("type", "auto"),
             quick_tests=ServiceTestConfig(
                 scope=quick_tests_raw.get("scope", "all"),
-                max_endpoints=quick_tests_raw.get("max_endpoints", 10)
+                max_endpoints=quick_tests_raw.get("max_endpoints", 10),
+                scenario=quick_tests_raw.get("scenario", ""),
             ),
             detail_tests=ServiceTestConfig(
                 scope=detail_tests_raw.get("scope", "all"),
-                max_endpoints=detail_tests_raw.get("max_endpoints", 10)
+                max_endpoints=detail_tests_raw.get("max_endpoints", 10),
+                scenario=detail_tests_raw.get("scenario", ""),
             ),
             cpu_throttle=svc_raw.get("cpu_throttle", 0.8),
             notify=NotifyConfig(
@@ -233,7 +235,8 @@ def _parse_testql_config(raw: dict) -> TestQLConfig:
         base_url_env=testql_raw.get("base_url_env", "WUP_BASE_URL"),
         service_base_urls=testql_raw.get("service_base_urls", {}),
         explicit_endpoints=testql_raw.get("explicit_endpoints", []),
-        endpoints_by_service=testql_raw.get("endpoints_by_service", {})
+        endpoints_by_service=testql_raw.get("endpoints_by_service", {}),
+        hardware_usb_modules=testql_raw.get("hardware_usb_modules", {}),
     )
 
 
@@ -473,6 +476,7 @@ def save_config(config: WupConfig, output_path: Path):
             "service_base_urls": config.testql.service_base_urls,
             "explicit_endpoints": config.testql.explicit_endpoints,
             "endpoints_by_service": config.testql.endpoints_by_service,
+            "hardware_usb_modules": config.testql.hardware_usb_modules,
         },
         "visual_diff": {
             "enabled": config.visual_diff.enabled,
@@ -531,11 +535,13 @@ def save_config(config: WupConfig, output_path: Path):
             "paths": svc.paths,
             "quick_tests": {
                 "scope": svc.quick_tests.scope,
-                "max_endpoints": svc.quick_tests.max_endpoints
+                "max_endpoints": svc.quick_tests.max_endpoints,
+                **({"scenario": svc.quick_tests.scenario} if svc.quick_tests.scenario else {}),
             },
             "detail_tests": {
                 "scope": svc.detail_tests.scope,
-                "max_endpoints": svc.detail_tests.max_endpoints
+                "max_endpoints": svc.detail_tests.max_endpoints,
+                **({"scenario": svc.detail_tests.scenario} if svc.detail_tests.scenario else {}),
             },
             "cpu_throttle": svc.cpu_throttle,
             "notify": {

{wup-0.2.64 → wup-0.2.65}/wup/models/config.py

@@ -23,6 +23,7 @@ class ServiceTestConfig:
     """Test configuration for a service (quick or detail)."""
     scope: str = "all"  # "read", "write", "auth", "all", or comma-separated
     max_endpoints: int = 10
+    scenario: str = ""  # Optional pinned scenario path (relative to project root or scenarios_dir)
 
 
 @dataclass
@@ -74,6 +75,8 @@ class TestQLConfig:
     service_base_urls: Dict[str, str] = field(default_factory=dict)  # optional per-service override
     explicit_endpoints: List[str] = field(default_factory=list)
     endpoints_by_service: Dict[str, List[str]] = field(default_factory=dict)
+    # USB kit modules: expand HTTP API probes from module_ids (no /dev/* paths).
+    hardware_usb_modules: Dict[str, object] = field(default_factory=dict)
 
 
 @dataclass

{wup-0.2.64 → wup-0.2.65}/wup/monitoring_manifest.py

@@ -105,15 +105,22 @@ def discover_docker_compose_services(project_root: Path) -> List[DockerComposeSe
     return discovered_services
 
 
+_BASH_DEFAULT_RE = re.compile(r"\$\{[^}]*:-(\d+)\}")
+
+
 def _host_port_from_mapping(mapping: str) -> Optional[int]:
-    """Extract host port from '8100:8100' or '8100:80'."""
+    """Extract host port from '8100:8100', '8100:80', or '${VAR:-8100}:8100'."""
     text = mapping.strip().strip("'\"")
     if ":" not in text:
         return None
-    host = text.split(":")[0]
+    # Split on last colon: ${VAR:-default}:container contains internal colons
+    host = text.rsplit(":", 1)[0]
     try:
         return int(host)
     except ValueError:
+        m = _BASH_DEFAULT_RE.search(host)
+        if m:
+            return int(m.group(1))
         return None
 
 
@@ -124,16 +131,34 @@ def _map_docker_to_wup_service(
     name = docker.compose_service.lower()
     container = docker.container_name.lower()
 
-    rules = [
+    def _connect_backend_target() -> Optional[str]:
+        if not (name.endswith("-backend") and "connect" in name):
+            return None
+        specific = name.replace("-backend", "")
+        if specific in wup_services:
+            return specific
+        if "backend" in wup_services:
+            return "backend"
+        return None
+
+    rules: list[tuple[Any, Any]] = [
         (lambda: "firmware" in name or "firmware" in container, "firmware"),
         (lambda: name == "frontend" or "frontend" in container, "frontend"),
         (lambda: name == "backend" or container == "identification-backend", "backend"),
-        (lambda: name.endswith("-backend") and "connect" in name, name.replace("-backend", "")),
+        (lambda: "connect-scenario" in name and "backend" not in name and "backend" in wup_services, "backend"),
     ]
     for predicate, target in rules:
-        if predicate() and target in wup_services:
+        if callable(target):
+            resolved = target()
+            if predicate() and resolved and resolved in wup_services:
+                return resolved
+        elif predicate() and target in wup_services:
             return target
 
+    connect_target = _connect_backend_target()
+    if connect_target:
+        return connect_target
+
     for svc in wup_services:
         token = svc.lower().replace("_", "-")
         if token in name or token in container:

{wup-0.2.64 → wup-0.2.65}/wup/testing/handlers/health_handlers.py

@@ -57,13 +57,17 @@ class ServiceHealthProjection:
 
         # Notify external systems
         if event.status in {"down", "degraded"}:
-            self.planfile_reporter.report_failure(
-                service=event.service,
-                status=event.status,
-                stage=event.stage,
-                message=event.message,
-                track_file=event.track_file,
-            )
+            # Non-strict fleet health uses status=degraded for optional probe gaps; do not spam planfile.
+            if event.stage == "health_scenario" and event.status == "degraded":
+                pass
+            else:
+                self.planfile_reporter.report_failure(
+                    service=event.service,
+                    status=event.status,
+                    stage=event.stage,
+                    message=event.message,
+                    track_file=event.track_file,
+                )
         elif event.status == "up":
             self.planfile_reporter.clear_service_stage(
                 service=event.service, stage=event.stage

{wup-0.2.64 → wup-0.2.65}/wup/testql_monitor.py

@@ -18,8 +18,12 @@ _API_LINE = re.compile(
     r"^\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*,\s*([^\s,]+)(?:\s*,\s*(\d+))?",
     re.MULTILINE,
 )
+_SHELL_CURL_URL = re.compile(
+    r"""^\s*SHELL\s+["']curl\b[^"']*\s(https?://[^\s"']+)""",
+    re.MULTILINE,
+)
 _HEALTH_HINT = re.compile(
-    r"(/health|/healthz|/ready|/live|/status|/openapi\.json|/execution/status|/execution/logs)",
+    r"(/health|/healthz|/ready|/live|/status|/openapi\.json)",
     re.IGNORECASE,
 )
 # Connect module APIs live on :8103+ — not valid health probes on frontend proxy :8100
@@ -76,13 +80,21 @@ def _parse_api_lines(content: str, source: str) -> List[ProbeTarget]:
     return probes
 
 
+def _parse_shell_curl_lines(content: str, source: str) -> List[ProbeTarget]:
+    probes: List[ProbeTarget] = []
+    for url in _SHELL_CURL_URL.findall(content):
+        url = url.strip().rstrip('"\'')
+        probes.append(ProbeTarget(url=url, method="GET", expected_status=200, source=source))
+    return probes
+
+
 def parse_scenario_probes(scenario_path: Path) -> List[ProbeTarget]:
     """Extract API probe rows from a TestQL TOON scenario file."""
     try:
         content = scenario_path.read_text(encoding="utf-8")
     except OSError:
         return []
-    return _parse_api_lines(content, source=str(scenario_path))
+    return _parse_api_lines(content, source=str(scenario_path)) + _parse_shell_curl_lines(content, source=str(scenario_path))
 
 
 def _extract_base_url(data: Dict[str, Any]) -> str:
@@ -137,23 +149,10 @@ def _connect_module_api_on_frontend_proxy(probe: ProbeTarget) -> bool:
     return any(path.startswith(prefix) for prefix in _CONNECT_API_PREFIXES)
 
 
-def _firmware_plugin_probe_without_runtime(probe: ProbeTarget) -> bool:
-    """Plugin health on :8202 requires loaded plugins — skip for bare simulator live probes."""
-    if not probe.url.startswith("http"):
-        return False
-    parsed = urlparse(probe.url)
-    if parsed.port != 8202:
-        return False
-    path = (parsed.path or "").lower()
-    return "/api/v1/plugins/" in path and path.endswith("/health")
-
-
 def is_monitoring_probe(probe: ProbeTarget) -> bool:
     """True when this endpoint should be used for live service health checks."""
     if _connect_module_api_on_frontend_proxy(probe):
         return False
-    if _firmware_plugin_probe_without_runtime(probe):
-        return False
     if probe.url.startswith("http"):
         path = urlparse(probe.url).path or probe.url
     else:
@@ -161,6 +160,13 @@ def is_monitoring_probe(probe: ProbeTarget) -> bool:
     path_lower = path.lower()
     if any(path_lower.startswith(prefix) for prefix in _CONNECT_API_PREFIXES):
         return False
+    if "/execution/" in path_lower:
+        return False
+    # Hardware USB kit: enumerate adapters via OqlOS/proxy HTTP (not serial port paths).
+    if "/hardware/identify" in path_lower:
+        return True
+    if "/peripheral-status/" in path_lower:
+        return True
     if _HEALTH_HINT.search(path):
         return True
     # Short GET smoke paths (/, /health) without heavy write APIs
@@ -228,7 +234,10 @@ def _assign_by_connect_backend(
 
 
 def _assign_http_probe(
-    probe: ProbeTarget, services: Sequence[ServiceConfig], path_lower: str
+    probe: ProbeTarget,
+    services: Sequence[ServiceConfig],
+    path_lower: str,
+    port_map: Optional[Dict[int, str]] = None,
 ) -> Optional[str]:
     """Map an HTTP probe to a service based on port and path."""
     parsed = urlparse(probe.url)
@@ -240,7 +249,16 @@ def _assign_http_probe(
         return _assign_by_port_8202(services)
     if port == 8100:
         return _assign_by_port_8100(services, path_lower)
-    
+
+    if port_map and port in port_map:
+        preferred = port_map[port]
+        result = _find_service_by_name(services, preferred)
+        if result:
+            return result
+        if preferred == "backend":
+            return _find_service_by_name(services, "backend")
+        return None
+
     return _assign_by_connect_backend(services, path_lower)
 
 
@@ -283,13 +301,17 @@ def _assign_by_path_prefix(
     return None
 
 
-def assign_probe_to_service(probe: ProbeTarget, services: Sequence[ServiceConfig]) -> Optional[str]:
+def assign_probe_to_service(
+    probe: ProbeTarget,
+    services: Sequence[ServiceConfig],
+    port_map: Optional[Dict[int, str]] = None,
+) -> Optional[str]:
     """Map a probe URL/path to a configured WUP service name."""
     path = urlparse(probe.url).path if probe.url.startswith("http") else probe.url
     path_lower = path.lower()
 
     if probe.url.startswith("http"):
-        result = _assign_http_probe(probe, services, path_lower)
+        result = _assign_http_probe(probe, services, path_lower, port_map=port_map)
         if result:
             return result
         return None
@@ -333,6 +355,67 @@ class TestQLMonitor:
         self.scenarios_dir = project_root / (tq.scenario_dir or "testql-scenarios")
         self.discovery = TestQLEndpointDiscovery(str(self.scenarios_dir))
 
+    def _load_dot_env(self) -> Dict[str, str]:
+        """Read key=value pairs from .env in project root (best-effort)."""
+        env: Dict[str, str] = {}
+        dot_env = self.project_root / ".env"
+        if not dot_env.exists():
+            return env
+        try:
+            for line in dot_env.read_text(encoding="utf-8").splitlines():
+                line = line.strip()
+                if not line or line.startswith("#") or "=" not in line:
+                    continue
+                key, _, value = line.partition("=")
+                env[key.strip()] = value.strip().strip("'\"")
+        except OSError:
+            pass
+        return env
+
+    def _build_port_map(self) -> Dict[int, str]:
+        """Build host-port → wup service name map from docker-compose files + .env."""
+        from .monitoring_manifest import (
+            _map_docker_to_wup_service,
+            discover_docker_compose_services,
+        )
+
+        dot_env = self._load_dot_env()
+
+        def resolve_port(raw: str) -> Optional[int]:
+            """Resolve host port from mapping, substituting .env vars before defaults."""
+            text = raw.strip().strip("'\"")
+            if ":" not in text:
+                return None
+            # Split on the LAST colon to correctly separate host:container
+            # (${VAR:-default} syntax contains colons internally)
+            host_part = text.rsplit(":", 1)[0]
+            try:
+                return int(host_part)
+            except ValueError:
+                pass
+            # Replace ${VAR:-default} using .env then fall back to default
+            def _replace(m: "re.Match[str]") -> str:
+                inner = m.group(0)[2:-1]  # strip ${ and }
+                var, _, default = inner.partition(":-")
+                return dot_env.get(var, default)
+            resolved = re.sub(r"\$\{[^}]+\}", _replace, host_part)
+            try:
+                return int(resolved)
+            except ValueError:
+                return None
+
+        wup_names = [s.name for s in self.config.services]
+        port_map: Dict[int, str] = {}
+        for docker_svc in discover_docker_compose_services(self.project_root):
+            mapped = _map_docker_to_wup_service(docker_svc, wup_names)
+            if not mapped:
+                continue
+            for raw_port in docker_svc.host_ports:
+                host_port = resolve_port(raw_port)
+                if host_port:
+                    port_map[host_port] = mapped
+        return port_map
+
     def _service_map_paths(self) -> List[Path]:
         globs = self.config.testql.service_map_globs or []
         paths: List[Path] = []
@@ -340,11 +423,69 @@ class TestQLMonitor:
             paths.extend(sorted(self.project_root.glob(pattern)))
         return paths
 
+    def _add_hardware_usb_module_endpoints(self, accumulator: "_ProbeAccumulator") -> None:
+        """Expand hardware_usb_modules from wup.yaml into OqlOS + proxy API probes."""
+        raw = getattr(self.config.testql, "hardware_usb_modules", None) or {}
+        if not isinstance(raw, dict) or not raw:
+            return
+        oqlos = str(raw.get("oqlos_url") or "http://localhost:8202").rstrip("/")
+        proxy = str(raw.get("proxy_url") or "http://localhost:8096").rstrip("/")
+        module_ids = raw.get("module_ids") or []
+        if not isinstance(module_ids, list):
+            return
+
+        catalog: List[Tuple[str, ProbeTarget]] = [
+            (
+                "firmware",
+                ProbeTarget(
+                    url=f"{oqlos}/api/v1/hardware/identify",
+                    source="wup.yaml:hardware_usb_modules",
+                ),
+            ),
+            (
+                "connect-scenario",
+                ProbeTarget(
+                    url=f"{proxy}/api/v3/hardware/identify",
+                    source="wup.yaml:hardware_usb_modules",
+                ),
+            ),
+        ]
+        for module_id in module_ids:
+            mid = str(module_id).strip()
+            if not mid:
+                continue
+            catalog.append(
+                (
+                    "firmware",
+                    ProbeTarget(
+                        url=f"{oqlos}/api/v1/plugins/{mid}/health",
+                        source="wup.yaml:hardware_usb_modules:plugin_health",
+                    ),
+                )
+            )
+            catalog.append(
+                (
+                    "connect-scenario",
+                    ProbeTarget(
+                        url=f"{proxy}/api/v3/hardware/peripheral-status/{mid}",
+                        source="wup.yaml:hardware_usb_modules",
+                    ),
+                )
+            )
+
+        for service, probe in catalog:
+            if not is_monitoring_probe(probe):
+                continue
+            if probe.source.endswith(":plugin_health"):
+                continue
+            accumulator.add(service, probe)
+
     def _add_config_endpoints(
         self,
         accumulator: "_ProbeAccumulator",
     ) -> None:
         """Add config-declared endpoints (paths or full URLs) per-service base URL."""
+        self._add_hardware_usb_module_endpoints(accumulator)
         for svc_name, paths in (self.config.testql.endpoints_by_service or {}).items():
             base = self._resolve_base_url_for_service(svc_name)
             for path in paths:
@@ -371,26 +512,28 @@ class TestQLMonitor:
     def _add_scenario_probes(
         self,
         accumulator: "_ProbeAccumulator",
+        port_map: Optional[Dict[int, str]] = None,
     ) -> None:
         """Add TestQL scenario probes mapped to services."""
         for scenario in self.discovery.discover_scenarios():
             for probe in parse_scenario_probes(scenario):
                 if not is_monitoring_probe(probe):
                     continue
-                assigned = assign_probe_to_service(probe, self.config.services)
+                assigned = assign_probe_to_service(probe, self.config.services, port_map=port_map)
                 if assigned:
                     accumulator.add(assigned, probe)
 
     def _add_service_map_probes(
         self,
         accumulator: "_ProbeAccumulator",
+        port_map: Optional[Dict[int, str]] = None,
     ) -> None:
         """Add service-map TOON/YAML probes mapped to services."""
         for map_path in self._service_map_paths():
             for probe in parse_service_map_probes(map_path):
                 if not is_monitoring_probe(probe):
                     continue
-                assigned = assign_probe_to_service(probe, self.config.services)
+                assigned = assign_probe_to_service(probe, self.config.services, port_map=port_map)
                 if assigned:
                     accumulator.add(assigned, probe)
 
@@ -401,8 +544,9 @@ class TestQLMonitor:
         self._add_config_endpoints(accumulator)
 
         if self.config.testql.endpoint_discovery:
-            self._add_scenario_probes(accumulator)
-            self._add_service_map_probes(accumulator)
+            port_map = self._build_port_map()
+            self._add_scenario_probes(accumulator, port_map=port_map)
+            self._add_service_map_probes(accumulator, port_map=port_map)
 
         return accumulator.by_service
 
@@ -449,16 +593,37 @@ class TestQLMonitor:
         return [p for p in merged if p.url.startswith("http://") or p.url.startswith("https://")]
 
     @staticmethod
-    def _sort_probes_for_live(probes: Sequence[ProbeTarget]) -> List[ProbeTarget]:
-        """Prefer wup.yaml endpoints before scenario discovery for pass/fail."""
+    def _sort_probes_for_live(
+        probes: Sequence[ProbeTarget],
+        service: str = "",
+    ) -> List[ProbeTarget]:
+        """Prefer wup.yaml endpoints, then /health URLs, before other scenario probes."""
 
-        def rank(probe: ProbeTarget) -> Tuple[int, str]:
+        def rank(probe: ProbeTarget) -> Tuple[int, int, int, str]:
             source = probe.source or ""
-            if source.startswith("wup.yaml:endpoints_by_service"):
-                return (0, probe.url)
-            if source.startswith("wup.yaml:explicit_endpoints"):
-                return (1, probe.url)
-            return (2, probe.url)
+            path = (urlparse(probe.url).path or probe.url).lower()
+            healthish = "/health" in path and "/execution/" not in path
+            if source.startswith("wup.yaml:hardware_usb_modules"):
+                tier = 0
+            elif source.startswith("wup.yaml:endpoints_by_service"):
+                tier = 1
+            elif source.startswith("wup.yaml:explicit_endpoints"):
+                tier = 2
+            else:
+                tier = 3
+            port = urlparse(probe.url).port if probe.url.startswith("http") else None
+            # Bench uses host OqlOS on :8202; :8100/firmware proxy often 503 without full make dev.
+            port_rank = 0
+            if service == "firmware" and port is not None:
+                if port == 8202:
+                    port_rank = 0
+                elif port == 8100:
+                    port_rank = 1
+                else:
+                    port_rank = 2
+            health_rank = 0 if healthish else 1
+            # Prefer /health liveness before heavier USB identify (tier-0 config).
+            return (health_rank, tier, port_rank, probe.url)
 
         return sorted(probes, key=rank)
 
@@ -475,7 +640,7 @@ class TestQLMonitor:
             return True, ""
 
         failed: List[str] = []
-        ordered = self._sort_probes_for_live(probes)
+        ordered = self._sort_probes_for_live(probes, service=service)
         for probe in ordered[:max_count]:
             ok, detail = probe.probe(timeout_s=timeout_s)
             if ok:

{wup-0.2.64 → wup-0.2.65}/wup/testql_watcher.py

@@ -323,6 +323,35 @@ class TestQLWatcher(WupWatcher):
                 return [candidate]
         return []
 
+    def _resolve_scenario_path(self, scenario: str) -> Optional[Path]:
+        """Resolve a pinned scenario path relative to scenarios_dir or project root."""
+        name = (scenario or "").strip()
+        if not name:
+            return None
+        path = Path(name)
+        if path.is_absolute() and path.exists():
+            return path
+        for base in (self.scenarios_dir, self.project_root):
+            candidate = base / name
+            if candidate.exists():
+                return candidate
+        return None
+
+    @staticmethod
+    def _testql_trailing_json_ok(result: subprocess.CompletedProcess) -> bool:
+        """True when TestQL --output json ends with ok:true and zero failed steps."""
+        blob = (result.stdout or "").strip()
+        start = blob.rfind("{")
+        if start < 0:
+            return False
+        try:
+            data = json.loads(blob[start:])
+        except json.JSONDecodeError:
+            return False
+        if not isinstance(data, dict):
+            return False
+        return data.get("ok") is True and int(data.get("failed", 1)) == 0
+
     @staticmethod
     def _health_summary_all_passed(summary: str) -> bool:
         """True when summary looks like N/N passed with zero failures."""
@@ -341,6 +370,12 @@ class TestQLWatcher(WupWatcher):
         limit = (svc_config.quick_tests.max_endpoints
                  if svc_config and svc_config.quick_tests else self.quick_limit)
 
+        pinned = svc_config.quick_tests.scenario if svc_config and svc_config.quick_tests else ""
+        if pinned:
+            resolved = self._resolve_scenario_path(pinned)
+            if resolved:
+                return [resolved][:limit]
+
         # Filter scenarios by service type
         svc_type = svc_config.type if svc_config else "auto"
         if getattr(self.config.testql, "quick_smoke_only", False):
@@ -350,6 +385,15 @@ class TestQLWatcher(WupWatcher):
 
         filtered_scenarios = self._filter_scenarios_by_type(all_scenarios, svc_type)
 
+        # connect-workshop / auto-api-connect-scenario-* also match token "connect".
+        if service == "connect-scenario":
+            filtered_scenarios = [
+                s
+                for s in filtered_scenarios
+                if s.name.lower().startswith("connect-scenario-wup-")
+                or s.name.lower().startswith("connect-scenario-modbus-")
+            ]
+
         selected = self._get_scored_scenarios(filtered_scenarios, self._tokenize_service(service), limit)
         if selected:
             return selected
@@ -623,7 +667,8 @@ class TestQLWatcher(WupWatcher):
         failed = data.get("failed")
         if not isinstance(passed, int) or not isinstance(failed, int):
             return None
-        total = passed + failed
+        steps = data.get("steps")
+        total = steps if isinstance(steps, int) and steps > 0 else passed + failed
         errors = data.get("errors") or []
         hint = f" — {errors[0]}" if errors else ""
         return f"{passed}/{total} passed, {failed} failed{hint}"
@@ -688,7 +733,11 @@ class TestQLWatcher(WupWatcher):
         args = ["run", str(scenario_path), "--output", "json", *self.testql_extra_args]
         result = self._run_testql(args, timeout=max(int(self._quick_probe_timeout()), 120))
         summary = self._summarize_health_scenario_failure(result)
-        if result.returncode == 0 or self._health_summary_all_passed(summary):
+        if (
+            result.returncode == 0
+            or self._testql_trailing_json_ok(result)
+            or self._health_summary_all_passed(summary)
+        ):
             self._record_health_transition(
                 service=fleet,
                 status="up",

{wup-0.2.64 → wup-0.2.65/wup.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wup
-Version: 0.2.64
+Version: 0.2.65
 Summary: WUP (What's Up) - Intelligent file watcher for regression testing in large projects
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -31,17 +31,17 @@ Dynamic: license-file
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.64-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$3.49-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-31.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.65-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$3.50-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-33.2h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $3.4940 (76 commits)
-- 👤 **Human dev:** ~$3168 (31.7h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $3.4955 (77 commits)
+- 👤 **Human dev:** ~$3318 (33.2h @ $100/h, 30min dedup)
 
-Generated on 2026-05-27 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-06-03 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.64-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.65-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.