code-coordinator 0.5.250__tar.gz → 0.5.252__tar.gz

{code_coordinator-0.5.250 → code_coordinator-0.5.252}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.250
+Version: 0.5.252
 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.250 → code_coordinator-0.5.252}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.250",
+  "tag": "0.5.252",
   "distance": 0,
-  "node": "g736f450ea5a6401a7a9b51d286e49fba0c0068e4",
+  "node": "g05161051c601022afb4bd68113723cd72c2514f1",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-27"

{code_coordinator-0.5.250 → code_coordinator-0.5.252}/coord/commands/_common.py

@@ -19,6 +19,7 @@ the server stack at import time. Keep it that way:
 from __future__ import annotations
 
 import json
+import logging
 import socket
 import sys
 import time
@@ -42,6 +43,8 @@ from coord.config import (
 if TYPE_CHECKING:  # pragma: no cover — typing only
     from collections.abc import Iterator
 
+log = logging.getLogger(__name__)
+
 # Canonical constant in coord.brain.AGENT_PORT — duplicated here as a literal
 # so the CLI decorator default doesn't have to import the brain (and, through
 # it, the provider stack) on every `coord` invocation.
@@ -470,6 +473,104 @@ def _apply_label_change(
     click.echo(success_message)
 
 
+# #2839: Pipeline membership label set — shared by `coord track` (the
+# interactive "send to Pipeline" door, above) and `coord drive-queue add`
+# (the queueing door, `coord/commands/drive_queue.py`). Enqueueing a drive is
+# a strictly STRONGER statement than "send to Pipeline", so its label write
+# must never be weaker than `track`'s own — kept as one literal pair so the
+# two doors cannot drift apart.
+PIPELINE_TRACK_LABELS_ADD = {"coord", "status:ready"}
+PIPELINE_TRACK_LABELS_REMOVE_IF_PRESENT = {"status:refining", "status:backlog"}
+
+
+def resolve_repo_slug_best_effort(config: Config | None, repo: str) -> str | None:
+    """Non-fatal sibling of :func:`_resolve_repo_slug` (#2839 review).
+
+    Returns the GitHub ``OWNER/REPO`` slug for *repo*, or ``None`` when it
+    cannot be determined. Unlike ``_resolve_repo_slug`` it never calls
+    ``sys.exit`` — it is for callers whose own job is not "talk to the
+    forge", where an unresolvable name must degrade rather than abort.
+
+    *config* is ``None`` when the caller could not load one at all (a thin
+    client whose board daemon is momentarily unreachable); that is a
+    legitimate, expected input, not an error.
+    """
+    if config is not None:
+        repo_entry = config.repo(repo)
+        if repo_entry is not None:
+            return repo_entry.github
+    # Not in coordinator.yml (or no config at all): a raw `OWNER/REPO` slug is
+    # still directly usable by the forge backend — same accepted fallback
+    # `_resolve_repo_slug` validates. Anything else is a bare local name we
+    # cannot map, so say so with `None` rather than guessing.
+    if "/" in repo:
+        return repo
+    return None
+
+
+def apply_pipeline_track_labels_best_effort(
+    repo: str, issue: int, *, config: Config | None,
+) -> None:
+    """Best-effort ``coord`` + ``status:ready`` label application (#2839).
+
+    Non-blocking sibling of :func:`_apply_label_change` for a caller whose
+    own job is NOT "change labels" — today, only ``coord drive-queue add``.
+    Enqueuing a drive must succeed even when GitHub is unreachable: the board
+    row is the source of truth for queue membership, and this label is only
+    a best-effort projection of it onto the Pipeline. Every failure (a
+    missing repo, an unreachable daemon, a `gh` error) is logged and
+    swallowed here — never raised — so the caller's own success can never
+    turn on this call landing.
+
+    Idempotent by construction: ``apply_issue_labels`` (and the ``gh``
+    backend underneath it) tolerates already-present ``add`` labels and
+    already-absent ``remove`` labels, so re-running this on an
+    already-tracked issue is a silent no-op, not a duplicate write.
+
+    *config* is passed IN, already loaded, rather than loaded here — the two
+    halves of the #2839 review, together:
+
+    * It must not be loaded via ``_load_config`` inside this function.
+      ``_load_config`` turns a config-load failure (a thin client's
+      ``fetch_remote_config`` round-trip to a momentarily-unreachable board
+      daemon; a briefly-unreadable ``coordinator.yml``) into ``sys.exit(2)``,
+      and ``SystemExit`` is a ``BaseException``, not an ``Exception``, so it
+      would blow straight through the ``except`` below and kill the whole
+      ``drive-queue add`` process *after* the board row was written.
+    * But the slug must still be RESOLVED. ``coordinator.yml``'s ``name:``
+      key is routinely not the GitHub slug (this repo's own
+      ``coordinator.example.yml`` documents ``name: code-coordinator`` vs
+      ``github: JDonaghy/claude-coordinator``), and
+      ``_apply_issue_labels_local``'s ``repo_github or repo_name`` fallback
+      would hand that bare local name to ``gh issue edit --repo``, which
+      requires ``[HOST/]OWNER/REPO`` and errors out — so the label would
+      still never land for exactly the repos #2839 was filed about, only
+      now silently.
+
+    Taking the caller's already-loaded ``Config`` satisfies both: real slug
+    resolution, no second (uncachable, per-``add``) round trip to the daemon,
+    and no ``SystemExit`` path inside a best-effort helper. ``config=None``
+    is accepted and simply degrades to the ``repo_name`` fallback.
+    """
+    from coord.state import apply_issue_labels  # noqa: PLC0415
+
+    try:
+        apply_issue_labels(
+            repo, issue,
+            add=PIPELINE_TRACK_LABELS_ADD,
+            remove=PIPELINE_TRACK_LABELS_REMOVE_IF_PRESENT,
+            repo_github=resolve_repo_slug_best_effort(config, repo),
+        )
+    except Exception as exc:  # noqa: BLE001 — see docstring: must never block the enqueue
+        log.warning(
+            "drive-queue add: failed to apply Pipeline labels (coord + "
+            "status:ready) to %s#%s: %s — the queue row was still written; "
+            "the label is a projection, not the source of truth, so the "
+            "enqueue proceeds",
+            repo, issue, exc,
+        )
+
+
 @dataclass
 class PollOutcome:
     """Result of polling an agent's ``/status`` for one assignment until it

{code_coordinator-0.5.250 → code_coordinator-0.5.252}/coord/commands/drive_queue.py

@@ -35,12 +35,12 @@ import socket
 import subprocess
 import time
 from pathlib import Path
-from typing import Any, Mapping
+from typing import TYPE_CHECKING, Any, Mapping
 
 import click
 
 from coord.block_log import INTERVENTION_CATEGORIES, STALL_STATES
-from coord.commands._common import _CONFIG_OPTION
+from coord.commands._common import _CONFIG_OPTION, apply_pipeline_track_labels_best_effort
 from coord.drive_state import WORK_LIKE
 from coord.drive_queue import (
     DEFAULT_MAX_ATTEMPTS,
@@ -105,6 +105,9 @@ from coord.overlap_predict import (
     tally,
 )
 
+if TYPE_CHECKING:  # pragma: no cover — typing only
+    from coord.config import Config
+
 log = logging.getLogger(__name__)
 
 # Wall-clock ceiling for the `coord drive --tmux` launch subprocess.  The
@@ -335,12 +338,18 @@ def drive_queue_add(
     existing_entries = entries_from_rows(list_drive_queue())
     if max_fix_rounds is not None and max_fix_rounds < 1:
         raise click.ClickException("--max-fix-rounds must be a positive integer")
+    # #2839: reused below for the Pipeline label write's slug resolution, so
+    # that best-effort projection costs no SECOND config load (a `GET /config`
+    # round trip to the board daemon on a thin client). `None` on the
+    # documented fail-open path — an unloadable config never blocks an
+    # enqueue, and never blocks the label write either.
+    cfg: Config | None = None
     try:
         after = parse_after_spec(after_specs, repo)
         # #2603: reuses `--after`'s own `N` / `REPO#N` parsing — a rejected
         # edge is named the same way an operator would name a real one.
         reject_after = set(parse_after_spec(reject_after_specs, repo))
-        validate_config_repo(config_path, repo)
+        cfg = validate_config_repo(config_path, repo)
         validate_hold_flags(hold_after, hold_reason, resume_when, hold_scope)
         validate_enqueue(existing_entries, repo, issue, after)
     except QueueError as exc:
@@ -402,6 +411,21 @@ def drive_queue_add(
         max_fix_rounds=max_fix_rounds,
         no_acceptance=no_acceptance,
     )
+    # #2839: queueing a drive is a strictly STRONGER statement than "send to
+    # Pipeline" (`coord track`), so it must never leave the issue in a
+    # weaker label state — apply the same `coord` + `status:ready` labels
+    # `track` does, resolved through the SAME `cfg` already loaded above
+    # (coordinator.yml's `name:` is routinely not the GitHub slug, so the
+    # forge needs the resolved `github:` value, not `repo`). Best-effort/
+    # non-blocking (a GitHub outage warns and carries on; the board row above
+    # is already written and is the
+    # source of truth for queue membership) and skipped for an entry that is
+    # already `running` — #2821 was mid-drive with `coord` but no
+    # `status:*`, and re-adding `status:ready` to a running card would
+    # misrepresent it as not-yet-started. This is enqueue-time ONLY: never
+    # mirrored onto `coord drive-queue remove`, which must not untrack.
+    if previous is None or previous.state != STATE_RUNNING:
+        apply_pipeline_track_labels_best_effort(repo, issue, config=cfg)
     if auto_after:
         _record_overlap_prediction(repo, issue, prediction, auto_after)
     suffix = f" after {', '.join(after)}" if after else ""
@@ -713,7 +737,12 @@ def _repo_coordinates(config_path: Path, repo: str) -> tuple[str, str] | None:
         from coord.commands._common import _load_config  # noqa: PLC0415
 
         repo_cfg = _load_config(config_path).repo(repo)
-    except Exception:  # noqa: BLE001 — a config that won't load means no prediction
+    except (Exception, SystemExit):  # noqa: BLE001 — a config that won't load
+        # means no prediction. `SystemExit` is listed for the same reason as in
+        # `validate_config_repo` (#2839 review): `_load_config` reports a
+        # `ConfigError` as `click.echo` + `sys.exit(2)`, a `BaseException`, so
+        # `except Exception` alone would abort `drive-queue add` here instead
+        # of degrading to "no overlap prediction" as documented.
         return None
     if repo_cfg is None:
         return None
@@ -878,7 +907,7 @@ def validate_hold_flags(
         )
 
 
-def validate_config_repo(config_path: Path, repo: str) -> None:
+def validate_config_repo(config_path: Path, repo: str) -> Config | None:
     """Refuse a repo coordinator.yml has never heard of.
 
     `coord drive <repo> <issue>` would fail at preflight anyway
@@ -886,16 +915,29 @@ def validate_config_repo(config_path: Path, repo: str) -> None:
     ``add`` time turns a mysterious tick-time block into an immediate typo
     report.  Fail-OPEN on a config that won't load at all: a thin client whose
     config cache is momentarily unreadable must still be able to queue work.
+
+    Returns the loaded ``Config`` (``None`` when it could not be loaded, i.e.
+    the fail-open path) so the caller does not have to load it a SECOND time
+    — on a thin client each load is a `GET /config` round trip to the board
+    daemon, and #2839's best-effort label write needs the same config only to
+    resolve `repo`'s GitHub slug.
+
+    ``SystemExit`` is caught alongside ``Exception`` deliberately (#2839
+    review): ``_load_config`` reports a ``ConfigError`` as ``click.echo`` +
+    ``sys.exit(2)``, which is a ``BaseException`` — so a bare ``except
+    Exception`` here would NOT fail open at all, it would abort `add` with
+    exit code 2, the exact opposite of this function's documented posture.
     """
     try:
         from coord.commands._common import _load_config  # noqa: PLC0415
 
         config = _load_config(config_path)
-    except Exception:  # noqa: BLE001 — see the fail-open note above
-        return
+    except (Exception, SystemExit):  # noqa: BLE001 — see the fail-open note above
+        return None
     if config.repo(repo) is None:
         known = ", ".join(sorted(r.name for r in config.repos)) or "(none)"
         raise QueueError(f"repo {repo!r} is not in coordinator.yml (known: {known})")
+    return config
 
 
 # ── list ─────────────────────────────────────────────────────────────────────
@@ -1413,7 +1455,13 @@ def drive_queue_log_intervention(
 @click.argument("issue", type=int)
 @_CONFIG_OPTION
 def drive_queue_remove(repo: str, issue: int, config_path: Path) -> None:
-    """Drop REPO ISSUE from the queue (positions are renumbered dense)."""
+    """Drop REPO ISSUE from the queue (positions are renumbered dense).
+
+    #2839: deliberately does NOT touch the `coord`/`status:*` labels `add`
+    applies — dropping out of the drive queue is not eviction from the
+    Pipeline. `coord untrack` stays the only way to evict a card; do not
+    "fix" this asymmetry by mirroring `add`'s label write here.
+    """
     from coord.state import dequeue_drive_queue, get_drive_queue_entry  # noqa: PLC0415
 
     # #2235 Phase 0: read the row BEFORE deleting it, because `remove` on a

{code_coordinator-0.5.250 → code_coordinator-0.5.252}/coord/commands/issues.py

@@ -14,6 +14,8 @@ from coord.commands._common import (
     _CONFIG_OPTION,
     _load_config,
     _resolve_repo_slug,
+    PIPELINE_TRACK_LABELS_ADD,
+    PIPELINE_TRACK_LABELS_REMOVE_IF_PRESENT,
 )
 
 
@@ -783,8 +785,8 @@ def track(repo: str, issue: int, config_path: Path) -> None:
     slug = _resolve_repo_slug(cfg, repo)
     _apply_label_change(
         repo, issue, config_path,
-        add={"coord", "status:ready"},
-        remove_if_present={"status:refining", "status:backlog"},
+        add=PIPELINE_TRACK_LABELS_ADD,
+        remove_if_present=PIPELINE_TRACK_LABELS_REMOVE_IF_PRESENT,
         success_message=(
             f"#{issue} ({slug}) sent to Pipeline (coord + status:ready)"
         ),