code-coordinator 0.5.52__tar.gz → 0.5.55__tar.gz

{code_coordinator-0.5.52 → code_coordinator-0.5.55}/.github/workflows/test.yml

@@ -115,6 +115,55 @@ jobs:
       - run: pip install -e ".[dev]"
       - run: scripts/run_tests_without_gh.sh python -m pytest tests/ -q
 
+  # #2170: run the full suite in the environment of a REAL FLEET MACHINE — a
+  # populated `~/.coord/` (thin-client shaped), no `sqlite3` on PATH, and a
+  # `$TMPDIR` under an ancestor pytest config.
+  #
+  # This job exists because the `test` matrix above is structurally incapable
+  # of catching the class it covers. Six tests failed on `origin/main` on every
+  # fleet machine while `ubuntu-latest` stayed green on 3.12 AND 3.13 — the
+  # INVERSE of the familiar "passes locally, fails only in CI ⇒ ambient $HOME"
+  # pattern. They passed in CI *precisely because* CI's `$HOME` is empty, and a
+  # matrix whose only environment is the empty one can never see that.
+  #
+  # What it cost while invisible: the Test stage on `precision` could not
+  # produce a green verdict for this repo on ANY branch. Every dispatch there
+  # returned `SMOKE: fail`, the branch was blamed for breakage it did not
+  # cause, and a human read the log and adjudicated — 11m36s and $0.61 for zero
+  # signal about the branch, repeatedly, for months (claude-coordinator#2158).
+  #
+  # SAME SHAPE AS `no-gh-on-path` ABOVE, AND FOR THE SAME REASON. That job
+  # (#1484) exists because a host-dependent `gh` made the suite's result depend
+  # on the machine rather than the code; this one exists because a
+  # host-dependent `$HOME`/`$PATH`/`$TMPDIR` did the same thing in the opposite
+  # direction. Both mask by NAME rather than by dropping PATH directories — see
+  # `scripts/run_tests_in_populated_home.sh`'s header for why
+  # `PATH=/usr/bin:/bin` is the wrong recipe here.
+  #
+  # `tests/test_ambient_home_isolation.py` pins the specific affected targets
+  # on every run everywhere (including this job, and including a fleet
+  # machine's own Test leg) — that is the always-on gate, and it is what fails
+  # first if one of the three regresses. THIS job is the whole-suite sweep: it
+  # is what finds the NEXT test of this class before a fleet machine does.
+  # Verified at authoring time: 9590 passed, 13 skipped under these three knobs.
+  populated-home:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]"
+      - run: scripts/run_tests_in_populated_home.sh python -m pytest tests/ -q
+      - name: What a red result here means
+        if: failure()
+        run: |
+          echo "::error::The suite is red under a POPULATED \$HOME (thin-client ~/.coord/, no sqlite3 on PATH, \$TMPDIR under an ancestor pytest config) while the plain 'test' job may well be green."
+          echo "That difference IS the finding, not noise: a test that needs an empty \$HOME cannot pass on any fleet machine, so the Test stage there can never go green and every dispatch costs a human adjudication (#2170)."
+          echo "Fix the TEST's isolation -- redirect \$HOME/XDG at tmp_path, drop COORD_SERVICE_URL/COORD_TOKEN/COORD_CONFIG, skip-guard an unprovisioned system binary, pin a nested pytest's --rootdir."
+          echo "Do NOT fix it by making the product trust an ambient path: 'coord config --config' is deliberately NOT authoritative on a thin client (CLAUDE.md, docs/EPHEMERAL_WORKERS.md)."
+          echo "Reproduce locally: scripts/run_tests_in_populated_home.sh python -m pytest tests/ -q"
+
   # #906: run the test suite in thin-client mode with COORD_STRICT_LOCAL_BOARD=1
   # so any board touch reachable from a thin-client path raises RuntimeError
   # instead of silently no-oping against an empty local DB.  This job catches

{code_coordinator-0.5.52/code_coordinator.egg-info → code_coordinator-0.5.55}/PKG-INFO

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

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

@@ -385,6 +385,7 @@ scripts/coord-test-runner.sh
 scripts/drive-batch.sh
 scripts/gen_board_fixture.py
 scripts/next_release_tag.py
+scripts/run_tests_in_populated_home.sh
 scripts/run_tests_without_gh.sh
 scripts/smoke_437_interactive.py
 scripts/verify_878_review_capture.py
@@ -425,6 +426,7 @@ tests/test_agent_update.py
 tests/test_agent_update_bluegreen.py
 tests/test_agent_usage_limit.py
 tests/test_agent_zero_commit.py
+tests/test_ambient_home_isolation.py
 tests/test_approve_reject_plan.py
 tests/test_approve_usage_gate.py
 tests/test_assignment_already_recorded_daemon.py
@@ -513,6 +515,7 @@ tests/test_config_usage_gate.py
 tests/test_conflict_fix.py
 tests/test_conflict_fix_semantic.py
 tests/test_coord_test.py
+tests/test_coord_test_runner_baseline.py
 tests/test_coord_test_runner_routing.py
 tests/test_coord_test_runner_toolchain.py
 tests/test_coord_web_sse_restart_live.py
@@ -640,6 +643,7 @@ tests/test_providers.py
 tests/test_providers_config_labels.py
 tests/test_providers_pty.py
 tests/test_quiet_hours.py
+tests/test_quiet_hours_store_2146.py
 tests/test_reap_merged_sessions.py
 tests/test_reap_stale_interactive_tick.py
 tests/test_reconcile_branch.py

{code_coordinator-0.5.52 → code_coordinator-0.5.55}/code_coordinator.egg-info/scm_file_list.json

@@ -375,6 +375,7 @@
     "scripts/drive-batch.sh",
     "scripts/gen_board_fixture.py",
     "scripts/next_release_tag.py",
+    "scripts/run_tests_in_populated_home.sh",
     "scripts/run_tests_without_gh.sh",
     "scripts/smoke_437_interactive.py",
     "scripts/verify_878_review_capture.py",
@@ -455,6 +456,7 @@
     "tests/test_agent_update_bluegreen.py",
     "tests/test_agent_usage_limit.py",
     "tests/test_agent_zero_commit.py",
+    "tests/test_ambient_home_isolation.py",
     "tests/test_approve_reject_plan.py",
     "tests/test_approve_usage_gate.py",
     "tests/test_assignment_already_recorded_daemon.py",
@@ -543,6 +545,7 @@
     "tests/test_conflict_fix.py",
     "tests/test_conflict_fix_semantic.py",
     "tests/test_coord_test.py",
+    "tests/test_coord_test_runner_baseline.py",
     "tests/test_coord_test_runner_routing.py",
     "tests/test_coord_test_runner_toolchain.py",
     "tests/test_coord_web_sse_restart_live.py",
@@ -670,6 +673,7 @@
     "tests/test_providers_config_labels.py",
     "tests/test_providers_pty.py",
     "tests/test_quiet_hours.py",
+    "tests/test_quiet_hours_store_2146.py",
     "tests/test_reap_merged_sessions.py",
     "tests/test_reap_stale_interactive_tick.py",
     "tests/test_reconcile_branch.py",

{code_coordinator-0.5.52 → code_coordinator-0.5.55}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.52",
+  "tag": "0.5.55",
   "distance": 0,
-  "node": "g330dc07157c3cfc0656c8d93b6c7d8a59ca29394",
+  "node": "g20ff70836aa359817f5f585fff5a5b9a075bb022",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-13"

{code_coordinator-0.5.52 → code_coordinator-0.5.55}/coord/cli.py

@@ -55,7 +55,7 @@ from coord.commands.setup import (
     install_skills,
     version,
 )
-from coord.commands.agent_ops import agent, pause, unpause
+from coord.commands.agent_ops import agent, pause, quiet_hours, unpause
 from coord.commands.gates import gates
 from coord.commands.status import diagnose, doctor, show_plan, status, usage
 from coord.commands.dispatch import (
@@ -376,6 +376,8 @@ main.add_command(bounce)
 main.add_command(sync)
 main.add_command(pause)
 main.add_command(unpause)
+# #2146: set a machine's quiet-hours window without a coordinator session.
+main.add_command(quiet_hours)
 main.add_command(refine_chat)
 main.add_command(test_chat)
 main.add_command(new_issue_chat)

{code_coordinator-0.5.52 → code_coordinator-0.5.55}/coord/client.py

@@ -283,6 +283,65 @@ def post_cordon(
     return post_record(svc, "/pause", payload, timeout=timeout)
 
 
+def fetch_quiet_hours(
+    svc: ServiceConfig, *, timeout: float = _DEFAULT_TIMEOUT
+) -> dict[str, dict]:
+    """GET /pause → the daemon's effective quiet-hours windows (#2146).
+
+    ``{machine: {start, end, tz, source}}`` for every machine with a window,
+    whether it currently covers "now" or not — a thin client needs the whole
+    map to render `coord quiet-hours --list` and to pre-fill a dialog, not
+    just the subset that happens to be active this minute.
+
+    ``{}`` when the daemon predates #2146 (the key is simply absent), which
+    is the right read for a daemon that has no operator-set store. Raises
+    ``httpx.HTTPError`` on transport/HTTP failure —
+    `coord.machine_pause.effective_quiet_hours()` catches that and degrades
+    to "no windows known", the same fail-soft read posture as
+    `fetch_paused_machines`.
+    """
+    resp = httpx.get(f"{svc.url}/pause", headers=_headers(svc), timeout=timeout)
+    resp.raise_for_status()
+    data = resp.json()
+    rows = data.get("quiet_hours") if isinstance(data, dict) else None
+    if not isinstance(rows, dict):
+        return {}
+    return {str(k): dict(v) for k, v in rows.items() if isinstance(v, dict)}
+
+
+def post_quiet_hours(
+    svc: ServiceConfig,
+    machine: str,
+    action: str,
+    *,
+    start: str | None = None,
+    end: str | None = None,
+    tz: str | None = None,
+    timeout: float = _WRITE_TIMEOUT,
+) -> dict:
+    """POST /pause {machine, action: set-quiet|clear-quiet, ...} (#2146).
+
+    Deliberately the SAME endpoint as pause/cordon: a quiet-hours window is
+    the same routing decision on a schedule, and one endpoint means one
+    place a thin client can be wrong about it.
+
+    Raises ``httpx.HTTPError`` on transport/HTTP failure — the whole point
+    of #2146 is that a thin client cannot edit `coordinator.yml` (its copy
+    is an overwritten cache), so a write that reported success and reached
+    nothing would rebuild the exact bug this closes. A daemon that predates
+    #2146 answers 400 ``unknown action``, which surfaces here as an
+    ``HTTPStatusError`` rather than a silent no-op: deploy the daemon first.
+    """
+    payload: dict = {"machine": machine, "action": action}
+    if start is not None:
+        payload["start"] = start
+    if end is not None:
+        payload["end"] = end
+    if tz is not None:
+        payload["tz"] = tz
+    return post_record(svc, "/pause", payload, timeout=timeout)
+
+
 def post_pause(
     svc: ServiceConfig, machine: str, action: str, *, timeout: float = _WRITE_TIMEOUT
 ) -> dict:

{code_coordinator-0.5.52 → code_coordinator-0.5.55}/coord/commands/agent_ops.py

@@ -1386,4 +1386,253 @@ def unpause(config_path: Path, machine: str) -> None:
             f"({outcome.tz}) — resumes its normal quiet schedule next window"
         )
     else:
-        click.echo(f"not paused: {machine}")
+        click.echo(f"not paused: {machine}")
+
+
+# ── #2146: `coord quiet-hours` ──────────────────────────────────────────────
+
+
+def _local_tz_name() -> str | None:
+    """The CLIENT's IANA zone name, or None if it can't be determined.
+
+    #2146: `--tz` must default to the operator's own zone — they mean "22:00
+    MY time", and the daemon runs UTC, so defaulting to the daemon's clock
+    would fire hours off. `datetime.now().astimezone().tzinfo` gives an
+    ABBREVIATION ("CDT"), not an IANA name `ZoneInfo` can resolve, so this
+    walks the usual POSIX sources first and only falls back to that.
+
+    Returning None (rather than guessing "UTC") is deliberate: the caller
+    turns it into "pass --tz explicitly", because a silently-UTC window is
+    exactly the wrong-hour failure #1862 made `tz` mandatory to prevent.
+    """
+    from zoneinfo import ZoneInfo  # noqa: PLC0415
+
+    def _ok(name: str | None) -> str | None:
+        if not name or name in ("localtime", "UTC0"):
+            return None
+        try:
+            ZoneInfo(name)
+        except Exception:  # noqa: BLE001 — not a resolvable zone, try the next source
+            return None
+        return name
+
+    candidates: list[str | None] = [os.environ.get("TZ")]
+    try:
+        candidates.append(Path("/etc/timezone").read_text(encoding="utf-8").strip())
+    except OSError:
+        pass
+    try:
+        parts = Path("/etc/localtime").resolve().parts
+        if "zoneinfo" in parts:
+            candidates.append("/".join(parts[parts.index("zoneinfo") + 1:]))
+    except OSError:
+        pass
+    from datetime import datetime as _dt  # noqa: PLC0415
+
+    candidates.append(_dt.now().astimezone().tzname())
+    for candidate in candidates:
+        resolved = _ok(candidate)
+        if resolved is not None:
+            return resolved
+    return None
+
+
+def _parse_window_arg(window: str) -> tuple[str, str]:
+    """``"22:00-08:00"`` → ``("22:00", "08:00")``. Shape only — the real
+    validation (HH:MM, IANA tz, start != end) is `coord.config`'s, so the
+    CLI can never accept a window `coordinator.yml` would reject."""
+    parts = window.split("-")
+    if len(parts) != 2 or not parts[0].strip() or not parts[1].strip():
+        raise ValueError(
+            f"window must look like '22:00-08:00', got {window!r}"
+        )
+    return parts[0].strip(), parts[1].strip()
+
+
+def _quiet_hours_rows(machines: Any) -> dict[str, dict]:
+    from coord.machine_pause import effective_quiet_hours  # noqa: PLC0415
+
+    return effective_quiet_hours(machines)
+
+
+def _describe_source(source: str) -> str:
+    return "set here" if source == "store" else "coordinator.yml"
+
+
+@click.command(
+    "quiet-hours",
+    help=(
+        "Show or set a machine's recurring no-new-dispatch window (#2146).\n\n"
+        "\b\n"
+        "  coord quiet-hours MACHINE 22:00-08:00 [--tz America/Chicago]\n"
+        "  coord quiet-hours MACHINE --clear\n"
+        "  coord quiet-hours [MACHINE] --list\n"
+        "  coord quiet-hours MACHINE --print-yaml\n\n"
+        "A window set here is stored on the DAEMON (alongside pauses and "
+        "release cordons) and overrides that machine's coordinator.yml "
+        "`quiet_hours:` block entirely — it does not rewrite the YAML. "
+        "`--print-yaml` emits a paste-ready block for when a window should "
+        "become permanent and version-controlled.\n\n"
+        "--tz defaults to THIS machine's zone, never the daemon's UTC, and "
+        "the resolved zone is echoed back so a wrong default is visible "
+        "immediately."
+    ),
+)
+
+
+@_CONFIG_OPTION
+@click.argument("machine", required=False)
+@click.argument("window", required=False)
+@click.option("--tz", "tz", default=None, help="IANA zone (default: this machine's).")
+@click.option("--clear", "clear_", is_flag=True, help="Remove an operator-set window.")
+@click.option("--list", "list_", is_flag=True, help="Show windows and where they came from.")
+@click.option(
+    "--print-yaml",
+    "print_yaml",
+    is_flag=True,
+    help="Emit a coordinator.yml `quiet_hours:` block for MACHINE.",
+)
+def quiet_hours(
+    config_path: Path,
+    machine: str | None,
+    window: str | None,
+    tz: str | None,
+    clear_: bool,
+    list_: bool,
+    print_yaml: bool,
+) -> None:
+    from coord.machine_pause import clear_quiet_hours, set_quiet_hours  # noqa: PLC0415
+
+    # Best-effort config, exactly like `unpause` above: an unloadable config
+    # must not block the (fully functional) store path — it only means
+    # coordinator.yml-sourced windows can't be listed alongside store ones.
+    machines = None
+    try:
+        from coord.config import load as _load_yaml_config  # noqa: PLC0415
+
+        machines = _load_yaml_config(config_path).machines
+    except Exception:  # noqa: BLE001
+        pass
+
+    if list_ or (machine is None and not (clear_ or print_yaml or window)):
+        rows = _quiet_hours_rows(machines)
+        if machine is not None:
+            rows = {k: v for k, v in rows.items() if k == machine}
+        if not rows:
+            click.echo(
+                "no quiet hours set"
+                + (f" for {machine}" if machine else "")
+                + " (set one: coord quiet-hours MACHINE 22:00-08:00)"
+            )
+            return
+        width = max(len(name) for name in rows)
+        for name, row in sorted(rows.items()):
+            click.echo(
+                f"{name.ljust(width)}  {row.get('start')}-{row.get('end')}  "
+                f"{row.get('tz')}  [{_describe_source(str(row.get('source') or ''))}]"
+            )
+        return
+
+    if machine is None:
+        click.echo("error: MACHINE is required", err=True)
+        sys.exit(2)
+
+    if print_yaml:
+        # The promotion path: a window that has proved itself belongs in
+        # version control, where a daemon rebuild can't lose it.
+        if window is not None:
+            try:
+                start, end = _parse_window_arg(window)
+            except ValueError as e:
+                click.echo(f"error: {e}", err=True)
+                sys.exit(2)
+            zone = tz or _local_tz_name()
+        else:
+            row = _quiet_hours_rows(machines).get(machine)
+            if row is None:
+                click.echo(
+                    f"error: no quiet hours known for {machine!r} — pass a window "
+                    "(e.g. `coord quiet-hours MACHINE 22:00-08:00 --print-yaml`)",
+                    err=True,
+                )
+                sys.exit(1)
+            start, end, zone = row.get("start"), row.get("end"), tz or row.get("tz")
+        if not zone:
+            click.echo(
+                "error: could not determine a time zone — pass --tz "
+                "(e.g. --tz America/Chicago)",
+                err=True,
+            )
+            sys.exit(2)
+        click.echo(f"  # machines[] entry for {machine!r} in coordinator.yml")
+        click.echo("  quiet_hours:")
+        click.echo(f'    start: "{start}"')
+        click.echo(f'    end: "{end}"')
+        click.echo(f'    tz: "{zone}"')
+        return
+
+    if clear_:
+        # #2146 acceptance: "nothing set" is NOT success. A machine can still
+        # have a coordinator.yml block this cannot touch, and reporting
+        # "cleared" for a no-op is the failure class this feature exists to
+        # avoid.
+        try:
+            changed = clear_quiet_hours(machine)
+        except Exception as e:  # noqa: BLE001
+            click.echo(
+                f"error: could not confirm clearing quiet hours for {machine!r} "
+                f"with the daemon: {e}",
+                err=True,
+            )
+            sys.exit(1)
+        if not changed:
+            click.echo(f"nothing set: {machine} has no operator-set quiet hours")
+            return
+        click.echo(f"cleared: {machine} quiet hours")
+        row = _quiet_hours_rows(machines).get(machine)
+        if row is not None:
+            click.echo(
+                f"note: {machine} still has a coordinator.yml window "
+                f"{row.get('start')}-{row.get('end')} ({row.get('tz')})"
+            )
+        return
+
+    if window is None:
+        click.echo(
+            "error: pass a window (e.g. `coord quiet-hours MACHINE 22:00-08:00`), "
+            "--clear, --list or --print-yaml",
+            err=True,
+        )
+        sys.exit(2)
+    try:
+        start, end = _parse_window_arg(window)
+    except ValueError as e:
+        click.echo(f"error: {e}", err=True)
+        sys.exit(2)
+    zone = tz or _local_tz_name()
+    if not zone:
+        click.echo(
+            "error: could not determine this machine's time zone — pass --tz "
+            "(e.g. --tz America/Chicago). Quiet hours never default to the "
+            "daemon's UTC clock: it would fire at the wrong local hour.",
+            err=True,
+        )
+        sys.exit(2)
+
+    # #1563/#2146: fail loudly. A thin client's write that never reaches the
+    # daemon must not print a confirmation.
+    try:
+        stored = set_quiet_hours(machine, start=start, end=end, tz=zone)
+    except Exception as e:  # noqa: BLE001
+        click.echo(
+            f"error: could not set quiet hours for {machine!r}: {e}",
+            err=True,
+        )
+        sys.exit(1)
+    # Echo the RESOLVED zone: a wrong `--tz` default is otherwise invisible
+    # until the machine goes quiet at the wrong hour.
+    click.echo(
+        f"quiet hours set: {machine} {stored.get('start')}-{stored.get('end')} "
+        f"({stored.get('tz')}) — overrides any coordinator.yml block for this "
+        f"machine; `coord quiet-hours {machine} --print-yaml` to make it permanent"
+    )

{code_coordinator-0.5.52 → code_coordinator-0.5.55}/coord/commands/status.py

@@ -130,13 +130,21 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
     # render "PAUSED" for a machine nobody paused and no `coord unpause` will
     # free — work stopping with no stated reason, which is the exact failure
     # the cordon mechanism is supposed to stop repeating.
+    # #2146: an operator-SET quiet-hours window lives in the daemon's state
+    # file, not in coordinator.yml, so a thin client resolving it locally
+    # would see the machine in `paused` with no local explanation and print
+    # the flatly wrong "PAUSED". Fetch the effective window map (daemon-aware,
+    # fail-soft) and hand it to describe_pause_state, which also names where
+    # each window came from — "set here" vs "from coordinator.yml".
     from coord.machine_pause import (  # noqa: PLC0415
         cordons as fetch_cordons,
         describe_pause_state,
+        effective_quiet_hours,
         paused_set,
     )
     paused = paused_set(cfg.machines)
     cordons = fetch_cordons()
+    quiet_windows = effective_quiet_hours(cfg.machines)
 
     statuses = check_all(machines, timeout=timeout)
     agent_completed: dict[str, dict] = {}
@@ -196,7 +204,9 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
         # pause — an operator debugging a stalled queue at 1AM needs to
         # know whether the machine will wake itself up or is waiting on
         # `coord unpause`.
-        pause_state = describe_pause_state(m, paused, cordons=cordons)
+        pause_state = describe_pause_state(
+            m, paused, cordons=cordons, quiet_hours=quiet_windows
+        )
         if pause_state is not None and pause_state.kind == "cordon":
             # #2101 trap E: name the version it is draining for, so a stopped
             # machine reads as "the fleet is upgrading itself" rather than as

{code_coordinator-0.5.52 → code_coordinator-0.5.55}/coord/commands/test_gate.py

@@ -649,8 +649,40 @@ def test(assignment_id: str, config_path: Path, verdict: str | None, reason: str
 
     if repo and repo.test_command:
         click.echo(f"Running tests: {repo.test_command}")
-        result = subprocess.run(repo.test_command, shell=True, cwd=str(wt_path))
+        # #2170: capture (stdout+stderr merged, same as an unpiped terminal
+        # would show) so a failure can be checked for the runner's `RESULT:
+        # BASELINE-RED` marker below — a failure the runner itself has
+        # already confirmed also reproduces on the merge-base is a
+        # statement about THIS MACHINE, not this branch, and must not be
+        # nudged towards `coord test --fail`. Relayed to the terminal after
+        # the run finishes rather than streamed live — the trade-off that
+        # buys the marker check `subprocess.run` (not `Popen`) keeps this
+        # call mockable exactly like every other one in this function.
+        result = subprocess.run(
+            repo.test_command, shell=True, cwd=str(wt_path),
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
+        )
+        if result.stdout:
+            click.echo(result.stdout, nl=False)
         if result.returncode != 0:
+            from coord.revalidate import is_baseline_red_failure  # noqa: PLC0415
+
+            if is_baseline_red_failure(result.returncode, result.stdout or ""):
+                click.echo(
+                    f"\nTests failed (exit {result.returncode}) — but the "
+                    "runner already confirmed every failure reproduces "
+                    "identically on the merge-base (#2170): this machine's "
+                    "BASELINE is red, not this branch.",
+                    err=True,
+                )
+                click.echo(f"  worktree kept for inspection: {wt_path}")
+                click.echo(
+                    "  run: coord test --skipped "
+                    f"{assignment_id} --reason \"baseline-red (#2170): "
+                    "pre-existing failures on this machine\"   "
+                    "# NOT --fail — the branch made nothing worse"
+                )
+                sys.exit(1)
             click.echo(f"Tests failed (exit {result.returncode})", err=True)
             click.echo(f"  worktree kept for inspection: {wt_path}")
             sys.exit(1)

{code_coordinator-0.5.52 → code_coordinator-0.5.55}/coord/config.py

@@ -1951,6 +1951,50 @@ def _parse_hhmm(raw: Any, *, field_path: str) -> time:
     return time(int(m.group(1)), int(m.group(2)))
 
 
+def parse_quiet_hours_window(
+    start: Any, end: Any, tz: Any, *, prefix: str = "quiet_hours"
+) -> QuietHours:
+    """Validate a raw ``start``/``end``/``tz`` triple into a `QuietHours`.
+
+    #2146: THE definition of "a valid quiet-hours window", shared by the
+    YAML path (`_parse_quiet_hours_block` below, i.e.
+    ``machines[i].quiet_hours`` and ``notifications.quiet_hours``) and by
+    the operator-set store path (`coord.machine_pause.local_set_quiet_hours`,
+    written by `coord quiet-hours` / the daemon's `/pause` endpoint).
+
+    The two sources must never diverge on what they accept: a window a
+    `coord quiet-hours` call takes but `coordinator.yml` rejects (or vice
+    versa) would make `--print-yaml`'s promotion path — the whole point of
+    which is "make this temporary window permanent" — emit a block that
+    fails to load. One validator, one answer.
+
+    Raises `ConfigError` (with *prefix* naming the offending field) on
+    anything invalid; the daemon endpoint relays that message verbatim in
+    its 400 so an operator sees the real reason, not "bad request".
+    """
+    parsed_start = _parse_hhmm(start, field_path=f"{prefix}.start")
+    parsed_end = _parse_hhmm(end, field_path=f"{prefix}.end")
+
+    if not tz or not isinstance(tz, str):
+        raise ConfigError(
+            f"{prefix}.tz is required (IANA zone name, e.g. 'America/Chicago') — "
+            "quiet hours never default to the daemon's own UTC clock, since that "
+            "would silently fire at the wrong local hour"
+        )
+    try:
+        ZoneInfo(tz)
+    except (ZoneInfoNotFoundError, ValueError, OSError) as e:
+        raise ConfigError(f"{prefix}.tz {tz!r} is not a known IANA zone name: {e}") from e
+
+    if parsed_start == parsed_end:
+        raise ConfigError(
+            f"{prefix}: start and end must differ ('always quiet' is ambiguous — "
+            "use `coord pause` to take a machine out of rotation indefinitely instead)"
+        )
+
+    return QuietHours(start=parsed_start, end=parsed_end, tz=tz)
+
+
 def _parse_quiet_hours_block(raw: Any, *, prefix: str) -> QuietHours | None:
     """Parse a ``{start, end, tz}`` quiet-hours mapping. ``None`` → ``None``.
 
@@ -1967,34 +2011,19 @@ def _parse_quiet_hours_block(raw: Any, *, prefix: str) -> QuietHours | None:
     operator wrote — a quiet-hours feature that activates early is worse
     than none, because it silently pulls the machine out of the fleet
     during the working day. Fail loudly here rather than default quietly.
+
+    #2146: the field-level rules themselves now live in
+    `parse_quiet_hours_window` above, so the operator-set store validates
+    identically to this YAML path.
     """
     if raw is None:
         return None
     if not isinstance(raw, dict):
         raise ConfigError(f"{prefix} must be a mapping")
 
-    start = _parse_hhmm(raw.get("start"), field_path=f"{prefix}.start")
-    end = _parse_hhmm(raw.get("end"), field_path=f"{prefix}.end")
-
-    tz = raw.get("tz")
-    if not tz or not isinstance(tz, str):
-        raise ConfigError(
-            f"{prefix}.tz is required (IANA zone name, e.g. 'America/Chicago') — "
-            "quiet hours never default to the daemon's own UTC clock, since that "
-            "would silently fire at the wrong local hour"
-        )
-    try:
-        ZoneInfo(tz)
-    except (ZoneInfoNotFoundError, ValueError, OSError) as e:
-        raise ConfigError(f"{prefix}.tz {tz!r} is not a known IANA zone name: {e}") from e
-
-    if start == end:
-        raise ConfigError(
-            f"{prefix}: start and end must differ ('always quiet' is ambiguous — "
-            "use `coord pause` to take a machine out of rotation indefinitely instead)"
-        )
-
-    return QuietHours(start=start, end=end, tz=tz)
+    return parse_quiet_hours_window(
+        raw.get("start"), raw.get("end"), raw.get("tz"), prefix=prefix
+    )
 
 
 def _parse_quiet_hours(raw: Any, *, machine_index: int, machine_name: str) -> QuietHours | None: