code-coordinator 0.5.46__tar.gz → 0.5.47__tar.gz

{code_coordinator-0.5.46/code_coordinator.egg-info → code_coordinator-0.5.47}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.46",
+  "tag": "0.5.47",
   "distance": 0,
-  "node": "g6b550e02d314120327e243cc96c1f09580e49af1",
+  "node": "g50ca8ee3f6cbe5afae47b1a43d23fc5faa997f84",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-12"

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/coord/commands/drive_queue.py

@@ -264,6 +264,7 @@ def drive_queue_list(repo: str | None, output_json: bool, config_path: Path) ->
     if not rows:
         click.echo("(drive queue is empty)")
         return
+    now = time.time()
     for entry in entries_from_rows(rows):
         bits = [f"{entry.position:>2}  {entry.key:<28} {entry.state}"]
         if entry.machine:
@@ -278,11 +279,43 @@ def drive_queue_list(repo: str | None, output_json: bool, config_path: Path) ->
             bits.append(f"hold={entry.hold_state or 'armed'}")
         click.echo("  ".join(bits))
         if entry.last_reason:
-            click.echo(f"      last: {entry.last_reason}")
+            click.echo(f"      last{_reason_age_suffix(entry, now)}: {entry.last_reason}")
         for line in _hold_lines(entry):
             click.echo(line)
 
 
+def _reason_age_suffix(entry: QueueEntry, now: float) -> str:
+    """`` (3h ago)`` / `` (42s ago)``, or ``''`` when the age is unknown.
+
+    #2133: a `last_reason` is a snapshot taken the instant the tick (or a
+    guard) wrote it — never re-validated — so displaying it bare lets an
+    hours-old, no-longer-true observation read as current state (that
+    misdirected a live diagnosis on #2104: `checks_failed` was still shown
+    ~3 hours after the named checks had gone green, while the actual
+    blocker — a later `request-changes` review — was nowhere in the
+    output). Stamping the age doesn't make the reason current, but it stops
+    it from being silently *mistaken* for current, which is the whole
+    defect. Empty for `entry.reason_at is None` — a row predating #2133's
+    migration, or an entry whose `last_reason` was never written through
+    `update_drive_queue_entry` (e.g. hand-built in a test) — rather than
+    guessing an age it doesn't have.
+    """
+    if entry.reason_at is None:
+        return ""
+    return f" ({_age_str(max(0.0, now - entry.reason_at))} ago)"
+
+
+def _age_str(delta_seconds: float) -> str:
+    """``42s`` / ``3h`` / ``5d`` — coarse, single-unit, matches #2133's ask."""
+    if delta_seconds < 60:
+        return f"{int(delta_seconds)}s"
+    if delta_seconds < 3600:
+        return f"{int(delta_seconds // 60)}m"
+    if delta_seconds < 86400:
+        return f"{int(delta_seconds // 3600)}h"
+    return f"{int(delta_seconds // 86400)}d"
+
+
 def _hold_lines(entry: QueueEntry) -> list[str]:
     """The gate's rendering for `list` / `status`, or `[]` when there is none.
 

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/coord/db.py

@@ -379,6 +379,18 @@ def _ensure_schema(conn: sqlite3.Connection) -> None:
             attempts      INTEGER NOT NULL DEFAULT 0,
             deferrals     INTEGER NOT NULL DEFAULT 0,
             last_reason   TEXT    NOT NULL DEFAULT '',
+            -- #2133: wall-clock time `last_reason` was last WRITTEN, stamped
+            -- by `coord.state._update_drive_queue_entry_local` every time a
+            -- `last_reason` update lands (never by a caller — it is not in
+            -- `_DRIVE_QUEUE_UPDATABLE`). `last_reason` is a point-in-time
+            -- observation, not a live probe; without this a `blocked` entry's
+            -- displayed text ages silently and a stale-but-plausible reason
+            -- reads as current state (2026-08-11's #2104 incident: a 3-hour-
+            -- stale `checks_failed` outlived the CI failure it named while
+            -- the real, later blocker — a request-changes review — went
+            -- unmentioned). NULL for a row written before this migration or
+            -- for a fresh row whose `last_reason` is still the '' default.
+            reason_at     REAL,
             session_name  TEXT,
             launched_at   REAL,
             enqueued_at   REAL    NOT NULL,
@@ -693,6 +705,11 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
         # "agent".
         "ALTER TABLE assignments ADD COLUMN verdict_source TEXT",
         "ALTER TABLE assignments ADD COLUMN verdict_source_reason TEXT",
+        # #2133: see the CREATE TABLE comment above — capture time of
+        # `drive_queue.last_reason`, so a `blocked` entry's displayed reason
+        # carries its age instead of rendering a stale snapshot as current
+        # state. NULL for every row predating this migration.
+        "ALTER TABLE drive_queue ADD COLUMN reason_at REAL",
     ]
     for sql in migrations:
         try:

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/coord/drive_queue.py

@@ -321,6 +321,14 @@ class QueueEntry:
     attempts: int = 0
     deferrals: int = 0
     last_reason: str = ""
+    # #2133: wall-clock capture time of `last_reason`, stamped by
+    # `coord.state._update_drive_queue_entry_local` every time `last_reason`
+    # is written. `None` for a row predating the migration or whose
+    # `last_reason` is still the '' default — never treated as "just now".
+    # A rendering that shows `last_reason` without also showing (or at least
+    # consulting) this is exactly the bug #2133 closes: a point-in-time
+    # observation displayed as if it were current state.
+    reason_at: float | None = None
     session_name: str = ""
     launched_at: float | None = None
     # #1870: the short hostname of the machine whose tick launched THIS
@@ -382,6 +390,11 @@ class QueueEntry:
             attempts=int(row.get("attempts") or 0),
             deferrals=int(row.get("deferrals") or 0),
             last_reason=str(row.get("last_reason") or ""),
+            reason_at=(
+                None
+                if row.get("reason_at") is None
+                else float(row.get("reason_at"))
+            ),
             session_name=str(row.get("session_name") or ""),
             launched_at=None if launched_at is None else float(launched_at),
             launch_host=str(row.get("launch_host") or ""),

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/coord/reports.py

@@ -814,6 +814,7 @@ DRIVE_QUEUE_STATUS_COLUMNS = [
     "attempts",
     "deferrals",
     "last_reason",
+    "reason_at",
     "enqueued_at",
     "launched_at",
     "hold_state",
@@ -831,6 +832,10 @@ DRIVE_QUEUE_STATUS_COLUMN_META = [
     ColumnMeta(id="attempts", label="Attempts", kind="int", align="right"),
     ColumnMeta(id="deferrals", label="Deferrals", kind="int", align="right"),
     ColumnMeta(id="last_reason", label="Last Reason", kind="text", weight=3.0),
+    # #2133: capture time of `last_reason` — a client renders it as an age
+    # next to the reason so a stale snapshot never reads as current state.
+    # `None`/absent for a row predating the migration.
+    ColumnMeta(id="reason_at", label="Reason At", kind="timestamp"),
     ColumnMeta(id="enqueued_at", label="Enqueued", kind="timestamp"),
     ColumnMeta(id="launched_at", label="Launched", kind="timestamp"),
     ColumnMeta(id="hold_state", label="Hold", kind="enum"),
@@ -876,6 +881,7 @@ def fold_drive_queue_status(
                 "attempts": int(entry.get("attempts") or 0),
                 "deferrals": int(entry.get("deferrals") or 0),
                 "last_reason": entry.get("last_reason") or "",
+                "reason_at": entry.get("reason_at"),
                 "enqueued_at": entry.get("enqueued_at"),
                 "launched_at": entry.get("launched_at"),
                 "hold_state": entry.get("hold_state") or "",

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/coord/state.py

@@ -5096,8 +5096,9 @@ def _list_drive_escalations_local(repo_name: str | None = None) -> list[dict]:
 
 _DRIVE_QUEUE_COLUMNS = (
     "id, repo_name, issue_number, position, machine, after_json, state, "
-    "attempts, deferrals, last_reason, session_name, launched_at, enqueued_at, "
-    "hold_after, hold_reason, resume_when, hold_state, hold_probes, launch_host"
+    "attempts, deferrals, last_reason, reason_at, session_name, launched_at, "
+    "enqueued_at, hold_after, hold_reason, resume_when, hold_state, "
+    "hold_probes, launch_host"
 )
 
 # Fields `update_drive_queue_entry` may write. Deliberately excludes the
@@ -5338,7 +5339,10 @@ def update_drive_queue_entry(repo_name: str, issue_number: int, **fields) -> boo
     Accepts any of ``state`` / ``attempts`` / ``deferrals`` / ``last_reason`` /
     ``session_name`` / ``launched_at`` / ``launch_host``; anything else raises
     ``ValueError`` (the queue's order is owned by ``enqueue``/``move``, not by
-    a tick).
+    a tick). A ``last_reason`` update is stamped with its capture time
+    (``reason_at``, #2133) by ``_update_drive_queue_entry_local`` — the one
+    function both this local path and the daemon's ``/drive-queue`` handler
+    call, so no caller can write a reason without also dating it.
 
     Routes to the daemon when ``board_service`` is set. Returns whether a row
     was actually updated.
@@ -5370,6 +5374,17 @@ def _update_drive_queue_entry_local(
         raise ValueError(f"not updatable on drive_queue: {sorted(unknown)}")
     if not fields:
         return False
+    if "last_reason" in fields:
+        # #2133: `last_reason` is a point-in-time observation (the tick's
+        # gate reading at the moment it wrote it), not a live probe. Without
+        # a capture timestamp a `blocked` entry's displayed reason ages
+        # silently and a stale-but-plausible reason reads as current state
+        # — see coord/db.py's CREATE TABLE comment for the incident this
+        # closes. Stamped here, the single choke point every `last_reason`
+        # write passes through (both the no-daemon local path and the
+        # daemon's `/drive-queue` update handler call this same function),
+        # so no caller can set one without the other.
+        fields = {**fields, "reason_at": time.time()}
     conn = get_connection()
     assignments = ", ".join(f"{name} = ?" for name in fields)
     cur = conn.execute(

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/docs/DRIVE_QUEUE.md

@@ -289,6 +289,14 @@ coord drive-queue remove REPO ISSUE && coord drive-queue add REPO ISSUE
 
 or, from the TUI overlay, select the blocked entry and press `u`.
 
+`last_reason` is a **snapshot**, taken the instant it was written and never
+re-validated (#2133) — the condition it names can resolve minutes or hours
+later while the text stays exactly as first written. `coord drive-queue
+list` shows its age next to it (`last (3h ago): checks_failed …`) precisely
+so it never reads as a live diagnosis; treat the reason as history and go
+check the board/CI/review state for what is *actually* blocking now,
+especially once the age climbs past a few minutes.
+
 ### 4a. Blocked *without* spending an attempt — permanent causes
 
 Two `blocked` reasons are **not** "died `attempts` times". They block on the

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/tests/test_cli_drive_queue.py

@@ -260,6 +260,98 @@ def test_list_json_emits_the_raw_rows(cli):
     assert rows[0]["after_json"] == []  # a real list on the wire, never a string
 
 
+# ── #2133: `last_reason` is a snapshot, never re-validated — its rendering
+# must carry its own age so it can never be mistaken for a current diagnosis.
+# Reproduces the shape of the #2104 incident: a `blocked` entry's reason was
+# captured once and then read, ~3 hours later, as if it still described the
+# present.
+
+
+def _backdate_reason(coord_db, issue: int, seconds: float) -> None:
+    """Age a queued entry's `reason_at` by *seconds* directly in SQLite —
+    simulating a `last_reason` snapshot captured that long ago. Bypasses
+    `update_drive_queue_entry` (which always stamps "now") on purpose: this
+    is standing in for the wall-clock time that has genuinely elapsed since
+    a real tick wrote the reason, exactly as `_backdate` does for
+    `launched_at` above.
+    """
+    coord_db.execute(
+        "UPDATE drive_queue SET reason_at = ? WHERE repo_name = ? AND issue_number = ?",
+        (time.time() - seconds, REPO, issue),
+    )
+    coord_db.commit()
+
+
+def test_list_shows_no_age_for_a_freshly_written_reason(cli):
+    cli("add", REPO, "1650")
+    state._update_drive_queue_entry_local(
+        REPO, 1650, state="blocked", last_reason="checks_failed: test (3.12)"
+    )
+    result = cli("list")
+    assert result.exit_code == 0, result.output
+    assert "checks_failed: test (3.12)" in result.output
+    assert "0s ago" in result.output, (
+        "a reason written this instant must still carry SOME age marker — "
+        "the point is that a reader never has to guess whether an age is "
+        "being shown at all:\n" + result.output
+    )
+
+
+def test_list_ages_a_stale_park_reason_instead_of_showing_it_bare(cli, coord_db):
+    """The #2104 reproduction: a `blocked` reason captured hours ago must
+    read as history, not as a live diagnosis of the current blocker."""
+    cli("add", REPO, "1650")
+    state._update_drive_queue_entry_local(
+        REPO, 1650, state="blocked", last_reason="checks_failed: test (3.12)"
+    )
+    _backdate_reason(coord_db, 1650, 3 * 3600 + 60)  # ~3h ago, clear of rounding
+
+    result = cli("list")
+    assert result.exit_code == 0, result.output
+    assert "checks_failed: test (3.12)" in result.output, (
+        "the reason text itself must still be legible:\n" + result.output
+    )
+    assert "(3h ago)" in result.output, (
+        "#2133: a stale `last_reason` rendered without its age is exactly "
+        "the trap that misdirected the #2104 diagnosis — the queue text "
+        "pointed at CI while the real, later blocker (a review verdict) "
+        "went unmentioned:\n" + result.output
+    )
+
+
+def test_list_json_carries_reason_at_for_a_client_to_render_its_own_age(cli, coord_db):
+    cli("add", REPO, "1650")
+    state._update_drive_queue_entry_local(
+        REPO, 1650, state="blocked", last_reason="checks_failed"
+    )
+    _backdate_reason(coord_db, 1650, 90.0)
+
+    rows = json.loads(cli("list", "--json").output)
+    assert rows[0]["last_reason"] == "checks_failed"
+    assert rows[0]["reason_at"] == pytest.approx(time.time() - 90.0, abs=5.0)
+
+
+def test_list_omits_age_for_a_reason_with_no_capture_time(cli, coord_db):
+    """A row predating #2133's migration (or written straight to the table by
+    hand) has `reason_at IS NULL` — the renderer must not fabricate an age
+    for it, just show the bare reason exactly as it always has."""
+    cli("add", REPO, "1650")
+    coord_db.execute(
+        "UPDATE drive_queue SET state = 'blocked', last_reason = 'legacy reason', "
+        "reason_at = NULL WHERE repo_name = ? AND issue_number = ?",
+        (REPO, 1650),
+    )
+    coord_db.commit()
+
+    result = cli("list")
+    assert result.exit_code == 0, result.output
+    assert "legacy reason" in result.output
+    assert "ago" not in result.output, (
+        "no `reason_at` means no age can be computed — inventing one would "
+        "be worse than showing nothing:\n" + result.output
+    )
+
+
 # ── remove / move ────────────────────────────────────────────────────────────
 
 

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/tests/test_reports.py

@@ -643,6 +643,7 @@ def _dq_row(
     attempts: int = 0,
     deferrals: int = 0,
     last_reason: str = "",
+    reason_at: float | None = None,
     session_name: str = "",
     launched_at: float | None = None,
     enqueued_at: float = 100.0,
@@ -664,6 +665,7 @@ def _dq_row(
         "attempts": attempts,
         "deferrals": deferrals,
         "last_reason": last_reason,
+        "reason_at": reason_at,
         "session_name": session_name,
         "launched_at": launched_at,
         "enqueued_at": enqueued_at,
@@ -695,7 +697,7 @@ class TestFoldDriveQueueStatus:
         assert [m.id for m in result.column_meta] == result.columns
         assert result.columns == [
             "position", "repo", "issue", "title", "state", "machine",
-            "attempts", "deferrals", "last_reason", "enqueued_at",
+            "attempts", "deferrals", "last_reason", "reason_at", "enqueued_at",
             "launched_at", "hold_state", "after",
         ]
 

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/tests/test_serve.py

@@ -3150,6 +3150,84 @@ def test_drive_queue_local_rejects_non_updatable_field(coord_db):
         state._update_drive_queue_entry_local("api", 7, machine="laptop")
 
 
+def test_drive_queue_local_stamps_reason_at_when_last_reason_is_written(coord_db):
+    """#2133: `last_reason` is a point-in-time observation, so every write to
+    it is dated — the queue's ONE choke point for both the no-daemon local
+    path and the daemon's `/drive-queue` update handler
+    (`serve_app.post_drive_queue` calls this exact function), so no caller
+    can set a reason without also dating it.
+    """
+    import time as _time
+
+    from coord import state
+
+    state._enqueue_drive_queue_local("api", 7)
+    assert state._get_drive_queue_entry_local("api", 7)["reason_at"] is None
+
+    before = _time.time()
+    assert state._update_drive_queue_entry_local(
+        "api", 7, state="blocked", last_reason="checks_failed"
+    )
+    after = _time.time()
+    entry = state._get_drive_queue_entry_local("api", 7)
+    assert entry["reason_at"] is not None
+    assert before <= entry["reason_at"] <= after
+    first_stamp = entry["reason_at"]
+
+    # A write that never touches `last_reason` must not re-date it — the
+    # timestamp names when the REASON was captured, not when the row last
+    # changed for any reason.
+    assert state._update_drive_queue_entry_local("api", 7, attempts=1)
+    entry = state._get_drive_queue_entry_local("api", 7)
+    assert entry["reason_at"] == first_stamp
+    assert entry["last_reason"] == "checks_failed"
+
+    # Re-writing `last_reason` — even to the identical text — re-dates it: a
+    # fresh observation of the same condition is still a fresh observation.
+    _time.sleep(0.01)
+    assert state._update_drive_queue_entry_local(
+        "api", 7, last_reason="checks_failed"
+    )
+    entry = state._get_drive_queue_entry_local("api", 7)
+    assert entry["reason_at"] > first_stamp
+
+
+def test_drive_queue_daemon_update_handler_also_stamps_reason_at(
+    tmp_path: Path, valid_config_path: Path, rw_db,
+):
+    """The daemon's `/drive-queue` update action must date `last_reason` the
+    same way the local (no-daemon) path does — #2133's fix has to hold for a
+    thin client too, not just a standalone `coord` invocation. Mirrors
+    `test_board_projection_carries_drive_queue`'s use of `rw_db` (a
+    thread-safe file-backed override `TestClient`'s worker thread can
+    actually see) rather than the autouse `:memory:` `coord_db`.
+    """
+    import time as _time
+
+    from coord import state
+
+    db_path = tmp_path / "rw.db"
+    app = build_app(SqliteStore(db_path), load_config(valid_config_path))
+    with TestClient(app) as cli:
+        cli.post(
+            "/drive-queue",
+            json={"action": "enqueue", "repo_name": "api", "issue_number": 7},
+        )
+        resp = cli.post(
+            "/drive-queue",
+            json={
+                "action": "update",
+                "repo_name": "api",
+                "issue_number": 7,
+                "fields": {"state": "blocked", "last_reason": "checks_failed"},
+            },
+        )
+    assert resp.status_code == 200, resp.text
+    entry = state._get_drive_queue_entry_local("api", 7)
+    assert entry["reason_at"] is not None
+    assert entry["reason_at"] <= _time.time()
+
+
 def test_drive_queue_local_move_clamps_out_of_range(coord_db):
     from coord import state
 

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/tui/src/app/drive_queue.rs

@@ -879,7 +879,7 @@ impl CoordApp {
                         .join(", "),
                 ),
                 queue_hold_cell(e),
-                or_dash(e.last_reason.clone()),
+                or_dash(queue_reason_cell(e)),
             ],
         }
     }
@@ -1878,6 +1878,36 @@ fn queue_hold_cell(e: &BoardDriveQueueEntry) -> String {
     }
 }
 
+/// The `Reason` cell for one entry — `last_reason` age-stamped with
+/// `reason_at` (#2133).
+///
+/// `last_reason` is a snapshot the tick (or a guard) wrote the instant it
+/// observed the condition, never re-validated afterwards. Rendering it bare
+/// lets an hours-old, no-longer-true observation read as a live diagnosis —
+/// the #2104 incident this closes: `checks_failed` was still shown roughly
+/// three hours after the named checks had gone green, while the actual
+/// blocker (a later `request-changes` review) was nowhere in the panel.
+/// Appending the age doesn't make the reason current, but it stops it from
+/// being silently mistaken for current. No suffix when `reason_at` is
+/// `None` — a row predating #2133's migration, or built without going
+/// through `update_drive_queue_entry` — rather than guessing an age it
+/// doesn't have.
+fn queue_reason_cell(e: &BoardDriveQueueEntry) -> String {
+    if e.last_reason.is_empty() {
+        return String::new();
+    }
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs_f64();
+    let age = format_age(e.reason_at, now);
+    if age.is_empty() {
+        e.last_reason.clone()
+    } else {
+        format!("{} ({})", e.last_reason, age)
+    }
+}
+
 /// Order two Queue rows by `col`.
 ///
 /// Numeric for the two numeric columns, case-insensitive text otherwise.

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/tui/src/app/mod.rs

@@ -1069,10 +1069,12 @@ pub(crate) struct ContextMenuState {
 
 /// Format a Unix timestamp as a human-readable "X ago" string relative to `now`.
 ///
-/// Used in the Merge Queue panel (#777) to show `enqueued_at` and `last_attempt`.
+/// Used in the Merge Queue panel (#777) to show `enqueued_at` and `last_attempt`,
+/// and (#2133) in the Queue panel to age-stamp a drive-queue entry's
+/// `last_reason` so a snapshot taken hours ago never renders as current state.
 /// Returns `""` for `None` timestamps.  Precision caps at minutes for < 1h,
 /// hours for < 24h, days otherwise — keeps panel rows terse.
-fn format_age(ts: Option<f64>, now: f64) -> String {
+pub(crate) fn format_age(ts: Option<f64>, now: f64) -> String {
     let ts = match ts {
         Some(t) if t > 0.0 => t,
         _ => return String::new(),

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/tui/src/app/tests.rs

@@ -44200,6 +44200,60 @@ Milestone tracking issue.
         );
     }
 
+    /// #2133: `last_reason` is a snapshot taken the instant it was written,
+    /// never re-validated — the #2104 incident it names is a `checks_failed`
+    /// reason that outlived the CI failure it described by ~3 hours while
+    /// the real, later blocker went unmentioned. The Queue panel must show
+    /// the reason's age so it can never read as a live diagnosis.
+    #[test]
+    fn tuidriver_queue_panel_age_stamps_a_stale_reason() {
+        let now = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs_f64();
+        // 3h + 60s ago: comfortably inside the "3h ago" bucket
+        // (`format_age` truncates to whole hours) with slack on both sides
+        // so a few milliseconds of test execution can never flip the digit.
+        let reason_at = now - (3.0 * 3600.0 + 60.0);
+        let fixture = format!(
+            r#"[
+                {{"repo_name": "myrepo", "issue_number": 703, "position": 0,
+                 "state": "blocked", "attempts": 9,
+                 "last_reason": "checks_failed: test (3.12)",
+                 "reason_at": {reason_at}}}
+            ]"#
+        );
+        let driver = queue_driver(&fixture, 200, 30);
+        let screen = driver.screen();
+        assert!(
+            screen.contains("checks_failed: test (3.12)"),
+            "the reason text itself must still be legible:\n{screen}"
+        );
+        assert!(
+            screen.contains("(3h ago)"),
+            "#2133: a stale `last_reason` must carry its age so it is never \
+             mistaken for a current diagnosis:\n{screen}"
+        );
+    }
+
+    /// A `reason_at`-less row (predates #2133's migration, or a fixture that
+    /// never set it) renders the bare reason — no fabricated age, and no
+    /// crash on the missing field.
+    #[test]
+    fn tuidriver_queue_panel_omits_age_when_reason_at_is_unknown() {
+        let driver = queue_driver(queue_fixture_json(), 160, 30);
+        let screen = driver.screen();
+        assert!(
+            screen.contains("REASON-BLOCKED"),
+            "the reason still renders on its own:\n{screen}"
+        );
+        assert!(
+            !screen.contains("REASON-BLOCKED ("),
+            "#2133: no `reason_at` means no age can be computed — the cell \
+             must not invent one:\n{screen}"
+        );
+    }
+
     #[test]
     fn tuidriver_queue_panel_states_are_visually_distinguishable() {
         // Colour is asserted at the model layer (the screen dump is plain

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/tui/src/app/types.rs

@@ -863,6 +863,13 @@ pub(crate) struct BoardDriveQueueEntry {
     pub(crate) deferrals: i64,
     #[serde(default)]
     pub(crate) last_reason: String,
+    /// #2133: capture time of `last_reason` — `last_reason` is a
+    /// point-in-time observation, never re-validated, so the Queue panel
+    /// age-stamps it (`queue_row`) rather than rendering it bare as if it
+    /// were current state. `None` for a row predating the migration or one
+    /// whose `last_reason` is still the `""` default.
+    #[serde(default)]
+    pub(crate) reason_at: Option<f64>,
     #[allow(dead_code)] // wire parity; the Queue panel shows `state`, not the clock
     #[serde(default)]
     pub(crate) launched_at: Option<f64>,

{code_coordinator-0.5.46 → code_coordinator-0.5.47}/tui/tests/fixtures/board_sample.json

@@ -236,6 +236,7 @@
       "launched_at": null,
       "machine": null,
       "position": 0,
+      "reason_at": null,
       "repo_name": "claude-coordinator",
       "resume_when": "",
       "session_name": null,
@@ -259,6 +260,7 @@
       "launched_at": null,
       "machine": "dellserver",
       "position": 1,
+      "reason_at": null,
       "repo_name": "claude-coordinator",
       "resume_when": "",
       "session_name": null,