code-coordinator 0.5.60__tar.gz → 0.5.62__tar.gz

{code_coordinator-0.5.60/code_coordinator.egg-info → code_coordinator-0.5.62}/PKG-INFO

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

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.62",
+  "distance": 0,
+  "node": "g84d64a795986ab501062308d9e29da81f86cfb79",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-14"
+}

{code_coordinator-0.5.60 → code_coordinator-0.5.62}/coord/agent.py

@@ -26,6 +26,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Iterable
 
 from coord import cargo_cache
+from coord.models import DELIVERABLE_ANALYSIS_LABEL
 from coord.platform_paths import default_coord_dir
 
 if TYPE_CHECKING:
@@ -604,6 +605,19 @@ class AssignmentSpec:
     # `AssignmentSpec(**body)` in agent_app.py 400s on those) unless the
     # operator has actually configured one.
     cost_ceiling_usd: float | None = None
+    # #2188: the issue's GitHub label names, mirroring `Proposal.issue_labels`
+    # (#1430) — carried on the wire so a reap running on a config-free agent
+    # (docs/EPHEMERAL_WORKERS.md; no local DB or GitHub token to ask) can
+    # still see `coord.models.DELIVERABLE_ANALYSIS_LABEL` without an extra
+    # round-trip. Only `coord/dispatch.py`'s `dispatch()` populates this (from
+    # `proposal.issue_labels`, itself only set for `type="work"` dispatches —
+    # see #1430's `model_for_labels`/`provider_for_labels` gating), and only
+    # when non-empty — an agent predating this field 400s on an unrecognized
+    # kwarg (`AssignmentSpec(**body)` in agent_app.py), same discipline as
+    # every other optional wire field above. Empty by default: a spec with no
+    # labels (or dispatched by a caller that never populated
+    # `Proposal.issue_labels`) behaves exactly as before this field existed.
+    issue_labels: list[str] = field(default_factory=list)
 
 
 class _GitError(RuntimeError):
@@ -2700,6 +2714,11 @@ class AgentAssignment:
     # #448: advisory reason when the worker exited cleanly (exit_code==0) but
     # pushed 0 commits.  None on all other status values.
     #
+    # #2188: also None (never set) for an issue labelled `deliverable:
+    # analysis` — that shape lands on `status == DONE`/`analysis_deliverable
+    # = True` below instead, since 0 commits is its SUCCESS condition, not
+    # something advisory.
+    #
     # #1323 used to *also* reuse this field (for "work"-type assignments,
     # see _ADVISORY_TYPES) to hold a reason when a configured artifact_paths
     # glob matched 0 files, downgrading DONE -> ADVISORY in the process.
@@ -2787,6 +2806,26 @@ class AgentAssignment:
     # ceiling kill is indistinguishable from a crash and the money is spent
     # again on the next pass.
     spend_ceiling_reason: str | None = None
+    # #2188: True when `_reap` classified a clean (exit_code==0), 0-commit
+    # exit as a DELIVERABLE — the issue was labelled
+    # `coord.models.DELIVERABLE_ANALYSIS_LABEL` (`spec.issue_labels`) — rather
+    # than the #448 "worker did nothing" ADVISORY. Only ever set alongside
+    # `status == DONE`; `False` on every other outcome, including a normal
+    # zero-commit ADVISORY (the label wasn't present) and a labelled issue
+    # whose worker actually pushed commits (that's an ordinary DONE, handled
+    # by the ordinary Test/Review/Merge pipeline — this flag is specifically
+    # "the deliverable IS the message, there is no diff").
+    analysis_deliverable: bool = False
+    # #2188: the worker's own final message — `result` off the last
+    # stream-json `result` event (`coord.worker_events.WorkerSummary.
+    # result_text`), captured here so the coordinator can post the actual
+    # deliverable (a diagnosis/audit's prose) to the issue instead of a bare
+    # "assignment complete" comment. The worker itself has no `gh` access to
+    # post this — see coord.notify.post_transition's EVENT_COMPLETION arm.
+    # Populated only when `analysis_deliverable` is True; `None` otherwise
+    # (a normal work assignment's deliverable is the diff itself, already
+    # visible on the PR — restating the transcript there would be noise).
+    result_text: str | None = None
 
     def to_dict(self) -> dict:
         d = asdict(self)
@@ -7209,6 +7248,16 @@ class AgentServer:
         # ("work",) to the full work-like set so `test-author`/`mock-author`
         # get the same downgrade; before that they could land on `done` with
         # an empty branch.
+        # #2188: an issue labelled `deliverable:analysis` inverts the #448
+        # reading — for it, a clean exit with 0 commits is the SUCCESS
+        # condition (the deliverable is the worker's own final message, not
+        # a diff), not the "worker did nothing" anomaly. Detected off
+        # `assignment.spec.issue_labels` (wire field, #2188) so this works on
+        # a config-free agent too — no DB or GitHub read required. Resolved
+        # in the SAME `_ahead == 0` branch as the advisory check below so
+        # the two can never disagree about what "0 commits" means for this
+        # assignment.
+        _analysis_deliverable = False
         _zero_commit_reason: str | None = None
         if (exit_code == 0 and assignment is not None
                 and assignment.worktree_path
@@ -7218,17 +7267,30 @@ class AgentServer:
                 _base = assignment.spec.branch or "main"
                 _ahead = self._commits_ahead(_wt_advisory, _base)
                 if _ahead == 0:
-                    _zero_commit_reason = (
-                        "worker exited cleanly but pushed 0 commits"
-                    )
-                    try:
-                        with open(assignment.log_path, "a") as reopen:
-                            reopen.write(
-                                "# reap: advisory — 0 commits ahead of "
-                                f"{_base}; status set to advisory\n"
-                            )
-                    except OSError:
-                        pass
+                    if DELIVERABLE_ANALYSIS_LABEL in (assignment.spec.issue_labels or []):
+                        _analysis_deliverable = True
+                        try:
+                            with open(assignment.log_path, "a") as reopen:
+                                reopen.write(
+                                    "# reap: analysis deliverable — 0 commits "
+                                    f"ahead of {_base}; issue labelled "
+                                    f"{DELIVERABLE_ANALYSIS_LABEL!r}, status "
+                                    "set to done (#2188)\n"
+                                )
+                        except OSError:
+                            pass
+                    else:
+                        _zero_commit_reason = (
+                            "worker exited cleanly but pushed 0 commits"
+                        )
+                        try:
+                            with open(assignment.log_path, "a") as reopen:
+                                reopen.write(
+                                    "# reap: advisory — 0 commits ahead of "
+                                    f"{_base}; status set to advisory\n"
+                                )
+                        except OSError:
+                            pass
 
         # This block MUST always run regardless of push outcome so that
         # the assignment transitions out of 'running'.
@@ -7296,6 +7358,22 @@ class AgentServer:
                         assignment.zero_commit_reason = _zero_commit_reason
                     else:
                         assignment.status = DONE
+                        if _analysis_deliverable:
+                            # #2188: 0 commits on a `deliverable:analysis`
+                            # issue is the success shape — capture the
+                            # worker's own final message (already parsed
+                            # into `_worker_summary` above) so the
+                            # coordinator can post the actual deliverable to
+                            # the issue instead of a bare "complete" comment.
+                            # Best-effort: a non-stream-json log (or one with
+                            # no terminal `result` event) just leaves
+                            # `result_text` `None` — the assignment is still
+                            # correctly `done`, only the auto-posted prose is
+                            # missing, same degradation as every other
+                            # best-effort log parse in this function.
+                            assignment.analysis_deliverable = True
+                            if _worker_summary is not None and _worker_summary.result_text:
+                                assignment.result_text = _worker_summary.result_text
                 else:
                     assignment.status = FAILED
                 # #1461: only ever attaches to a FAILED/ADVISORY transition —

{code_coordinator-0.5.60 → code_coordinator-0.5.62}/coord/commands/release.py

@@ -1877,9 +1877,82 @@ def _drain(
         sleep_fn(max(0.0, min(poll_interval, deadline - elapsed)))
 
 
+def _parse_trailing_json(stdout: str) -> dict | None:
+    """The last top-level JSON object printed to *stdout*, or ``None``.
+
+    #2187: this used to look only at the LAST LINE of stdout and try to
+    parse THAT LINE alone as JSON. `coord release propagate --json` (like
+    every ``--json`` command in this codebase) prints its record via
+    ``json.dumps(..., indent=2, ...)`` — pretty-printed, for a human running
+    it by hand — which means the payload spans many lines and its own last
+    line is just ``}``, never a complete object on its own. The old check
+    therefore never found the record for ANY propagate run, successful or
+    not, and every call fell back to the ``f"exit {code}"`` placeholder in
+    `_run_propagate` below — which is exactly the false "propagate-failed
+    (status=exit 0, exit=0)" #2187 reports for a verified, exit-0 roll.
+
+    This instead finds the LAST line that is the object's own unindented
+    ``{`` (json.dumps never indents the outermost brace) and parses
+    everything from there to the end of stdout as one document. A single
+    compact line (no ``indent=``) still works too, tried second.
+    """
+    import json as _json  # noqa: PLC0415
+
+    text = stdout.strip()
+    if not text:
+        return None
+    lines = text.splitlines()
+    for idx in range(len(lines) - 1, -1, -1):
+        if lines[idx].strip() != "{":
+            continue
+        try:
+            payload = _json.loads("\n".join(lines[idx:]))
+        except ValueError:
+            continue
+        if isinstance(payload, dict):
+            return payload
+    for line in reversed(lines):
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            payload = _json.loads(line)
+        except ValueError:
+            continue
+        if isinstance(payload, dict):
+            return payload
+    return None
+
+
+def _latest_propagate_record_since(state_dir: Path, since: float) -> dict | None:
+    """The propagation journal's own record for the run started at/after
+    *since*, if any — the ground truth `coord release history` itself reads.
+
+    #2187 proposal 1: "read `coord release history` for the run it just
+    launched rather than inferring from a side-channel [stdout]." The
+    journal has no request id to join on, so this uses ``started_at``: the
+    subprocess `_run_propagate` shells out to is synchronous, so by the
+    time it has returned, a successful run has already appended its record
+    with a ``started_at`` at or after the moment this function's caller
+    launched it. Picks the OLDEST such record — the first thing written
+    after launch — in case some unrelated `coord release propagate` run
+    elsewhere raced it onto the same shared journal.
+    """
+    from coord import release_propagate as rp  # noqa: PLC0415
+
+    candidates = [
+        rec for rec in rp.read_records(state_dir)
+        if isinstance(rec.get("started_at"), (int, float)) and rec["started_at"] >= since
+    ]
+    if not candidates:
+        return None
+    return min(candidates, key=lambda rec: rec["started_at"])
+
+
 def _run_propagate(
-    *, daemon_host: str, target_version: str, config_path: Path, runner=None,
-) -> tuple[str, int, str]:
+    *, daemon_host: str, target_version: str, config_path: Path, state_dir: Path,
+    runner=None, now_fn=None,
+) -> tuple[str, int, str, float | None]:
     """``coord release propagate --daemon-host ... --target ... --json``.
 
     A real subprocess of THIS interpreter (matches `_roll_tui`/
@@ -1890,15 +1963,26 @@ def _run_propagate(
     run decided was needed is the version that actually rolls, even if a new
     release lands on PyPI mid-drain.
 
-    Returns ``(status, exit_code, combined_output)``. ``status`` is parsed
-    from the last JSON line of stdout (propagate's own record); parsing
-    failures fall back to ``f"exit {code}"`` rather than raising — a window
-    run must never crash because propagate's output was unexpected.
+    Returns ``(status, exit_code, combined_output, propagate_started_at)``.
+    ``status`` is read from the propagation journal entry that run itself
+    wrote (:func:`_latest_propagate_record_since`) — the same ground truth
+    `coord release history` reads — not reparsed from stdout (#2187:
+    reparsing stdout was the false-negative bug). ``propagate_started_at``
+    is that record's own ``started_at``, stamped onto the window's own
+    record so `window-history` can be joined to `history` (#2187 proposal
+    2) instead of the two stores re-deciding the same outcome separately.
+    Only when no journal entry can be found — the subprocess died before
+    writing one, or the journal write itself failed — does this fall back
+    to `_parse_trailing_json` on stdout, and then to ``f"exit {code}"``;
+    either fallback returns ``None`` for ``propagate_started_at`` since
+    there is then nothing to join to.
     """
-    import json as _json  # noqa: PLC0415
     import subprocess  # noqa: PLC0415
+    import time  # noqa: PLC0415
 
     run = runner or subprocess.run
+    clock = now_fn or time.time
+    launched_at = clock()
     argv = [
         sys.executable, "-m", "coord.cli", "release", "propagate",
         "--daemon-host", daemon_host, "--target", target_version,
@@ -1908,23 +1992,22 @@ def _run_propagate(
         proc = run(argv, capture_output=True, text=True, timeout=1800)
     except Exception as exc:  # noqa: BLE001
         detail = f"{type(exc).__name__}: {exc}"
-        return f"error: {detail}", 1, detail
+        return f"error: {detail}", 1, detail, None
     code = getattr(proc, "returncode", 1)
     stdout = getattr(proc, "stdout", "") or ""
     stderr = getattr(proc, "stderr", "") or ""
-    status = f"exit {code}"
-    for line in reversed(stdout.strip().splitlines()):
-        line = line.strip()
-        if not line.startswith("{"):
-            continue
-        try:
-            payload = _json.loads(line)
-        except ValueError:
-            continue
-        if isinstance(payload, dict) and payload.get("status"):
-            status = str(payload["status"])
-        break
-    return status, code, (stdout + ("\n" + stderr if stderr else "")).strip()
+    output = (stdout + ("\n" + stderr if stderr else "")).strip()
+
+    record = _latest_propagate_record_since(state_dir, launched_at)
+    if record is not None:
+        status = str(record.get("status") or f"exit {code}")
+        return status, code, output, record.get("started_at")
+
+    payload = _parse_trailing_json(stdout)
+    status = (
+        str(payload["status"]) if payload and payload.get("status") else f"exit {code}"
+    )
+    return status, code, output, None
 
 
 #: Where a skipped/failed nightly window (trap 3) is recorded — same
@@ -2161,13 +2244,14 @@ def release_nightly_window(  # noqa: PLR0912, PLR0915 — a pipeline; see module
                 status = rw.STATUS_DRAIN_TIMEOUT
             else:
                 # ── 5. roll — the daemon host is now provably free ─────────
-                prop_status, prop_exit, prop_output = _run_propagate(
+                prop_status, prop_exit, prop_output, prop_started_at = _run_propagate(
                     daemon_host=daemon_name, target_version=record.target_version,
-                    config_path=config_path,
+                    config_path=config_path, state_dir=state_dir,
                 )
                 record.propagate_status = prop_status
                 record.propagate_exit_code = prop_exit
                 record.propagate_output = prop_output
+                record.propagate_started_at = prop_started_at
                 if prop_output:
                     click.echo(prop_output)
 
@@ -2193,11 +2277,38 @@ def release_nightly_window(  # noqa: PLR0912, PLR0915 — a pipeline; see module
                     click.echo(f"error: {record.error}", err=True)
                     _escalate_window(record, reason=record.error)
                     status = rw.STATUS_PROPAGATE_DEFERRED
+                elif prop_status.startswith("exit ") or prop_status.startswith("error:"):
+                    # #2187 proposal 3: this arm is reached only when NEITHER
+                    # ground truth was available — no matching entry in
+                    # `coord release history` (see
+                    # `_latest_propagate_record_since`) AND no parseable
+                    # `--json` payload on stdout (`_parse_trailing_json`).
+                    # `prop_status` here is one of those two functions'
+                    # placeholder fallbacks, never a real outcome — so the
+                    # message must say exactly what evidence is missing
+                    # instead of quoting the placeholder as if it were one
+                    # (the old text, "status=exit 0, exit=0", read as a
+                    # verification failure when exit 0 is what a VERIFIED
+                    # roll also produces).
+                    record.error = (
+                        f"coord release propagate exited {prop_exit}, but its "
+                        "outcome could not be confirmed: no matching entry "
+                        "was found in `coord release history` for this run, "
+                        "and its --json stdout had no parseable status "
+                        "either — see propagate_output"
+                    )
+                    click.echo(f"error: {record.error}", err=True)
+                    _escalate_window(record, reason=record.error)
+                    status = rw.STATUS_PROPAGATE_FAILED
+                    exit_code = prop_exit or 1
                 else:
+                    # A real, ground-truth status from `coord release
+                    # history` — just not a verified roll (e.g. `failed` or
+                    # `rolled-back`).
                     record.error = (
-                        f"coord release propagate did not verify a roll "
-                        f"(status={prop_status}, exit={prop_exit}) despite a "
-                        f"drained daemon host"
+                        f"coord release propagate did not verify a roll — "
+                        f"`coord release history` recorded status="
+                        f"{prop_status!r} (exit {prop_exit}) for this run"
                     )
                     click.echo(f"error: {record.error}", err=True)
                     _escalate_window(record, reason=record.error)

{code_coordinator-0.5.60 → code_coordinator-0.5.62}/coord/dispatch.py

@@ -755,6 +755,14 @@ def dispatch(
     # field reject unknown payload keys with a 400.
     if getattr(proposal, "resume_session_id", None):
         payload["resume_session_id"] = proposal.resume_session_id
+    # #2188: the issue's GitHub labels, so the agent's own reap can see
+    # `coord.models.DELIVERABLE_ANALYSIS_LABEL` without a DB/GitHub round
+    # trip (config-free agent — docs/EPHEMERAL_WORKERS.md). Only sent when
+    # non-empty, same discipline as every optional wire field above — an
+    # agent predating `AssignmentSpec.issue_labels` 400s on an unrecognized
+    # kwarg.
+    if proposal.issue_labels:
+        payload["issue_labels"] = list(proposal.issue_labels)
     # #2131: per-leg spend ceiling, resolved here (CLI/daemon lane) and
     # carried on the wire so a config-free agent is covered too. Sent ONLY
     # when the operator has actually configured one — with no `budget:` block

{code_coordinator-0.5.60 → code_coordinator-0.5.62}/coord/drive.py

@@ -109,6 +109,7 @@ from coord.interactive import (
 )
 from coord.dead_end import DeadEnd, detect_dead_end
 from coord.failure_class import classify_failure, plan_usage_limit_resume
+from coord.models import DELIVERABLE_ANALYSIS_LABEL
 from coord.usage_limits import PlanLimits, evaluate_usage_gate, get_plan_limits
 # Lost in the #1584-onto-#1590 rebase: _decide_review() calls this, but the
 # import lived in a hunk #1590 rewrote, so the merge came out textually clean
@@ -1397,6 +1398,32 @@ def decide(
             f"{state.work_machine or machine}"
         )
 
+    # ---- analysis deliverable: done + 0 commits is the SUCCESS shape (#2188)
+    #
+    # An issue labelled `deliverable:analysis` inverts the read on a 0-commit
+    # exit: the deliverable is the worker's own final message (already
+    # posted to the issue by the coordinator — see coord.notify.
+    # post_transition's EVENT_COMPLETION arm), not a diff. `coord.agent.
+    # AgentServer._reap` only ever produces this shape on `status == "done"`
+    # (never "advisory" — see `AgentAssignment.analysis_deliverable`), so
+    # this only needs to guard the `done` arm above, and it runs BEFORE the
+    # "no branch"/dead-end/Test/Review/Merge machinery below: none of that
+    # applies when there is nothing to test, review, or merge. A labelled
+    # issue whose worker DID push commits (the label describes the common
+    # case, not a hard rule) falls through unchanged — `branch_has_commits`
+    # is False only for the genuine 0-commit shape.
+    if (
+        state.work_status == "done"
+        and DELIVERABLE_ANALYSIS_LABEL in state.issue_labels
+        and (not state.work_branch or not verifier.branch_has_commits(state))
+    ):
+        return _succeed(
+            f"✓ ANALYSIS DELIVERABLE — {state.work_aid} completed with 0 "
+            f"commits (issue labelled `{DELIVERABLE_ANALYSIS_LABEL}`); the "
+            "worker's final message is the deliverable and was posted to "
+            "the issue automatically — nothing to test, review, or merge."
+        )
+
     # A 'done' row with no branch never pushed anything either.
     if not state.work_branch:
         return _die(

{code_coordinator-0.5.60 → code_coordinator-0.5.62}/coord/models.py

@@ -354,6 +354,22 @@ def test_mode_from_labels(labels) -> str | None:
     return None
 
 
+# #2188: the per-issue DELIVERABLE policy label — mirrors `TEST_MODE_*_LABEL`'s
+# shape (cheapest fit, no body parsing). An issue whose deliverable is a
+# written artifact (a diagnosis, an audit, a spike/investigation writeup)
+# rather than a diff cannot succeed in the default pipeline: a worker that
+# does exactly what was asked ends with 0 commits by design, which the reap
+# otherwise reads as the #448 "worker did nothing" ADVISORY and `coord drive`
+# gives up on — discarding the whole deliverable (#2188's own worked example,
+# #2132, lost $1.65 of correct, on-topic analysis this way). Labelling the
+# issue `deliverable:analysis` inverts that reading: a clean exit with 0
+# commits is `coord.agent.AgentServer._reap`'s SUCCESS condition for this
+# issue, not its anomaly — see `_ZERO_COMMIT_TYPES`/`AgentAssignment.
+# analysis_deliverable` in coord/agent.py and the `decide()` short-circuit in
+# coord/drive.py that skips Test/Review/Merge for it.
+DELIVERABLE_ANALYSIS_LABEL = "deliverable:analysis"
+
+
 @dataclass
 class Assignment:
     machine_name: str

{code_coordinator-0.5.60 → code_coordinator-0.5.62}/coord/notify.py

@@ -2470,7 +2470,24 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
                 failure_reason=_failure_reason,
             )
     elif transition.event == EVENT_COMPLETION:
-        post_completion(exit_code=transition.exit_code or 0, **common)
+        # #2188: a `deliverable:analysis` issue that legitimately ended with
+        # 0 commits has no diff to point at — the deliverable IS the
+        # worker's own final message (`AgentAssignment.result_text`, see
+        # `coord.agent.AgentServer._reap`). Post it as the completion
+        # comment's summary so it reaches the issue automatically; the
+        # worker itself has no `gh` access to post it. Every other
+        # completion (the overwhelming majority) is unaffected — `entry.get
+        # ("analysis_deliverable")` is only ever truthy for this one shape.
+        _analysis_summary = (
+            entry.get("result_text") or ""
+            if entry.get("analysis_deliverable")
+            else ""
+        )
+        post_completion(
+            exit_code=transition.exit_code or 0,
+            summary=_analysis_summary,
+            **common,
+        )
         mark_notified(
             transition.assignment_id,
             transition.event,

{code_coordinator-0.5.60 → code_coordinator-0.5.62}/coord/release_window.py

@@ -190,6 +190,14 @@ class WindowRecord:
     propagate_status: str | None = None
     propagate_exit_code: int | None = None
     propagate_output: str = ""
+    #: The propagation journal record's OWN ``started_at`` — the join key
+    #: (#2187 proposal 2) that lets `window-history` be correlated to
+    #: `coord release history` for the SAME run, instead of each store
+    #: independently re-deciding what happened. ``None`` when no matching
+    #: journal record could be found (see
+    #: `coord.commands.release._latest_propagate_record_since`) — there is
+    #: then nothing to join to.
+    propagate_started_at: float | None = None
     finished_at: float | None = None
     error: str | None = None
     dry_run: bool = False
@@ -327,9 +335,14 @@ def render_record(record: WindowRecord | Mapping[str, Any]) -> list[str]:
         if data.get("drain_detail"):
             lines.append(f"      {data['drain_detail']}")
     if data.get("propagate_status"):
+        joined = (
+            f" [history @ {_stamp(data['propagate_started_at'])}]"
+            if data.get("propagate_started_at")
+            else ""
+        )
         lines.append(
             f"    propagate: {data['propagate_status']} "
-            f"(exit {data.get('propagate_exit_code')})"
+            f"(exit {data.get('propagate_exit_code')}){joined}"
         )
     if data.get("queue_restarted") is not None:
         lines.append(