qaas-python 0.2.0__tar.gz → 0.2.1__tar.gz

{qaas_python-0.2.0 → qaas_python-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: qaas-python
-Version: 0.2.0
+Version: 0.2.1
 Summary: A multi-agent QA system: finds real defects, reproduces them, files tickets, fixes them, and proves the fix
 Project-URL: Homepage, https://github.com/allaabdella2-us/qa-multi-agent-system
 Project-URL: Repository, https://github.com/allaabdella2-us/qa-multi-agent-system

{qaas_python-0.2.0 → qaas_python-0.2.1}/pyproject.toml

@@ -2,7 +2,7 @@
 # Distribution name is `qaas-python` (`qaas` was taken); the import package and
 # the CLI are both `qaas`.
 name = "qaas-python"
-version = "0.2.0"
+version = "0.2.1"
 description = "A multi-agent QA system: finds real defects, reproduces them, files tickets, fixes them, and proves the fix"
 readme = "README.md"
 license = "MIT"

{qaas_python-0.2.0 → qaas_python-0.2.1}/src/qaas/cli.py

@@ -449,16 +449,14 @@ def doctor(
 
 
 def _agent_usable(spec, caps: dict[str, bool]) -> bool:
-    """Whether an agent can do useful work with the capabilities available.
+    """Delegates to `target.agent_usable`, which the conductor also uses.
 
-    SURFACE without a browser-reachable UI has nothing to do; the rest can all
-    contribute from static analysis alone, at lower confidence.
+    Two copies of this rule meant `qaas doctor` could report an agent unusable
+    while a run dispatched it anyway.
     """
-    if spec.name == "SURFACE":
-        return caps["live_ui"]
-    if spec.name == "PROOF":
-        return caps["live_api"] or caps["static_analysis"]
-    return True
+    from qaas.target import agent_usable
+
+    return agent_usable(spec.name, caps)
 
 
 @app.command()

{qaas_python-0.2.0 → qaas_python-0.2.1}/src/qaas/conductor.py

@@ -25,6 +25,7 @@ from typing import Any, Callable
 
 from qaas.config import AgentSpec, SystemConfig, load_config
 from qaas.envelope import DefectEnvelope
+from qaas.target import agent_usable
 from qaas.mcp.context import ToolContext
 from qaas.runner import RunOutcome, run_agent
 from qaas.store import RunStore, SystemMapStore
@@ -269,6 +270,27 @@ class Conductor:
     async def _phase_discover(self, specs, store, budget, report, mode, map_version) -> None:
         """Discovery agents are independent. Run them concurrently, bounded."""
         discovery = [s for name, s in specs.items() if s.layer == "discovery"]
+
+        # Skip agents this target cannot support. `qaas doctor` has always
+        # reported these ("agents that cannot: SURFACE"), but nothing acted on
+        # it, so a run against a target with no reachable UI would still
+        # dispatch SURFACE and spend its entire budget hunting a browser that
+        # was never there. Being told an agent cannot work and then watching it
+        # run is worse than not being told.
+        profile = getattr(self.config, "profile", None)
+        if profile is not None:
+            caps = profile.capabilities()
+            unusable = [s for s in discovery if not agent_usable(s.name, caps)]
+            if unusable:
+                discovery = [s for s in discovery if s not in unusable]
+                store.log(
+                    "skipped",
+                    reason="target cannot support these agents",
+                    agents=[s.name for s in unusable],
+                )
+                for spec in unusable:
+                    self._emit("skipped", agent=spec.name, reason="target lacks the capability")
+
         if not discovery:
             return
 

{qaas_python-0.2.0 → qaas_python-0.2.1}/src/qaas/target.py

@@ -259,3 +259,21 @@ def load_target(name: str, targets_dir: Path | str = "config/targets") -> Target
 # directory is the bug that hid `<project>/config/targets/` the moment anything
 # wrote into `.qaas/config/targets/`; profiles layer across every config
 # directory, and `config.target_files(dirs)` is the one place that knows it.
+
+
+def agent_usable(agent_name: str, caps: dict[str, bool]) -> bool:
+    """Whether an agent can do useful work with the capabilities available.
+
+    Lives here, beside `capabilities()`, because it has two callers that must
+    agree: `qaas doctor` reports it, and the conductor acts on it. They did not
+    agree for a while -- doctor would say "agents that cannot: SURFACE" and then
+    a run would dispatch SURFACE anyway and spend its whole budget looking for a
+    browser that was never there. Being told an agent cannot work and then
+    watching it run is worse than not being told.
+
+    Everything except SURFACE can contribute from static analysis alone, at
+    lower confidence. SURFACE without a reachable UI has nothing to do at all.
+    """
+    if agent_name == "SURFACE":
+        return caps.get("live_ui", False)
+    return True

{qaas_python-0.2.0 → qaas_python-0.2.1}/tests/test_conductor.py

@@ -561,3 +561,23 @@ async def test_a_new_discovery_agent_runs_without_a_hand_written_task(cfg, tmp_p
     report = await make_conductor(cfg, tmp_path).run("nightly")
     ran = {name for name, _ in calls}
     assert {"VAULT", "WARDEN"} <= ran, f"a config-only agent was skipped: {sorted(ran)}"
+
+
+async def test_an_agent_the_target_cannot_support_is_not_dispatched(cfg, tmp_path, fake_agents):
+    """`qaas doctor` has always reported "agents that cannot: SURFACE" for a
+    target with no reachable UI. Nothing acted on it: the run dispatched SURFACE
+    anyway and spent its budget looking for a browser that was never there.
+
+    Being told an agent cannot work and then watching it run is worse than not
+    being told, which is why this asserts the dispatch, not the report.
+    """
+    calls, behaviour = fake_agents
+    from qaas.target import Environment, TargetProfile
+
+    static_only = TargetProfile(name="static", root=".", environment=Environment(mode="none"))
+    cfg2 = cfg.model_copy(update={"profile": static_only})
+
+    await make_conductor(cfg2, tmp_path).run("pr-check")
+    ran = {name for name, _ in calls}
+    assert "SURFACE" not in ran, "dispatched SURFACE at a target with no UI"
+    assert "CONDUIT" in ran, "static analysis agents must still run"