code-coordinator 0.5.515__tar.gz → 0.5.517__tar.gz

{code_coordinator-0.5.515 → code_coordinator-0.5.517}/PKG-INFO

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

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

@@ -265,6 +265,7 @@ coord/health/checks/graph.py
 coord/health/checks/graphify_cli.py
 coord/health/checks/index_lock.py
 coord/health/checks/issues_sync_staleness.py
+coord/health/checks/local_machine_identity.py
 coord/health/checks/plan_usage.py
 coord/health/checks/pr_churn.py
 coord/health/checks/release_cordon.py
@@ -685,6 +686,7 @@ tests/test_human_attended_437.py
 tests/test_init.py
 tests/test_install_agent_venv_2911.py
 tests/test_integration.py
+tests/test_interactive.py
 tests/test_interactive_briefing_echo.py
 tests/test_interactive_pane_log_2541.py
 tests/test_interactive_prefill_state.py

{code_coordinator-0.5.515 → code_coordinator-0.5.517}/code_coordinator.egg-info/scm_file_list.json

@@ -174,6 +174,7 @@
     "coord/health/checks/graphify_cli.py",
     "coord/health/checks/index_lock.py",
     "coord/health/checks/issues_sync_staleness.py",
+    "coord/health/checks/local_machine_identity.py",
     "coord/health/checks/plan_usage.py",
     "coord/health/checks/pr_churn.py",
     "coord/health/checks/release_cordon.py",
@@ -711,6 +712,7 @@
     "tests/test_init.py",
     "tests/test_install_agent_venv_2911.py",
     "tests/test_integration.py",
+    "tests/test_interactive.py",
     "tests/test_interactive_briefing_echo.py",
     "tests/test_interactive_pane_log_2541.py",
     "tests/test_interactive_prefill_state.py",

code_coordinator-0.5.517/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.517",
+  "distance": 0,
+  "node": "g2cc5b156d53fe993bfa01632f5a6070991c56383",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-25"
+}

{code_coordinator-0.5.515 → code_coordinator-0.5.517}/coord/claim.py

@@ -454,6 +454,40 @@ def _default_branch_lookup(repo_github: str, issue_number: int) -> list[str]:
     return _drop_merged_branches(repo_github, branches)
 
 
+# #3442: bracket-tag issue_title prefixes (`f"[{tag}] {title}"`, see
+# `coord.review.dispatch_review` / `coord.review._dispatch_scoped_review` /
+# `coord.smoke.dispatch_pending_smoke` / `coord.gate_b`'s tracking-issue
+# dispatch) that a review/smoke/gate-b leg dispatch uses when it does NOT
+# pin `target_branch` to the real work branch — the agent then derives its
+# own throwaway branch name by slugifying that bracketed title
+# (`coord.agent._slugify`), landing on `issue-{N}-{tag}-...`. These legs
+# are read-only observers: a review posts a verdict comment, a smoke run
+# executes a command, gate-b posts a milestone verdict — none of them ever
+# commits to its own checkout, so that branch sits at `ahead_by == 0`
+# against the default branch from the moment it's created, forever,
+# regardless of whether the issue's REAL work has landed. It is not
+# evidence of anything. Every OTHER dispatcher that continues real work on
+# an issue (conflict-fix, retry, fix-N) pins `target_branch` to the actual
+# work branch instead of letting one of these get minted, so this list is
+# deliberately just the observer legs, not every bracket tag in the
+# codebase — though as #3442's own review round found for gate-b, that
+# distinction has to be verified per-dispatcher, not assumed; see the
+# issue's suggested structural alternative (branch never had commits, ever)
+# for a fix that wouldn't require keeping this list exhaustive by hand.
+_OBSERVER_LEG_TAGS = ("review", "scoped-review", "smoke", "gate-b")
+
+
+def _is_observer_leg_branch(branch: str, issue_number: int) -> bool:
+    """True when *branch* is a review/smoke leg's own throwaway checkout,
+    not a branch that could ever carry real work (see `_OBSERVER_LEG_TAGS`).
+    """
+    for tag in _OBSERVER_LEG_TAGS:
+        prefix = f"issue-{issue_number}-{tag}"
+        if branch == prefix or branch.startswith(prefix + "-"):
+            return True
+    return False
+
+
 def any_matching_branch_merged(
     repo_github: str, issue_number: int, *, branch: str | None = None
 ) -> bool:
@@ -476,17 +510,29 @@ def any_matching_branch_merged(
     merged" behaviour only when *branch* is `None` — a caller with nothing
     assigned yet (a pre-dispatch check before any branch exists) has no
     single branch to ask about, so the issue-scoped signal is the best one
-    available. Reuses the exact merge-detection `_drop_merged_branches`
-    already performs for claim detection (PR-merged OR `ahead_by == 0`
-    ancestry, survives squash merges — #3103): this is just "did filtering
-    drop anything", with the fail-open direction flipped to match a
-    REFUSAL predicate rather than a claim-signal — no matching branch at
-    all, or any lookup failure, returns `False` ("not merged, don't refuse
-    dispatch on this"), never `True`.
+    available. #3442: that fallback first drops every known
+    `_is_observer_leg_branch` candidate — #3436 only fixed the case where
+    the dispatch's OWN branch was already known; a plain `coord assign`
+    (or any other caller with no branch recorded yet, which is exactly when
+    this fallback runs) has no branch of its own to scope to, so without
+    this filter a single zero-commit `issue-{N}-review-*`/`issue-{N}-smoke-
+    *` leg branch still reads the WHOLE issue as merged and permanently
+    refuses dispatch — the same bug #3436 fixed for the branch-known case,
+    reopened for the branch-unknown one. Reuses the exact merge-detection
+    `_drop_merged_branches` already performs for claim detection (PR-merged
+    OR `ahead_by == 0` ancestry, survives squash merges — #3103): this is
+    just "did filtering drop anything", with the fail-open direction
+    flipped to match a REFUSAL predicate rather than a claim-signal — no
+    matching branch at all, or any lookup failure, returns `False` ("not
+    merged, don't refuse dispatch on this"), never `True`.
     """
     if branch is not None:
         return not _drop_merged_branches(repo_github, [branch])
-    branches = list_matching_remote_branches(repo_github, issue_number)
+    branches = [
+        b
+        for b in list_matching_remote_branches(repo_github, issue_number)
+        if not _is_observer_leg_branch(b, issue_number)
+    ]
     if not branches:
         return False
     unmerged = set(_drop_merged_branches(repo_github, branches))

{code_coordinator-0.5.515 → code_coordinator-0.5.517}/coord/commands/dispatch.py

@@ -6,7 +6,6 @@ Extracted from coord/cli.py (#747)."""
 from __future__ import annotations
 
 import dataclasses
-import socket
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -1498,7 +1497,7 @@ def assign(
     if interactive:
         setup = _build_interactive_launch_setup(
             machine=machine, repo=repo, issue=issue, machine_obj=machine_obj,
-            dry_run=dry_run,
+            dry_run=dry_run, config=cfg,
         )
         provider = setup.provider
         _is_local = setup.is_local
@@ -1635,6 +1634,7 @@ def _build_interactive_launch_setup(
     issue: int,
     machine_obj: object,
     dry_run: bool,
+    config: object,
 ) -> _InteractiveLaunchSetup:
     # #2086: the authoritative gate — see _require_interactive_tty's
     # docstring. Every --interactive flavour in BOTH callers (assign()'s
@@ -1668,13 +1668,13 @@ def _build_interactive_launch_setup(
         )
 
     # Detect whether the target machine is the local machine so we can
-    # choose the local TTY path vs the remote SSH+tmux path (#494).
-    # Mirrors the hostname-matching logic in _save_config_snapshot.
-    _local_hn = socket.gethostname().split(".")[0].lower()
-    _is_local = (
-        machine_obj.name.lower() == _local_hn
-        or machine_obj.host.split(".")[0].lower() == _local_hn
-    )
+    # choose the local TTY path vs the remote SSH+tmux path (#494). Routed
+    # through the single shared resolver (#3440) — alias list, Tailscale
+    # identity, then hostname fallback, not a private hostname comparison.
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
+    _resolved_local = resolve_local_machine(config)
+    _is_local = _resolved_local is not None and _resolved_local.name == machine_obj.name
 
     # #590/#749: on a thin client the local board/DB is empty, so resolve the
     # interactive-launch target (--review-of/--fix-of/--rework-of/--smoke-of/

{code_coordinator-0.5.515 → code_coordinator-0.5.517}/coord/commands/release.py

@@ -2461,16 +2461,15 @@ def _uncordon_hosts(hosts: list[str], journal: dict, *, quiet: bool = False) ->
 
 
 def _local_machine_name(config) -> str | None:
-    """This host's name in ``coordinator.yml``, if it is in there at all."""
-    import socket  # noqa: PLC0415
+    """This host's name in ``coordinator.yml``, if it is in there at all.
 
-    here = socket.gethostname().split(".")[0].lower()
-    for machine in getattr(config, "machines", ()) or ():
-        if machine.name.lower() == here:
-            return machine.name
-        if str(getattr(machine, "host", "")).split(".")[0].lower() == here:
-            return machine.name
-    return None
+    Routes through :func:`coord.config.resolve_local_machine` (#3440) rather
+    than a private hostname comparison — "one question, one answer".
+    """
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
+    resolved = resolve_local_machine(config)
+    return resolved.name if resolved is not None else None
 
 
 def _roll_python(machine, *, target_version: str, agent_port: int, timeout: float,

{code_coordinator-0.5.515 → code_coordinator-0.5.517}/coord/commands/sessions.py

@@ -6,7 +6,6 @@ from __future__ import annotations
 import fnmatch
 import os
 import shutil
-import socket
 import subprocess
 import sys
 import time
@@ -561,11 +560,10 @@ def pull_artifact(
     # rsync-over-ssh to our own hostname FAILS ("Permission denied" — no
     # self-ssh key), which surfaced as a meaningless pull error in the TUI.
     # Copy locally if the destination differs; otherwise it is a no-op.
-    local_hostname = socket.gethostname().split(".")[0].lower()
-    is_local = (
-        machine.name.lower() == local_hostname
-        or machine.host.split(".")[0].lower() == local_hostname
-    )
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
+    _resolved_local = resolve_local_machine(cfg)
+    is_local = _resolved_local is not None and _resolved_local.name == machine.name
     if is_local:
         src_dir = Path.home() / ".coord" / "artifacts" / repo_name / sanitized
         # Nothing to copy when the destination IS the stash directory
@@ -678,8 +676,8 @@ def _prune_dead_sessions(enriched: "list[dict]", config_path: "Path") -> None:
     from coord.state import COORD_DIR, get_connection  # noqa: PLC0415
     from coord.agent import _commits_ahead  # noqa: PLC0415
     from coord.interactive import tmux_session_name  # noqa: PLC0415
+    from coord.config import resolve_local_machine  # noqa: PLC0415
 
-    _local_hn = socket.gethostname().split(".")[0].lower()
     worktrees_dir = COORD_DIR / "worktrees"
     now = time.time()
 
@@ -688,9 +686,11 @@ def _prune_dead_sessions(enriched: "list[dict]", config_path: "Path") -> None:
         cfg = _load_config(config_path)
         machines_by_name = {m.name: m for m in cfg.machines}
         repos_by_name = {r.name: r for r in cfg.repos}
+        _resolved_local = resolve_local_machine(cfg)
     except Exception:  # noqa: BLE001
         machines_by_name = {}
         repos_by_name = {}
+        _resolved_local = None
 
     pruned = 0
     for s in enriched:
@@ -703,8 +703,7 @@ def _prune_dead_sessions(enriched: "list[dict]", config_path: "Path") -> None:
             mobj = machines_by_name.get(raw_machine)
             if mobj is not None:
                 _is_local = (
-                    mobj.name.lower() == _local_hn
-                    or mobj.host.split(".")[0].lower() == _local_hn
+                    _resolved_local is not None and _resolved_local.name == mobj.name
                 )
             else:
                 # Machine name set but not in config — treat as remote to be safe.
@@ -887,14 +886,13 @@ def sessions_cmd(
         import concurrent.futures as _cf  # noqa: PLC0415
 
         try:
+            from coord.config import resolve_local_machine  # noqa: PLC0415
+
             _cfg = _load_config(config_path)
-            _local_hn = socket.gethostname().split(".")[0].lower()
+            _resolved_local = resolve_local_machine(_cfg)
             _remotes = [
                 m for m in _cfg.machines
-                if not (
-                    m.name.lower() == _local_hn
-                    or m.host.split(".")[0].lower() == _local_hn
-                )
+                if _resolved_local is None or m.name != _resolved_local.name
             ]
         except Exception:  # noqa: BLE001
             _remotes = []
@@ -1275,10 +1273,12 @@ def reattach(assignment_id: str, config_path: Path) -> None:
                         else ("$HOME" if rp == "~" else rp)
                     )
                 ssh_target_val = machine_obj.host
-                _local_hn = socket.gethostname().split(".")[0].lower()
+                from coord.config import resolve_local_machine  # noqa: PLC0415
+
+                _resolved_local = resolve_local_machine(cfg)
                 is_local_session = (
-                    machine_obj.name.lower() == _local_hn
-                    or machine_obj.host.split(".")[0].lower() == _local_hn
+                    _resolved_local is not None
+                    and _resolved_local.name == machine_obj.name
                 )
     except Exception:  # noqa: BLE001
         pass
@@ -1904,12 +1904,13 @@ def watch(
         sys.exit(2)
 
     # ── Detect whether the assignment lives on a remote agent ────────────
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
     machine_name = record.get("machine_name", "")
     machine = next((m for m in cfg.machines if m.name == machine_name), None)
-    hostname = socket.gethostname().split(".")[0]
+    _resolved_local = resolve_local_machine(cfg)
     is_remote = machine is not None and (
-        machine.name != hostname
-        and machine.host.split(".")[0] != hostname
+        _resolved_local is None or _resolved_local.name != machine.name
     )
 
     if is_remote:

{code_coordinator-0.5.515 → code_coordinator-0.5.517}/coord/commands/terminal.py

@@ -29,12 +29,17 @@ import subprocess
 import sys
 from datetime import datetime, timezone
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import click
 
 from coord.commands._common import _CONFIG_OPTION, _load_config
 from coord.interactive import TERM_SESSION_PREFIX, TmuxHost, tmux_available, tmux_session_alive
 
+if TYPE_CHECKING:
+    from coord.config import Config
+    from coord.models import Machine
+
 __all__ = [
     "terminal_group",
     "terminal_session_name",
@@ -129,9 +134,17 @@ def _local_short_hostname() -> str:
     return socket.gethostname().split(".")[0].lower()
 
 
-def _is_local_machine(name: str, host: str) -> bool:
-    local_hn = _local_short_hostname()
-    return name.lower() == local_hn or host.split(".")[0].lower() == local_hn
+def _is_local_machine(cfg: "Config", machine: "Machine") -> bool:
+    """Is *machine* the host this process is running on?
+
+    Routes through :func:`coord.config.resolve_local_machine` (#3440) — the
+    shared "is this the local machine or must I SSH?" answer — rather than a
+    private hostname comparison.
+    """
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
+    resolved = resolve_local_machine(cfg)
+    return resolved is not None and resolved.name == machine.name
 
 
 def _resolve_machine_host(
@@ -153,7 +166,7 @@ def _resolve_machine_host(
         click.echo(f"error: machine {machine_name!r} not in config", err=True)
         sys.exit(1)
 
-    if _is_local_machine(machine.name, machine.host):
+    if _is_local_machine(cfg, machine):
         return TmuxHost(ssh_target=None), machine.name
     return TmuxHost(ssh_target=machine.host), machine.name
 
@@ -261,7 +274,7 @@ def terminal_list(output_json: bool, remote: bool, config_path: Path) -> None:
     local_host_str = local_hn
     if cfg is not None:
         m = next(
-            (mm for mm in cfg.machines if _is_local_machine(mm.name, mm.host)), None
+            (mm for mm in cfg.machines if _is_local_machine(cfg, mm)), None
         )
         if m is not None:
             local_machine_name = m.name
@@ -274,7 +287,7 @@ def terminal_list(output_json: bool, remote: bool, config_path: Path) -> None:
 
     if remote and cfg is not None:
         remotes = [
-            m for m in cfg.machines if not _is_local_machine(m.name, m.host)
+            m for m in cfg.machines if not _is_local_machine(cfg, m)
         ]
         if remotes:
             import concurrent.futures as _cf  # noqa: PLC0415

{code_coordinator-0.5.515 → code_coordinator-0.5.517}/coord/config.py

@@ -3,9 +3,15 @@
 from __future__ import annotations
 
 import fnmatch
+import json
 import os
 import re
+import socket
+import subprocess
 import sys
+# `from datetime import time` below shadows the stdlib `time` module in this
+# namespace, so the monotonic clock is imported under an explicit alias.
+import time as time_module
 from dataclasses import dataclass, field, fields
 from datetime import time
 from pathlib import Path
@@ -2408,6 +2414,192 @@ class Config:
         return next((r for r in self.repos if r.name == name), None)
 
 
+def _local_short_hostname() -> str:
+    """The OS short hostname (split on '.', lowercased).
+
+    Isolated so tests can patch ``coord.config._local_short_hostname``
+    without monkey-patching the global ``socket`` module. This is the
+    lowest-priority signal :func:`resolve_local_machine` consults — see
+    its docstring.
+    """
+    return socket.gethostname().split(".")[0].lower()
+
+
+def _tailscale_self_dns_name(*, timeout: float = 3.0) -> str | None:
+    """This host's Tailscale DNS name via ``tailscale status --self --json``,
+    or ``None`` when it can't be determined.
+
+    ``Self.DNSName`` (falling back to ``Self.HostName``) is exactly what a
+    machine's ``host:`` is set FROM in a Tailscale fleet (#3440) — e.g.
+    ``macmini.tailf46ef8.ts.net``. Degrades quietly (never raises) when the
+    ``tailscale`` binary is absent, the call times out, or the output isn't
+    the JSON shape expected: this is an optional identity signal, one of
+    several :func:`resolve_local_machine` tries, not a hard dependency.
+    """
+    try:
+        result = subprocess.run(
+            ["tailscale", "status", "--self", "--json"],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0 or not result.stdout:
+        return None
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return None
+    self_info = data.get("Self") if isinstance(data, dict) else None
+    if not isinstance(self_info, dict):
+        return None
+    dns_name = self_info.get("DNSName") or self_info.get("HostName")
+    if not isinstance(dns_name, str) or not dns_name:
+        return None
+    return dns_name.rstrip(".").lower()
+
+
+# #3440: memo for :func:`_cached_tailscale_self_dns_name` — ``(monotonic
+# deadline | None, answer)``. A ``None`` deadline means "never expires".
+_TS_SELF_DNS_MEMO: tuple[float | None, str | None] | None = None
+
+# How long a FAILED probe is remembered. Deliberately short and finite: see
+# :func:`_cached_tailscale_self_dns_name`.
+TS_SELF_DNS_NEGATIVE_TTL = 60.0
+
+
+def reset_tailscale_self_dns_cache() -> None:
+    """Forget the memoized Tailscale self-identity.
+
+    Exported for tests (``tests/conftest.py`` resets it between tests, the
+    same shape as ``reset_resource_route_support``): a module-level memo
+    would otherwise leak one test's stubbed identity into the next.
+    """
+    global _TS_SELF_DNS_MEMO
+    _TS_SELF_DNS_MEMO = None
+
+
+def _cached_tailscale_self_dns_name(
+    *, now: float | None = None,
+) -> str | None:
+    """:func:`_tailscale_self_dns_name`, memoized — the accessor
+    :func:`resolve_local_machine` actually calls.
+
+    Why memoize at all: ``resolve_local_machine`` is called on a timer by
+    long-lived processes (``coord serve``'s reap ticks, every few seconds).
+    On a host that matches no machine by hostname — precisely the #3440 host,
+    and every thin client — the Tailscale tier is reached on EVERY call, so
+    an unmemoized probe is a ``tailscale`` subprocess (up to a 3s timeout)
+    every few seconds, forever.
+
+    Why a SUCCESS is cached forever but a FAILURE is not (#2096): a host's
+    Tailscale DNS name is a stable fact for the lifetime of a process, so
+    re-probing after a successful answer buys nothing. A failed probe is
+    *not* a fact about the host — it is a fact about the last 3 seconds
+    (``tailscaled`` not up yet, the daemon started at boot before the network
+    did). Caching that forever would turn a transient miss into a permanent,
+    uncontradictable "this host is not in the fleet" verdict for a daemon
+    that runs for days, which is the same class of bug as the one #3440 is
+    fixing. So a negative answer is retried after
+    ``TS_SELF_DNS_NEGATIVE_TTL`` seconds — bounded cost, self-healing.
+    """
+    global _TS_SELF_DNS_MEMO
+
+    now = time_module.monotonic() if now is None else now
+    memo = _TS_SELF_DNS_MEMO
+    if memo is not None:
+        expires_at, answer = memo
+        if expires_at is None or now < expires_at:
+            return answer
+
+    answer = _tailscale_self_dns_name()
+    _TS_SELF_DNS_MEMO = (
+        None if answer else now + TS_SELF_DNS_NEGATIVE_TTL,
+        answer,
+    )
+    return answer
+
+
+def resolve_local_machine(
+    config: "Config", *, env: "dict[str, str] | None" = None,
+) -> "Machine | None":
+    """The single answer to "which configured machine, if any, IS the host
+    this process is running on?" (#3440).
+
+    Every "is this local or remote" call site in the codebase must call
+    this instead of keeping a private ``socket.gethostname()`` comparison —
+    two independent implementations of the same question are a split-brain
+    waiting to happen (see #2085). Tried in order, first match wins:
+
+    1. Each machine's own ``local_hostnames:`` alias list (the operator's
+       escape hatch) against the OS short hostname — for hosts whose OS
+       hostname matches neither ``name`` nor ``host`` (macOS's default
+       ``Johns-Mac-mini``, observed on macmini).
+    2. The historical fallback: OS short hostname vs ``machine.name`` or
+       the first label of ``machine.host``. Tried BEFORE the Tailscale
+       probe below — deliberately: this comparison is pure and free, it
+       resolves the overwhelming majority of fleet machines (whose OS
+       hostname already agrees with `coordinator.yml`), and periodic
+       callers (`coord serve`'s reap ticks) run it every few seconds —
+       shelling out to `tailscale` that often, when a free comparison
+       already answers the question, is both wasteful and, in one
+       audited path, breaks a ToS no-unexpected-subprocess guardrail
+       (`tests/test_reap_merged_sessions.py`).
+    3. This host's Tailscale identity
+       (:func:`_cached_tailscale_self_dns_name`) against ``machine.host``'s
+       full DNS name, not just its first label — ``host:`` is set FROM the
+       Tailscale DNS name in this fleet, so this is the tier that actually
+       fixes #3440: it catches exactly the hosts step 2 cannot (an OS
+       hostname with nothing to do with the fleet name). Only reached when
+       steps 1–2 found nothing, AND memoized per process, so the subprocess
+       cost is paid once by the hosts that actually need it rather than on
+       every reap tick.
+    4. ``$COORD_LOCAL_MACHINE`` (or *env*'s override) naming a machine by
+       ``name`` exactly — the last-resort override for when none of the
+       above can match at all.
+
+    Returns ``None`` when nothing matches — callers must treat that as
+    "this host isn't a recognized machine in coordinator.yml", never
+    silently assume remote OR local.
+    """
+    local_hostname = _local_short_hostname()
+
+    for machine in config.machines:
+        # getattr, not a bare attribute read: some call sites pass
+        # duck-typed test fixtures predating this field rather than a real
+        # `coord.models.Machine` — treat "no attribute" the same as "empty
+        # list" (this field's own documented default) rather than raising.
+        aliases = {a.lower() for a in getattr(machine, "local_hostnames", None) or []}
+        if local_hostname in aliases:
+            return machine
+
+    for machine in config.machines:
+        if (
+            machine.name.lower() == local_hostname
+            or machine.host.split(".")[0].lower() == local_hostname
+        ):
+            return machine
+
+    ts_dns = _cached_tailscale_self_dns_name()
+    if ts_dns:
+        for machine in config.machines:
+            host = (machine.host or "").rstrip(".").lower()
+            if host and host == ts_dns:
+                return machine
+
+    if env is None:
+        env = os.environ
+    override = env.get("COORD_LOCAL_MACHINE")
+    if override:
+        for machine in config.machines:
+            if machine.name.lower() == override.lower():
+                return machine
+
+    return None
+
+
 def load(path: str | Path | None = None) -> Config:
     """Load and validate a coordinator.yml file.
 
@@ -3095,6 +3287,16 @@ def _parse_machines(raw: Any, repos: list[Repo]) -> list[Machine]:
             entry.get("quiet_hours"), machine_index=i, machine_name=name,
         )
 
+        # #3440: optional alias list of OS short hostnames that should be
+        # treated as "this machine" by `resolve_local_machine` — the
+        # operator's escape hatch for hosts whose OS hostname (e.g. macOS's
+        # `Johns-Mac-mini` default) matches neither `name` nor `host`.
+        local_hostnames = entry.get("local_hostnames", []) or []
+        if not isinstance(local_hostnames, list) or not all(
+            isinstance(h, str) for h in local_hostnames
+        ):
+            raise ConfigError(f"machines[{i}].local_hostnames must be a list of strings")
+
         # #3366: optional fact about which init system supervises this
         # host's `coord agent` — see `Machine.supervisor`'s docstring for
         # why it isn't inferred. Validated against the two names
@@ -3136,6 +3338,7 @@ def _parse_machines(raw: Any, repos: list[Repo]) -> list[Machine]:
                 quiet_hours=quiet_hours,
                 health_timeout=machine_health_timeout,
                 supervisor=machine_supervisor,
+                local_hostnames=local_hostnames,
             )
         )
     return machines

{code_coordinator-0.5.515 → code_coordinator-0.5.517}/coord/dashboard/server.py

@@ -3234,21 +3234,18 @@ def build_app(
             # Seeded roster — no tmux, no ssh fan-out in fixture mode.
             return JSONResponse(_fixture.sessions())
 
+        from coord.config import resolve_local_machine
         from coord.interactive import (
             TMUX_SESSION_PREFIX,
             TmuxHost,
-            _get_local_short_hostname,
             list_coord_tmux_sessions,
         )
 
         loop = asyncio.get_running_loop()
-        local_hn = _get_local_short_hostname()
+        _resolved_local = resolve_local_machine(config)
 
         def _is_local_machine(machine) -> bool:
-            return (
-                machine.name.lower() == local_hn
-                or machine.host.split(".")[0].lower() == local_hn
-            )
+            return _resolved_local is not None and _resolved_local.name == machine.name
 
         def _sweep_one(machine):
             is_local = _is_local_machine(machine)