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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.111
+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.111 → 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.111
+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.111 → code_coordinator-0.5.113}/code_coordinator.egg-info/SOURCES.txt

@@ -786,6 +786,7 @@ tests/acceptance/ms-example/mocks/home-active.html
 tests/fixtures/board-pipeline-basic.json
 tests/fixtures/board-pipeline-terminal-gates.json
 tests/fixtures/opencode_run_failure_sample.jsonl
+tests/fixtures/opencode_run_length_sample.jsonl
 tests/fixtures/opencode_run_sample.jsonl
 tests/fixtures/playwright/all_pass.json
 tests/fixtures/playwright/global_setup_crash.json

{code_coordinator-0.5.111 → code_coordinator-0.5.113}/code_coordinator.egg-info/scm_file_list.json

@@ -433,6 +433,7 @@
     "tests/fixtures/board-pipeline-basic.json",
     "tests/fixtures/board-pipeline-terminal-gates.json",
     "tests/fixtures/opencode_run_failure_sample.jsonl",
+    "tests/fixtures/opencode_run_length_sample.jsonl",
     "tests/fixtures/opencode_run_sample.jsonl",
     "tests/fixtures/playwright/all_pass.json",
     "tests/fixtures/playwright/global_setup_crash.json",

{code_coordinator-0.5.111 → code_coordinator-0.5.113}/code_coordinator.egg-info/scm_version.json

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

{code_coordinator-0.5.111 → 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.111 → 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.111 → 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.111 → 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.111 → 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.111 → 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.111 → 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.111 → 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.111 → 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.111 → code_coordinator-0.5.113}/coord/worker_events.py

@@ -462,7 +462,15 @@ def _tool_name_from_event(event: WorkerEvent) -> str | None:
     """Try a few plausible field paths for the tool name."""
     raw = event.raw
     if event.type == "tool_use":
-        return raw.get("name") or raw.get("tool") or raw.get("tool_name")
+        name = raw.get("name") or raw.get("tool") or raw.get("tool_name")
+        if name:
+            return name
+        # #2315: opencode's `tool_use` events carry the name one level down,
+        # at `part.tool` — {"type":"tool_use","part":{"tool":"bash",...}} —
+        # not at any of the top-level keys above, which is why every opencode
+        # tool call used to render `[tool] ?`.
+        tool, _ = _opencode_tool_input(raw)
+        return tool
     # Assistant events may embed a tool_use block in `message.content[*]`.
     if event.type == "assistant":
         message = raw.get("message") or {}
@@ -472,6 +480,29 @@ def _tool_name_from_event(event: WorkerEvent) -> str | None:
     return None
 
 
+def _opencode_tool_input(raw: dict) -> tuple[str | None, dict | None]:
+    """Pull ``(tool_name, input_dict)`` out of an opencode ``tool_use``
+    event's nested ``part`` (#2315).
+
+    opencode's wire shape is ``{"type":"tool_use","part":{"tool":"bash",
+    "state":{"input":{"command":"..."},...}}}`` — see
+    :meth:`coord.providers.opencode.OpenCodeProvider.parse_log`'s docstring,
+    which this mirrors (the provider's own parser already reads this
+    correctly; this is the same lookup for the render side). Returns
+    ``(None, None)`` for anything else — missing/malformed ``part``, or a
+    ``state.input`` that isn't a dict.
+    """
+    part = raw.get("part")
+    if not isinstance(part, dict):
+        return None, None
+    tool = part.get("tool")
+    tool = tool if isinstance(tool, str) and tool else None
+    state = part.get("state")
+    input_obj = state.get("input") if isinstance(state, dict) else None
+    input_obj = input_obj if isinstance(input_obj, dict) else None
+    return tool, input_obj
+
+
 def _iter_content_blocks(message: dict) -> Iterable[dict]:
     """Yield content blocks from an Anthropic-style message payload."""
     content = message.get("content")
@@ -493,6 +524,12 @@ def _bash_command_from_event(event: WorkerEvent) -> str | None:
         for block in _iter_content_blocks(message):
             if block.get("type") == "tool_use" and block.get("name") == "Bash":
                 return _command_from_input(block.get("input"))
+    if event.type == "tool_use":
+        # #2315: opencode's bash call — command lives at `part.state.input.
+        # command`, tool name (lowercase) at `part.tool`.
+        tool, input_obj = _opencode_tool_input(raw)
+        if tool == "bash":
+            return _command_from_input(input_obj)
     return None
 
 
@@ -506,13 +543,24 @@ def _command_from_input(input_obj: object) -> str | None:
 
 
 def _file_path_from_event(event: WorkerEvent) -> str | None:
-    """Pull file_path out of an Edit/Write tool_use, if present."""
+    """Pull file_path out of an Edit/Write tool_use, if present.
+
+    Name matching is case-insensitive so this covers both claude's
+    ``Edit``/``Write``/``NotebookEdit`` and opencode's lowercase ``edit``/
+    ``write`` (#2315).
+    """
     raw = event.raw
     name = _tool_name_from_event(event)
-    if name not in ("Edit", "Write", "NotebookEdit"):
+    if not name or name.lower() not in ("edit", "write", "notebookedit"):
         return None
     if event.type == "tool_use":
-        return _file_from_input(raw.get("input"))
+        input_obj = raw.get("input")
+        if input_obj is not None:
+            return _file_from_input(input_obj)
+        # #2315: opencode carries the input nested under `part.state.input`
+        # rather than a top-level `input` key.
+        _, opencode_input = _opencode_tool_input(raw)
+        return _file_from_input(opencode_input)
     if event.type == "assistant":
         message = raw.get("message") or {}
         for block in _iter_content_blocks(message):
@@ -528,7 +576,8 @@ def _file_path_from_event(event: WorkerEvent) -> str | None:
 def _file_from_input(input_obj: object) -> str | None:
     if not isinstance(input_obj, dict):
         return None
-    for key in ("file_path", "path", "notebook_path"):
+    # `filePath` is opencode's key (#2315); the rest are claude's.
+    for key in ("file_path", "path", "notebook_path", "filePath"):
         v = input_obj.get(key)
         if isinstance(v, str):
             return v
@@ -1012,10 +1061,15 @@ def render_event(event: WorkerEvent, *, turn_counter: list[int] | None = None) -
 
     if event.type == "tool_use":
         name = _tool_name_from_event(event) or "?"
-        if name == "Bash":
+        # Case-insensitive: claude's tool names are `Bash`/`Edit`/`Write`/
+        # `NotebookEdit`; opencode's equivalents are lowercase (#2315). The
+        # original casing from *name* is kept in the rendered line either
+        # way — only the branch dispatch is case-insensitive.
+        name_lower = name.lower()
+        if name_lower == "bash":
             cmd = _bash_command_from_event(event) or ""
-            return f"[tool] Bash: {_truncate(cmd, 100)}"
-        if name in ("Edit", "Write", "NotebookEdit"):
+            return f"[tool] {name}: {_truncate(cmd, 100)}"
+        if name_lower in ("edit", "write", "notebookedit"):
             fp = _file_path_from_event(event)
             return f"[tool] {name}: {fp or '?'}"
         return f"[tool] {name}"
@@ -1027,6 +1081,44 @@ def render_event(event: WorkerEvent, *, turn_counter: list[int] | None = None) -
         tag = " error" if is_error else ""
         return f"[tool_result{tag}] {tool_use_id}"
 
+    if event.type == "step_finish":
+        # opencode's per-turn completion event (#2315) — claude has no
+        # equivalent. `part.reason` is `"tool-calls"` for every turn but the
+        # last one (which is always followed by another `step_start`);
+        # anything else — `"stop"` (normal completion), `"length"` (ran out
+        # of output budget mid-turn), `"error"`, or any other value — means
+        # the run ended on THIS step, because opencode never emits a
+        # terminal event of its own the way claude's `result` event above
+        # does (see OpenCodeProvider.parse_log's docstring). So a
+        # non-"tool-calls" reason also gets an appended `[result]` line —
+        # the only place `coord log` ever prints a stop reason for an
+        # opencode run. Cost/tokens here are this step's own figures (there
+        # is no cumulative-total field anywhere in opencode's stream, so a
+        # single event can't report a running total — see the same
+        # docstring), which is still the diagnostic fact that matters: e.g.
+        # `reason=length out=32000 $0.145` says outright that the model
+        # spent its whole output budget on one turn and got cut off.
+        part = raw.get("part")
+        part = part if isinstance(part, dict) else {}
+        # `reason_raw` (as opposed to `reason`, the display value with the
+        # `?` placeholder substituted in) drives the terminality check below
+        # — a genuinely absent/malformed reason must NOT be treated as
+        # terminal just because the placeholder string happens to differ
+        # from `"tool-calls"`.
+        reason_raw = part.get("reason")
+        reason_raw = reason_raw if isinstance(reason_raw, str) and reason_raw else None
+        reason = reason_raw or "?"
+        tokens = part.get("tokens")
+        tokens = tokens if isinstance(tokens, dict) else {}
+        out_tok = tokens.get("output")
+        out_str = str(out_tok) if isinstance(out_tok, int) else "?"
+        cost = part.get("cost")
+        cost_str = f"${float(cost):.3f}" if isinstance(cost, (int, float)) else "$?"
+        line = f"[step_finish] reason={reason} out={out_str} {cost_str}"
+        if reason_raw is not None and reason_raw != "tool-calls":
+            line += f"\n[result] stop={reason_raw}, {cost_str}"
+        return line
+
     if event.type == "rate_limit_event":
         status, resets = _rate_limit_info(raw)
         return f"[rate_limit] status={status or '?'} resets_at={resets if resets is not None else '?'}"

code_coordinator-0.5.113/tests/fixtures/opencode_run_length_sample.jsonl

@@ -0,0 +1,5 @@
+{"type":"step_start","timestamp":1785788589000,"sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","part":{"id":"prt_2315len001peaLrUkvfXkzF4","messageID":"msg_2315len001B2TN1bVanhA48U","sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","snapshot":"40c925c779fe9cd39801d60400818aa70d6a49b0","type":"step-start"}}
+{"type":"tool_use","timestamp":1785788589900,"sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","part":{"type":"tool","tool":"bash","callID":"call_2315len_01","state":{"status":"completed","input":{"command":"git status"},"output":"On branch issue-2315\nnothing to commit, working tree clean\n","metadata":{},"title":"","time":{"start":1785788589850,"end":1785788589890}},"id":"prt_2315len002D1oKOLzO3u64k1","sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","messageID":"msg_2315len001B2TN1bVanhA48U"}}
+{"type":"step_finish","timestamp":1785788589950,"sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","part":{"id":"prt_2315len003QbgfV5ZEEm7pIO","reason":"tool-calls","snapshot":"40c925c779fe9cd39801d60400818aa70d6a49b0","messageID":"msg_2315len001B2TN1bVanhA48U","sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","type":"step-finish","tokens":{"total":520,"input":440,"output":80,"reasoning":0,"cache":{"write":0,"read":0}},"cost":0.002}}
+{"type":"step_start","timestamp":1785788590600,"sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","part":{"id":"prt_2315len004abWeGE97E8opKR","messageID":"msg_2315len004XNhYw1dBJxV99P","sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","snapshot":"40c925c779fe9cd39801d60400818aa70d6a49b0","type":"step-start"}}
+{"type":"step_finish","timestamp":1785788969600,"sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","part":{"id":"prt_2315len005pw1TMWsekKMlNS","reason":"length","snapshot":"40c925c779fe9cd39801d60400818aa70d6a49b0","messageID":"msg_2315len004XNhYw1dBJxV99P","sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","type":"step-finish","tokens":{"total":32410,"input":410,"output":32000,"reasoning":32000,"cache":{"write":0,"read":0}},"cost":0.145}}