code-coordinator 0.5.62__tar.gz → 0.5.63__tar.gz

{code_coordinator-0.5.62/code_coordinator.egg-info → code_coordinator-0.5.63}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.62",
+  "tag": "0.5.63",
   "distance": 0,
-  "node": "g84d64a795986ab501062308d9e29da81f86cfb79",
+  "node": "gb547d297bb611bfa65077c4a7d42c08edbf3cd8c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.62 → code_coordinator-0.5.63}/coord/acceptance.py

@@ -886,6 +886,75 @@ def find_ms_manifest_for_issue_via_api(
     return None
 
 
+def missing_expected_red_warning(
+    repo_github: str, branch: str, issue_number: int, *, gh_ops: Any = None,
+) -> str | None:
+    """#2191 — the writer/gate seam: is *issue_number* the signature of an
+    unwritten ``expected_red`` registry on *branch*'s manifest? That
+    signature is checkable without ever running the suite: the manifest
+    maps at least one test id to *issue_number* (a slice was authored for
+    it) but records ZERO ``expected_red`` entries for it, and the issue is
+    still open. #2164 shipped a reader (:func:`apply_expected_red`), a
+    clearer (:func:`clear_expected_red_via_pr`) and a lister
+    (:func:`list_expected_red_via_api`) for this registry but no writer —
+    :data:`coord.test_author.TEST_AUTHOR_SYSTEM_PROMPT` step 4b is the
+    writer (the test-author records what it observed FAIL in its step-4
+    run). This function is the gate half: it does not trust the prompt was
+    followed, so it re-derives "was anything recorded" from the manifest
+    itself at slice-PR-open time (:func:`coord.merge_queue.process`'s
+    "Open PRs first" loop, gated on ``assignment_type == "test-author"``)
+    and flags exactly the case a skipped step 4b produces.
+
+    Returns ``None`` — nothing to flag — when: *branch*'s manifest doesn't
+    reference *issue_number* at all (no slice authored yet, out of scope);
+    ``expected_red`` already has a non-empty entry for it (the writer did
+    its job, or the slice is genuinely all-green and needs none); the issue
+    is closed (its slice already served its purpose — flagging it now is
+    stale noise, not #2191's live deadlock); or any lookup fails. The last
+    case is deliberate fail-open, matching every other best-effort API
+    sweep in this module (:func:`find_ms_manifest_for_issue_via_api`,
+    :func:`coord.merge_queue._issue_has_expected_red_entries`) — this check
+    is advisory (see the "refused or warned" phrasing in #2191's acceptance
+    criteria; callers choose which), so an unreachable API must degrade to
+    "say nothing," never to blocking a PR the check itself couldn't
+    evaluate.
+
+    Otherwise returns a human-readable warning naming the missing ids.
+    """
+    ops = gh_ops or _default_github_ops()
+    found = find_ms_manifest_for_issue_via_api(
+        repo_github, branch, issue_number, gh_ops=ops,
+    )
+    if found is None:
+        return None
+    path, _text, _blob_sha, data = found
+    if data.expected_red.get(issue_number):
+        return None
+    test_ids = test_ids_for_issue(data.tests, issue_number)
+    if not test_ids:
+        return None
+    live_state = getattr(ops, "get_issues_live_state", None)
+    if live_state is None:
+        return None
+    try:
+        states = live_state(repo_github, [issue_number])
+    except Exception:  # noqa: BLE001 — best-effort, fail open (see docstring)
+        return None
+    if states.get(issue_number) != "open":
+        return None
+    return (
+        f"#{issue_number}: {path} maps {len(test_ids)} test-id(s) to this "
+        f"issue ({', '.join(sorted(test_ids))}) but records no "
+        "`expected_red` entries for it — the #2191 signature of an "
+        "unwritten registry (the test-author's step 4b never ran, or was "
+        "skipped). If this slice is genuinely all-green already, ignore; "
+        "otherwise every red id here fails CI with nothing telling "
+        "`coord acceptance run --all --ci` that's expected, and `coord "
+        "merge` will need `--force-merge` or a hand-edited manifest to "
+        "land it."
+    )
+
+
 def list_expected_red_via_api(
     repo_github: str, branch: str, *, gh_ops: Any = None,
 ) -> "dict[str, dict[int, frozenset[str]]]":

{code_coordinator-0.5.62 → code_coordinator-0.5.63}/coord/commands/drive_queue.py

@@ -43,6 +43,8 @@ from coord.drive_queue import (
     DEFAULT_MAX_ATTEMPTS,
     DEFAULT_MAX_PARALLEL_PER_REPO,
     HOLD_RELEASED,
+    HOLD_SCOPE_ENTRY,
+    HOLD_SCOPE_FLEET,
     QUEUE_ALERT_ISSUE,
     QUEUE_ALERT_REPO,
     QUEUE_ALERT_STAGE,
@@ -155,6 +157,19 @@ def drive_queue_group() -> None:
         "treated as a failure. Requires --hold-after."
     ),
 )
+@click.option(
+    "--scope",
+    "hold_scope",
+    type=click.Choice([HOLD_SCOPE_ENTRY, HOLD_SCOPE_FLEET]),
+    default=HOLD_SCOPE_ENTRY,
+    show_default=True,
+    help=(
+        "How far a fired gate reaches (#2186). `entry` holds only entries "
+        "whose own --after names THIS one. `fleet` is the whole-queue stop — "
+        "launch NOTHING anywhere, for the rare case (a rename, a schema "
+        "migration) where that is really what's needed. Requires --hold-after."
+    ),
+)
 @_CONFIG_OPTION
 def drive_queue_add(
     repo: str,
@@ -165,6 +180,7 @@ def drive_queue_add(
     hold_after: bool,
     hold_reason: str,
     resume_when: str,
+    hold_scope: str,
     config_path: Path,
 ) -> None:
     """Queue REPO ISSUE for `coord drive`, or update it if already queued.
@@ -175,14 +191,36 @@ def drive_queue_add(
     """
     from coord.state import enqueue_drive_queue, list_drive_queue  # noqa: PLC0415
 
+    existing_entries = entries_from_rows(list_drive_queue())
     try:
         after = parse_after_spec(after_specs, repo)
         validate_config_repo(config_path, repo)
-        validate_hold_flags(hold_after, hold_reason, resume_when)
-        validate_enqueue(entries_from_rows(list_drive_queue()), repo, issue, after)
+        validate_hold_flags(hold_after, hold_reason, resume_when, hold_scope)
+        validate_enqueue(existing_entries, repo, issue, after)
     except QueueError as exc:
         raise click.ClickException(str(exc)) from None
 
+    # #2186: the UPDATE path in `_enqueue_drive_queue_local` always writes
+    # whatever `hold_scope` THIS call passed (default `entry`) — so re-adding
+    # an already fleet-scoped gate without repeating `--scope fleet` silently
+    # narrows it. That fails toward the safer/narrower scope, not a
+    # correctness bug, but it is a real behaviour change an operator who only
+    # meant to touch `--machine`/`--after` would not expect, so it is echoed
+    # rather than left silent.
+    previous = next((e for e in existing_entries if e.key == entry_key(repo, issue)), None)
+    scope_downgrade_warning = ""
+    if (
+        previous is not None
+        and previous.hold_scope == HOLD_SCOPE_FLEET
+        and hold_after
+        and hold_scope != HOLD_SCOPE_FLEET
+    ):
+        scope_downgrade_warning = (
+            f"\nwarning: {entry_key(repo, issue)} was scope=fleet — this add did not "
+            f"repeat --scope {HOLD_SCOPE_FLEET}, so its gate is now scope={hold_scope} "
+            "(entries-only). Pass --scope fleet again if the fleet-wide stop was still needed."
+        )
+
     enqueue_drive_queue(
         repo,
         issue,
@@ -192,37 +230,51 @@ def drive_queue_add(
         hold_after=hold_after,
         hold_reason=hold_reason,
         resume_when=resume_when,
+        hold_scope=hold_scope,
     )
     suffix = f" after {', '.join(after)}" if after else ""
     pinned = f" on {machine}" if machine else ""
     gate = ""
     if hold_after:
         gate = " · holds the queue when done"
+        if hold_scope == HOLD_SCOPE_FLEET:
+            gate += " (fleet-wide — nothing anywhere launches)"
         if resume_when:
             gate += f" (auto-resume when `{resume_when}` passes)"
-    click.echo(f"queued {entry_key(repo, issue)}{pinned}{suffix}{gate}")
+    click.echo(f"queued {entry_key(repo, issue)}{pinned}{suffix}{gate}{scope_downgrade_warning}")
 
 
-def validate_hold_flags(hold_after: bool, hold_reason: str, resume_when: str) -> None:
-    """Refuse gate detail without a gate (#1757).
-
-    `--resume-when` / `--hold-reason` on an entry with no `--hold-after` would
-    be stored and then never read — a silent no-op on the ONE flag whose whole
-    job is to stop the queue.  An operator who mistyped that has no signal at
-    all that overnight sequencing will now blow straight through the deploy
-    step, so this is a usage error, not a warning.
+def validate_hold_flags(
+    hold_after: bool,
+    hold_reason: str,
+    resume_when: str,
+    hold_scope: str = HOLD_SCOPE_ENTRY,
+) -> None:
+    """Refuse gate detail without a gate (#1757, extended by #2186).
+
+    `--resume-when` / `--hold-reason` / a non-default `--scope` on an entry
+    with no `--hold-after` would be stored and then never read — a silent
+    no-op on the ONE flag whose whole job is to stop the queue (or narrow
+    what it stops).  An operator who mistyped that has no signal at all that
+    overnight sequencing will now blow straight through the deploy step, so
+    this is a usage error, not a warning.
     """
     if hold_after:
         return
     offenders = [
         flag
-        for flag, value in (("--resume-when", resume_when), ("--hold-reason", hold_reason))
+        for flag, value in (
+            ("--resume-when", resume_when),
+            ("--hold-reason", hold_reason),
+        )
         if value
     ]
+    if hold_scope == HOLD_SCOPE_FLEET:
+        offenders.append("--scope=fleet")
     if offenders:
         raise QueueError(
             f"{' and '.join(offenders)} require --hold-after "
-            "(without it there is no gate to resume or explain)"
+            "(without it there is no gate to resume, explain, or scope)"
         )
 
 
@@ -277,6 +329,8 @@ def drive_queue_list(repo: str | None, output_json: bool, config_path: Path) ->
             bits.append(f"deferrals={entry.deferrals}")
         if entry.hold_after:
             bits.append(f"hold={entry.hold_state or 'armed'}")
+            if entry.hold_scope == HOLD_SCOPE_FLEET:
+                bits.append("scope=fleet")
         click.echo("  ".join(bits))
         if entry.last_reason:
             click.echo(f"      last{_reason_age_suffix(entry, now)}: {entry.last_reason}")
@@ -325,7 +379,12 @@ def _hold_lines(entry: QueueEntry) -> list[str]:
     """
     if not entry.hold_after:
         return []
-    lines = [f"      hold-after: {entry.gate_reason}"]
+    scope_suffix = (
+        " [fleet-wide — holds everything, not just this entry's dependents]"
+        if entry.hold_scope == HOLD_SCOPE_FLEET
+        else ""
+    )
+    lines = [f"      hold-after: {entry.gate_reason}{scope_suffix}"]
     if entry.resume_when:
         probe = f"      resume-when: {entry.resume_when}"
         if entry.hold_probes:
@@ -416,6 +475,10 @@ def drive_queue_status(output_json: bool, config_path: Path) -> None:
                             "reason": e.gate_reason,
                             "resume_when": e.resume_when,
                             "probes": e.hold_probes,
+                            # #2186: typed, so a client reads what this gate
+                            # holds without parsing the `[fleet-wide ...]`
+                            # suffix back out of the rendered text.
+                            "scope": e.hold_scope,
                         }
                         for e in held
                     ],

{code_coordinator-0.5.62 → code_coordinator-0.5.63}/coord/db.py

@@ -401,6 +401,13 @@ def _ensure_schema(conn: sqlite3.Connection) -> None:
             hold_state    TEXT    NOT NULL DEFAULT '',
             hold_probes   INTEGER NOT NULL DEFAULT 0,
             launch_host   TEXT    NOT NULL DEFAULT '',
+            -- #2186: how far a FIRED gate reaches. 'entry' (the default) holds
+            -- only entries whose own after_json names this row's key; 'fleet'
+            -- is the pre-#2186 whole-queue stop, kept for an explicit
+            -- --scope=fleet. NOT NULL DEFAULT 'entry' so a row written before
+            -- this column existed reads as the narrower scope, never a silent
+            -- fleet-wide one — see coord.drive_queue.QueueEntry.hold_scope.
+            hold_scope    TEXT    NOT NULL DEFAULT 'entry',
             UNIQUE(repo_name, issue_number)
         );
 
@@ -717,6 +724,13 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
         # carries its age instead of rendering a stale snapshot as current
         # state. NULL for every row predating this migration.
         "ALTER TABLE drive_queue ADD COLUMN reason_at REAL",
+        # #2186: deploy-gate SCOPE — see the CREATE TABLE comment above and
+        # coord/drive_queue.py's HOLD_SCOPE_ENTRY/HOLD_SCOPE_FLEET. Every row
+        # predating this migration (and every armed-but-not-yet-fired gate)
+        # defaults to 'entry', the narrower reading — a fired gate on such a
+        # row holds only its own dependents rather than the whole queue, which
+        # is the #2186 fix itself, not just a schema detail.
+        "ALTER TABLE drive_queue ADD COLUMN hold_scope TEXT NOT NULL DEFAULT 'entry'",
     ]
     for sql in migrations:
         try: