code-coordinator 0.5.112__tar.gz → 0.5.113__tar.gz

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.112",
+  "tag": "0.5.113",
   "distance": 0,
-  "node": "g6173265320032222560fcd77419a9f74fc98d14e",
+  "node": "ga030a27e286c5012119c4cdbfb871f070e331e8a",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-16"

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/coord/_board_mapping.py

@@ -158,6 +158,9 @@ def row_to_assignment(row: object) -> Assignment:
         # row predating this column and for a normally-parsed verdict.
         verdict_source=d.get("verdict_source"),
         verdict_source_reason=d.get("verdict_source_reason"),
+        # #2316: raw terminal stop_reason; None for rows predating this
+        # column or a worker whose log carried no such field.
+        stop_reason=d.get("stop_reason"),
     )
 
 

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/coord/agent.py

@@ -232,6 +232,51 @@ def _looks_like_policy_refusal(text: str | None) -> bool:
     return any(marker in lowered for marker in _POLICY_REFUSAL_MARKERS)
 
 
+# #2316: `WorkerSummary.stop_reason` values that mean the model was CUT OFF
+# by an output-token ceiling before it could finish — as opposed to a normal
+# stop (`end_turn`/`stop_sequence`, see `coord.progress`'s identical "unusual
+# stop" allowlist). `"length"` is opencode's `step_finish` reason
+# (`coord.providers.opencode.OpenCodeProvider.parse_log`, gated on opencode's
+# `OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX`); `"max_tokens"` is Anthropic's own
+# `stop_reason` for the same shape. Either one on a 0-commit clean exit means
+# the worker never got a turn to write anything — the space-invaders#1
+# incident (13 successful tool calls, then one reasoning block burned the
+# entire 32k-token budget and exited 0 with nothing on disk) is exactly this:
+# `exit_code == 0` looked like "worker exited cleanly but pushed 0 commits"
+# (the #448 ADVISORY reading) when it was actually a truncation nobody could
+# have acted on differently. See `_reap`, which checks this BEFORE the #448
+# zero-commit downgrade.
+_TRUNCATION_STOP_REASONS = frozenset({"length", "max_tokens"})
+
+# #2321: the opencode-specific knob named in the GitHub comment so an
+# operator reading "cut off at its output limit" doesn't have to go
+# rediscover — as the #2316 investigation had to — that the ceiling is
+# adjustable per provider definition.
+_OPENCODE_OUTPUT_TOKEN_MAX_ENV = "OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"
+
+
+def _format_truncation_reason(stop_reason: str, provider_name: str | None) -> str:
+    """#2316: human-readable diagnostic for a 0-commit run truncated by an
+    output-token ceiling — used for both `AgentAssignment.truncation_reason`
+    (persisted `failure_reason`) and `AgentAssignment.error` (the GitHub
+    completion comment's `error=` text, see `coord.notify`'s FAILED arms).
+
+    Deliberately says "cut off" rather than "exited cleanly" — `exit_code ==
+    0` is what a truncated run looks like, not evidence the worker finished.
+    Names :data:`_OPENCODE_OUTPUT_TOKEN_MAX_ENV` for an opencode worker
+    (#2321: the ceiling is raisable per provider definition) so an operator
+    doesn't have to rediscover that from scratch.
+    """
+    base = "the model was cut off at its output limit before writing anything"
+    if provider_name == "opencode":
+        return (
+            f"{base} (stop_reason={stop_reason!r}; opencode's output-token "
+            f"ceiling is set by {_OPENCODE_OUTPUT_TOKEN_MAX_ENV} and is "
+            "raisable per provider definition — #2321)"
+        )
+    return f"{base} (stop_reason={stop_reason!r})"
+
+
 # ── Reap tuning ───────────────────────────────────────────────────────────────
 # claude-cli sometimes does not exit after emitting its final
 # `{"type":"result"}` message — a child process (MCP server, tool subprocess)
@@ -2999,6 +3044,20 @@ class AgentAssignment:
     # one of `analysis_deliverable`/`zero_commit_reason`/this field is ever
     # set for a given assignment).
     policy_refusal_reason: str | None = None
+    # #2316: set when `_reap` classifies a clean (exit_code==0), 0-commit
+    # exit as a TRUNCATION — the worker's last `result`/`step_finish` event
+    # carries a `stop_reason` in `_TRUNCATION_STOP_REASONS` (opencode's
+    # `"length"`, claude's `"max_tokens"`) — rather than the #448 ADVISORY
+    # default. Formatted with `_format_truncation_reason`. Only ever set
+    # alongside `status == FAILED` (never ADVISORY: a truncated run is not a
+    # "worker looked and found nothing to do", it is a cut-off nobody chose),
+    # and `None` on every other outcome — including a genuine clean-exit-no-
+    # commits run (no truncation marker matched) and a truncated run that DID
+    # push commits (`_ahead != 0` never reaches this check at all). Mutually
+    # exclusive with `zero_commit_reason`/`analysis_deliverable`/
+    # `policy_refusal_reason`: all four are decided in the SAME `_ahead == 0`
+    # branch of `_reap`, and this one is checked first — see that method.
+    truncation_reason: str | None = None
 
     def to_dict(self) -> dict:
         d = asdict(self)
@@ -7897,6 +7956,13 @@ class AgentServer:
         # readings of "0 commits" can never disagree about which one applies
         # to this assignment.
         _policy_refusal_reason: str | None = None
+        # #2316: checked FIRST in the `_ahead == 0` branch below, ahead of
+        # `_analysis_deliverable`/`_policy_refusal_reason`/`_zero_commit_
+        # reason` — a truncated run's `result_text` is whatever the model
+        # managed to emit before the ceiling cut it off, not a considered
+        # final message, so it must not be read as a positive "deliverable"
+        # or "policy refusal" signal just because it happens to match one.
+        _truncation_reason: str | None = None
         if (exit_code == 0 and assignment is not None
                 and assignment.worktree_path
                 and assignment.spec.type in _ZERO_COMMIT_TYPES):
@@ -7905,7 +7971,28 @@ class AgentServer:
                 _base = assignment.spec.branch or "main"
                 _ahead = self._commits_ahead(_wt_advisory, _base)
                 if _ahead == 0:
-                    if DELIVERABLE_ANALYSIS_LABEL in (assignment.spec.issue_labels or []):
+                    if (_worker_summary is not None
+                            and _worker_summary.stop_reason in _TRUNCATION_STOP_REASONS):
+                        # #2316: the model was guillotined by its own
+                        # output-token ceiling before it could act — exit
+                        # code 0 here is what a truncated run looks like, NOT
+                        # evidence of a clean "nothing to do" finish. Must be
+                        # re-driven, not parked in the advisory bucket
+                        # nobody re-drives (space-invaders#1).
+                        _truncation_reason = _format_truncation_reason(
+                            _worker_summary.stop_reason, assignment.spec.provider
+                        )
+                        try:
+                            with open(assignment.log_path, "a") as reopen:
+                                reopen.write(
+                                    "# reap: truncated — 0 commits ahead of "
+                                    f"{_base}; stop_reason="
+                                    f"{_worker_summary.stop_reason!r}, status "
+                                    "set to failed (#2316)\n"
+                                )
+                        except OSError:
+                            pass
+                    elif DELIVERABLE_ANALYSIS_LABEL in (assignment.spec.issue_labels or []):
                         _analysis_deliverable = True
                         try:
                             with open(assignment.log_path, "a") as reopen:
@@ -8014,6 +8101,22 @@ class AgentServer:
                         # shrug.
                         assignment.status = FAILED
                         assignment.push_failure_reason = _push_failure_reason
+                    elif _truncation_reason is not None:
+                        # #2316: the worker's own output-token ceiling cut it
+                        # off before it committed anything — checked BEFORE
+                        # `_policy_refusal_reason`/`_zero_commit_reason` (the
+                        # `_reap` computation above already guarantees the
+                        # four are mutually exclusive; kept parallel here for
+                        # readability). FAILED, not ADVISORY: exit_code==0 is
+                        # not evidence of a clean finish for a truncated run,
+                        # and nobody re-drives an advisory. `error` is set
+                        # too (not just `truncation_reason`) so the existing
+                        # generic `entry.get("error")` fallback in
+                        # `coord.notify`'s FAILED comment arms carries this
+                        # text without needing its own dedicated wiring.
+                        assignment.status = FAILED
+                        assignment.truncation_reason = _truncation_reason
+                        assignment.error = _truncation_reason
                     elif _policy_refusal_reason is not None:
                         # #2234: clean exit, no commits, and the worker's own
                         # final message cites a standing repo-rule

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/coord/dashboard/webapp/src/api/generated.ts

@@ -173,4 +173,5 @@ export interface Assignment {
   audit_run_number: number | null
   for_issue_number: number | null
   driven_by: string | null
+  stop_reason: string | null
 }

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/coord/db.py

@@ -896,6 +896,19 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
         # own default and identical in effect to `attempts <= 0` (no backoff
         # window active).
         "ALTER TABLE drive_queue ADD COLUMN retry_backoff_at REAL",
+        # #2316: the worker's own terminal `stop_reason` (e.g. `"end_turn"`,
+        # opencode's `"length"`, claude's `"max_tokens"`) — see
+        # `coord.agent.AgentServer._reap`'s `/status` `completed` entry
+        # (already sent by every agent build) and `coord.reconcile._capture_
+        # stop_reason_best_effort`, which persists it here for EVERY terminal
+        # assignment, not just failed ones. Previously this value reached the
+        # agent's own `/status` response and nothing else — `coord gates`,
+        # `coord status` and the dashboard had no column to read it from and
+        # a truncated (`stop_reason == "length"`/`"max_tokens"`), 0-commit
+        # run was recorded `advisory` with no trace of WHY. NULL for every
+        # row predating this migration and for a non-stream-json / PTY
+        # worker whose log carries no such field.
+        "ALTER TABLE assignments ADD COLUMN stop_reason TEXT",
     ]
     for sql in migrations:
         try:

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/coord/models.py

@@ -702,6 +702,27 @@ class Assignment:
     # `coord/drive.py`'s work-stage `Action` sets on every `coord assign` it
     # shells out to.
     driven_by: str | None = None
+    # #2316: the worker's own terminal `stop_reason` (e.g. `"end_turn"`,
+    # opencode's `"length"`, claude's `"max_tokens"`) — persisted for EVERY
+    # terminal work-like assignment, not just failed ones, so `coord gates`/
+    # `coord status`/the dashboard can show it and a future gate can act on
+    # it. Captured from the agent's own `/status` `completed` entry (already
+    # sent by every agent build — `coord.agent.AgentServer.list_assignments`
+    # parses the worker's log and includes it there) by
+    # `coord.reconcile._capture_stop_reason_best_effort`. `None` for rows
+    # predating this column and for a non-stream-json / PTY worker whose log
+    # carries no such field.
+    #
+    # This is the raw diagnostic value, distinct from `failure_reason`: a
+    # truncated (`stop_reason` in `coord.agent._TRUNCATION_STOP_REASONS`),
+    # 0-commit run is separately classified FAILED by `AgentServer._reap`
+    # with a human-readable `failure_reason` naming the truncation — see
+    # `coord.agent.AgentAssignment.truncation_reason`. Before #2316 that same
+    # shape (space-invaders#1: the model spent its whole output budget on one
+    # reasoning block and hit opencode's 32k-token ceiling) landed on
+    # `advisory` — the same bucket as a worker that looked and correctly
+    # found nothing to do — so nobody re-drove it.
+    stop_reason: str | None = None
 
 
 def effective_issue_number(assignment: "Assignment | dict") -> int:

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/coord/notify.py

@@ -2638,11 +2638,20 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
         # says "spend ceiling" instead of leaving an operator to guess why a
         # leg died mid-task. Mutually exclusive with the other three (see
         # `coord.reconcile.reconcile_completed_assignments`).
+        # #2316: `truncation_reason` is the same column again — the worker's
+        # output-token ceiling cut it off before it committed anything. It
+        # must reach `error=` below too, so the GitHub failure comment reads
+        # "the model was cut off at its output limit before writing
+        # anything" instead of the misleading "exited cleanly but pushed 0
+        # commits" the #448 ADVISORY default would otherwise have produced.
+        # Mutually exclusive with the other four (see
+        # `coord.reconcile.reconcile_completed_assignments`).
         _failure_reason = (
             entry.get("usage_limit_reason")
             or entry.get("api_error_reason")
             or entry.get("push_failure_reason")
             or entry.get("spend_ceiling_reason")
+            or entry.get("truncation_reason")
         )
         post_failure(
             exit_code=transition.exit_code,
@@ -2738,11 +2747,20 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
         # says "spend ceiling" instead of leaving an operator to guess why a
         # leg died mid-task. Mutually exclusive with the other three (see
         # `coord.reconcile.reconcile_completed_assignments`).
+        # #2316: `truncation_reason` is the same column again — the worker's
+        # output-token ceiling cut it off before it committed anything. It
+        # must reach `error=` below too, so the GitHub failure comment reads
+        # "the model was cut off at its output limit before writing
+        # anything" instead of the misleading "exited cleanly but pushed 0
+        # commits" the #448 ADVISORY default would otherwise have produced.
+        # Mutually exclusive with the other four (see
+        # `coord.reconcile.reconcile_completed_assignments`).
         _failure_reason = (
             entry.get("usage_limit_reason")
             or entry.get("api_error_reason")
             or entry.get("push_failure_reason")
             or entry.get("spend_ceiling_reason")
+            or entry.get("truncation_reason")
         )
         post_failure(
             exit_code=transition.exit_code,

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/coord/reconcile.py

@@ -429,11 +429,23 @@ def reconcile_completed_assignments(
         # was killed for spending, not for hitting a usage limit. Stamping it
         # here is what makes the kill distinguishable from a crash for
         # `coord retry`, the auto-reassign skip below, and the escalation.
+        # #2316: `truncation_reason` is the SAME column again — stamped by
+        # `AgentServer._reap` when a 0-commit clean exit's `stop_reason`
+        # shows the worker was cut off by its output-token ceiling
+        # (`coord.agent._TRUNCATION_STOP_REASONS`) rather than genuinely
+        # finding nothing to do. Never coexists with the other three: it is
+        # only ever set on the SAME `_ahead == 0` branch as the #448 ADVISORY
+        # default (see `AgentServer._reap`'s `elif` chain), which the other
+        # three all preempt before that branch even runs. Without this, a
+        # truncated run lands FAILED with no `failure_reason` recorded —
+        # exactly the "advisory looks the same as this" gap #2316 exists to
+        # close.
         _failure_reason = (
             entry.get("usage_limit_reason")
             or entry.get("api_error_reason")
             or entry.get("push_failure_reason")
             or entry.get("spend_ceiling_reason")
+            or entry.get("truncation_reason")
         )
         _escalate_spend_ceiling_best_effort(a, entry)
         update_state_fn(
@@ -482,6 +494,14 @@ def reconcile_completed_assignments(
         # failure is swallowed so it can't break the reconcile.
         _capture_tokens_best_effort(aid, entry)
 
+        # #2316: capture the raw stop_reason from the /status entry for
+        # EVERY terminal assignment (not just failed ones) — the enabling
+        # persistence step; `_failure_reason` above already carries the
+        # human-readable classification for a truncated run specifically.
+        # Best-effort — any failure is swallowed so it can't break the
+        # reconcile.
+        _capture_stop_reason_best_effort(aid, entry)
+
         reconciled.append(
             {
                 "assignment_id": aid,
@@ -747,6 +767,29 @@ def _capture_tokens_best_effort(assignment_id: str, entry: dict) -> None:
         pass
 
 
+def _capture_stop_reason_best_effort(assignment_id: str, entry: dict) -> None:
+    """#2316: persist the raw ``stop_reason`` from a /status completed entry.
+
+    The agent parses its own log and includes ``stop_reason`` on every
+    terminal ``completed`` entry (``coord.agent.AgentServer.list_assignments``
+    — this predates #2316, only the write path is new). Captured for EVERY
+    terminal assignment, not gated on status, so the column reflects the
+    worker's own last word (``"end_turn"``, ``"length"``, ``"max_tokens"``,
+    ...) regardless of how ``_failure_reason``/the board's ``status``
+    classified the run. Best-effort — any failure is swallowed so it can't
+    break the reconcile.
+    """
+    try:
+        stop_reason = entry.get("stop_reason")
+        if not stop_reason:
+            return
+        from coord.state import update_assignment_stop_reason  # noqa: PLC0415
+
+        update_assignment_stop_reason(assignment_id, stop_reason)
+    except Exception:  # noqa: BLE001 — never let this capture break the reconcile
+        pass
+
+
 def _build_fix_round_retry_briefing(
     failed: Assignment, board: Board, repo_cfg, max_review_iterations: int,
 ) -> str | None:
@@ -1407,6 +1450,10 @@ def _record_usage_limit_reason(assignment_id: str | None, entry: dict) -> None:
         # mutual exclusivity as the three above (see the identical chain in
         # `reconcile_completed_assignments`).
         or entry.get("spend_ceiling_reason")
+        # #2316: a truncated (output-token-ceiling) 0-commit run. Same
+        # column, same mutual exclusivity — see the identical chain in
+        # `reconcile_completed_assignments`.
+        or entry.get("truncation_reason")
     )
     if not reason or not assignment_id:
         return

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/coord/serve_app.py

@@ -2636,6 +2636,7 @@ def _openapi_spec() -> dict:
                                         "items": {"type": "string"},
                                         "nullable": True,
                                     },
+                                    "stop_reason": {"type": "string", "nullable": True},
                                 },
                                 "required": ["assignment_id"],
                             }
@@ -5257,6 +5258,10 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
                 state._update_assignment_smoke_tests_local(aid, body["smoke_tests"])
             if "completion_summary" in body and body["completion_summary"]:
                 state._update_assignment_completion_summary_local(aid, body["completion_summary"])
+            if body.get("stop_reason"):
+                # #2316: same endpoint, same reason as the fields above —
+                # one round-trip covers the diagnostic capture too.
+                state._update_assignment_stop_reason_local(aid, body["stop_reason"])
         except Exception as e:  # noqa: BLE001
             return JSONResponse(
                 {"error": "assignment-usage write failed", "detail": str(e)},

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/coord/state.py

@@ -2811,6 +2811,56 @@ def _update_assignment_tokens_local(
         pass
 
 
+def update_assignment_stop_reason(assignment_id: str, stop_reason: str) -> None:
+    """#2316: record the worker's terminal ``stop_reason`` — routes to the
+    daemon when set.
+
+    Persisted for EVERY terminal work-like assignment (not just failed
+    ones) so ``coord gates``/``coord status``/the dashboard have something
+    to read — before this column existed, a truncated worker's ``/status``
+    already carried ``stop_reason`` but the coordinator dropped it on
+    receipt (see ``coord.agent.AgentServer.list_assignments``, which parses
+    the log and includes it on every terminal ``completed`` entry).
+
+    Idempotent: the UPDATE only fires when the row's ``stop_reason`` is
+    still NULL (first-writer-wins) — a terminal row's stop reason cannot
+    change after the fact, so a later reconcile tick re-observing the same
+    ``/status`` entry is a no-op rather than a redundant write.  Silently
+    no-ops on a falsy *stop_reason* or a missing assignment row, and
+    swallows ``OperationalError`` so a pre-migration DB (tests, an older
+    install that hasn't restarted the coordinator yet) never crashes the
+    reconcile/notify path this is called from.
+    """
+    if not assignment_id or not stop_reason:
+        return
+    svc = _board_service()
+    resp = _route_write(
+        svc,
+        "/assignment-usage",
+        {"assignment_id": assignment_id, "stop_reason": stop_reason},
+    )
+    if resp is not None:
+        return
+    _update_assignment_stop_reason_local(assignment_id, stop_reason)
+
+
+def _update_assignment_stop_reason_local(assignment_id: str, stop_reason: str) -> None:
+    """Write ``stop_reason`` directly to the local DB.  Called by the daemon endpoint."""
+    if not assignment_id or not stop_reason:
+        return
+    conn = get_connection()
+    try:
+        conn.execute(
+            "UPDATE assignments SET stop_reason=? WHERE assignment_id=? "
+            "AND stop_reason IS NULL",
+            (stop_reason, assignment_id),
+        )
+        conn.commit()
+    except sqlite3.OperationalError:
+        # Column may not exist yet (pre-migration DB or test fixtures).
+        pass
+
+
 def mark_assignment_interactive(assignment_id: str) -> None:
     """#546/#665: flag the row as interactive — routes to the daemon when set.
 

{code_coordinator-0.5.112 → code_coordinator-0.5.113}/tests/test_agent.py

@@ -5028,6 +5028,80 @@ class TestListAssignmentsTokens:
         assert entry.get("input_tokens", 0) == 0
 
 
+# ── #2316: stop_reason / truncation_reason reach /status ───────────────────────
+
+
+class TestStopReasonInCompletedEntry:
+    """`list_assignments()['completed']` must carry `stop_reason` (parsed
+    fresh from the log on every /status call, same as `num_turns`/
+    `total_cost_usd` above) so `coord.reconcile._capture_stop_reason_best_
+    effort` has something to persist — this is the wire half of #2316's
+    "the information is already there and is thrown away" gap."""
+
+    def _make_spec(self, repo_path: Path) -> AssignmentSpec:
+        return AssignmentSpec(
+            repo_name="api",
+            repo_path=str(repo_path),
+            issue_number=2316,
+            issue_title="t",
+            briefing="b",
+            branch="main",
+        )
+
+    def test_stop_reason_appears_in_completed_entry(self, tmp_path: Path) -> None:
+        import json as _json
+
+        repo = _init_repo(tmp_path / "repo")
+        server = _server(tmp_path, repo_path=repo)
+        spec = self._make_spec(repo)
+
+        log_path = tmp_path / "trunc1.log"
+        log_path.write_text(
+            _json.dumps(
+                {
+                    "type": "result",
+                    "subtype": "success",
+                    "is_error": False,
+                    "stop_reason": "max_tokens",
+                    "result": "",
+                }
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+
+        a = AgentAssignment(
+            id="trunc1",
+            spec=spec,
+            status=FAILED,
+            finished_at=1.0,
+            exit_code=0,
+            log_path=str(log_path),
+            truncation_reason=(
+                "the model was cut off at its output limit before writing "
+                "anything (stop_reason='max_tokens')"
+            ),
+            error=(
+                "the model was cut off at its output limit before writing "
+                "anything (stop_reason='max_tokens')"
+            ),
+        )
+        server._assignments[a.id] = a
+
+        listing = server.list_assignments()
+        completed = listing["completed"]
+        assert len(completed) == 1
+        entry = completed[0]
+        # `stop_reason`: freshly parsed from the log on every /status call.
+        assert entry.get("stop_reason") == "max_tokens"
+        # `truncation_reason`/`error`: plain dataclass fields, already on the
+        # assignment — `to_status_dict()`'s `asdict` carries them through
+        # exactly like `usage_limit_reason`/`api_error_reason` do.
+        assert entry.get("truncation_reason") is not None
+        assert "cut off at its output limit" in entry["truncation_reason"]
+        assert entry.get("error") == entry["truncation_reason"]
+
+
 # ── #1492: agent-side clearing of terminal ADVISORY entries ────────────────────