code-coordinator 0.5.587__tar.gz → 0.5.589__tar.gz

{code_coordinator-0.5.587 → code_coordinator-0.5.589}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.587
+Version: 0.5.589
 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.587 → code_coordinator-0.5.589}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.587
+Version: 0.5.589
 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.587 → code_coordinator-0.5.589}/code_coordinator.egg-info/SOURCES.txt

@@ -517,6 +517,7 @@ tests/test_cli_drive_queue.py
 tests/test_cli_escalate.py
 tests/test_cli_fix_headless_review.py
 tests/test_cli_gate_a.py
+tests/test_cli_inject_board_less.py
 tests/test_cli_install_drift.py
 tests/test_cli_install_skills.py
 tests/test_cli_issue_comment.py

{code_coordinator-0.5.587 → code_coordinator-0.5.589}/code_coordinator.egg-info/scm_file_list.json

@@ -544,6 +544,7 @@
     "tests/test_cli_escalate.py",
     "tests/test_cli_fix_headless_review.py",
     "tests/test_cli_gate_a.py",
+    "tests/test_cli_inject_board_less.py",
     "tests/test_cli_install_drift.py",
     "tests/test_cli_install_skills.py",
     "tests/test_cli_issue_comment.py",

{code_coordinator-0.5.587 → code_coordinator-0.5.589}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.587",
+  "tag": "0.5.589",
   "distance": 0,
-  "node": "g81a6f30503a2fdb64cbd57beb67d5d4bc78612ee",
+  "node": "gc52e2e56b54057dea9163515ac96450778a0532e",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-03"

{code_coordinator-0.5.587 → code_coordinator-0.5.589}/coord/bugbash.py

@@ -54,11 +54,25 @@ 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.
+against a fake explorer in ``tests/test_bugbash.py``; as of #3566 the
+production explorer (:func:`coord.commands.bugbash._dispatch_and_await_lane`)
+also sets ``unavailable`` — it detects a lane worker's own "unavailable"
+report (:func:`parse_unavailable_report`) and the real ``mac-native`` driver
+now emits a genuine ``status="unavailable"`` verdict for a denied
+Accessibility-trust grant (see :mod:`coord.mac_native_driver`'s own module
+docstring), so this is reachable in production, not just in a test fixture.
+A real two-lane live dry run against the fleet is still outstanding — see
+``coord.commands.bugbash``'s own "KNOWN GAP" note.
+
+**#3566: lane routing cross-references live ``/health`` probes, not just the
+static ``coordinator.yml`` claim.** :func:`_pick_lane_machine` mirrors
+:mod:`coord.smoke`'s ``dispatch_smoke`` cross-check
+(:func:`coord.smoke._capability_probe_reasons`): a machine whose declared
+capability is contradicted by its own live probe (e.g. ``macos`` declared
+but Accessibility trust denied, or Screen Recording denied) is skipped
+rather than picked, so ``coord bugbash`` refuses to route to it the same way
+``dispatch_smoke`` already does — not just in `/health`'s own JSON, but in
+the machine selection that actually dispatches a worker.
 """
 
 from __future__ import annotations
@@ -339,6 +353,76 @@ def parse_findings_block(text: str, *, platform: str, repo: str) -> FindingsPars
     return FindingsParseResult(findings=findings)
 
 
+#: #3566 ask #4/#5: the briefing's hard-rule reporting contract for a lane
+#: worker that hits a missing permission (Accessibility/Screen Recording
+#: trust, a locked/absent GUI session, ...) instead of improvising a
+#: workaround. Mirrors :data:`FINDINGS_FENCE`'s "one constant, used by both
+#: the briefing and the parser" discipline so the two can never drift apart.
+UNAVAILABLE_FENCE = "bugbash-unavailable"
+
+_UNAVAILABLE_FENCE_RE = re.compile(
+    rf"```{re.escape(UNAVAILABLE_FENCE)}\s*\n(.*?)```", re.DOTALL,
+)
+
+#: Fallback signatures (#3566 ask #5, "a driver session/permission
+#: failure") — a worker that forgot to fence its unavailable report, or
+#: whose own driver call surfaced the condition directly in a tool result,
+#: still has one of these strings somewhere in its raw transcript. Matched
+#: against the FULL log text (not just the final assistant message), so a
+#: worker that reported the condition mid-session and then crashed is still
+#: caught. Kept narrow and literal: `"no unlocked GUI session is available"`/
+#: `"the screen is locked"`/`"is not on the console"`/
+#: `"AXIsProcessTrusted() is False"` are the exact strings
+#: `coord.mac_native_driver`'s own `session_available`/`ax_trust_available`
+#: precheck now actually emits in production (#3566) — reachable, not just
+#: hand-written in a test. `"AXIsProcessTrusted() returned False"` and
+#: `"CGPreflightScreenCaptureAccess"` are defensive-only: no in-tree driver
+#: emits that exact phrasing today, but `coord.prereqs`'s own `/health` probe
+#: text and a future Screen-Recording driver precheck are plausible sources,
+#: and keeping the signature narrow and literal costs nothing. None of these
+#: are a vague substring that could false-positive on an unrelated mention of
+#: "unavailable" in a finding's prose.
+_UNAVAILABLE_SIGNATURES: tuple[str, ...] = (
+    '"status": "unavailable"',
+    '"status":"unavailable"',
+    "no unlocked GUI session is available",
+    "the screen is locked",
+    "is not on the console",
+    "AXIsProcessTrusted() is False",
+    "AXIsProcessTrusted() returned False",
+    "CGPreflightScreenCaptureAccess",
+)
+
+
+def parse_unavailable_report(text: str) -> str:
+    """The lane-unavailable reason from *text* (a lane worker's full
+    transcript), or ``""`` if none is present (#3566).
+
+    First checks for the authoritative fenced
+    ```` ```bugbash-unavailable ```` block the briefing instructs a worker
+    to write when it hits a missing permission or absent session rather
+    than improvising a workaround (ask #4's hard rule). Falls back to
+    :data:`_UNAVAILABLE_SIGNATURES` — a driver-level session/permission
+    failure surfacing directly in a tool result even without the worker's
+    own cooperation.
+
+    Never raises. The caller
+    (:func:`coord.commands.bugbash._dispatch_and_await_lane`) treats a
+    non-empty return as :attr:`ExploreOutcome.unavailable`, never
+    ``ok=False``/a protocol error — #2096's "one question, one answer":
+    this is the ONE place that question is answered.
+    """
+    match = _UNAVAILABLE_FENCE_RE.search(text)
+    if match:
+        reason = match.group(1).strip()
+        if reason:
+            return reason
+    for signature in _UNAVAILABLE_SIGNATURES:
+        if signature in text:
+            return f"driver/session signal found in transcript: {signature!r}"
+    return ""
+
+
 # ── dedupe ───────────────────────────────────────────────────────────────
 
 
@@ -527,7 +611,9 @@ class BugbashLane:
     reference: bool = False
 
 
-def discover_lanes(config: Any, repo_name: str, *, reference_backend: str = "") -> list[BugbashLane]:
+def discover_lanes(
+    config: Any, repo_name: str, *, reference_backend: str = "", http_client: Any = None,
+) -> list[BugbashLane]:
     """Derive *repo_name*'s bugbash lanes from its acceptance drivers,
     routed to a capable machine the same way
     :mod:`coord.smoke`'s ``capability_rules`` routes smoke legs.
@@ -535,11 +621,15 @@ def discover_lanes(config: Any, repo_name: str, *, reference_backend: str = "")
     Walks the repo's top-level driver plus every ``routes:`` entry (mirrors
     :meth:`coord.config.AcceptanceConfig.entrypoints`'s walk), keeps only
     :data:`LANE_DRIVER_KINDS` entries, and drops any that has no configured
-    machine listing both *repo_name* and the driver's ``capability`` — a
-    lane with no capable machine is omitted rather than returned with
-    ``machine=""``, so a caller never has to separately check "is this lane
-    actually runnable." *reference_backend*, when it names one of the
-    surviving lanes' ``platform``, marks that lane's ``reference=True``.
+    machine listing both *repo_name* and the driver's ``capability`` AND
+    whose live ``/health`` probe doesn't contradict that claim (#3566, see
+    :func:`_pick_lane_machine`) — a lane with no capable machine is omitted
+    rather than returned with ``machine=""``, so a caller never has to
+    separately check "is this lane actually runnable." *reference_backend*,
+    when it names one of the surviving lanes' ``platform``, marks that
+    lane's ``reference=True``. *http_client*, when given, is forwarded to
+    the ``/health`` cross-check (tests inject a fake; production leaves it
+    ``None`` and gets a real ``httpx`` call).
     """
     entry = config.acceptance.drivers.get(repo_name)
     if entry is None:
@@ -550,7 +640,7 @@ def discover_lanes(config: Any, repo_name: str, *, reference_backend: str = "")
     for cfg in candidates:
         if cfg.kind not in LANE_DRIVER_KINDS:
             continue
-        machine = _pick_lane_machine(config, repo_name, cfg.capability)
+        machine = _pick_lane_machine(config, repo_name, cfg.capability, http_client=http_client)
         if machine is None:
             continue
         lanes.append(
@@ -565,10 +655,42 @@ def discover_lanes(config: Any, repo_name: str, *, reference_backend: str = "")
     return lanes
 
 
-def _pick_lane_machine(config: Any, repo_name: str, capability: str) -> str | None:
+def _pick_lane_machine(
+    config: Any, repo_name: str, capability: str, *, http_client: Any = None,
+) -> str | None:
+    """The first configured machine that both claims *capability* in
+    ``coordinator.yml`` AND repo-membership for *repo_name* — cross-checked
+    against that machine's own live ``/health`` tool probes (#3566) before
+    it's picked, not just the static claim.
+
+    Before this fix, this function (and therefore every ``coord bugbash``
+    dispatch) only ever asked ``capability in m.capabilities`` — a
+    hand-written ``coordinator.yml`` claim nothing verified — while
+    :mod:`coord.smoke`'s own ``dispatch_smoke`` already cross-referenced
+    ``/health``'s ``tool_versions`` (:func:`coord.smoke
+    ._capability_probe_reasons`) before routing smoke work. A ``macos``
+    machine whose Accessibility/Screen-Recording trust (:mod:`coord.prereqs`'s
+    ``macos-accessibility-trust``/``macos-screen-recording`` probes) was
+    revoked therefore still looked dispatchable to bugbash even though
+    ``/health`` itself would have said otherwise — the exact gap the first
+    live ``mac-native`` attempt hit. Reusing
+    :func:`coord.smoke._capability_probe_reasons` here (rather than a second,
+    independently-drifting copy of the same dict) means ``coord bugbash``
+    now refuses to route to a machine with a known-unmet required-capability
+    prereq the same way ``dispatch_smoke`` already does, falling through to
+    the next capable-on-paper machine (or returning ``None`` if none remain)
+    instead of dispatching a worker that can never actually run the lane.
+    """
+    from coord.smoke import _capability_probe_reasons  # noqa: PLC0415 — avoid an import cycle
+
     for m in config.machines:
-        if repo_name in m.repos and (not capability or capability in m.capabilities):
-            return m.name
+        if repo_name not in m.repos:
+            continue
+        if capability and capability not in m.capabilities:
+            continue
+        if capability and _capability_probe_reasons(m, [capability], http_client=http_client):
+            continue  # declared but the machine's own /health probe denies it
+        return m.name
     return None
 
 
@@ -592,6 +714,16 @@ def build_exploration_briefing(
         "",
         f"Reference backend for comparison: {reference_backend or '(none configured)'}",
         "",
+        "HARD RULE — drive the app ONLY through this lane's own driver "
+        "(coord.mac_native_driver / coord.win_native_driver / "
+        "coord.gtk_native_driver, whichever this lane is). Never use "
+        "osascript, System Events, a Terminal/iTerm `do script`, a "
+        "home-made input-injection helper, or System Settings. If a "
+        "required permission (Accessibility, Screen Recording, a locked/"
+        "absent GUI session, ...) is missing, STOP IMMEDIATELY and report "
+        "the lane unavailable (see below) — do NOT improvise a workaround, "
+        "and do NOT send any key or click to recover (#3566).",
+        "",
         "1. Run this repo's Tier-2 smoke spec for this driver to completion.",
         "2. Then walk the exploration checklist below on the real app, using "
         "the native driver's own probes/captures as evidence:",
@@ -603,7 +735,13 @@ def build_exploration_briefing(
         "For anything that behaves differently from the reference backend, "
         "or crashes, hangs, or renders wrong, report it as a finding.",
         "",
-        "When done, end your final message with a fenced "
+        "If the HARD RULE above fires (a required permission/session is "
+        "missing), skip the findings fence entirely and end your final "
+        "message with a fenced "
+        f"```{UNAVAILABLE_FENCE}``` block containing one line: the reason "
+        "the lane is unavailable.",
+        "",
+        "Otherwise, when done, end your final message with a fenced "
         f"```{FINDINGS_FENCE}``` block containing a JSON array of finding "
         "objects, each with: title, expected, actual, repro, evidence, "
         "suspected_repo (the repo the FIX belongs in — the app, its UI "
@@ -657,9 +795,10 @@ class ExploreOutcome:
     :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.
+    :func:`coord.commands.bugbash._dispatch_and_await_lane`, sets this flag
+    too (#3566): it detects a worker's own "lane unavailable" report (or a
+    driver session/permission failure surfacing directly in the transcript)
+    via :func:`parse_unavailable_report`.
 
     ``protocol_error`` is a FOURTH, separate outcome (#3517): the lane
     worker DID run to completion (``ok=True``, unlike a dispatch/poll/log

{code_coordinator-0.5.587 → code_coordinator-0.5.589}/coord/commands/bugbash.py

@@ -23,6 +23,20 @@ to the generic catch-all worker (full Read/Edit/Write/Bash/Monitor,
 ``WORKER_SYSTEM_PROMPT``) — a tracked follow-up, since that module is
 outside this issue's file scope (see the PR description).
 
+#3566 closed the gap this module used to carry here: the first live
+``mac-native`` bugbash attempt found ``AXIsProcessTrusted() == False`` and
+improvised an unsafe workaround instead of stopping, and the two later
+attempts that DID stop correctly still reported ``terminated='zero_findings'``
+— a lane that never ran read identically to a clean pass.
+:func:`coord.bugbash.build_exploration_briefing` now carries a hard rule
+("drive the app only through this lane's own driver... if a permission is
+missing, stop and report unavailable") plus the exact reporting contract,
+and :func:`_dispatch_and_await_lane` below detects it
+(:func:`coord.bugbash.parse_unavailable_report`) and sets
+:attr:`coord.bugbash.ExploreOutcome.unavailable` — so
+:func:`coord.bugbash.run_bugbash` reports ``lanes_unavailable``, not
+``zero_findings``, for a lane that never actually ran.
+
 KNOWN GAP (#3487 acceptance, "one real dry run against vimcode on at least
 two lanes"): this module was written and unit-tested from THIS worktree,
 which has no reachable Tailscale fleet and — deliberately — no business
@@ -52,6 +66,7 @@ from coord.bugbash import (
     discover_lanes,
     finding_target_repo,
     parse_findings_block,
+    parse_unavailable_report,
     run_bugbash,
     subprocess_coord_runner,
 )
@@ -190,6 +205,22 @@ def _dispatch_and_await_lane(
         if text.strip():
             last_assistant_text = text
 
+    # #3566 ask #5: a worker's own "lane unavailable" report (the
+    # briefing's hard rule — a missing permission/session, never an
+    # improvised workaround) OR a driver session/permission failure
+    # surfacing directly in the transcript is a THIRD outcome, distinct
+    # from both a clean pass and a protocol error — checked against the
+    # FULL raw log text (not just the last assistant message) so it's
+    # caught even if the worker reported it mid-session before crashing.
+    # Must be checked BEFORE `parse_findings_block`: an unavailable report
+    # deliberately carries no findings fence (the briefing tells the
+    # worker to skip it), which would otherwise read as a protocol error.
+    unavailable_reason = parse_unavailable_report(log_resp.text)
+    if unavailable_reason:
+        return ExploreOutcome(
+            unavailable=True, cost=summary.total_cost_usd, notes=unavailable_reason,
+        )
+
     parsed = parse_findings_block(last_assistant_text, platform=lane.platform, repo=repo_name)
     if parsed.protocol_error:
         # #3517: the worker completed, but its report can't be trusted as a

{code_coordinator-0.5.587 → code_coordinator-0.5.589}/coord/commands/dispatch.py

@@ -1733,6 +1733,76 @@ def _build_interactive_launch_setup(
     )
 
 
+@dataclasses.dataclass(frozen=True)
+class _InjectTarget:
+    """Resolved (machine, repo_name, issue_number) for an `inject` call —
+    repo_name/issue_number are display-only (the final "delivered to ..."
+    line), never used to route the POST itself (that's machine + the
+    assignment id alone)."""
+
+    machine: "Machine"
+    repo_name: str
+    issue_number: int
+
+
+def _resolve_inject_target(assignment_id: str, board, cfg) -> tuple[_InjectTarget | None, str]:
+    """Resolve *assignment_id* to a machine, preferring the board but
+    falling back to scanning every configured machine's own `/status`
+    (#3566 ask #6). Returns ``(target, "")`` on success, or ``(None,
+    reason)`` naming exactly why resolution failed.
+
+    `coord inject` used to refuse outright on any assignment not on the
+    board (``assignment '<id>' not found in board``) — but a dispatched
+    `bugbash-explore` worker (``issue_number=0``, no GitHub issue, by
+    construction never written to the board) has no board row to find.
+    That left an operator who needed to redirect a runaway lane worker
+    (the exact #3566 incident: injecting guidance into a worker that was
+    about to send unsafe input) with no `coord inject` path at all, only a
+    raw ``POST /inject/{id}`` straight to the agent.
+
+    The board lookup stays first and is unchanged for every ordinary
+    (board-tracked) assignment — this is additive, never a behaviour
+    change for the common case. The fallback is a live, per-machine
+    ``GET /status`` scan (#2096: an agent's own current state, not a
+    locally-cached guess) — the SAME ``{"active": [...], "completed":
+    [...]}`` shape the chat-continue session-id fallback above this
+    function already reads, so "which machine is this assignment on" has
+    one answer, reached one way, for everyone who needs it (#2096's "one
+    question, one answer")."""
+    assignment = board.find_by_id(assignment_id)
+    if assignment is not None:
+        machine = next(
+            (m for m in cfg.machines if m.name == assignment.machine_name), None
+        )
+        if machine is None:
+            return None, f"machine {assignment.machine_name!r} not in config"
+        return _InjectTarget(
+            machine=machine, repo_name=assignment.repo_name,
+            issue_number=assignment.issue_number,
+        ), ""
+
+    from coord.network import fetch_status  # noqa: PLC0415
+
+    for machine in cfg.machines:
+        status_result = fetch_status(machine)
+        if not status_result.ok or not status_result.data:
+            continue
+        for bucket in ("active", "completed"):
+            for entry in status_result.data.get(bucket, []):
+                if entry.get("id") != assignment_id:
+                    continue
+                spec = entry.get("spec") or {}
+                return _InjectTarget(
+                    machine=machine,
+                    repo_name=spec.get("repo_name", "") or "",
+                    issue_number=int(spec.get("issue_number", 0) or 0),
+                ), ""
+    return None, (
+        f"assignment {assignment_id!r} not found in board or on any "
+        "configured machine's /status"
+    )
+
+
 @click.command(help="Send a user message to a running worker mid-session.")
 @click.argument("assignment_id")
 @click.argument("text", nargs=-1, required=True)
@@ -1743,6 +1813,10 @@ def inject(assignment_id: str, text: tuple[str, ...], config_path: Path) -> None
     The worker picks the message up at its next turn boundary — between
     tool calls, not mid-tool.  Useful for adding guidance to a worker
     that's going off the rails without having to stop + re-dispatch.
+
+    Resolves the target machine via :func:`_resolve_inject_target` — the
+    board when the assignment is board-tracked, or a live per-machine
+    `/status` scan when it isn't (e.g. a `bugbash-explore` worker, #3566).
     """
     from coord.board_service import read_board
     from coord.network import inject_message
@@ -1750,16 +1824,9 @@ def inject(assignment_id: str, text: tuple[str, ...], config_path: Path) -> None
     cfg = _load_config(config_path)
     board = read_board()
 
-    assignment = board.find_by_id(assignment_id)
-    if assignment is None:
-        click.echo(f"error: assignment {assignment_id!r} not found in board", err=True)
-        sys.exit(1)
-
-    machine = next(
-        (m for m in cfg.machines if m.name == assignment.machine_name), None
-    )
-    if machine is None:
-        click.echo(f"error: machine {assignment.machine_name!r} not in config", err=True)
+    target, reason = _resolve_inject_target(assignment_id, board, cfg)
+    if target is None:
+        click.echo(f"error: {reason}", err=True)
         sys.exit(1)
 
     message = " ".join(text).strip()
@@ -1768,16 +1835,17 @@ def inject(assignment_id: str, text: tuple[str, ...], config_path: Path) -> None
         sys.exit(2)
 
     try:
-        status, body = inject_message(machine, assignment_id, message)
+        status, body = inject_message(target.machine, assignment_id, message)
     except (httpx.HTTPError, httpx.TimeoutException) as e:
-        click.echo(f"error: could not reach agent on {machine.name}: {e}", err=True)
+        click.echo(f"error: could not reach agent on {target.machine.name}: {e}", err=True)
         sys.exit(1)
 
     if status == 202:
-        click.echo(
-            f"Message delivered to {assignment.repo_name} #{assignment.issue_number} "
-            f"on {machine.name}"
+        destination = (
+            f"{target.repo_name} #{target.issue_number}"
+            if target.repo_name else "(no board/repo info — board-less assignment)"
         )
+        click.echo(f"Message delivered to {destination} on {target.machine.name}")
     else:
         click.echo(
             f"error: agent rejected message (HTTP {status}): {body.get('error', body)}",