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

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

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

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

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

{code_coordinator-0.5.60 → code_coordinator-0.5.61}/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.61}/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(

{code_coordinator-0.5.60 → code_coordinator-0.5.61}/tests/test_cli_release_window.py

@@ -120,12 +120,13 @@ def _stub_drain(monkeypatch, *, drained: bool, elapsed: float = 5.0, detail: str
     return calls
 
 
-def _stub_propagate(monkeypatch, *, status: str, exit_code: int, output: str = "ok"):
+def _stub_propagate(monkeypatch, *, status: str, exit_code: int, output: str = "ok",
+                    started_at: float | None = None):
     calls = []
 
     def _fake(**kwargs):
         calls.append(kwargs)
-        return status, exit_code, output
+        return status, exit_code, output, started_at
 
     monkeypatch.setattr(release_cmd, "_run_propagate", _fake)
     return calls
@@ -399,7 +400,7 @@ def test_a_propagate_subprocess_that_cannot_even_run_is_reported_not_a_success(
 
     monkeypatch.setattr(release_cmd, "_run_propagate",
                         lambda **k: ("error: TimeoutError: propagate subprocess timed out",
-                                    1, "TimeoutError: propagate subprocess timed out"))
+                                    1, "TimeoutError: propagate subprocess timed out", None))
     result = CliRunner().invoke(
         main,
         ["release", "nightly-window", "--config", str(valid_config_path),
@@ -594,3 +595,263 @@ def test_drain_treats_an_unreadable_board_as_fleet_wide_busy():
     )
     assert outcome.drained is False
     assert "board unreadable" in outcome.detail
+
+
+# ── #2187: a VERIFIED, exit-0 propagate must never be reported as
+#    `propagate-failed` — the whole bug this issue is about ─────────────────
+#
+# The tests above all stub `_run_propagate` wholesale via `_stub_propagate`,
+# which bypasses the exact code that was broken: parsing what a REAL
+# `coord release propagate --json` subprocess prints. These exercise
+# `_parse_trailing_json`, `_latest_propagate_record_since` and
+# `_run_propagate` itself directly, then drive the full CLI command with a
+# faked subprocess boundary (not `_run_propagate` itself) so the fix is
+# proven end to end, the same way the real bug reached production.
+
+
+def test_parse_trailing_json_reads_a_pretty_printed_indent2_payload():
+    """The exact shape `coord release propagate --json` prints
+    (`json.dumps(..., indent=2, sort_keys=True)`) — this is the shape the
+    old single-line heuristic never matched (#2187's root cause)."""
+    import json as _json
+
+    payload = {"status": "verified", "target_version": "0.5.50"}
+    stdout = (
+        "note: some warning on stdout\n"
+        + _json.dumps(payload, indent=2, sort_keys=True)
+        + "\n"
+    )
+    parsed = release_cmd._parse_trailing_json(stdout)
+    assert parsed == payload
+
+
+def test_parse_trailing_json_still_reads_a_compact_single_line_payload():
+    import json as _json
+
+    stdout = "some preamble\n" + _json.dumps({"status": "deferred"}, sort_keys=True)
+    assert release_cmd._parse_trailing_json(stdout) == {"status": "deferred"}
+
+
+def test_parse_trailing_json_on_no_json_at_all_is_none():
+    assert release_cmd._parse_trailing_json("just some plain log output\nnothing here") is None
+
+
+def test_parse_trailing_json_on_empty_stdout_is_none():
+    assert release_cmd._parse_trailing_json("") is None
+
+
+def test_latest_propagate_record_since_finds_the_run_just_launched(tmp_path, monkeypatch):
+    from coord import release_propagate as rp
+
+    rp.append_record(tmp_path, rp.PropagationRecord(started_at=100.0, status=rp.STATUS_FAILED))
+    rp.append_record(tmp_path, rp.PropagationRecord(started_at=200.0, status=rp.STATUS_VERIFIED))
+    record = release_cmd._latest_propagate_record_since(tmp_path, 150.0)
+    assert record["started_at"] == 200.0
+    assert record["status"] == rp.STATUS_VERIFIED
+
+
+def test_latest_propagate_record_since_ignores_older_runs(tmp_path):
+    from coord import release_propagate as rp
+
+    rp.append_record(tmp_path, rp.PropagationRecord(started_at=100.0, status=rp.STATUS_VERIFIED))
+    assert release_cmd._latest_propagate_record_since(tmp_path, 150.0) is None
+
+
+def test_latest_propagate_record_since_on_no_journal_is_none(tmp_path):
+    assert release_cmd._latest_propagate_record_since(tmp_path, 0.0) is None
+
+
+def test_run_propagate_prefers_the_journal_over_stdout(tmp_path):
+    """Ground truth (#2187 proposal 1): even if stdout were unparseable, a
+    matching journal entry is what decides the status — and it stamps
+    `propagate_started_at`, the join key (#2187 proposal 2)."""
+    from coord import release_propagate as rp
+
+    def _fake_runner(argv, **kwargs):
+        import subprocess as _subprocess
+
+        rp.append_record(
+            tmp_path,
+            rp.PropagationRecord(started_at=500.0, status=rp.STATUS_VERIFIED,
+                                 target_version="0.5.50", finished_at=505.0),
+        )
+        return _subprocess.CompletedProcess(argv, 0, stdout="not json at all", stderr="")
+
+    status, exit_code, output, started_at = release_cmd._run_propagate(
+        daemon_host="dellserver", target_version="0.5.50",
+        config_path=tmp_path / "coordinator.yml", state_dir=tmp_path,
+        runner=_fake_runner, now_fn=lambda: 499.0,
+    )
+    assert status == rp.STATUS_VERIFIED
+    assert exit_code == 0
+    assert started_at == 500.0
+
+
+def test_run_propagate_falls_back_to_pretty_printed_stdout_when_no_journal_entry(tmp_path):
+    """#2187's exact root-cause repro: no journal record can be found (the
+    write races or fails), but stdout carries the SAME pretty-printed
+    (`indent=2`) `--json` payload the real command emits. The old
+    single-line heuristic returned the `f"exit {code}"` placeholder here for
+    every successful, exit-0 roll — this must now read `verified` instead."""
+    import json as _json
+    import subprocess as _subprocess
+
+    def _fake_runner(argv, **kwargs):
+        payload = {"status": "verified", "target_version": "0.5.50"}
+        stdout = _json.dumps(payload, indent=2, sort_keys=True)
+        return _subprocess.CompletedProcess(argv, 0, stdout=stdout, stderr="")
+
+    status, exit_code, output, started_at = release_cmd._run_propagate(
+        daemon_host="dellserver", target_version="0.5.50",
+        config_path=tmp_path / "coordinator.yml", state_dir=tmp_path,
+        runner=_fake_runner, now_fn=lambda: 0.0,
+    )
+    assert status == "verified"
+    assert exit_code == 0
+    assert started_at is None  # nothing to join to — no journal entry found
+
+
+def test_run_propagate_with_no_journal_and_no_parseable_stdout_names_the_gap(tmp_path):
+    """Neither ground truth is available: falls back to the honest
+    `f"exit {code}"` placeholder — the CALLER (below) is responsible for
+    turning that into a message that names what's missing, not one that
+    misreports it as a real, examined status."""
+    import subprocess as _subprocess
+
+    def _fake_runner(argv, **kwargs):
+        return _subprocess.CompletedProcess(argv, 0, stdout="garbage, no json", stderr="")
+
+    status, exit_code, output, started_at = release_cmd._run_propagate(
+        daemon_host="dellserver", target_version="0.5.50",
+        config_path=tmp_path / "coordinator.yml", state_dir=tmp_path,
+        runner=_fake_runner, now_fn=lambda: 0.0,
+    )
+    assert status == "exit 0"
+    assert exit_code == 0
+    assert started_at is None
+
+
+def _fake_propagate_subprocess(monkeypatch, state_dir, *, status: str, exit_code: int,
+                               target_version: str = "0.5.50", write_journal: bool = True):
+    """Stands in for a REAL `python -m coord.cli release propagate --json`
+    subprocess: appends the same journal record `_finish` would (#2187's
+    ground truth) and returns the SAME pretty-printed (`indent=2`) --json
+    stdout shape the real command emits, so the whole `_run_propagate`
+    boundary — not just its already-stubbed replacement — is exercised."""
+    import json as _json
+    import subprocess as _subprocess
+    import time as _time
+
+    from coord import release_propagate as rp
+
+    calls = []
+
+    def _fake_run(argv, **kwargs):
+        calls.append(argv)
+        if write_journal:
+            # A REAL `started_at` — not a fixed constant — because
+            # `_run_propagate` compares this against `time.time()` captured
+            # right before launch (`_latest_propagate_record_since`'s
+            # `since`); a hardcoded past timestamp would look like an OLDER,
+            # unrelated run and be filtered out exactly like a real stale
+            # entry would be.
+            rp.append_record(
+                state_dir,
+                rp.PropagationRecord(
+                    started_at=_time.time(), target_version=target_version,
+                    status=status, finished_at=_time.time(),
+                ),
+            )
+        payload = {"status": status, "target_version": target_version}
+        stdout = _json.dumps(payload, indent=2, sort_keys=True)
+        return _subprocess.CompletedProcess(argv, exit_code, stdout=stdout, stderr="")
+
+    monkeypatch.setattr(_subprocess, "run", _fake_run)
+    return calls
+
+
+def test_window_end_to_end_a_verified_roll_is_never_reported_as_failed(
+    valid_config_path, state_dir, no_network, escalations, monkeypatch
+):
+    """#2187 acceptance arm 1: a propagate that exits 0 and records
+    `verified` produces a clean window-history entry and a clean exit —
+    through the REAL `_run_propagate`, not a stub of it."""
+    _stub_verify(monkeypatch, daemon_version="0.5.49")
+    _stub_systemctl(monkeypatch)
+    _stub_drain(monkeypatch, drained=True)
+    _fake_propagate_subprocess(monkeypatch, state_dir, status=rp.STATUS_VERIFIED,
+                               exit_code=0, target_version="0.5.50")
+
+    result = CliRunner().invoke(
+        main,
+        ["release", "nightly-window", "--config", str(valid_config_path),
+         "--target", "0.5.50", "--daemon-host", "server"],
+    )
+    assert result.exit_code == 0, result.output
+    record = _records(state_dir)[0]
+    assert record["status"] == rw.STATUS_ROLLED
+    assert record["status"] in rw.OK_STATUSES
+    assert record["propagate_status"] == rp.STATUS_VERIFIED
+    # The join key (#2187 proposal 2): stamped from the propagation
+    # journal's OWN `started_at`, proving `window-history` can now be
+    # correlated to `history` for this exact run.
+    assert record["propagate_started_at"] is not None
+    assert record["propagate_started_at"] > 0
+    assert not record["error"]
+    assert not escalations
+
+
+def test_window_end_to_end_a_genuine_failure_is_still_reported_failed(
+    valid_config_path, state_dir, no_network, escalations, monkeypatch
+):
+    """#2187 acceptance arm 2: a propagate that genuinely fails still
+    produces `propagate-failed` and a non-zero exit — the fix must not turn
+    every outcome green."""
+    _stub_verify(monkeypatch, daemon_version="0.5.49")
+    _stub_systemctl(monkeypatch)
+    _stub_drain(monkeypatch, drained=True)
+    _fake_propagate_subprocess(monkeypatch, state_dir, status=rp.STATUS_FAILED,
+                               exit_code=1, target_version="0.5.50")
+
+    result = CliRunner().invoke(
+        main,
+        ["release", "nightly-window", "--config", str(valid_config_path),
+         "--target", "0.5.50", "--daemon-host", "server"],
+    )
+    assert result.exit_code == 1, result.output
+    record = _records(state_dir)[0]
+    assert record["status"] == rw.STATUS_PROPAGATE_FAILED
+    assert record["status"] not in rw.OK_STATUSES
+    assert record["propagate_status"] == rp.STATUS_FAILED
+    assert len(escalations) == 1
+
+
+def test_window_end_to_end_an_unconfirmable_exit_0_names_the_missing_evidence(
+    valid_config_path, state_dir, no_network, escalations, monkeypatch
+):
+    """No journal entry AND no parseable stdout, despite exit 0 (#2187
+    proposal 3): the error must name the specific missing artifacts, never
+    read as `status=exit 0, exit=0` with nothing further explained."""
+    import subprocess as _subprocess
+
+    _stub_verify(monkeypatch, daemon_version="0.5.49")
+    _stub_systemctl(monkeypatch)
+    _stub_drain(monkeypatch, drained=True)
+
+    def _fake_run(argv, **kwargs):
+        return _subprocess.CompletedProcess(argv, 0, stdout="", stderr="")
+
+    monkeypatch.setattr(_subprocess, "run", _fake_run)
+
+    result = CliRunner().invoke(
+        main,
+        ["release", "nightly-window", "--config", str(valid_config_path),
+         "--target", "0.5.50", "--daemon-host", "server"],
+    )
+    assert result.exit_code != 0, result.output
+    record = _records(state_dir)[0]
+    assert record["status"] == rw.STATUS_PROPAGATE_FAILED
+    assert "status=exit 0, exit=0" not in (record["error"] or "")
+    assert "no matching entry" in (record["error"] or "")
+    assert "no parseable" in (record["error"] or "")
+    assert len(escalations) == 1

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

@@ -1,8 +0,0 @@
-{
-  "tag": "0.5.60",
-  "distance": 0,
-  "node": "ge01001eaf8201fb10e8bd9b1a0f6c018d93b3fb8",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-13"
-}