code-coordinator 0.5.538__tar.gz → 0.5.540__tar.gz

{code_coordinator-0.5.538 → code_coordinator-0.5.540}/PKG-INFO

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

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

@@ -151,6 +151,7 @@ coord/scorecard.py
 coord/self_health.py
 coord/serve_app.py
 coord/smoke.py
+coord/smoke_tags.py
 coord/spend_ceiling.py
 coord/split_work.py
 coord/sql.py

{code_coordinator-0.5.538 → code_coordinator-0.5.540}/code_coordinator.egg-info/scm_file_list.json

@@ -277,6 +277,7 @@
     "coord/skills/tui-quadraui-workflow/SKILL.md",
     "coord/skills/update-issue/SKILL.md",
     "coord/smoke.py",
+    "coord/smoke_tags.py",
     "coord/spend_ceiling.py",
     "coord/split_work.py",
     "coord/sql.py",

{code_coordinator-0.5.538 → code_coordinator-0.5.540}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.538",
+  "tag": "0.5.540",
   "distance": 0,
-  "node": "g497e677b9148b371539abe944ff11b260e6dc373",
+  "node": "g4350dd13ffcba5e53083059269232d07634c175d",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.538 → code_coordinator-0.5.540}/coord/smoke.py

@@ -82,7 +82,6 @@ independence; for smoke we want a *capable* machine for hardware, and
 
 from __future__ import annotations
 
-import base64
 import json
 import logging
 import re
@@ -123,6 +122,24 @@ from coord.models import (
 # runner actually emits, or from what `coord.notify` parses back out of the
 # agent's own transcript (see `_smoke_baseline_red_reason` there).
 from coord.revalidate import BASELINE_RED_OUTPUT_MARKER, RUNNER_BASELINE_RED_EXIT
+# The #3182 fan-out's on-the-board text encodings, DEFINED in a leaf module
+# and re-exported here under their original spellings so every existing
+# importer (`coord.notify`, `coord.diagnose`, `coord.reconcile`, the tests)
+# still reads them off `coord.smoke`, with exactly one definition of each.
+# See `coord/smoke_tags.py`'s docstring for why they were split out: they are
+# pure `re`/`base64` string handling, and `coord.stage_projection` — a
+# deliberately dependency-free leaf module — has to parse both to count Test
+# rounds (#3191). Reaching them through THIS module would drag the whole
+# dispatch stack (`coord.config`, `coord.dispatch`, `coord.github_ops`,
+# `coord.revalidate`, `httpx`) into `coord serve`'s `/board` request path.
+from coord.smoke_tags import (  # noqa: F401  (re-export; see note above)
+    _FANOUT_MANIFEST_RE,
+    _LEG_TAG_RE,
+    _encode_fanout_manifest,
+    _parse_fanout_manifest,
+    smoke_leg_capabilities,
+    smoke_leg_issue_title,
+)
 
 logger = logging.getLogger("coord.smoke")
 
@@ -638,114 +655,13 @@ def partition_capability_requirements(
 # sweep if a partition never got a machine at all — the existing, generic
 # mechanism, not a fan-out-specific reinvention of it.
 
-# Restricted to `[a-z0-9+_-]` — every capability name in this codebase
-# (gtk, windows, macos, browser, provider:opencode via `+`-joining, etc.)
-# fits that class. If `coordinator.yml` ever declares a capability with an
-# uppercase letter, a dot, or another character outside it,
-# `smoke_leg_capabilities()` silently returns None for that leg (misread as
-# an ordinary untagged row) rather than raising — nothing today validates
-# capability naming at config-load time, so keep new capability names
-# lowercase/`[a-z0-9+_-]` until that validation exists.
-_LEG_TAG_RE = re.compile(r"^\[smoke:([a-z0-9+_-]+)\] ")
-
-
-def smoke_leg_issue_title(base_title: str, capabilities: tuple[str, ...]) -> str:
-    """The ``issue_title`` for one capability-partition leg of a #3182 fan-out.
-
-    Encodes *capabilities* (sorted, ``+``-joined) as a parseable prefix —
-    ``"[smoke:gtk+windows] <base_title>"`` — so :func:`smoke_leg_capabilities`
-    can read it back off the board. Used both for the per-partition in-flight
-    dedupe (:func:`_find_leg_for_partition`) and for telling a fan-out leg's
-    own verdict apart from an ordinary single-leg smoke row's when processing
-    it (``coord.notify``).
-    """
-    tag = "+".join(sorted(capabilities))
-    return f"[smoke:{tag}] {base_title}"
-
-
-def smoke_leg_capabilities(issue_title: str | None) -> tuple[str, ...] | None:
-    """The capability set :func:`smoke_leg_issue_title` encoded, or ``None``.
-
-    ``None`` for an ordinary (untagged) smoke row — every pre-#3182 ``[smoke]
-    ...`` single-partition dispatch, which never carries this prefix — or for
-    any non-smoke row. Never raises on a malformed or missing title.
-    """
-    if not issue_title:
-        return None
-    m = _LEG_TAG_RE.match(issue_title)
-    if not m:
-        return None
-    return tuple(m.group(1).split("+"))
-
-
-_FANOUT_MANIFEST_RE = re.compile(r"^\[\[smoke-fanout:([^\]]*)\]\]\n?")
-
-
-def _encode_fanout_manifest(
-    legs: list[tuple[str, tuple[str, ...], str | None]],
-) -> str:
-    """The manifest line stamped at the FRONT of the parent's ``test_reason``
-    for a #3182 fan-out: ``[[smoke-fanout:<id>=<caps>=<command_b64>,...]]``,
-    one entry per leg dispatched (or already active/completed) this round.
-    Preserved byte-for-byte across every later rewrite of the parent's
-    ``test_reason`` (the running-progress stamp, and the final aggregate) so
-    :func:`finalize_smoke_fanout` can always find its siblings again from
-    just the parent's own row — see the module note above for why this, and
-    not a new query endpoint.
-
-    ``command_b64`` (#3298) is the partition's own resolved Test-stage
-    command, URL-safe base64-encoded so an arbitrary shell command — commas,
-    brackets, newlines, anything a real ``test_command``/rule ``command`` can
-    contain — can never corrupt this manifest's own ``,``/``=``/``]``
-    delimiters. Encodes as an empty third field when the command is unknown
-    (``None``), which round-trips through :func:`_parse_fanout_manifest` as
-    ``command=None`` rather than raising or misparsing.
-    """
-    def _entry(leg_id: str, caps: tuple[str, ...], command: str | None) -> str:
-        cap_str = "+".join(sorted(caps))
-        cmd_b64 = (
-            base64.urlsafe_b64encode(command.encode()).decode() if command else ""
-        )
-        return f"{leg_id}={cap_str}={cmd_b64}"
-
-    body = ",".join(_entry(leg_id, caps, command) for leg_id, caps, command in legs)
-    return f"[[smoke-fanout:{body}]]"
-
-
-def _parse_fanout_manifest(
-    test_reason: str | None,
-) -> list[tuple[str, tuple[str, ...], str | None]] | None:
-    """The ``(leg_id, capabilities, command)`` triples
-    :func:`_encode_fanout_manifest` wrote, or ``None`` when *test_reason*
-    carries no manifest (not a fan-out row). Tolerates a malformed entry by
-    skipping just that entry, never raising.
-
-    ``command`` is ``None`` for a pre-#3298 two-field entry
-    (``<id>=<caps>``, no trailing ``=<command_b64>``) — an already-in-flight
-    row from before this field existed — as well as for a malformed base64
-    payload; either way the caller gets "unknown command", never a crash.
-    """
-    if not test_reason:
-        return None
-    m = _FANOUT_MANIFEST_RE.match(test_reason)
-    if not m:
-        return None
-    legs: list[tuple[str, tuple[str, ...], str | None]] = []
-    for entry in m.group(1).split(","):
-        if not entry:
-            continue
-        leg_id, _, rest = entry.partition("=")
-        caps, _, cmd_b64 = rest.partition("=")
-        if not leg_id or not caps:
-            continue
-        command: str | None = None
-        if cmd_b64:
-            try:
-                command = base64.urlsafe_b64decode(cmd_b64.encode()).decode()
-            except (ValueError, UnicodeDecodeError):
-                command = None
-        legs.append((leg_id, tuple(caps.split("+")), command))
-    return legs
+# `smoke_leg_issue_title` / `smoke_leg_capabilities` (the `[smoke:<caps>]`
+# tag on each leg's `issue_title`) and `_encode_fanout_manifest` /
+# `_parse_fanout_manifest` (the `[[smoke-fanout:...]]` manifest on the
+# parent's `test_reason`) used to be DEFINED here. They now live in
+# `coord/smoke_tags.py` and are re-exported by the import at the top of this
+# module, so `from coord.smoke import ...` is unchanged for every caller —
+# see that module's docstring for why the split exists.
 
 
 def _build_fanout_running_reason(

code_coordinator-0.5.540/coord/smoke_tags.py

@@ -0,0 +1,140 @@
+"""The #3182 fan-out's on-the-board *text encodings*, and nothing else.
+
+A capability-partition fan-out records two things as plain text on rows the
+board already has, rather than in a new table (see ``coord.smoke``'s own
+module note for why): each leg's ``issue_title`` carries a
+``[smoke:<caps>]`` tag, and the parent work row's ``test_reason`` carries a
+``[[smoke-fanout:...]]`` manifest naming every leg in that round.
+
+Those four functions used to live in ``coord/smoke.py``, next to the
+dispatcher that writes them. They are split out here because ``coord.smoke``
+imports the whole dispatch stack (``coord.config``, ``coord.dispatch``,
+``coord.github_ops``, ``coord.revalidate``, ``httpx``), while the encodings
+themselves are pure ``re``/``base64`` string handling with no coord
+dependency at all — and ``coord.stage_projection``, which has to *read* both
+encodings to count Test rounds (#3191), is deliberately a leaf module
+("Pure computation: ... no I/O, no side effects") whose only other
+production import is ``coord.models``. Importing ``coord.smoke`` from it
+just to reach two regexes would have dragged the entire dispatch stack into
+``coord serve``'s ``/board`` request path — a first-request-time import of
+half the package inside a threadpool worker — for no benefit.
+
+``coord.smoke`` re-exports every name below under its original spelling, so
+existing importers (``coord.notify``, ``coord.diagnose``,
+``coord.reconcile``, and the tests) are unaffected and there is exactly one
+definition of each encoding.
+"""
+
+from __future__ import annotations
+
+import base64
+import re
+
+# Restricted to `[a-z0-9+_-]` — every capability name in this codebase
+# (gtk, windows, macos, browser, provider:opencode via `+`-joining, etc.)
+# fits that class. If `coordinator.yml` ever declares a capability with an
+# uppercase letter, a dot, or another character outside it,
+# `smoke_leg_capabilities()` silently returns None for that leg (misread as
+# an ordinary untagged row) rather than raising — nothing today validates
+# capability naming at config-load time, so keep new capability names
+# lowercase/`[a-z0-9+_-]` until that validation exists.
+_LEG_TAG_RE = re.compile(r"^\[smoke:([a-z0-9+_-]+)\] ")
+
+
+def smoke_leg_issue_title(base_title: str, capabilities: tuple[str, ...]) -> str:
+    """The ``issue_title`` for one capability-partition leg of a #3182 fan-out.
+
+    Encodes *capabilities* (sorted, ``+``-joined) as a parseable prefix —
+    ``"[smoke:gtk+windows] <base_title>"`` — so :func:`smoke_leg_capabilities`
+    can read it back off the board. Used both for the per-partition in-flight
+    dedupe (``coord.smoke._find_leg_for_partition``) and for telling a
+    fan-out leg's own verdict apart from an ordinary single-leg smoke row's
+    when processing it (``coord.notify``).
+    """
+    tag = "+".join(sorted(capabilities))
+    return f"[smoke:{tag}] {base_title}"
+
+
+def smoke_leg_capabilities(issue_title: str | None) -> tuple[str, ...] | None:
+    """The capability set :func:`smoke_leg_issue_title` encoded, or ``None``.
+
+    ``None`` for an ordinary (untagged) smoke row — every pre-#3182 ``[smoke]
+    ...`` single-partition dispatch, which never carries this prefix — or for
+    any non-smoke row. Never raises on a malformed or missing title.
+    """
+    if not issue_title:
+        return None
+    m = _LEG_TAG_RE.match(issue_title)
+    if not m:
+        return None
+    return tuple(m.group(1).split("+"))
+
+
+_FANOUT_MANIFEST_RE = re.compile(r"^\[\[smoke-fanout:([^\]]*)\]\]\n?")
+
+
+def _encode_fanout_manifest(
+    legs: list[tuple[str, tuple[str, ...], str | None]],
+) -> str:
+    """The manifest line stamped at the FRONT of the parent's ``test_reason``
+    for a #3182 fan-out: ``[[smoke-fanout:<id>=<caps>=<command_b64>,...]]``,
+    one entry per leg dispatched (or already active/completed) this round.
+    Preserved byte-for-byte across every later rewrite of the parent's
+    ``test_reason`` (the running-progress stamp, and the final aggregate) so
+    ``coord.smoke.finalize_smoke_fanout`` can always find its siblings again
+    from just the parent's own row — see that module's note for why this, and
+    not a new query endpoint.
+
+    ``command_b64`` (#3298) is the partition's own resolved Test-stage
+    command, URL-safe base64-encoded so an arbitrary shell command — commas,
+    brackets, newlines, anything a real ``test_command``/rule ``command`` can
+    contain — can never corrupt this manifest's own ``,``/``=``/``]``
+    delimiters. Encodes as an empty third field when the command is unknown
+    (``None``), which round-trips through :func:`_parse_fanout_manifest` as
+    ``command=None`` rather than raising or misparsing.
+    """
+    def _entry(leg_id: str, caps: tuple[str, ...], command: str | None) -> str:
+        cap_str = "+".join(sorted(caps))
+        cmd_b64 = (
+            base64.urlsafe_b64encode(command.encode()).decode() if command else ""
+        )
+        return f"{leg_id}={cap_str}={cmd_b64}"
+
+    body = ",".join(_entry(leg_id, caps, command) for leg_id, caps, command in legs)
+    return f"[[smoke-fanout:{body}]]"
+
+
+def _parse_fanout_manifest(
+    test_reason: str | None,
+) -> list[tuple[str, tuple[str, ...], str | None]] | None:
+    """The ``(leg_id, capabilities, command)`` triples
+    :func:`_encode_fanout_manifest` wrote, or ``None`` when *test_reason*
+    carries no manifest (not a fan-out row). Tolerates a malformed entry by
+    skipping just that entry, never raising.
+
+    ``command`` is ``None`` for a pre-#3298 two-field entry
+    (``<id>=<caps>``, no trailing ``=<command_b64>``) — an already-in-flight
+    row from before this field existed — as well as for a malformed base64
+    payload; either way the caller gets "unknown command", never a crash.
+    """
+    if not test_reason:
+        return None
+    m = _FANOUT_MANIFEST_RE.match(test_reason)
+    if not m:
+        return None
+    legs: list[tuple[str, tuple[str, ...], str | None]] = []
+    for entry in m.group(1).split(","):
+        if not entry:
+            continue
+        leg_id, _, rest = entry.partition("=")
+        caps, _, cmd_b64 = rest.partition("=")
+        if not leg_id or not caps:
+            continue
+        command: str | None = None
+        if cmd_b64:
+            try:
+                command = base64.urlsafe_b64decode(cmd_b64.encode()).decode()
+            except (ValueError, UnicodeDecodeError):
+                command = None
+        legs.append((leg_id, tuple(caps.split("+")), command))
+    return legs

{code_coordinator-0.5.538 → code_coordinator-0.5.540}/coord/stage_projection.py

@@ -35,6 +35,15 @@ import dataclasses
 from typing import Any, Protocol, runtime_checkable
 
 from coord.models import CLOSES_ISSUE_TYPES, WORK_LIKE_TYPES, effective_issue_number
+# #3191: the two #3182 fan-out encodings this module has to PARSE to count
+# Test *rounds* rather than raw smoke rows — see `_test_stage_leg_count`.
+# Imported from the leaf `coord.smoke_tags`, never from `coord.smoke`, so
+# this module keeps the property its docstring above claims: the only thing
+# it pulls in is pure computation. `coord.smoke` would bring `coord.config`,
+# `coord.dispatch`, `coord.github_ops`, `coord.revalidate` and `httpx` with
+# it, and `compute_board_stage_projection` runs inside `coord serve`'s
+# `/board` handler.
+from coord.smoke_tags import _parse_fanout_manifest, smoke_leg_capabilities
 
 # ── Stage-status vocabulary — mirrors tui/src/app/pipeline.rs::StageStatus ──
 PENDING = "pending"
@@ -75,6 +84,7 @@ class _AssignmentLike(Protocol):
     review_verdict: str | None
     review_of_assignment_id: str | None
     test_state: str | None
+    test_reason: str | None
     repo_name: str
     issue_number: int
     acceptance_state: str | None
@@ -82,6 +92,7 @@ class _AssignmentLike(Protocol):
     acceptance_passed: int | None
     uat_state: str | None
     uat_reason: str | None
+    issue_title: str | None
 
 
 # ── Helpers ──────────────────────────────────────────────────────────────
@@ -195,7 +206,11 @@ def _leg_count_for_stage(
       field exists to surface, and a strict ``type == "work"`` match would
       never see them.
     * ``"test"`` has no ``type="test"`` assignment — the Test-stage's
-      dispatched worker is ``type="smoke"`` (``coord.smoke``).
+      dispatched worker is ``type="smoke"`` (``coord.smoke``). Since #3182,
+      one Test *attempt* can dispatch more than one ``type="smoke"`` row (a
+      fan-out leg per capability partition), so a flat row count over-reports
+      — see :func:`_test_stage_leg_count` for how rows are folded back into
+      rounds.
     * ``"merge"`` has no ``type="merge"`` assignment either — repeated
       landing attempts show up as ``type="conflict-fix"`` legs (#241). Note
       the counting convention this implies differs from every other stage:
@@ -230,7 +245,7 @@ def _leg_count_for_stage(
         ]
         return len(matching) + len(extra)
     if stage == "test":
-        return sum(1 for a in assignments_for_issue if (a.type or "work") == "smoke")
+        return _test_stage_leg_count(assignments_for_issue)
     if stage == "merge":
         return sum(1 for a in assignments_for_issue if (a.type or "work") == "conflict-fix")
     if stage == "acceptance":
@@ -242,6 +257,77 @@ def _leg_count_for_stage(
     return len(assignments_for_stage(assignments_for_issue, stage, require_plan=require_plan))
 
 
+def _test_stage_leg_count(assignments_for_issue: list) -> int:
+    """How many separate Test-stage *attempts* — not raw ``type="smoke"``
+    rows — this issue has had (#3191).
+
+    Before #3182, one Test attempt was always exactly one ``type="smoke"``
+    row, so :func:`_leg_count_for_stage`'s flat row count was already
+    correct. #3182's fan-out (``coord.smoke._dispatch_smoke_fanout``) breaks
+    that: a diff whose ``capability_rules`` matches span more than one
+    machine-satisfiable partition (e.g. ``gtk+windows`` and ``macos``)
+    dispatches one smoke row PER partition for a single Test round, so a
+    clean, fully-successful first attempt reported ``stage_counts["test"] ==
+    2`` — read by every board client as "this needed a retry" (#3013), which
+    is exactly backwards.
+
+    A fan-out leg's own ``issue_title`` carries a ``[smoke:<caps>]`` tag
+    (``coord.smoke_tags.smoke_leg_issue_title``/``smoke_leg_capabilities``);
+    an ordinary single-leg dispatch (the pre-#3182 path, and every row that
+    predates it) carries none. Untagged rows keep counting 1:1 — no
+    behaviour change for the common case.
+
+    A tagged leg's round is identified via the ``[[smoke-fanout:...]]``
+    manifest (``coord.smoke_tags._encode_fanout_manifest``/
+    ``_parse_fanout_manifest``) stamped on the leg's own parent row
+    (``review_of_assignment_id``) — every leg the manifest names is one
+    round, and rounds collapse to a single count regardless of how many
+    partitions they fanned out to.
+
+    Known limitation, not fixed here: a Test retry clears the parent's
+    ``test_reason`` (``coord.state.reset_work_test_state``) before the next
+    round dispatches and writes a fresh manifest, so a SUPERSEDED round's
+    manifest no longer exists to fold its legs back together by the time
+    this runs — those orphaned tagged legs fall back to counting 1 each,
+    same as before this fix. That only ever *over*-counts a past, already-
+    resolved round; it never reproduces the bug this closes, which was
+    about the live/most-recent round (the one every reader actually looks
+    at) reporting a false retry on a clean first attempt.
+    """
+    smoke_legs = [a for a in assignments_for_issue if (a.type or "work") == "smoke"]
+    if not smoke_legs:
+        return 0
+
+    # Every row's own manifest, keyed by that row's `assignment_id` — a
+    # fan-out leg's PARENT (the work-like row `review_of_assignment_id`
+    # points back to) is the one that carries it, not the leg itself.
+    manifest_leg_ids_by_parent: dict[str, frozenset[str]] = {}
+    for a in assignments_for_issue:
+        parsed = _parse_fanout_manifest(getattr(a, "test_reason", None))
+        if parsed and a.assignment_id:
+            manifest_leg_ids_by_parent[a.assignment_id] = frozenset(
+                leg_id for leg_id, _caps, _cmd in parsed if leg_id
+            )
+
+    count = 0
+    counted_rounds: set[tuple[str, frozenset[str]]] = set()
+    for leg in smoke_legs:
+        if smoke_leg_capabilities(getattr(leg, "issue_title", None)) is None:
+            count += 1
+            continue
+        manifest_ids = manifest_leg_ids_by_parent.get(leg.review_of_assignment_id or "")
+        if not manifest_ids or leg.assignment_id not in manifest_ids:
+            # Orphaned tagged leg — see the "Known limitation" note above.
+            count += 1
+            continue
+        round_key = (leg.review_of_assignment_id or "", manifest_ids)
+        if round_key in counted_rounds:
+            continue
+        counted_rounds.add(round_key)
+        count += 1
+    return count
+
+
 def _widen_work_like_types(assignments: list) -> list:
     """Return *assignments* with every :data:`WORK_LIKE_TYPES` row (#3013:
     ``mock-author``/``test-author``, not just literal ``type="work"``)

{code_coordinator-0.5.538 → code_coordinator-0.5.540}/scripts/fleet_watchdog.py

@@ -836,6 +836,11 @@ def check_disabled_timers(ctx: WatchdogContext) -> list[Finding]:
     stabilises, see ``docs/AGENT_OPERATIONS.md``). Suppress the specific
     unit in ``watchdog-suppress.json`` to keep this from paging on an
     intentional operator decision.
+
+    A ``transient`` unit (created via ``systemd-run``, living only in
+    ``/run/user/<uid>/systemd/transient/``) is excluded from this check
+    entirely — it has no on-disk enablement symlink to be "disabled", so
+    the state is normal, not a finding (#2815).
     """
     if SYSTEMCTL is None:
         return []
@@ -862,7 +867,7 @@ def check_disabled_timers(ctx: WatchdogContext) -> list[Finding]:
         if len(parts) < 2:
             continue
         unit, state = parts[0], parts[1]
-        if state in ("enabled", "static", "generated", "alias"):
+        if state in ("enabled", "static", "generated", "alias", "transient"):
             continue
         findings.append(
             Finding(

{code_coordinator-0.5.538 → code_coordinator-0.5.540}/tests/test_fleet_watchdog.py

@@ -400,6 +400,62 @@ class TestSuppressionSentinel:
         assert (tmp_path / ".local" / "bin" / "coord").is_symlink()
 
 
+class TestDisabledTimerCheck:
+    """#2815: a transient ``coord-*.timer`` (created via ``systemd-run``,
+    e.g. #2587's overnight guard) must not be misread as disabled — it has
+    no on-disk enablement state to be "disabled" from. A genuinely
+    disabled/masked timer must still be reported."""
+
+    def test_transient_timer_produces_no_finding(self, tmp_path, monkeypatch):
+        fake_systemctl = tmp_path / "fake-systemctl"
+        fake_systemctl.write_text(
+            "#!/usr/bin/env bash\n"
+            "if [[ \"$*\" == *list-unit-files* ]]; then\n"
+            "  echo 'coord-rollpending-guard.timer transient'\n"
+            "fi\n"
+        )
+        fake_systemctl.chmod(0o755)
+        monkeypatch.setattr(fleet_watchdog, "SYSTEMCTL", str(fake_systemctl))
+
+        ctx = _ctx(tmp_path)
+        findings = fleet_watchdog.check_disabled_timers(ctx)
+        assert findings == []
+
+    def test_disabled_timer_still_reported(self, tmp_path, monkeypatch):
+        fake_systemctl = tmp_path / "fake-systemctl"
+        fake_systemctl.write_text(
+            "#!/usr/bin/env bash\n"
+            "if [[ \"$*\" == *list-unit-files* ]]; then\n"
+            "  echo 'coord-some-timer.timer disabled'\n"
+            "fi\n"
+        )
+        fake_systemctl.chmod(0o755)
+        monkeypatch.setattr(fleet_watchdog, "SYSTEMCTL", str(fake_systemctl))
+
+        ctx = _ctx(tmp_path)
+        findings = fleet_watchdog.check_disabled_timers(ctx)
+        [finding] = findings
+        assert finding.condition == "timer-disabled"
+        assert finding.signature == "coord-some-timer.timer"
+
+    def test_masked_timer_still_reported(self, tmp_path, monkeypatch):
+        fake_systemctl = tmp_path / "fake-systemctl"
+        fake_systemctl.write_text(
+            "#!/usr/bin/env bash\n"
+            "if [[ \"$*\" == *list-unit-files* ]]; then\n"
+            "  echo 'coord-some-other.timer masked'\n"
+            "fi\n"
+        )
+        fake_systemctl.chmod(0o755)
+        monkeypatch.setattr(fleet_watchdog, "SYSTEMCTL", str(fake_systemctl))
+
+        ctx = _ctx(tmp_path)
+        findings = fleet_watchdog.check_disabled_timers(ctx)
+        [finding] = findings
+        assert finding.condition == "timer-disabled"
+        assert finding.signature == "coord-some-other.timer"
+
+
 # ---------------------------------------------------------------------------
 # Acceptance test 4: the Nth consecutive identical repair escalates instead
 # of repairing.