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

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

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

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

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

{code_coordinator-0.5.113 → code_coordinator-0.5.115}/coord/commands/dispatch.py

@@ -1873,18 +1873,35 @@ def retry(assignment_id: str, config_path: Path, acknowledge_cost: bool = False)
         # an independent inline copy of the same "branch empty → 0, repo
         # missing → None, else ask GitHub" logic.
         ahead = github_ops.branch_commits_ahead_for_assignment(assignment, cfg)
-        if ahead != 0:
-            detail = (
-                "its commit count could not be confirmed (gh lookup failed)"
-                if ahead is None
-                else f"{ahead} commit(s) present on its branch"
+        if ahead is None:
+            # #2324: a genuine lookup failure (network error, auth, rate
+            # limit, repo missing) is NOT evidence that commits exist — it's
+            # just an unanswered question. Don't assert the #1357
+            # false-positive shape or point at `--accept-advisory`, which
+            # assumes real commits are sitting on the branch; nothing here
+            # established that. Say the lookup failed and name what to
+            # check instead. (A confirmed 404 on the head branch is handled
+            # above this `is None` check — `branch_commits_ahead_for_assignment`
+            # reads that as 0, not None.)
+            click.echo(
+                f"error: assignment {assignment_id} is 'advisory', and its "
+                "commit count could not be confirmed (gh lookup failed) — "
+                "coord retry only re-dispatches a GENUINE zero-commit "
+                "advisory, and a failed lookup isn't confirmation either "
+                "way. Check `gh api` access and the recorded branch/repo, "
+                "then retry; or inspect by hand: coord log "
+                f"{assignment_id}.",
+                err=True,
             )
+            sys.exit(1)
+        if ahead != 0:
             click.echo(
-                f"error: assignment {assignment_id} is 'advisory', and {detail} "
-                "— coord retry only re-dispatches a GENUINE zero-commit "
-                "advisory. This looks like the #1357 false-positive "
-                "signature instead; use `coord drive --accept-advisory` to "
-                "proceed with the existing commits, or inspect by hand.",
+                f"error: assignment {assignment_id} is 'advisory', and "
+                f"{ahead} commit(s) are present on its branch — coord retry "
+                "only re-dispatches a GENUINE zero-commit advisory. This is "
+                "the #1357 false-positive signature instead; use `coord "
+                "drive --accept-advisory` to proceed with the existing "
+                "commits, or inspect by hand.",
                 err=True,
             )
             sys.exit(1)

{code_coordinator-0.5.113 → code_coordinator-0.5.115}/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.113 → code_coordinator-0.5.115}/coord/diagnose.py

@@ -1069,6 +1069,12 @@ def _work_advisory_commits_ahead(assignment: "Assignment", config: "Config") ->
     zero-commit gate uses) rather than a local git checkout — `coord
     diagnose` runs on the daemon host, which has no guarantee of a local
     clone of every worker's branch.
+
+    #2324: ``None`` here means the lookup genuinely couldn't be confirmed
+    (network/auth/rate-limit/repo-missing) — a head branch GitHub positively
+    404s, with the base branch still resolving, comes back as ``0`` instead
+    (see :func:`coord.github_ops.branch_commits_ahead`), since a deleted
+    branch is proof nothing was pushed, not an unknown.
     """
     from coord import github_ops  # noqa: PLC0415
 

{code_coordinator-0.5.113 → code_coordinator-0.5.115}/coord/github_ops.py

@@ -1775,6 +1775,58 @@ def get_compare_files(repo: str, base: str, head: str) -> list[str] | None:
     return [line for line in (ln.strip() for ln in raw.splitlines()) if line]
 
 
+def _gh_ref_confirmed_missing(exc: Exception) -> bool:
+    """True when *exc* (raised by ``_gh`` for a ``gh api`` ref/compare call)
+    is GitHub positively saying "no such ref" — a 404 — as opposed to an
+    auth, rate-limit, network, or other transient failure that merely looks
+    like one from the caller's point of view.
+
+    #2324: deliberately narrower than the "http 4" match
+    :func:`branch_exists_on_remote` uses (which folds 401/403/429 in with
+    404, and fails open elsewhere for that function's own reasons). This is
+    the one call site where conflating "confirmed gone" with "auth/rate-limit
+    blip" would make `coord retry`'s zero-commit gate treat a locked-out
+    ``gh`` as proof a branch was deleted and race ahead re-dispatching real,
+    unconfirmed work — so it checks :func:`_is_transient_error`'s keywords
+    first and only then looks for an explicit "404"/"not found" signal.
+    """
+    if _is_transient_error(exc):
+        return False
+    msg = str(exc).lower()
+    return "404" in msg or "not found" in msg
+
+
+def _head_branch_confirmed_deleted(repo: str, base: str, branch: str) -> bool:
+    """True when *branch* 404s on *repo* while *base* still resolves.
+
+    #2324: :func:`branch_commits_ahead`'s three-dot compare call 404s
+    identically whether it's the head branch that's gone, the base branch,
+    or something else entirely obscures both — the compare error text alone
+    can't tell them apart. This asks each ref directly (the same
+    ``git/refs/heads`` lookup :func:`branch_exists_on_remote` uses) so a
+    branch that was genuinely deleted — the normal cleanup after a
+    zero-commit worker exit — reads as "confirmed gone" instead of being
+    lumped in with an unrelated failure and reported as unknown.
+
+    Only returns True on the one shape that's actually conclusive: the head
+    ref 404s (via :func:`_gh_ref_confirmed_missing`) *and* the base ref
+    still resolves. Any other combination — head resolves fine, head lookup
+    itself fails inconclusively, or base can't be confirmed either — returns
+    False so the caller keeps its existing fail-closed ``None``.
+    """
+    try:
+        _gh("api", f"repos/{repo}/git/refs/heads/{branch}")
+        return False  # head resolves fine; compare failed for some other reason
+    except RuntimeError as exc:
+        if not _gh_ref_confirmed_missing(exc):
+            return False  # inconclusive — do not guess
+    try:
+        _gh("api", f"repos/{repo}/git/refs/heads/{base}")
+    except RuntimeError:
+        return False  # base itself unconfirmable — don't trust the read
+    return True  # head confirmed gone, base confirmed present
+
+
 def branch_commits_ahead(repo: str, base: str, branch: str) -> int | None:
     """Commits *branch* is ahead of *base* on the remote, or ``None``.
 
@@ -1790,6 +1842,16 @@ def branch_commits_ahead(repo: str, base: str, branch: str) -> int | None:
     real reviews.  This is the opposite polarity from
     :func:`branch_is_fully_merged`, which returns a plain ``False`` on error
     because *its* fail-safe direction is "keep the PR open".
+
+    #2324 exception: when the compare call fails, a *confirmed* 404 on the
+    head branch while the base branch still resolves
+    (:func:`_head_branch_confirmed_deleted`) returns ``0``, not ``None`` — a
+    head ref that GitHub positively says doesn't exist is the strongest
+    possible evidence nothing was ever pushed to it (a branch carrying
+    commits would still be there). Every other failure shape — the compare
+    call fails for a reason that isn't a confirmed head-branch 404, or the
+    follow-up ref checks themselves are inconclusive — keeps the existing
+    fail-closed ``None``.
     """
     if not branch or not base:
         return None
@@ -1799,6 +1861,8 @@ def branch_commits_ahead(repo: str, base: str, branch: str) -> int | None:
         raw = _gh("api", f"repos/{repo}/compare/{base}...{branch}")
         cmp = json.loads(raw)
     except Exception:  # noqa: BLE001 — unknown, not zero
+        if _head_branch_confirmed_deleted(repo, base, branch):
+            return 0
         return None
     if not isinstance(cmp, dict):
         return None
@@ -1832,7 +1896,11 @@ def branch_commits_ahead_for_assignment(assignment: Any, config: Any) -> int | N
     that ``config`` doesn't know about returns ``None`` ("cannot confirm"),
     never a bare 0, matching :func:`branch_commits_ahead`'s own fail-closed
     polarity: an unconfirmable commit count must never be silently read as
-    "empty branch, safe to touch".
+    "empty branch, safe to touch" — *except* the one case
+    :func:`branch_commits_ahead` itself carves out (#2324): a recorded
+    branch whose head ref GitHub positively 404s, with the base branch still
+    resolving, comes back as 0 rather than ``None`` — a deleted branch
+    proves nothing was pushed at least as conclusively as a blank one does.
     """
     branch = (getattr(assignment, "branch", None) or "").strip()
     if not branch:

{code_coordinator-0.5.113 → code_coordinator-0.5.115}/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.113 → code_coordinator-0.5.115}/tests/test_config.py

@@ -1349,6 +1349,93 @@ def test_providers_definition_env_non_string_value_raises(tmp_path: Path) -> Non
         load(p)
 
 
+# ── providers.definitions[*].env OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX (#2321) ─
+
+
+def test_providers_output_token_max_valid_value_accepted(tmp_path: Path) -> None:
+    """A bare positive-integer string is accepted and stored verbatim."""
+    p = tmp_path / "coordinator.yml"
+    p.write_text(
+        _MIN_CONFIG
+        + "providers:\n"
+        "  definitions:\n"
+        "    oc:\n"
+        "      type: opencode\n"
+        "      env:\n"
+        "        OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX: '131072'\n"
+    )
+    cfg = load(p)
+    env = cfg.providers.definitions["oc"].env
+    assert env["OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"] == "131072"
+
+
+@pytest.mark.parametrize(
+    "bad_value",
+    [
+        "131072 ",  # trailing whitespace — opencode's parser silently discards
+        " 131072",  # leading whitespace
+        "131_072",  # underscore digit-grouping — Number() coercion rejects
+        "0",  # not > 0
+        "-1",  # not > 0, has a sign
+        "1.5",  # decimal point
+        "unlimited",  # non-numeric
+        "",  # empty
+    ],
+)
+def test_providers_output_token_max_bad_value_raises(
+    tmp_path: Path, bad_value: str
+) -> None:
+    """A value opencode's own parser would silently discard is rejected
+    loudly at config-parse time (#2321) instead of silently reverting to
+    the 32000 default with no warning."""
+    p = tmp_path / "coordinator.yml"
+    p.write_text(
+        _MIN_CONFIG
+        + "providers:\n"
+        "  definitions:\n"
+        "    oc:\n"
+        "      type: opencode\n"
+        "      env:\n"
+        f"        OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX: {bad_value!r}\n"
+    )
+    with pytest.raises(ConfigError, match="OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"):
+        load(p)
+
+
+def test_providers_output_token_max_absent_does_not_raise(tmp_path: Path) -> None:
+    """Not setting the key at all is fine — env() supplies its own default."""
+    p = tmp_path / "coordinator.yml"
+    p.write_text(
+        _MIN_CONFIG
+        + "providers:\n"
+        "  definitions:\n"
+        "    oc:\n"
+        "      type: opencode\n"
+    )
+    cfg = load(p)
+    assert "OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX" not in cfg.providers.definitions["oc"].env
+
+
+def test_providers_output_token_max_validated_after_var_expansion(
+    tmp_path: Path, monkeypatch
+) -> None:
+    """The value is validated AFTER ${VAR} expansion — an expanded bad
+    value is caught, not just a literal one."""
+    monkeypatch.setenv("COORD_TEST_BAD_TOKEN_MAX", "not-a-number")
+    p = tmp_path / "coordinator.yml"
+    p.write_text(
+        _MIN_CONFIG
+        + "providers:\n"
+        "  definitions:\n"
+        "    oc:\n"
+        "      type: opencode\n"
+        "      env:\n"
+        "        OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX: '${COORD_TEST_BAD_TOKEN_MAX}'\n"
+    )
+    with pytest.raises(ConfigError, match="OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"):
+        load(p)
+
+
 def test_providers_extra_args_non_string_element_raises(tmp_path: Path) -> None:
     """extra_args elements must be strings."""
     p = tmp_path / "coordinator.yml"

{code_coordinator-0.5.113 → code_coordinator-0.5.115}/tests/test_diagnose.py

@@ -1651,6 +1651,43 @@ def test_zero_commit_advisory_is_not_reported_healthy(monkeypatch, config) -> No
     assert res.recovered is False
 
 
+def test_zero_commit_advisory_with_deleted_branch_is_not_reported_healthy(
+    monkeypatch, config
+) -> None:
+    """#2324: space-invaders#1's exact shape — a genuine zero-commit
+    advisory whose branch has already been deleted. Unlike the other tests
+    in this section, `_work_advisory_commits_ahead` is deliberately NOT
+    stubbed here — this exercises the real call into
+    `github_ops.branch_commits_ahead_for_assignment`, mocking only `gh`
+    itself, to prove the full chain (not just the diagnose-side branching)
+    reads a confirmed-404 head branch as 0, not None. Before #2324 this
+    reported "could not be confirmed" and steered toward `coord drive
+    --accept-advisory`, which assumes commits exist."""
+    _stub(monkeypatch, session="dead")
+
+    def _gh_dispatch(*args, **kwargs):
+        path = args[1] if len(args) > 1 else ""
+        if path == "repos/acme/api/compare/main...issue-42-deleted":
+            raise RuntimeError("gh: Not Found (HTTP 404)")
+        if path == "repos/acme/api/git/refs/heads/issue-42-deleted":
+            raise RuntimeError("gh: Not Found (HTTP 404)")
+        if path == "repos/acme/api/git/refs/heads/main":
+            return "{}"
+        raise AssertionError(f"unexpected _gh call: {args!r}")
+
+    monkeypatch.setattr("coord.github_ops._gh", _gh_dispatch)
+
+    a = _assign(aid="w-advisory-deleted", status="advisory", branch="issue-42-deleted")
+    board = Board(completed=[a])
+    res = diagnose.diagnose_stage(board, config, "api", 42, "work")
+
+    assert not any("looks healthy" in f for f in res.findings), res.findings
+    assert not any("could not be confirmed" in f for f in res.findings), res.findings
+    assert any("0 commits" in f for f in res.findings), res.findings
+    assert any("coord retry w-advisory-deleted" in f for f in res.findings), res.findings
+    assert res.recovered is False
+
+
 def test_zero_commit_advisory_on_a_plan_row_is_not_reported_healthy(
     monkeypatch, config
 ) -> None: