code-coordinator 0.5.150__tar.gz → 0.5.154__tar.gz

{code_coordinator-0.5.150 → code_coordinator-0.5.154}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.150
+Version: 0.5.154
 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.154/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.154",
+  "distance": 0,
+  "node": "g318d3f718e0a8945e4363a00807cd76278153173",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-19"
+}

{code_coordinator-0.5.150 → code_coordinator-0.5.154}/coord/commands/drive_queue.py

@@ -71,6 +71,7 @@ from coord.drive_queue import (
     find_cycle,
     fired_holds,
     is_permanent_block_reason,
+    is_unsatisfiable_prereq_reason,
     parse_after_spec,
     parse_key,
     pending_probe_targets,
@@ -562,13 +563,31 @@ _BLOCKED_REMEDY = (
     "actually fixed, not merely because a pre-req merged"
 )
 
-# #2230: `blocked`'s MERGE GATE (as opposed to its `after=` graph, which
-# `_BLOCKED_REMEDY` above still correctly calls never-re-checked) is no
-# longer unconditionally terminal — see `coord.drive_queue.
-# is_permanent_block_reason`/`_reconcile_blocked`. Shown only for `blocked`
-# (never `failed`, which #2230 does not touch at all) so an operator reading
-# `list` right after this ships doesn't have to go read the issue to learn
-# their remove+add might be about to race an automatic resume.
+# #2362: a `blocked` row (never `failed` — the tick's `after=` resume sweep,
+# `coord.drive_queue._reconcile_blocked_after`, is scoped to `blocked` only)
+# whose OWN `last_reason` IS `_resolve_prereqs`'s "queued but blocked/failed
+# — it will never satisfy" verdict is auto re-checked every tick, and
+# resumes to `waiting` on its own the moment every named pre-req lands.
+# `_BLOCKED_REMEDY` above is flatly wrong for exactly this row shape (it is
+# in fact re-checked, on its own, without an operator) — this note replaces
+# it there instead of merely appending, mirroring #2230's own concern: an
+# operator told "never re-checked" for a row about to self-resume would
+# either do a needless remove+add or race the automatic one.
+_BLOCKED_AFTER_NOTE = (
+    "remedy: {state}'s `after=` graph above IS re-checked automatically "
+    "every tick (#2362) — once every named pre-req lands (`facts.landed`), "
+    "this row resumes to `waiting` on its own, attempt budget reset; no "
+    "operator remove+add needed. See `resumes=` above if it has already "
+    "self-resumed and re-blocked for an unrelated reason."
+)
+
+# #2230: `blocked`'s MERGE GATE (as opposed to its `after=` graph, handled by
+# `_BLOCKED_AFTER_NOTE`/`_BLOCKED_REMEDY` above) is no longer unconditionally
+# terminal — see `coord.drive_queue.is_permanent_block_reason`/
+# `_reconcile_blocked`. Shown only for `blocked` (never `failed`, which
+# #2230 does not touch at all) so an operator reading `list` right after this
+# ships doesn't have to go read the issue to learn their remove+add might be
+# about to race an automatic resume.
 _BLOCKED_GATE_NOTE = (
     "note: a re-evaluable blocked cause (i.e. not a #1844/#2019 permanent "
     "refusal) IS re-checked against the merge gate automatically (#2230) — "
@@ -693,12 +712,37 @@ def drive_queue_list(repo: str | None, output_json: bool, config_path: Path) ->
             # #2183 point 4: `blocked`/`failed` is terminal — say so where the
             # operator is already reading the row, not just in an unrelated
             # operator's hand-written `--hold-after` note.
-            click.echo(f"      {_BLOCKED_REMEDY.format(state=entry.state)}")
+            #
+            # #2404: EXCEPT when this row's own `last_reason` is exactly the
+            # unsatisfiable-`after=`-pre-req verdict on a `blocked` (not
+            # `failed`) entry — that shape auto-resumes on its own every tick
+            # (#2362), so the generic "never re-checked on its own" remedy
+            # would be actively wrong for it; swap in the note that says so.
+            if entry.state == STATE_BLOCKED and is_unsatisfiable_prereq_reason(
+                entry.last_reason
+            ):
+                click.echo(f"      {_BLOCKED_AFTER_NOTE.format(state=entry.state)}")
+            else:
+                click.echo(f"      {_BLOCKED_REMEDY.format(state=entry.state)}")
         # #2230: independent of the `after=` diagnosis above (most `blocked`
         # rows have no `after=` at all — they blocked on attempts, not a
         # pre-req), so gated on the row's OWN state and cause, not `diagnosed`.
-        if entry.state == STATE_BLOCKED and not is_permanent_block_reason(
-            entry.last_reason
+        #
+        # #2404 review: EXCLUDE the unsatisfiable-`after=`-pre-req shape
+        # `_BLOCKED_AFTER_NOTE` above already covers. #2230's sweep
+        # (`_blocked_gate_reading`) returns `None` — "no evidence" — for an
+        # entry that never reached the merge queue at all, which is exactly
+        # what a purely `after=`-caused block is; showing this note there
+        # would stack two auto-recheck notes citing two different issue
+        # numbers under one row, one of which has nothing to say about that
+        # row's actual cause. `is_permanent_block_reason` rows already skip
+        # this note on their own; this adds the sibling exclusion so the two
+        # notes stay mutually exclusive, matching what each mechanism can
+        # actually promise for a given row.
+        if (
+            entry.state == STATE_BLOCKED
+            and not is_permanent_block_reason(entry.last_reason)
+            and not is_unsatisfiable_prereq_reason(entry.last_reason)
         ):
             click.echo(f"      {_BLOCKED_GATE_NOTE}")
         for line in _hold_lines(entry):

{code_coordinator-0.5.150 → code_coordinator-0.5.154}/coord/commands/release.py

@@ -1070,10 +1070,22 @@ def release_propagate(  # noqa: PLR0912, PLR0915 — a pipeline; the decisions a
     gate = rp.scope_verification(record.verification, lanes=record.lanes)
     record.gate = gate.to_dict()
     for finding in gate.advisory:
+        host = finding.get("host")
+        # #2403: elitebook sat on 0.5.146 (expected 0.5.148) for the length
+        # of a cordon's full lifetime with this line as the ONLY signal an
+        # operator got — "fix by hand" with no hand to follow. When the
+        # finding names a host, name the two commands that actually clear
+        # it, so nobody has to derive them from scratch under time pressure.
+        remedy = (
+            f" — run `coord agent update --machine {host}` then "
+            f"`coord release cordon --clear {host}`"
+            if host
+            else ""
+        )
         click.echo(
-            f"  ~ advisory [{finding.get('severity')}] {finding.get('host')} "
+            f"  ~ advisory [{finding.get('severity')}] {host} "
             f"{finding.get('lane')}: {finding.get('summary')} "
-            "— outside propagation's reach, fix by hand",
+            f"— outside propagation's reach, fix by hand{remedy}",
             err=True,
         )
     if gate.unrollable:

{code_coordinator-0.5.150 → code_coordinator-0.5.154}/coord/drive_queue.py

@@ -1600,6 +1600,19 @@ def _is_unsatisfiable_prereq_reason(text: str | None) -> bool:
     return bool(text) and _UNSATISFIABLE_PREREQ_MARKER in text
 
 
+def is_unsatisfiable_prereq_reason(text: str | None) -> bool:
+    """Public alias for :func:`_is_unsatisfiable_prereq_reason`.
+
+    `coord drive-queue list`'s rendering (#2404) needs to tell whether a
+    `blocked` row's frozen ``last_reason`` is the exact shape
+    :func:`_reconcile_blocked_after` (#2362) auto-resumes once every named
+    pre-req lands, so it can stop telling the operator the ``after=`` graph
+    "is never re-checked on its own" for a row where that has stopped being
+    true — see ``coord.commands.drive_queue._BLOCKED_AFTER_NOTE``.
+    """
+    return _is_unsatisfiable_prereq_reason(text)
+
+
 def _reconcile_blocked_after(
     entry: QueueEntry,
     board: BoardView,

{code_coordinator-0.5.150 → code_coordinator-0.5.154}/tests/test_cli_drive_queue.py

@@ -692,6 +692,65 @@ def test_blocked_row_purely_by_an_unsatisfiable_prereq_is_unchanged(cli, seed):
     assert dep_reason in result.output
 
 
+def test_blocked_row_purely_by_an_unsatisfiable_prereq_gets_the_2362_note(
+    cli, seed
+):
+    """#2404: unlike a `blocked` row whose own cause is unrelated to its
+    `after=` graph (genuinely "never re-checked on its own" — see the #542
+    control case above), a row blocked purely because a named pre-req is
+    itself `blocked`/`failed` DOES get re-checked automatically every tick
+    (#2362): the moment that pre-req lands, this row resumes to `waiting` on
+    its own. `list`'s remedy line must say so instead of sending an operator
+    to a needless (or racing) manual `remove`+`add`."""
+    seed(issues={1650: "open"})
+    # 1650: blocked for its own, unrelated reason — nothing re-checks this.
+    cli("add", REPO, "1650")
+    state._update_drive_queue_entry_local(
+        REPO, 1650, state="blocked", last_reason="drive session died"
+    )
+    # 1654 (the #492 shape): blocked ONLY because its pre-req (1650) is
+    # itself blocked — the exact shape #2362's tick sweep auto-resumes.
+    cli("add", REPO, "1654", "--after", "1650")
+    dep_reason = f"pre-req {REPO}#1650 is queued but blocked — it will never satisfy"
+    state._update_drive_queue_entry_local(
+        REPO, 1654, state="blocked", last_reason=dep_reason
+    )
+
+    result = cli("list")
+    assert result.exit_code == 0, result.output
+
+    # 1650 has no `after=` at all, so #2183's diagnosis (and any remedy
+    # line) never applies to it — nothing to assert there beyond it existing.
+    assert _row_for(result.output, f"{REPO}#1650")
+
+    # Split the transcript at 1654's own row header — 1654 is the last
+    # (only remaining) row, so everything from there on is exactly ITS
+    # block (summary/last:/note lines), never 1650's.
+    idx_1654 = result.output.index(f"{REPO}#1654")
+    block_1650 = result.output[:idx_1654]
+    block_1654 = result.output[idx_1654:]
+
+    # 1654's remedy line is the new #2362 note, not the stale "never
+    # re-checked on its own" advice — this row auto-resumes without an
+    # operator.
+    assert "IS re-checked automatically every tick (#2362)" in block_1654
+    assert "no operator remove+add needed" in block_1654
+    assert "never re-checked on its own" not in block_1654
+
+    # #2404 review (non-blocking finding): #2230's merge-gate note must NOT
+    # also print for this row. `_blocked_gate_reading` returns `None` — no
+    # evidence — for an entry that never reached the merge queue, which is
+    # exactly what a purely `after=`-caused block is; showing it here would
+    # stack two auto-recheck notes citing two different issue numbers under
+    # one row, one of which has nothing to say about this row's real cause.
+    assert "re-checked against the merge gate automatically (#2230)" not in block_1654
+
+    # …but an ordinary blocked row whose cause is unrelated to its `after=`
+    # graph (1650, blocked on "drive session died") still gets #2230's note
+    # exactly as before — this exclusion is scoped to the #2362 shape only.
+    assert "re-checked against the merge gate automatically (#2230)" in block_1650
+
+
 def test_list_with_no_after_is_unaffected_by_the_2183_diagnosis(cli):
     """A `blocked` entry that never declared any `after=` at all keeps
     rendering exactly as it always has — no board dependency, no remedy

{code_coordinator-0.5.150 → code_coordinator-0.5.154}/tests/test_cli_release_propagate.py

@@ -847,6 +847,57 @@ def test_a_green_roll_is_verified_and_journalled(valid_config_path, state_dir,
     assert record["verification"]["severity"] == "ok"
 
 
+def test_a_waiting_between_legs_entry_rolls_its_host_normally(
+    valid_config_path, state_dir, no_network, monkeypatch
+):
+    """#2403, end to end: `laptop`'s only queue entry is `waiting` — deferred
+    by an unrelated repo-capacity cap (#1972), exactly `claude-coordinator
+    #2005`'s live shape on 2026-08-18 — with a terminal assignment recording
+    `laptop` as its last worker. #2240's "last known host" fallback exists
+    for a `running` between-legs row; it must not reach a `waiting` one. A
+    genuinely idle `laptop` has to roll and verify like any other free host,
+    not sit deferred and cordoned on the strength of a queue row that never
+    launched anything."""
+    monkeypatch.setattr(
+        release_cmd, "_fetch_board",
+        lambda: (
+            {
+                "drive_queue": [
+                    {"repo_name": "api", "issue_number": 2005,
+                     "state": "waiting", "deferrals": 3, "attempts": 2},
+                ],
+                "assignments": [
+                    {"repo_name": "api", "issue_number": 2005,
+                     "machine_name": "laptop", "status": "COMPLETED",
+                     "dispatched_at": 100.0},
+                ],
+            },
+            None,
+        ),
+    )
+    calls = _stub_lanes(monkeypatch)
+    _stub_verify(monkeypatch, versions={"laptop": ["0.4.110"], "server": ["0.4.110"]},
+                 daemon="server")
+    result = CliRunner().invoke(
+        main,
+        ["release", "propagate", "--config", str(valid_config_path),
+         "--target", "0.4.111"],
+    )
+    assert result.exit_code == 0, result.output
+    assert rp.STATUS_DEFERRED not in result.output
+    assert any(host == "laptop" for _lane, host in calls), (
+        "a waiting queue row must never defer the host it names as its "
+        "last known worker"
+    )
+    record = _records(state_dir)[0]
+    assert record["status"] == rp.STATUS_VERIFIED
+    assert not any(
+        l["host"] == "laptop" and l["lane"] == "-" for l in record["lanes"]
+    )
+    # Nothing is left cordoned behind a row that was never actually running.
+    assert mp.cordoned_names() == set()
+
+
 def test_a_red_verification_rolls_every_updated_host_back(valid_config_path, state_dir,
                                                           no_network, monkeypatch):
     """#1835: 'a red post-deploy verification must roll back, not just
@@ -1221,6 +1272,47 @@ def test_2026_08_09_a_good_roll_is_not_reverted_by_lanes_it_cannot_roll(
     assert "advisory" in result.output
 
 
+def test_the_outside_reach_message_names_the_manual_remedy(
+    valid_config_path, state_dir, no_network, monkeypatch
+):
+    """#2403: elitebook sat behind for the length of a cordon's lifetime with
+    only `"outside propagation's reach, fix by hand"` as its signal — no
+    remedy, just an instruction to invent one under time pressure. A
+    finding that names a host must name the two commands that actually fix
+    it: `coord agent update --machine <host>` and `coord release cordon
+    --clear <host>`."""
+    from coord import release_verify as rv
+
+    # `laptop` has a live assignment, so its python lane is deferred (never
+    # attempted) this run — exactly why its own version-mismatch finding
+    # lands as advisory rather than blocking (#2052's `attempted_scope`).
+    monkeypatch.setattr(
+        release_cmd, "_fetch_board",
+        lambda: ({"assignments": [{"machine_name": "laptop", "issue_number": 9,
+                                   "status": "RUNNING"}]}, None),
+    )
+    _stub_lanes(monkeypatch)
+    _stub_verify(
+        monkeypatch,
+        versions={"laptop": ["0.4.110"], "server": ["0.4.110"]},
+        daemon="server",
+        findings=[
+            rv.Finding(severity="crit", host="laptop",
+                       lane="~/.coord-venv (laptop)",
+                       summary="on 0.4.104, expected 0.4.111"),
+        ],
+    )
+    result = CliRunner().invoke(
+        main,
+        ["release", "propagate", "--config", str(valid_config_path),
+         "--target", "0.4.111"],
+    )
+    assert result.exit_code == 0, result.output
+    assert "outside propagation's reach, fix by hand" in result.output
+    assert "coord agent update --machine laptop" in result.output
+    assert "coord release cordon --clear laptop" in result.output
+
+
 def test_a_crit_on_a_lane_this_run_rolled_still_reverts(valid_config_path, state_dir,
                                                         no_network, monkeypatch):
     """Scoping the gate is not removing it."""

{code_coordinator-0.5.150 → code_coordinator-0.5.154}/tests/test_drive_queue.py

@@ -2433,6 +2433,116 @@ def test_a_permanently_blocked_entry_is_not_resumed_even_once_its_after_lands():
     assert plan.launch is None
 
 
+# ── #2404 review: a CHAINED (two-hop) after= block, not just single-hop ────
+#
+# The live incident this issue is about (claude-coordinator#2284-#2288) was
+# never a single `after=` edge: #2284-#2288 all declared `after=2283`, and
+# #2283 was ITSELF `blocked` on `after=2282` — a two-hop chain (root 2282 ->
+# middle 2283 -> leaf 2284..2288), not the one-hop shape every test above
+# pins. `_reconcile_blocked_after`'s resume check is driven entirely by
+# `board.facts(dep).landed` — a real, board-derived merge fact, never by a
+# dependency's in-tick `states` entry — so in principle each hop should
+# resolve independently the moment ITS OWN named pre-req actually lands,
+# with no special-casing needed for the chain shape. These two tests are the
+# repro the review asked for: they exercise `plan_tick` against an actual
+# two-hop graph to confirm that holds (it does), and pin the one subtlety a
+# naive "chain" fix could get wrong — a leaf must not resume just because
+# its immediate pre-req was ITSELF re-queued to `waiting` this same tick;
+# only that pre-req actually landing (merged/closed) may resume the leaf.
+
+
+def test_a_two_hop_after_chain_resumes_in_one_tick_once_both_hops_have_landed():
+    """The exact live-incident shape: by the time anyone looked, BOTH the
+    root (2282-analog) and the middle (2283-analog) pre-reqs had already
+    merged — the middle's queue row just hadn't been reconciled yet. A
+    single tick must resolve the WHOLE chain: the middle reconciles to
+    `done` via #2055's landed check, and the leaf (2284..2288-analog),
+    reading the middle's REAL board fact rather than its stale on-disk
+    `blocked` state, resumes to `waiting` in that same tick — no operator
+    action, and no second tick needed once both merges are real."""
+    root = entry_key(REPO, 1650)
+    middle = entry_key(REPO, 1654)
+    entries = [
+        entry(1650, position=0, state=STATE_DONE),
+        entry(
+            1654,
+            position=1,
+            after=(root,),
+            state=STATE_BLOCKED,
+            attempts=2,
+            last_reason=f"pre-req {root} is queued but blocked — it will never satisfy",
+        ),
+        entry(
+            1658,
+            position=2,
+            after=(middle,),
+            state=STATE_BLOCKED,
+            attempts=1,
+            last_reason=f"pre-req {middle} is queued but blocked — it will never satisfy",
+        ),
+    ]
+    # Both the root AND the middle have actually merged — mirrors the live
+    # incident, where #2283 (middle) itself showed `done — issue already
+    # merged while blocked (#2055)` once anyone looked.
+    plan = plan_tick(entries, board(merged=(1650, 1654)), capacity=3)
+
+    middle_reconcile = next(r for r in plan.reconciles if r.key == middle)
+    assert middle_reconcile.outcome == "done"
+    assert middle_reconcile.updates["state"] == STATE_DONE
+
+    leaf_reconcile = next(r for r in plan.reconciles if r.key == entry_key(REPO, 1658))
+    assert leaf_reconcile.outcome == "resumed"
+    assert leaf_reconcile.updates["state"] == STATE_WAITING
+    assert leaf_reconcile.updates["attempts"] == 0
+    assert leaf_reconcile.updates["resumes"] == 1
+
+    # …and, exactly like the single-hop case, the freshly-resumed leaf falls
+    # straight into this SAME tick's launch selection.
+    assert plan.launch is not None and plan.launch.issue == 1658
+
+
+def test_a_two_hop_after_chain_leaf_is_not_resumed_until_its_own_pre_req_lands():
+    """Guard against the false-resume a naive "propagate through `states`"
+    chain fix would introduce: once the root lands, the middle correctly
+    resumes to `waiting` THIS tick (single-hop #2362 behaviour) — but the
+    leaf's own named pre-req is the MIDDLE, which has only been re-queued,
+    not merged. The leaf must stay `blocked` until the middle itself
+    actually lands, even though `states[middle]` already reads `waiting` by
+    the time the leaf is walked in this same tick."""
+    root = entry_key(REPO, 1650)
+    middle = entry_key(REPO, 1654)
+    entries = [
+        entry(1650, position=0, state=STATE_DONE),
+        entry(
+            1654,
+            position=1,
+            after=(root,),
+            state=STATE_BLOCKED,
+            attempts=2,
+            last_reason=f"pre-req {root} is queued but blocked — it will never satisfy",
+        ),
+        entry(
+            1658,
+            position=2,
+            after=(middle,),
+            state=STATE_BLOCKED,
+            attempts=1,
+            last_reason=f"pre-req {middle} is queued but blocked — it will never satisfy",
+        ),
+    ]
+    # Only the root has landed — the middle has not (it is only about to be
+    # re-queued to `waiting` THIS tick, not merged).
+    plan = plan_tick(entries, board(merged=(1650,)), capacity=3)
+
+    middle_reconcile = next(r for r in plan.reconciles if r.key == middle)
+    assert middle_reconcile.outcome == "resumed"
+    assert middle_reconcile.updates["state"] == STATE_WAITING
+
+    # The leaf gets NO reconcile at all this tick — it stays blocked, with
+    # its existing (still-true) "it will never satisfy" reason untouched.
+    assert all(r.key != entry_key(REPO, 1658) for r in plan.reconciles)
+
+
 def test_is_unsatisfiable_prereq_reason_recognises_only_the_exact_verdict_shape():
     from coord.drive_queue import _is_unsatisfiable_prereq_reason
 

{code_coordinator-0.5.150 → code_coordinator-0.5.154}/tests/test_release_propagate.py

@@ -332,6 +332,39 @@ def test_an_unpinned_entry_between_legs_is_unattributable_not_launch_host():
     assert q.rollable_hosts(["dellserver", "elitebook"]) == []
 
 
+def test_a_waiting_entry_between_legs_is_not_attributed_to_its_last_known_host():
+    """#2403, live 2026-08-18 ~23:17 UTC: elitebook was genuinely idle
+    (`active: []` on both `/status` and `/health`), and `coord drive-queue
+    list` showed `claude-coordinator#2005` in state `waiting` — deferred by
+    an unrelated per-repo concurrency cap, not running anywhere. `coord
+    release propagate` nonetheless deferred and cordoned elitebook, reading
+    the log line #2240's fix writes for a genuinely *between-legs* `running`
+    row: "attributed to its last known host".
+
+    #2240's fallback (`_last_assignment_hosts`) exists to narrow an
+    unattributable RUNNING row from fleet-wide to one host — it is not
+    licence to treat a WAITING row as though it were running just because it
+    once had an assignment. Only `state == STATE_RUNNING` may reach that
+    fallback at all; a `waiting` row — however recently it ran, however many
+    times it has been deferred — has no live assignment and no in-flight
+    process anywhere, and must roll its host normally."""
+    entry = {"repo_name": "claude-coordinator", "issue_number": 2005,
+             "state": STATE_WAITING, "deferrals": 3, "attempts": 2}
+    q = rp.assess_quiescence(
+        queue_entries=[entry],
+        # The exact shape `_last_assignment_hosts` reads: a terminal
+        # assignment naming elitebook as the entry's last worker.
+        assignments=[{"repo_name": "claude-coordinator", "issue_number": 2005,
+                      "machine_name": "elitebook", "status": "COMPLETED",
+                      "dispatched_at": 100.0}],
+    )
+    assert q.busy == ()
+    assert q.quiescent
+    assert q.rollable_hosts(["dellserver", "elitebook", "precision"]) == [
+        "dellserver", "elitebook", "precision",
+    ]
+
+
 def test_a_live_assignment_is_attributed_to_its_machine():
     q = rp.assess_quiescence(
         assignments=[{"machine_name": "dellserver", "issue_number": 42,

{code_coordinator-0.5.150 → code_coordinator-0.5.154}/tui/src/app/data.rs

@@ -2626,7 +2626,19 @@ pub(crate) fn start_data_load() -> std::sync::mpsc::Receiver<BoardData> {
     // the real local SQLite DB and overwrite pipeline_issues / data.assignments
     // with whatever the developer's coord.db currently contains, making
     // TuiDriver tests non-deterministic and machine-dependent.
-    #[cfg(test)]
+    //
+    // #2284 (ms-65 §3, manifest finding 7): gated on `feature = "test-support"`
+    // too, not just `cfg(test)` — the sealed `tests/acceptance/**` suite
+    // (`tui/tests/acceptance.rs`, the #1042 seam) is a separate integration-test
+    // crate, so the `coord_tui` it links against is built *without* `cfg(test)`
+    // (only the top-level `cargo test` binary gets that cfg). Without this
+    // widening, entering the Pipeline panel in that suite kicks
+    // `maybe_kick_pipeline_loader` -> `refresh` -> this function, which fell
+    // through to the real network/SQLite path and wholesale-replaced the
+    // seeded fixture on the very next dispatched event (a RACE — whichever
+    // finished first) — mirrors the exact same trap `resolve_board_service`
+    // above already widened for (#1039).
+    #[cfg(any(test, feature = "test-support"))]
     {
         let _ = tx.send(BoardData::default());
         return rx;