code-coordinator 0.5.553__tar.gz → 0.5.555__tar.gz

{code_coordinator-0.5.553 → code_coordinator-0.5.555}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.553
+Version: 0.5.555
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.553 → code_coordinator-0.5.555}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.553
+Version: 0.5.555
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.553 → code_coordinator-0.5.555}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.553",
+  "tag": "0.5.555",
   "distance": 0,
-  "node": "g08b8bc7ce4b5def5fdf426d91f30704832a6c88b",
+  "node": "gac0862387979879fadb0cebb83a122d18f77e3c7",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-01"

{code_coordinator-0.5.553 → code_coordinator-0.5.555}/coord/acceptance.py

@@ -957,13 +957,22 @@ def build_verdict(
     passed = sum(1 for t in tests if t.get("status") == "pass")
     failed = sum(1 for t in tests if t.get("status") == "fail")
     skipped = sum(1 for t in tests if t.get("status") == "skip")
+    # #3510: a session precheck (win-native/mac-native/gtk-native) that
+    # finds a locked/absent GUI reports a distinct "unavailable" status,
+    # not "fail" — it's an environment condition, not an app bug. It must
+    # still block `green`/`ci_green`: an unconfirmed result is not a pass
+    # (epic #2096's "a gate must be able to fail" / "unconfirmed success
+    # is a defect"). Counted and reported separately so callers can tell
+    # "the app is broken" apart from "go unlock the host".
+    unavailable = sum(1 for t in tests if t.get("status") == "unavailable")
     payload: dict[str, Any] = {
         "scope": scope,
         "total": len(tests),
         "passed": passed,
         "failed": failed,
         "skipped": skipped,
-        "green": failed == 0 and len(tests) > 0,
+        "unavailable": unavailable,
+        "green": failed == 0 and unavailable == 0 and len(tests) > 0,
         "tests": tests,
     }
     if issue_number is not None:
@@ -1038,12 +1047,18 @@ def apply_expected_red(verdict: dict[str, Any], expected_red_ids: "set[str]") ->
     real_failures = sum(
         1 for t in tests if t.get("status") == "fail" and t["id"] not in expected_red_ids
     )
+    # #3510: an `unavailable` entry (locked/absent GUI session) is never
+    # expected-red-eligible — it isn't a test failure to excuse, it's a
+    # precheck that never ran anything — so it always counts against
+    # `ci_green` just like it does against `green` in build_verdict.
+    unavailable = verdict.get("unavailable", 0)
     verdict["unexpected_green"] = unexpected_green
     verdict["expected_red_still_red"] = expected_red_still_red
     verdict["missing_expected_red_ids"] = missing_expected_red_ids
     verdict["ci_green"] = (
         len(tests) > 0
         and real_failures == 0
+        and unavailable == 0
         and not unexpected_green
         and not missing_expected_red_ids
     )

{code_coordinator-0.5.553 → code_coordinator-0.5.555}/coord/acceptance_drivers.py

@@ -782,7 +782,15 @@ def _run_win_native(run_command: str, cwd: str, entrypoint: str, *, timeout: int
     except WinNativeRuntimeError as e:
         raise DriverError(f"win-native driver could not run: {e}") from e
 
-    exit_code = 0 if tests and all(t.get("status") != "fail" for t in tests) else 1
+    # #3510: a locked/absent interactive session reports a distinct
+    # "unavailable" status (coord.win_native_driver's session precheck),
+    # not "fail" — it must still fail this exit code rather than read as a
+    # silent pass. An unconfirmed result is not a pass.
+    exit_code = (
+        0
+        if tests and all(t.get("status") not in ("fail", "unavailable") for t in tests)
+        else 1
+    )
     raw_output = "\n".join(
         f"{t.get('status')}: {t.get('id')} {t.get('message', '')}".rstrip()
         for t in tests
@@ -843,7 +851,14 @@ def _run_mac_native(run_command: str, cwd: str, entrypoint: str, *, timeout: int
     except MacNativeRuntimeError as e:
         raise DriverError(f"mac-native driver could not run: {e}") from e
 
-    exit_code = 0 if tests and all(t.get("status") != "fail" for t in tests) else 1
+    # #3510: a locked/absent GUI session reports a distinct "unavailable"
+    # status (coord.mac_native_driver's session precheck), not "fail" —
+    # it must still fail this exit code rather than read as a silent pass.
+    exit_code = (
+        0
+        if tests and all(t.get("status") not in ("fail", "unavailable") for t in tests)
+        else 1
+    )
     raw_output = "\n".join(
         f"{t.get('status')}: {t.get('id')} {t.get('message', '')}".rstrip()
         for t in tests
@@ -904,7 +919,15 @@ def _run_gtk_native(run_command: str, cwd: str, entrypoint: str, *, timeout: int
     except GtkNativeRuntimeError as e:
         raise DriverError(f"gtk-native driver could not run: {e}") from e
 
-    exit_code = 0 if tests and all(t.get("status") != "fail" for t in tests) else 1
+    # #3510: a missing $DISPLAY/$WAYLAND_DISPLAY reports a distinct
+    # "unavailable" status (coord.gtk_native_driver's session precheck),
+    # not "fail" — it must still fail this exit code rather than read as a
+    # silent pass.
+    exit_code = (
+        0
+        if tests and all(t.get("status") not in ("fail", "unavailable") for t in tests)
+        else 1
+    )
     raw_output = "\n".join(
         f"{t.get('status')}: {t.get('id')} {t.get('message', '')}".rstrip()
         for t in tests

{code_coordinator-0.5.553 → code_coordinator-0.5.555}/coord/agent.py

@@ -3795,6 +3795,39 @@ internal-only change (CLAUDE.md's existing exemption), say so explicitly \
 in your final message instead — that already satisfies the reviewer, no \
 test required.
 
+#3502: this ONLY applies to `type="work"` assignments — the ones whose \
+merge auto-closes the linked issue (`CLOSES_ISSUE_TYPES` in \
+`coord/models.py`). If you were dispatched as `mock-author`, \
+`test-author`, or `epic-decompose`, the `issue_number` you were given is \
+a milestone's TRACKING issue, not one your merge closes — this marker is \
+meaningless on those legs and you should omit it. For `type="work"`: your \
+PR merging does NOT automatically mean issue it's for is \
+actually resolved. If merging this PR would make the coordinator \
+auto-close the issue, but you know the issue's own problem is NOT fully \
+fixed — root cause lives in another repo and only a dependent half of \
+the fix landed here, this PR is investigation-only (no production change, \
+or only one hypothesis ruled out), or you only confirmed a symptom \
+without fixing the cause — say so explicitly, right before your \
+SMOKE_TESTS block:
+
+  ISSUE_RESOLUTION: partial — <what remains, in one sentence>
+
+or
+
+  ISSUE_RESOLUTION: investigation — <what you ruled out / what's still \
+unknown>
+
+Omit the line entirely (it defaults to `resolved`, today's behaviour) \
+when this PR genuinely fixes the issue. A drafted-but-unfiled upstream \
+issue — a bullet in a design doc, a TODO comment, a line in a tracking \
+markdown file — is NOT "filed"; only a real GitHub issue number counts, \
+so don't write `partial — see quadraui issue` unless that issue actually \
+exists and you name its number. This is read by the coordinator's merge \
+gate (not posted to GitHub by you — never run `gh` commands): a `partial`/ \
+`investigation` here keeps the issue OPEN after your PR merges, with a \
+comment on the issue quoting what remains, instead of auto-closing work \
+that still has a reported bug live.
+
 #252: before exiting, emit a SMOKE_TESTS block telling the human what to \
 manually verify.  You changed the code; you know what's worth poking.
 

{code_coordinator-0.5.553 → code_coordinator-0.5.555}/coord/bugbash.py

@@ -45,6 +45,20 @@ routing does — a lane only exists when some configured machine actually
 carries the driver's declared ``capability``, so a repo with no capable
 machine for a platform silently gets no lane rather than a lane that can
 never run.
+
+**#3510: an unavailable lane is not a bug finding.** When a win-native/
+mac-native/gtk-native lane's own driver reports a locked or absent GUI
+session (or no usable display), an explorer that sets
+:attr:`ExploreOutcome.unavailable` causes :func:`run_bugbash` to skip that
+lane for the round (:attr:`RoundReport.unavailable_lanes`) rather than
+running the exploration checklist against it or filing any finding from it
+— a locked desktop is an environment condition for the operator to fix,
+not evidence of an app bug. This engine-level behavior is unit-tested
+against a fake explorer in ``tests/test_bugbash.py``; the production
+explorer (:func:`coord.commands.bugbash._dispatch_and_await_lane`) does
+not itself set ``unavailable`` yet — see its own module docstring's
+"KNOWN GAP" note — so a live ``coord bugbash`` run does not currently
+benefit from this skip until that wiring lands.
 """
 
 from __future__ import annotations
@@ -426,12 +440,31 @@ class ExploreOutcome:
     there were findings," the second means "we looked, and there weren't
     any" — :func:`run_bugbash` keeps them distinguishable in
     :attr:`RoundReport.lane_failures` and its termination reason, rather
-    than collapsing both into "zero findings"."""
+    than collapsing both into "zero findings".
+
+    ``unavailable`` is a THIRD, separate outcome (#3510): the lane's own
+    native driver observed a locked/absent GUI session (win-native/
+    mac-native) or no usable display (gtk-native) and ran no exploration at
+    all — a host/environment condition, never a bug finding and never a
+    dispatch/poll failure. An explorer that sets ``unavailable=True`` (as
+    the fake explorers in ``tests/test_bugbash.py`` do, modeling a
+    dispatched worker whose Tier-2 lane result came back
+    ``status="unavailable"`` — see ``coord.win_native_driver``'s/
+    ``coord.mac_native_driver``'s/``coord.gtk_native_driver``'s own
+    precheck) causes :func:`run_bugbash` to skip that lane for the round —
+    recording it in :attr:`RoundReport.unavailable_lanes` instead of
+    :attr:`RoundReport.lane_failures` — and never file findings from it
+    this round, even defensively, regardless of what ``findings`` carries.
+    The production explorer,
+    :func:`coord.commands.bugbash._dispatch_and_await_lane`, does not yet
+    set this flag (tracked as a KNOWN GAP in that module's docstring) —
+    today this is exercised only at the engine/unit-test level."""
 
     findings: tuple[Finding, ...] = ()
     cost: float = 0.0
     notes: str = ""
     ok: bool = True
+    unavailable: bool = False
 
 
 #: ``(lane, round_num) -> ExploreOutcome`` — "go run this lane's
@@ -628,6 +661,16 @@ class RoundReport:
     #: a lane skipped for having blown its per-lane cost cap was never
     #: asked a question this round, so it can't have failed to answer one).
     lane_failures: dict[str, str] = field(default_factory=dict)
+    #: ``{platform: notes}`` for every lane explored this round whose
+    #: :attr:`ExploreOutcome.unavailable` was ``True`` (#3510) — a locked or
+    #: absent GUI session (win-native/mac-native) or no usable display
+    #: (gtk-native). Distinct from :attr:`lane_failures`: this is a verified
+    #: observation (the native driver's own session precheck ran and
+    #: reported it), not a dispatch/poll/log failure — but it is ALSO not a
+    #: verified "ran the checklist and found nothing" either, so it is
+    #: tracked separately rather than folded into either bucket. No
+    #: findings are ever filed from a lane recorded here this round.
+    unavailable_lanes: dict[str, str] = field(default_factory=dict)
 
     @property
     def explored_lanes(self) -> set[str]:
@@ -643,10 +686,27 @@ class RoundReport:
         not a clean pass" signal (#2096). A round with nothing explored at
         all (e.g. every lane skipped on its cost cap) is NOT reported as
         "all failed" — there is nothing to distrust, just nothing that
-        ran."""
+        ran. Does NOT count an ``unavailable`` lane as failed — see
+        :attr:`all_explored_lanes_unavailable_or_failed` for the combined
+        check."""
         explored = self.explored_lanes
         return bool(explored) and explored <= set(self.lane_failures)
 
+    @property
+    def all_explored_lanes_unavailable_or_failed(self) -> bool:
+        """``True`` when every lane explored this round either failed to
+        dispatch/poll/log OR reported its GUI session/display unavailable
+        (#3510) — i.e. NONE of them actually ran the exploration checklist.
+        Used by :func:`run_bugbash` to pick the ``"lanes_unavailable"``
+        termination reason over a false ``"zero_findings"`` clean-pass read
+        when every lane this round was simply locked/absent rather than
+        genuinely explored (#2096: zero findings is only a clean pass when
+        something was actually observed to run)."""
+        explored = self.explored_lanes
+        return bool(explored) and explored <= (
+            set(self.lane_failures) | set(self.unavailable_lanes)
+        )
+
 
 @dataclass
 class BugbashReport:
@@ -677,6 +737,15 @@ class BugbashReport:
         part of what it observed along the way was unverified (#2096)."""
         return any(r.lane_failures for r in self.rounds)
 
+    @property
+    def any_lane_unavailable(self) -> bool:
+        """``True`` if ANY round recorded a lane as unavailable (#3510) —
+        surfaced regardless of whether it happened to be the terminating
+        round, so an operator glancing at a run that otherwise filed/found
+        plenty still sees that one platform was locked/absent the whole
+        time and needs attention, not a bug report."""
+        return any(r.unavailable_lanes for r in self.rounds)
+
 
 def run_bugbash(
     config: BugbashConfig,
@@ -701,14 +770,24 @@ def run_bugbash(
     ``new_count``/cost, never inferred from "no exception was raised":
 
     - ``"zero_findings"`` — this round's non-duplicate finding count is 0,
-      AND at least one explored lane actually completed
-      (``RoundReport.all_explored_lanes_failed`` is ``False``) — a genuine
-      observed clean pass.
+      AND at least one explored lane actually completed its checklist
+      (neither ``RoundReport.all_explored_lanes_failed`` nor
+      ``RoundReport.all_explored_lanes_unavailable_or_failed`` is ``True``)
+      — a genuine observed clean pass.
     - ``"lane_failure"`` — this round's non-duplicate finding count is ALSO
       0, but every lane explored this round came back ``ok=False``
       (dispatch/poll/log failure) — #2096: a fleet-wide dispatch outage
       must never be reported identically to a clean bugbash pass. Check
       ``BugbashReport.rounds[-1].lane_failures`` for what actually broke.
+    - ``"lanes_unavailable"`` — this round's non-duplicate finding count is
+      ALSO 0, no lane came back a dispatch/poll/log failure, but every lane
+      explored this round reported its GUI session/display unavailable
+      (#3510: locked or absent, e.g. a locked dell64) — a different reason
+      from ``"lane_failure"`` (the explorer DID run and DID get a verified
+      answer, it's just "the host is locked", not "I don't know"), and
+      still not a clean pass either, since nothing was actually exercised
+      against the app. Check ``BugbashReport.rounds[-1].unavailable_lanes``
+      for which host needs unlocking.
     - ``"cost_cap"`` — cumulative cost has reached ``cost_cap_total``.
     - ``"round_cap"`` — ``config.max_rounds`` rounds ran without either of
       the above firing.
@@ -730,6 +809,16 @@ def run_bugbash(
             lane_cost[lane.platform] += outcome.cost
             report.lane_cost[lane.platform] = lane_cost[lane.platform]
             total_cost += outcome.cost
+            if outcome.unavailable:
+                # #3510: a locked/absent GUI session (or missing display)
+                # is a host condition, not a finding — recorded separately
+                # from both a clean pass and a dispatch/poll failure, and
+                # NEVER contributes findings this round, even defensively
+                # if the explorer happened to also hand some back.
+                report.unavailable_lanes[lane.platform] = (
+                    outcome.notes or "lane unavailable — no usable GUI session/display"
+                )
+                continue
             report.findings.extend(outcome.findings)
             if not outcome.ok:
                 # #2096: this lane's "findings" (almost certainly empty) are
@@ -788,11 +877,20 @@ def run_bugbash(
 
         if report.new_count == 0:
             # #2096: "zero findings" is only a genuine clean-pass verdict
-            # when at least one lane was actually verified to have run this
-            # round. A round where every explored lane failed to dispatch,
-            # poll, or fetch its log gets its own distinct reason instead —
-            # see RoundReport.lane_failures for what broke.
-            reason = "lane_failure" if report.all_explored_lanes_failed else "zero_findings"
+            # when at least one lane was actually verified to have RUN THE
+            # CHECKLIST this round. A round where every explored lane failed
+            # to dispatch/poll/fetch its log gets "lane_failure"; a round
+            # where every explored lane instead reported its session/display
+            # unavailable (#3510 — locked or absent, never a dispatch
+            # failure) gets its own distinct "lanes_unavailable" reason, in
+            # that priority order since a round can't be "all failed" AND
+            # "all unavailable" (each lane only sets one of the two).
+            if report.all_explored_lanes_failed:
+                reason = "lane_failure"
+            elif report.all_explored_lanes_unavailable_or_failed:
+                reason = "lanes_unavailable"
+            else:
+                reason = "zero_findings"
             break
         if total_cost >= config.cost_cap_total:
             reason = "cost_cap"

{code_coordinator-0.5.553 → code_coordinator-0.5.555}/coord/commands/release.py

@@ -4551,6 +4551,12 @@ def _load_release_gate_observations(
             passed=_require_bool(entry["passed"], field_name="lanes[].passed"),
             detail=entry.get("detail", ""),
             checked_at=entry.get("checked_at"),
+            # #3510: a locked/absent GUI session or missing display, as
+            # reported by the native driver's own session precheck — never
+            # coerced from a truthy non-bool, same discipline as `passed`.
+            unavailable=_require_bool(
+                entry.get("unavailable", False), field_name="lanes[].unavailable",
+            ),
         )
         for entry in payload.get("lanes", []) or []
     ]
@@ -4576,7 +4582,10 @@ def _gate_verdict_to_dict(verdict: "Any") -> dict[str, Any]:
         "gate_passed": verdict.gate_passed,
         "effective_passed": verdict.effective_passed,
         "steps": [
-            {"name": s.name, "passed": s.passed, "detail": s.detail}
+            {
+                "name": s.name, "passed": s.passed, "detail": s.detail,
+                "unavailable": s.unavailable,
+            }
             for s in verdict.steps
         ],
         "override": None if verdict.override is None else {
@@ -4590,7 +4599,15 @@ def _gate_verdict_to_dict(verdict: "Any") -> dict[str, Any]:
 def _render_gate_verdict(verdict: "Any") -> str:
     lines = [f"release gate: {verdict.repo} @ {verdict.release_sha}"]
     for step in verdict.steps:
-        marker = "PASS" if step.passed else "FAIL"
+        # #3510: a locked/absent GUI session is blocking but is NOT the app
+        # failing — labeled distinctly so an operator knows to unlock the
+        # host rather than go debug the app.
+        if step.unavailable:
+            marker = "UNAVAILABLE"
+        elif step.passed:
+            marker = "PASS"
+        else:
+            marker = "FAIL"
         lines.append(f"  [{marker}] {step.name}: {step.detail}")
     if verdict.override is not None:
         lines.append(