code-coordinator 0.5.261__tar.gz → 0.5.263__tar.gz

{code_coordinator-0.5.261 → code_coordinator-0.5.263}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.261",
+  "tag": "0.5.263",
   "distance": 0,
-  "node": "gdf4e499710b63d60b2e356a67c40269d877fa1a9",
+  "node": "g48c97e278762fe857dec843b91373c0a1ce790b2",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-28"

{code_coordinator-0.5.261 → code_coordinator-0.5.263}/coord/commands/lifecycle.py

@@ -565,7 +565,17 @@ def serve(config_path: Path, bind_host: str, bind_port: int, token: str | None)
         from coord.dao import SqliteStore
         from coord.db import DB_PATH
         from coord.serve_app import build_app as build_serve_app
-        from coord.serve_app import resolve_serve_token
+        from coord.serve_app import configure_daemon_logging, resolve_serve_token
+
+    # #2862: turn the daemon's own logging on BEFORE anything else runs.
+    # Without this the root logger has no handler and sits at WARNING, and
+    # `uvicorn.run(log_level="info")` below does not change that (it only
+    # configures the `uvicorn*` loggers) — so every `log.info(...)` in
+    # `serve_app._tick_loop`, including the customer-portal bridge's per-pass
+    # summary, was discarded before it was formatted. That is what made "Step
+    # 3d is quiet" unfalsifiable from the journal in #2824 and again in #2862.
+    # Level via $COORD_LOG_LEVEL (default INFO).
+    configure_daemon_logging()
 
     # #2824: `allow_thin_client=False` — `coord serve` IS the daemon every
     # thin client's `_load_config()` proxies to; it must always load the

{code_coordinator-0.5.261 → code_coordinator-0.5.263}/coord/housekeeping.py

@@ -21,6 +21,18 @@ Two guarantees make the sweep safe:
 The sweep runs automatically on a low-cadence daemon tick and on demand via
 ``coord housekeeping`` (which routes through the daemon — the canonical DB lives
 there).
+
+#1107 Part 3: the same sweep also archives ``merge_queue`` rows in the
+``MERGED`` terminal state once they're older than the retention window, into
+``merge_queue_archive`` — mirroring the move-not-delete pattern above.
+``merge_queue`` has no natural "close" event of its own (unlike assignments,
+which age out via ``TERMINAL_STATUSES``), so without this a MERGED row lives
+forever: 192 such rows had accumulated by 2026-07-12 and 61 more by
+2026-07-30, both requiring a manual one-off ``DELETE``/``coord merge --drop``
+declog. ``coord.merge_queue.merged_issue_keys()`` unions the live table with
+the archive so the "already merged, don't re-enqueue" dedup in
+``enqueue_approved_work``/``staging_items`` keeps working after a row ages
+out.
 """
 
 from __future__ import annotations
@@ -48,6 +60,9 @@ _ASSIGNMENTS = "assignments"
 _ASSIGNMENTS_ARCHIVE = "assignments_archive"
 _NOTIFICATIONS = "notifications"
 _NOTIFICATIONS_ARCHIVE = "notifications_archive"
+_MERGE_QUEUE = "merge_queue"
+_MERGE_QUEUE_ARCHIVE = "merge_queue_archive"
+_MERGE_QUEUE_MERGED_STATE = "merged"
 _BATCH = 400  # keep IN(...) clauses well under SQLite's 999-variable limit
 
 
@@ -124,20 +139,26 @@ def _move_rows(
 
 
 def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
-    """Archive stale terminal assignments + their notifications.
+    """Archive stale terminal assignments + their notifications + merged
+    merge_queue entries.
 
     Returns ``{"archived_assignments": N, "archived_notifications": M,
-    "dry_run": bool, "retention_days": D}``.  ``archived_*`` are the counts that
-    were (or, for ``dry_run``, would be) moved.  A no-op returns zeros.
+    "archived_merge_queue": K, "dry_run": bool, "retention_days": D}``.
+    ``archived_*`` are the counts that were (or, for ``dry_run``, would be)
+    moved.  A no-op returns zeros.
 
     Conservative by construction: nothing active, recent (within the archive
     window), queued-for-merge, latest-of-an-open-issue, or review-linked to any
-    such row is ever moved.
+    such row is ever moved. Merge queue entries are archived only once they
+    are in the terminal ``MERGED`` state (#1107 Part 3) — non-terminal /
+    conflicted entries are left for ``prune_stale_queue_entries`` or manual
+    ``coord merge --drop``.
     """
     cutoff = _archive_cutoff(now)
     result = {
         "archived_assignments": 0,
         "archived_notifications": 0,
+        "archived_merge_queue": 0,
         "dry_run": dry_run,
         "retention_days": _archive_retention_days(),
     }
@@ -151,13 +172,19 @@ def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
             conn, f"SELECT {_KEEP_INDEX_COLUMNS} FROM {_ASSIGNMENTS}"  # noqa: S608
         ).fetchall()
     ]
-    mq_ids = {
+    mq_rows = sql.execute(
+        conn,
+        "SELECT assignment_id, state, last_attempt, enqueued_at "  # noqa: S608
+        f"FROM {_MERGE_QUEUE}",
+    ).fetchall()
+    mq_ids = {r["assignment_id"] for r in mq_rows if r["assignment_id"]}
+    mq_merged_ids = [
         r["assignment_id"]
-        for r in sql.execute(
-            conn, f"SELECT assignment_id FROM merge_queue"  # noqa: S608
-        ).fetchall()
+        for r in mq_rows
         if r["assignment_id"]
-    }
+        and (r["state"] or "").lower() == _MERGE_QUEUE_MERGED_STATE
+        and (r["last_attempt"] or r["enqueued_at"] or 0) < cutoff
+    ]
     open_keys = {
         (r["repo_name"], r["number"])
         for r in sql.execute(
@@ -194,7 +221,8 @@ def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
 
     result["archived_assignments"] = len(candidates)
     result["archived_notifications"] = len(notif_ids)
-    if dry_run or (not candidates and not notif_ids):
+    result["archived_merge_queue"] = len(mq_merged_ids)
+    if dry_run or (not candidates and not notif_ids and not mq_merged_ids):
         return result
 
     with conn:
@@ -206,4 +234,8 @@ def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
             _move_rows(
                 conn, _ASSIGNMENTS, _ASSIGNMENTS_ARCHIVE, "assignment_id", candidates
             )
+        if mq_merged_ids:
+            _move_rows(
+                conn, _MERGE_QUEUE, _MERGE_QUEUE_ARCHIVE, "assignment_id", mq_merged_ids
+            )
     return result

{code_coordinator-0.5.261 → code_coordinator-0.5.263}/coord/merge_queue.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 import inspect
 import json
 import logging
+import sqlite3
 import time
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
@@ -3753,6 +3754,58 @@ def save_queue(items: list[QueuedMerge]) -> None:
     retry_on_locked(_write)
 
 
+# ── Merged-history lookups (#1107 Part 3) ───────────────────────────────────
+#
+# `housekeeping.sweep()` archives MERGED merge_queue rows older than the
+# archive retention window into `merge_queue_archive` (same move-not-delete
+# pattern as `assignments`/`notifications`) so the live table stays bounded
+# instead of growing forever. `enqueue_approved_work()` and `staging_items()`
+# both dedup on "(repo, issue) already merged" to avoid re-surfacing an issue
+# whose prior work attempt already shipped — once the winning entry ages out
+# of the live table, that check must still see it, so it consults the
+# archive too.
+
+def _archived_merged_issue_keys(conn: sqlite3.Connection) -> set[tuple[str, int]]:
+    """(repo_name, issue_number) pairs recorded MERGED in the archive.
+
+    `merge_queue_archive` only exists once a housekeeping sweep has archived
+    at least one row (or archiving is disabled entirely), so this is
+    defensive against the table being absent.
+    """
+    try:
+        rows = sql.execute(
+            conn,
+            "SELECT repo_name, issue_number FROM merge_queue_archive WHERE state = ?",
+            (MERGED,),
+        ).fetchall()
+    except sql.driver_errors():  # #2784: not just sqlite3.OperationalError
+        # "no such table" surfaces as a *different* driver-named exception
+        # per backend (sqlite3.OperationalError vs psycopg.errors.
+        # UndefinedTable), so this must go through the dialect seam or the
+        # not-yet-archived case becomes an uncaught crash on Postgres.
+        return set()
+    return {(r["repo_name"], r["issue_number"]) for r in rows}
+
+
+def merged_issue_keys() -> set[tuple[str, int]]:
+    """All ``(repo_name, issue_number)`` pairs ever recorded MERGED.
+
+    Unions the live ``merge_queue`` table with ``merge_queue_archive`` so
+    callers get a correct answer regardless of whether the winning entry has
+    since been archived by ``housekeeping.sweep()``.
+    """
+    conn = get_connection()
+    live = {
+        (r["repo_name"], r["issue_number"])
+        for r in sql.execute(
+            conn,
+            "SELECT repo_name, issue_number FROM merge_queue WHERE state = ?",
+            (MERGED,),
+        ).fetchall()
+    }
+    return live | _archived_merged_issue_keys(conn)
+
+
 # ── Enqueue ──────────────────────────────────────────────────────────────
 
 def enqueue(
@@ -5403,12 +5456,10 @@ def staging_items(board, config, gh_ops: "GhOps | None" = None) -> list[StagingI
     queued_branches: set[str] = {x.branch for x in existing_queue if x.branch}
 
     # Fast-lookup: (repo_name, issue_number) pairs already MERGED so we skip
-    # issues whose prior attempt was already shipped.
-    already_merged: set[tuple[str, int]] = {
-        (x.repo_name, x.issue_number)
-        for x in existing_queue
-        if x.state == MERGED
-    }
+    # issues whose prior attempt was already shipped. Consults the archive
+    # too (#1107 Part 3) since the winning entry may have aged out of the
+    # live table by the time a later duplicate work item shows up here.
+    already_merged = merged_issue_keys()
 
     result: list[StagingItem] = []
     completed = list(getattr(board, "completed", []) or [])

{code_coordinator-0.5.261 → code_coordinator-0.5.263}/coord/serve_app.py

@@ -60,6 +60,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     import asyncio
+    import logging
 
 from starlette.applications import Starlette
 from starlette.middleware import Middleware
@@ -85,6 +86,84 @@ SERVE_PORT = 7435
 SERVE_TOKEN_ENV = "COORD_SERVE_TOKEN"
 SERVE_TOKEN_FILE = Path.home() / ".coord" / "serve_token"
 
+# #2862: the daemon's own logging configuration.  See
+# ``configure_daemon_logging`` for why this exists at all.
+DAEMON_LOG_LEVEL_ENV = "COORD_LOG_LEVEL"
+DEFAULT_DAEMON_LOG_LEVEL = "INFO"
+#: ``logging.Handler.name`` of the handler this module installs, so repeated
+#: calls update it in place instead of stacking duplicates onto the logger.
+DAEMON_LOG_HANDLER_NAME = "coord-daemon"
+#: The logger tree the handler is attached to — every ``coord.*`` logger in
+#: this package (``coord.serve``, ``coord.review``, ``coord.notify``, …).
+DAEMON_LOG_LOGGER = "coord"
+
+
+def configure_daemon_logging(level: str | None = None) -> "logging.Logger":
+    """Make ``coord.*`` log records actually reach the journal (#2862).
+
+    **This repo configures logging nowhere else, and that is a bug in exactly
+    one place: the long-lived daemons.**  For a short-lived CLI the default is
+    fine — Python's root logger sits at ``WARNING`` with no handler attached,
+    so ``log.warning`` reaches :data:`logging.lastResort` (a bare stderr
+    ``StreamHandler``) and ``log.info`` is dropped before it is even
+    formatted, because ``Logger.isEnabledFor(INFO)`` is ``False``.
+
+    ``coord serve`` inherits that default, and ``uvicorn.run(...,
+    log_level="info")`` does **not** fix it: uvicorn's ``LOGGING_CONFIG``
+    configures only the ``uvicorn`` / ``uvicorn.error`` / ``uvicorn.access``
+    loggers and leaves the root logger handler-less.  The consequence is the
+    whole of #2862: every ``log.info`` in ``_tick_loop`` — the passive
+    reconcile, the notify drain, auto-drain, milestone-gate and, the one that
+    cost two debugging rounds, **Step 3d's portal-sync summary** — was a
+    silent no-op on the real daemon.  "Zero portal-related lines in the
+    journal" was therefore never evidence that the bridge was quiet; it was
+    guaranteed by construction whether the bridge ran or not.
+
+    Called from ``coord serve``'s entry point (``coord.commands.lifecycle``)
+    **before** ``uvicorn.run``.  uvicorn's own ``dictConfig`` sets
+    ``disable_existing_loggers: False``, so the handler installed here
+    survives that call untouched.
+
+    *level* defaults to ``$COORD_LOG_LEVEL`` and then to ``INFO``; an
+    unrecognised value degrades to ``INFO`` rather than raising (a typo in a
+    systemd ``EnvironmentFile`` must not stop the daemon from booting).
+
+    ``propagate`` is deliberately left at its default ``True``: the root
+    logger has no handlers under uvicorn, and :meth:`logging.Logger.callHandlers`
+    only falls back to ``lastResort`` when it found *no* handler anywhere in
+    the chain — so records are emitted exactly once, while pytest's ``caplog``
+    (which captures at the root) still sees them.
+
+    Idempotent: repeated calls re-level the existing handler instead of
+    stacking a second copy, so a test (or a future second entry point) can
+    call it freely.  Returns the configured logger.
+    """
+    import logging  # noqa: PLC0415
+
+    raw = level or os.environ.get(DAEMON_LOG_LEVEL_ENV) or DEFAULT_DAEMON_LOG_LEVEL
+    resolved = logging.getLevelName(str(raw).strip().upper())
+    if not isinstance(resolved, int):
+        # `getLevelName` returns the string "Level FOO" for an unknown name.
+        resolved = logging.INFO
+
+    logger = logging.getLogger(DAEMON_LOG_LOGGER)
+    logger.setLevel(resolved)
+    for existing in logger.handlers:
+        if getattr(existing, "name", None) == DAEMON_LOG_HANDLER_NAME:
+            existing.setLevel(resolved)
+            return logger
+
+    handler = logging.StreamHandler(sys.stderr)
+    handler.name = DAEMON_LOG_HANDLER_NAME
+    handler.setLevel(resolved)
+    # No timestamp: journald stamps every line itself, and a second one only
+    # makes `journalctl -u coord-serve | grep portal` noisier.  The logger
+    # name IS the grep handle — `coord.serve`, `coord.portal_sync`, … — which
+    # `lastResort` (message only, no name, no level) never gave us.
+    handler.setFormatter(logging.Formatter("%(levelname)s %(name)s: %(message)s"))
+    logger.addHandler(handler)
+    return logger
+
 
 def resolve_serve_token(flag_token: str | None = None) -> str | None:
     """Resolve the daemon's bearer token: flag > ``COORD_SERVE_TOKEN`` > file.
@@ -598,7 +677,8 @@ def _audit_housekeeping_sweep(swept: dict) -> None:
         summary=(
             f"housekeeping: archived {swept.get('archived_assignments', 0)} "
             f"assignment(s), {swept.get('archived_notifications', 0)} "
-            "notification(s)"
+            f"notification(s), {swept.get('archived_merge_queue', 0)} "
+            "merge_queue entry(ies)"
         ),
         details=swept,
     )
@@ -7804,6 +7884,11 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
         # portal's queue, and the heartbeat the portal uses to decide whether
         # to trust the status it is showing is stale by exactly the downtime.
         last_portal_sync = 0.0
+        # #2862: the last (enabled, interval-positive) gate state Step 3d
+        # logged, so a *change* — including the very first evaluation, from
+        # ``None`` — is announced exactly once instead of either never (a
+        # `False` boolean gate is silent by design) or on every 30 s tick.
+        last_portal_gate_state: tuple[bool, bool] | None = None
 
         # #1220: fleet-wide orphaned-worktree sweep on its own slow cadence
         # (default hourly; 0 disables).  Separate timer from housekeeping/
@@ -7973,6 +8058,7 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
         async def _tick_loop() -> None:
             nonlocal last_housekeeping, last_merge_reconcile, last_worktree_clean, last_wal_checkpoint
             nonlocal last_notify_drain, last_notifier, last_portal_sync
+            nonlocal last_portal_gate_state
             from coord.audit import (  # noqa: PLC0415
                 flush_lock_contention_summary as _flush_audit_lock_contention_summary,
             )
@@ -8315,29 +8401,92 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
                 # `config` actually *is* (`_config_mtime`/`config.path` at the
                 # top of `_tick_loop`, and how the daemon was launched) before
                 # re-suspecting this expression.
+                #
+                # #2862 — the SECOND time this went quiet, with #2824's root
+                # cause ruled out (no `~/.coord/client.toml` on the daemon
+                # host, the right `--config` on argv, `portal.enabled: true`
+                # in that exact file). The check the note above asks for came
+                # back clean, and the actual answer was that the *question was
+                # unanswerable from the journal*: `coord serve` never
+                # configures logging, and `uvicorn.run(log_level="info")`
+                # configures only the `uvicorn*` loggers — so the root logger
+                # stayed handler-less at WARNING and `log.info(...)` below was
+                # dropped before formatting, on every pass, forever. "Zero
+                # portal lines in the journal" was therefore not evidence of a
+                # quiet bridge; it was true whether Step 3d ran or not. Fixed
+                # at the source by `configure_daemon_logging()` (top of this
+                # module, called from `coord serve`'s entry point). Two
+                # consequences are handled right here:
+                #
+                #   1. The gate's *state* is now announced on change (below),
+                #      so "Step 3d is not running, and here is which half of
+                #      the guard said no" is greppable instead of inferred
+                #      from a frozen DB column three layers down. A `False`
+                #      boolean gate is silent by design — that is the shape of
+                #      a boolean, so the fix is to log the boolean, not to
+                #      keep re-reading the expression.
+                #   2. Every pass now logs exactly one line, and a pass that
+                #      failed logs it at WARNING. The old `elif not
+                #      portal_result.heartbeat_ok: log.warning(...)` could
+                #      never fire for the case it was written for: a heartbeat
+                #      that *raises* also appends to `SyncResult.errors` (see
+                #      `coord.portal_sync.sync_tick`), so the `if
+                #      ... or portal_result.errors` branch above it always won
+                #      and downgraded the report to the INFO level that was
+                #      being discarded. A failed heartbeat is the single most
+                #      important thing this step can say — the portal is
+                #      showing a status nothing is refreshing — and it was
+                #      structurally unable to say it.
                 try:
-                    portal_due = (
-                        portal_sync_interval > 0
-                        and config.portal.enabled
-                        and _time.monotonic() - last_portal_sync
-                        >= portal_sync_interval
-                    )
+                    portal_enabled = bool(config.portal.enabled)
                 except Exception:  # noqa: BLE001
-                    portal_due = False
+                    portal_enabled = False
                     log.warning("portal sync guard failed", exc_info=True)
+                portal_gate_state = (portal_enabled, portal_sync_interval > 0)
+                if portal_gate_state != last_portal_gate_state:
+                    last_portal_gate_state = portal_gate_state
+                    if not portal_enabled:
+                        log.warning(
+                            "portal sync: Step 3d DISABLED — portal.enabled is "
+                            "false in the config this daemon is running on "
+                            "(%s); the customer-portal bridge will not run",
+                            config.path,
+                        )
+                    elif portal_sync_interval <= 0:
+                        log.warning(
+                            "portal sync: Step 3d DISABLED — "
+                            "COORD_PORTAL_SYNC_INTERVAL=%s; the "
+                            "customer-portal bridge will not run",
+                            portal_sync_interval,
+                        )
+                    else:
+                        log.info(
+                            "portal sync: Step 3d ENABLED — every %.0fs "
+                            "(config=%s)",
+                            portal_sync_interval,
+                            config.path,
+                        )
+                portal_due = (
+                    portal_gate_state[0]
+                    and portal_gate_state[1]
+                    and _time.monotonic() - last_portal_sync >= portal_sync_interval
+                )
                 if portal_due:
                     last_portal_sync = _time.monotonic()
                     try:
                         portal_result = await run_in_threadpool(
                             _portal_sync_tick, config
                         )
-                        if portal_result.moved or portal_result.errors:
-                            log.info("%s", portal_result.summary())
-                        elif not portal_result.heartbeat_ok:
-                            # A quiet pass that could not even heartbeat is the
-                            # one thing worth saying out loud: the portal is
-                            # now showing a status nothing is refreshing.
+                        # One line per pass, unconditionally (#2862): a
+                        # heartbeat that lands and moves nothing is the
+                        # bridge's healthy steady state, and it is exactly
+                        # the state whose absence took two issues to notice.
+                        # `summary()` already opens with "portal sync: " — do
+                        # not prefix it again.
+                        if portal_result.errors or not portal_result.heartbeat_ok:
                             log.warning("%s", portal_result.summary())
+                        else:
+                            log.info("%s", portal_result.summary())
                     except Exception:  # noqa: BLE001
                         log.warning("portal sync tick failed", exc_info=True)
                 # Step 4: #762 archival sweep on a slow cadence (default hourly).
@@ -8352,14 +8501,17 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
 
                         os.environ["COORD_HOUSEKEEPING_ON_DAEMON"] = "1"
                         swept = await run_in_threadpool(_hk.sweep)
-                        if swept.get("archived_assignments") or swept.get(
-                            "archived_notifications"
+                        if (
+                            swept.get("archived_assignments")
+                            or swept.get("archived_notifications")
+                            or swept.get("archived_merge_queue")
                         ):
                             log.info(
                                 "housekeeping: archived %d assignment(s), "
-                                "%d notification(s)",
+                                "%d notification(s), %d merge_queue entry(ies)",
                                 swept["archived_assignments"],
                                 swept["archived_notifications"],
+                                swept.get("archived_merge_queue", 0),
                             )
                             _audit_housekeeping_sweep(swept)
                     except Exception:  # noqa: BLE001
@@ -8494,30 +8646,84 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
                     except Exception:  # noqa: BLE001
                         log.warning("wal-checkpoint tick failed", exc_info=True)
 
+        def _watch(task, name: str):  # noqa: ANN001,ANN202
+            """Say so — loudly — if a background loop ever stops (#2862).
+
+            These are bare ``asyncio.create_task`` loops with no supervisor:
+            if one raises out of its ``while True``, its entire cadence stops
+            for the rest of the process's life and nothing says a word.
+            ``asyncio``'s own "Task exception was never retrieved" warning
+            only fires when the task object is garbage-collected, and these
+            are held alive by ``_ctx``'s frame until shutdown — so in
+            practice the traceback surfaces at process exit, if ever.
+
+            #2862 listed "the tick loop itself stalled" as suspect 3, to be
+            "ruled out first" and filed separately if confirmed, and there
+            was no way to do either from the journal. Now there is: a dead
+            loop is one ERROR line naming itself.
+
+            Returns *task* so call sites stay one expression.
+            """
+            if task is None:
+                return None
+
+            def _done(t) -> None:  # noqa: ANN001
+                if t.cancelled():
+                    return  # normal shutdown — `_ctx`'s finally cancels these
+                exc = t.exception()
+                log.error(
+                    "daemon loop %r STOPPED (%s) — its periodic work will not "
+                    "run again until `coord serve` is restarted",
+                    name,
+                    "raised" if exc is not None else "returned unexpectedly",
+                    exc_info=exc,
+                )
+
+            task.add_done_callback(_done)
+            return task
+
         @contextlib.asynccontextmanager
         async def _ctx(_a):  # noqa: ANN202
-            task = (
-                asyncio.create_task(_tick_loop()) if interval > 0 else None
-            )
-            gate_task = (
+            # #2862: name the config this daemon is actually running on, once,
+            # at startup. Step 3d's debugging note asks whoever hits the next
+            # "the bridge is quiet" to "check what `config` actually *is* ...
+            # and how the daemon was launched" — this is that check, answered
+            # in the journal instead of by reading /proc.
+            log.info(
+                "tick loop starting: config=%s portal.enabled=%s "
+                "reconcile=%.0fs portal_sync=%.0fs",
+                config.path,
+                getattr(getattr(config, "portal", None), "enabled", None),
+                interval,
+                portal_sync_interval,
+            )
+            task = _watch(
+                asyncio.create_task(_tick_loop()) if interval > 0 else None,
+                "tick",
+            )
+            gate_task = _watch(
                 asyncio.create_task(_gate_refresh_loop())
                 if interval > 0 and gate_refresh_interval > 0
-                else None
+                else None,
+                "gate-refresh",
             )
-            health_task = (
+            health_task = _watch(
                 asyncio.create_task(_health_refresh_loop())
                 if interval > 0 and health_poll_interval > 0
-                else None
+                else None,
+                "health-refresh",
             )
-            phantom_heal_task = (
+            phantom_heal_task = _watch(
                 asyncio.create_task(_phantom_heal_loop())
                 if interval > 0 and phantom_heal_interval > 0
-                else None
+                else None,
+                "phantom-heal",
             )
-            auto_revalidate_task = (
+            auto_revalidate_task = _watch(
                 asyncio.create_task(_auto_revalidate_loop())
                 if interval > 0 and auto_revalidate_interval > 0
-                else None
+                else None,
+                "auto-revalidate",
             )
             try:
                 yield