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

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

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

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

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

{code_coordinator-0.5.112 → code_coordinator-0.5.114}/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.114}/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.114}/coord/config.py

@@ -3321,6 +3321,51 @@ def _expand_env_vars(value: str) -> str:
     return _ENV_VAR_RE.sub(_replace, value)
 
 
+#: Matches exactly what opencode's own ``OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX``
+#: parser (#2321) accepts as a *string form* of a number: one or more ASCII
+#: digits, nothing else — no sign, no decimal point, no whitespace, no
+#: underscore digit-grouping. Combined with the ``> 0`` check below this
+#: mirrors opencode's own rule (integer, ``> 0``) closely enough to reject
+#: every value opencode is documented to silently discard: ``"131072 "``
+#: (trailing whitespace), ``"131_072"`` (underscore grouping — Python's
+#: ``int()`` would accept this but JS ``Number()`` coercion does not),
+#: ``"0"`` (fails ``> 0``), ``"1.5"`` (decimal point), and ``"unlimited"``
+#: (non-numeric).
+_OPENCODE_OUTPUT_TOKEN_MAX_RE = re.compile(r"[0-9]+")
+
+#: The env var name gated by :data:`_OPENCODE_OUTPUT_TOKEN_MAX_RE` — kept as
+#: a constant rather than a literal so config.py and opencode.py can be
+#: grepped for the exact same string (deliberately NOT imported from
+#: coord.providers.opencode: config.py must not depend on provider modules).
+OPENCODE_OUTPUT_TOKEN_MAX_ENV_VAR = "OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"
+
+
+def _validate_opencode_output_token_max_env(value: str, *, context: str) -> None:
+    """Reject an ``OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX`` override that
+    opencode's own parser would silently discard (#2321).
+
+    opencode's env-var parser demands an integer ``> 0``; anything else
+    (a non-numeric string, a decimal, a value with surrounding whitespace
+    or underscore digit-grouping, zero or negative) maps to ``undefined``
+    internally, which silently restores opencode's 32,000-token default
+    with **no warning anywhere** — exactly the failure mode #2321 exists
+    to end. Config-parse time is the only point where "silently reverted
+    to 32,000" can be turned into a loud, actionable error instead of a
+    truncated worker run discovered hours later.
+
+    Raises:
+        ConfigError: when *value* is not a bare positive-integer string.
+    """
+    if not _OPENCODE_OUTPUT_TOKEN_MAX_RE.fullmatch(value) or int(value) <= 0:
+        raise ConfigError(
+            f"{context} must be a positive integer string with no "
+            "surrounding whitespace, sign, decimal point, or underscores "
+            "(opencode's OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX parser "
+            "silently discards anything else and reverts to its 32000 "
+            f"default) — got {value!r}"
+        )
+
+
 _PORTAL_PLAIN_STR_FIELDS = ("base_url",)
 _PORTAL_SECRET_STR_FIELDS = ("bridge_client_id", "bridge_client_secret")
 
@@ -3471,6 +3516,20 @@ def _parse_providers(raw: Any) -> ProvidersConfig:
         # Expand ${VAR} in env values.
         env: dict[str, str] = {k: _expand_env_vars(v) for k, v in env_raw.items()}
 
+        # #2321: an operator override of opencode's output-token-cap knob
+        # must be a value opencode's own parser will actually honour — see
+        # _validate_opencode_output_token_max_env for why a bad value here
+        # (e.g. a trailing space) is worse than a normal type error: it
+        # doesn't fail, it silently reverts to the 32000 default.
+        if OPENCODE_OUTPUT_TOKEN_MAX_ENV_VAR in env:
+            _validate_opencode_output_token_max_env(
+                env[OPENCODE_OUTPUT_TOKEN_MAX_ENV_VAR],
+                context=(
+                    f"providers.definitions[{def_name!r}].env"
+                    f"[{OPENCODE_OUTPUT_TOKEN_MAX_ENV_VAR!r}]"
+                ),
+            )
+
         extra_args_raw = def_raw.get("extra_args", []) or []
         if not isinstance(extra_args_raw, list) or not all(
             isinstance(a, str) for a in extra_args_raw

{code_coordinator-0.5.112 → code_coordinator-0.5.114}/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.114}/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.114}/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.114}/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.114}/coord/providers/opencode.py

@@ -76,6 +76,12 @@ Differences from :class:`~.claude.ClaudeProvider`:
 * ``env()`` always sets ``OPENCODE_CONFIG_DIR`` (agent-file discovery, see
   above) and ``OPENCODE_CONFIG`` (the OpenRouter upstream-routing pin, see
   ``coord/agents/opencode/routing.jsonc`` and :data:`ROUTING_PIN_PATH`).
+* ``env()`` also seeds ``OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX`` to
+  :data:`OUTPUT_TOKEN_MAX_DEFAULT` (#2321) — unlike the two variables
+  above, this one *is* operator-overridable (it's a tuning knob, not a
+  safety mechanism); see :meth:`env`'s docstring for why it sits on the
+  opposite side of ``self._env`` from ``OPENCODE_CONFIG_DIR``/
+  ``OPENCODE_CONFIG``.
 """
 
 from __future__ import annotations
@@ -148,6 +154,46 @@ AGENTS_ROOT = Path(__file__).resolve().parent.parent / "agents" / "opencode"
 #: onto the worker's environment as ``OPENCODE_CONFIG`` by :meth:`env`.
 ROUTING_PIN_PATH = AGENTS_ROOT / "routing.jsonc"
 
+#: Default value for ``OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX`` (#2321).
+#:
+#: opencode caps every request's output tokens at 32,000 (its internal
+#: ``OY = 32000`` default) unless this environment variable overrides it —
+#: and on a reasoning model that 32,000-token budget is *shared* with the
+#: model's own reasoning, so a long reasoning block can consume the whole
+#: cap before a single tool call is emitted.  This is not hypothetical:
+#: space-invaders#1 (``8c95182b0749``) spent all 32,000 tokens on one
+#: 113 KB reasoning block, was truncated (``"reason":"length"``), emitted
+#: no tool call, and exited 0 with nothing on disk — the run this issue is
+#: named for.
+#:
+#: opencode computes the *effective* cap as
+#: ``min(model.limit.output, $OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX)`` —
+#: it is a ceiling suggestion, not a per-model override.  Raising it can
+#: never push a model's output above what that model's own
+#: ``limit.output`` allows; it can only stop opencode's own 32,000
+#: default from clamping a model that allows more.  That makes a single
+#: generous constant safe across every model dispatched through this
+#: provider — no need to look up ``limit.output`` per model at dispatch
+#: time.
+#:
+#: Chosen as 384,000 — the largest ``limit.output`` among the opencode
+#: model definitions coord currently routes through (``oc-cheap`` /
+#: ``opencode/deepseek-v4-flash`` and ``oc-heavy`` /
+#: ``opencode/deepseek-v4-pro``, both 384,000; ``oc-mid`` /
+#: ``opencode/glm-5.2`` is lower at 131,072 and is naturally clamped to
+#: its own true ceiling by the ``min()`` above — never pushed past it).
+#:
+#: Both fleet binaries already read this variable (1.18.11 on dellserver —
+#: the machine that hit the space-invaders#1 truncation — and 1.18.12 on
+#: precision), and it is not gated behind ``OPENCODE_EXPERIMENTAL`` the
+#: way other ``experimental*``-named flags are (that gating uses a
+#: different internal helper; this flag's parser reads the env var
+#: directly, unconditionally). No version-floor probe is needed here and
+#: none should be added later on speculation: on a binary that predates
+#: this flag it is simply inert and the cap silently stays at 32,000 —
+#: never a hard failure.
+OUTPUT_TOKEN_MAX_DEFAULT = 384_000
+
 
 class OpenCodeAgentNotFoundError(RuntimeError):
     """Raised when no committed opencode agent definition exists for a
@@ -641,35 +687,62 @@ class OpenCodeProvider(Provider):
     def env(self) -> dict[str, str]:
         """Extra environment variables for the worker subprocess.
 
-        Two parts:
-
-        1. ``ProviderDef.env`` (already ``${VAR}``-expanded by config
+        Three parts, deliberately split across **both sides** of
+        ``self._env`` — that asymmetry is the whole point, see below:
+
+        1. **#2321, seeded BEFORE ``self._env``, operator-overridable:**
+           ``OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX`` defaults to
+           :data:`OUTPUT_TOKEN_MAX_DEFAULT` (see that constant for the
+           full rationale). Unlike part 3 below, this is a *tuning knob*,
+           not a safety mechanism — an operator has a legitimate reason to
+           pin it lower (e.g. to cap cost) or higher (a future model with
+           a larger ``limit.output``), so it is seeded first and then
+           allowed to be shadowed by ``self._env`` like any other
+           ``ProviderDef.env`` entry.  ``coord/config.py``'s
+           ``_parse_providers`` rejects a value at config-parse time that
+           opencode's own parser would silently discard (non-integer,
+           ``<= 0``, or containing whitespace/underscores) — see that
+           function for the validation opencode itself performs.
+        2. ``ProviderDef.env`` (already ``${VAR}``-expanded by config
            parsing, #1706) — how an operator points a named ``opencode``
            provider definition at a specific set of credentials without
-           baking them into the machine's agent unit.
-        2. **#1705, always set, not operator-overridable:**
-           ``OPENCODE_CONFIG_DIR`` (:data:`AGENTS_ROOT` — where the
-           committed per-spec-type agent files live, see the module
-           docstring for why an env var rather than a worktree file copy)
-           and ``OPENCODE_CONFIG`` (:data:`ROUTING_PIN_PATH` — the
-           OpenRouter routing pin, see ``coord/agents/opencode/routing.jsonc``).
-           These are applied **after** ``self._env`` so a
-           ``ProviderDef.env`` entry cannot accidentally (or maliciously,
-           via a compromised ``coordinator.yml`` edit that isn't the
-           security-reviewed agent-file path) shadow the deny-list
-           discovery mechanism — see :class:`OpenCodeAgentNotFoundError`'s
-           docstring for why silently losing this would be bad.  Verified
-           empirically that ``OPENCODE_CONFIG_DIR`` is inert for a provider
-           the operator hasn't configured credentials for (real opencode
-           1.18.11 run against a non-OpenRouter model with both variables
-           set completed normally) — see
+           baking them into the machine's agent unit.  This is also where
+           an operator's override of part 1 above lands, since dict
+           ``.update()`` here happens after the default is seeded.
+        3. **#1705, always set AFTER ``self._env``, NOT
+           operator-overridable:** ``OPENCODE_CONFIG_DIR``
+           (:data:`AGENTS_ROOT` — where the committed per-spec-type agent
+           files live, see the module docstring for why an env var rather
+           than a worktree file copy) and ``OPENCODE_CONFIG``
+           (:data:`ROUTING_PIN_PATH` — the OpenRouter routing pin, see
+           ``coord/agents/opencode/routing.jsonc``).  These are applied
+           **after** ``self._env`` so a ``ProviderDef.env`` entry cannot
+           accidentally (or maliciously, via a compromised
+           ``coordinator.yml`` edit that isn't the security-reviewed
+           agent-file path) shadow the deny-list discovery mechanism —
+           see :class:`OpenCodeAgentNotFoundError`'s docstring for why
+           silently losing this would be bad.  Verified empirically that
+           ``OPENCODE_CONFIG_DIR`` is inert for a provider the operator
+           hasn't configured credentials for (real opencode 1.18.11 run
+           against a non-OpenRouter model with both variables set
+           completed normally) — see
            ``test_opencode_routing_pin_inert_without_openrouter_credential_end_to_end``.
 
+        The asymmetry: part 1 is a default an operator must be able to
+        override (seeded *before* the merge, operator wins); part 3 is a
+        safety mechanism an operator must never be able to override (set
+        *after* the merge, coord wins).  Do not "fix" this into a single
+        consistent ordering — the two groups need opposite precedence on
+        purpose.
+
         Returns a fresh dict each call.
         """
-        merged = dict(self._env)
-        merged["OPENCODE_CONFIG_DIR"] = str(AGENTS_ROOT)
-        merged["OPENCODE_CONFIG"] = str(ROUTING_PIN_PATH)
+        merged: dict[str, str] = {
+            "OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX": str(OUTPUT_TOKEN_MAX_DEFAULT),
+        }
+        merged.update(self._env)  # operator wins over the tuning-knob default
+        merged["OPENCODE_CONFIG_DIR"] = str(AGENTS_ROOT)  # coord wins, unchanged
+        merged["OPENCODE_CONFIG"] = str(ROUTING_PIN_PATH)  # coord wins, unchanged
         return merged
 
     def parse_log(

{code_coordinator-0.5.112 → code_coordinator-0.5.114}/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.114}/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)},