code-coordinator 0.5.537__tar.gz → 0.5.538__tar.gz

{code_coordinator-0.5.537 → code_coordinator-0.5.538}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.537",
+  "tag": "0.5.538",
   "distance": 0,
-  "node": "g0b0484bb17ec9c86ad41ee4d4d8123042044c389",
+  "node": "g497e677b9148b371539abe944ff11b260e6dc373",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.537 → code_coordinator-0.5.538}/coord/commands/lifecycle.py

@@ -428,7 +428,7 @@ def done(config_path: Path) -> None:
             pass
 
     all_assignments = list(board.active) + list(board.completed)
-    session_usage = build_session_usage(all_assignments, started_at=started_at)
+    session_usage = build_session_usage(all_assignments, started_at=started_at, cfg=cfg)
     total_cost = session_usage.total_cost_usd
 
     click.echo("")

{code_coordinator-0.5.537 → code_coordinator-0.5.538}/coord/commands/status.py

@@ -980,7 +980,7 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
                 pass
 
         all_assignments = list(board.active) + list(board.completed)
-        session_usage = build_session_usage(all_assignments, started_at=started_at)
+        session_usage = build_session_usage(all_assignments, started_at=started_at, cfg=cfg)
         burn_line = format_burn_rate_line(session_usage)
         if burn_line:
             click.echo("")
@@ -1103,7 +1103,7 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
         machine_by_aid = {
             a.assignment_id: a.machine_name for a in rows if a.assignment_id
         }
-        usage = build_session_usage(rows, remote_by_id=agent_completed or None)
+        usage = build_session_usage(rows, remote_by_id=agent_completed or None, cfg=cfg)
         for au in usage.assignments:
             # #3376 review round 2: `cost_unknown` means no local log AND no
             # remote entry. That is the ghost-dispatch signal ONLY if this
@@ -2992,6 +2992,14 @@ def usage(
             pass
 
     # Optionally fetch remote cost data for assignments without local logs.
+    # #2305: cfg is only loaded here (not unconditionally) — the bare
+    # `coord usage` view has always worked with no coordinator.yml present
+    # at all (see TestUsageCommandBareViewHonorsWindowFlags), and that must
+    # stay true. When it IS loaded (here, or by --remote below), it's
+    # threaded into build_session_usage() so a tier-named provider (e.g.
+    # "oc-mid") resolves correctly instead of degrading to ClaudeProvider
+    # log parsing.
+    cfg: "Config | None" = None
     remote_by_id: dict[str, dict] = {}
     if remote and all_assignments:
         cfg = _load_config(config_path)
@@ -3027,6 +3035,7 @@ def usage(
         all_assignments,
         remote_by_id=remote_by_id if remote_by_id else None,
         started_at=started_at,
+        cfg=cfg,
     )
     click.echo(format_usage_report(session, window_label=window_label))
 

{code_coordinator-0.5.537 → code_coordinator-0.5.538}/coord/failure_class.py

@@ -79,6 +79,7 @@ from coord.worker_events import (
 )
 
 if TYPE_CHECKING:
+    from coord.config import Config
     from coord.providers.base import Provider
 
 # ── the two classes ─────────────────────────────────────────────────────────
@@ -461,6 +462,7 @@ def classify_log(
     tail_bytes: int = 65536,
     provider_name: str | None = None,
     provider: "Provider | None" = None,
+    cfg: "Config | None" = None,
 ) -> FailureClassification:
     """Classify a worker's terminal state from its log.
 
@@ -484,6 +486,14 @@ def classify_log(
     an escape hatch for tests to pass an already-constructed provider
     directly, bypassing name resolution.
 
+    *cfg* (#2305): the coordinator's :class:`~coord.config.Config`, passed
+    straight through to :func:`coord.providers.get_provider` so a
+    tier-named ``providers.definitions`` entry (e.g. ``oc-mid``) resolves to
+    its real backend instead of silently degrading to
+    :class:`~coord.providers.claude.ClaudeProvider` — *provider_name* alone
+    only ever matches the built-in type names. ``None`` (the default)
+    preserves pre-#2305 behaviour.
+
     #1710 NOTE — a documented, narrow behaviour difference from the
     pre-#1710 implementation: that version additionally scanned the raw
     ``result`` event's ``error`` and bare ``subtype`` fields (via
@@ -509,7 +519,7 @@ def classify_log(
 
     if provider is None:
         from coord.providers import get_provider  # noqa: PLC0415
-        provider = get_provider(provider_name)
+        provider = get_provider(provider_name, cfg=cfg)
     summary = provider.parse_log(log_path, tail_bytes=tail_bytes)
 
     classification = classify_failure(

{code_coordinator-0.5.537 → code_coordinator-0.5.538}/coord/progress.py

@@ -26,6 +26,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from coord.config import Config
     from coord.providers.base import Provider
 
 
@@ -118,6 +119,7 @@ def parse_progress(
     *,
     provider_name: str | None = None,
     provider: "Provider | None" = None,
+    cfg: "Config | None" = None,
 ) -> WorkerProgress:
     """Parse progress from a worker log.
 
@@ -137,6 +139,15 @@ def parse_progress(
             precedence over *provider_name*. Mainly for tests that want to
             exercise a specific (e.g. fake, non-claude) provider without
             wiring up a full :class:`~coord.config.Config`.
+        cfg: The coordinator's :class:`~coord.config.Config`, when the caller
+            has one in scope. #2305: without this, ``provider_name`` only
+            ever resolves against the built-in provider *types*
+            (``claude``/``claude-pty``/``opencode``) — a **tier-named**
+            ``providers.definitions`` entry (e.g. ``oc-mid``) silently
+            degrades to :class:`~coord.providers.claude.ClaudeProvider`.
+            Passed straight through to :func:`coord.providers.get_provider`;
+            ``None`` (the default) preserves the pre-#2305 built-ins-only
+            resolution, so existing callers are unaffected.
     """
     from coord.worker_events import detect_anomalies, is_stream_json
 
@@ -147,7 +158,7 @@ def parse_progress(
     if is_stream_json(p):
         if provider is None:
             from coord.providers import get_provider  # noqa: PLC0415
-            provider = get_provider(provider_name)
+            provider = get_provider(provider_name, cfg=cfg)
         summary = provider.parse_log(p, tail_bytes=tail_bytes)
         progress = WorkerProgress()
         # Synthesise a single rolling "update" line so coord status keeps

{code_coordinator-0.5.537 → code_coordinator-0.5.538}/coord/usage.py

@@ -27,6 +27,7 @@ from coord.models import Assignment
 from coord.state import COORD_DIR
 
 if TYPE_CHECKING:
+    from coord.config import Config
     from coord.providers.base import Provider
 
 _log = logging.getLogger(__name__)
@@ -155,6 +156,7 @@ def parse_usage_from_log(
     *,
     provider_name: str | None = None,
     provider: "Provider | None" = None,
+    cfg: "Config | None" = None,
 ) -> AssignmentUsage | None:
     """Parse an :class:`AssignmentUsage` from a worker log file.
 
@@ -172,6 +174,14 @@ def parse_usage_from_log(
     behaviour byte-for-byte for every caller that doesn't pass it. *provider*
     is an escape hatch to pass an already-constructed provider directly
     (tests; bypasses name resolution).
+
+    *cfg* (#2305): the coordinator's :class:`~coord.config.Config`, passed
+    straight through to :func:`coord.providers.get_provider` so a
+    **tier-named** ``providers.definitions`` entry (e.g. ``oc-mid``) resolves
+    to its real backend instead of silently degrading to
+    :class:`~coord.providers.claude.ClaudeProvider` — *provider_name* alone
+    only ever matches the built-in type names. ``None`` (the default)
+    preserves pre-#2305 behaviour.
     """
     from coord.worker_events import is_stream_json
 
@@ -179,7 +189,7 @@ def parse_usage_from_log(
         return None
     if provider is None:
         from coord.providers import get_provider  # noqa: PLC0415
-        provider = get_provider(provider_name)
+        provider = get_provider(provider_name, cfg=cfg)
     if not is_stream_json(log_path):
         # #1710: a provider that claims it reports cost but whose log isn't
         # stream-json shaped gets NO cost/token data here — that mismatch is
@@ -221,6 +231,7 @@ def _assignment_to_usage(
     *,
     logs_dir: Path | None = None,
     remote_data: dict | None = None,
+    cfg: "Config | None" = None,
 ) -> AssignmentUsage:
     """Build an :class:`AssignmentUsage` for *a*.
 
@@ -229,6 +240,12 @@ def _assignment_to_usage(
 
     *remote_data* is a dict from the agent's ``list_assignments()`` response
     (e.g. ``{"cost_so_far": 0.12, "model_used": "claude-sonnet-4-6", ...}``).
+
+    *cfg* (#2305): threaded through to both the local-log parse and the
+    "neither local nor remote" ``get_provider`` fallback below, so a
+    tier-named provider (e.g. ``oc-mid``) resolves to its real backend
+    rather than :class:`~coord.providers.claude.ClaudeProvider`. ``None``
+    (the default) preserves pre-#2305 behaviour.
     """
     _logs_dir = logs_dir if logs_dir is not None else LOGS_DIR
     from coord.models import effective_issue_number  # noqa: PLC0415
@@ -252,7 +269,7 @@ def _assignment_to_usage(
         # #1710: thread the assignment's resolved provider name through so
         # the parse uses the right provider's parse_log() rather than always
         # assuming claude.
-        parsed = parse_usage_from_log(log_path, provider_name=a.provider_name)
+        parsed = parse_usage_from_log(log_path, provider_name=a.provider_name, cfg=cfg)
         if parsed is not None:
             usage.model = parsed.model or a.model
             usage.total_cost_usd = parsed.total_cost_usd
@@ -283,7 +300,7 @@ def _assignment_to_usage(
     if a.assignment_id:
         from coord.providers import get_provider  # noqa: PLC0415
 
-        provider = get_provider(a.provider_name)
+        provider = get_provider(a.provider_name, cfg=cfg)
         if provider.capabilities().cost_reporting:
             usage.cost_unknown = True
 
@@ -298,6 +315,7 @@ def collect_usage(
     *,
     logs_dir: Path | None = None,
     remote_by_id: dict[str, dict] | None = None,
+    cfg: "Config | None" = None,
 ) -> list[AssignmentUsage]:
     """Collect :class:`AssignmentUsage` for every assignment on the board.
 
@@ -305,13 +323,21 @@ def collect_usage(
     whose logs live on a remote machine.  Pass ``None`` (the default) to skip
     remote lookups entirely — the result will still be correct for any
     assignment whose log is available locally.
+
+    *cfg* (#2305): the coordinator's :class:`~coord.config.Config`, when the
+    caller has one — threaded to :func:`_assignment_to_usage` so a
+    tier-named ``providers.definitions`` entry resolves correctly rather
+    than degrading to :class:`~coord.providers.claude.ClaudeProvider`.
+    ``None`` (the default) preserves pre-#2305 behaviour.
     """
     result: list[AssignmentUsage] = []
     for a in board_assignments:
         if not a.assignment_id:
             continue
         remote = (remote_by_id or {}).get(a.assignment_id)
-        result.append(_assignment_to_usage(a, logs_dir=logs_dir, remote_data=remote))
+        result.append(
+            _assignment_to_usage(a, logs_dir=logs_dir, remote_data=remote, cfg=cfg)
+        )
     return result
 
 
@@ -321,12 +347,16 @@ def build_session_usage(
     logs_dir: Path | None = None,
     remote_by_id: dict[str, dict] | None = None,
     started_at: float | None = None,
+    cfg: "Config | None" = None,
 ) -> SessionUsage:
     """Build a :class:`SessionUsage` from the current board.
 
     *started_at* should come from ``session.json["started_at"]`` (parsed to
     a Unix timestamp).  If not provided we fall back to the oldest
     ``dispatched_at`` among the assignments.
+
+    *cfg* (#2305): passed straight through to :func:`collect_usage` — see
+    its docstring.
     """
     if started_at is None:
         # Derive from oldest dispatch time on the board.
@@ -341,6 +371,7 @@ def build_session_usage(
         board_assignments,
         logs_dir=logs_dir,
         remote_by_id=remote_by_id,
+        cfg=cfg,
     )
     return SessionUsage(started_at=started_at, assignments=assignments)
 

{code_coordinator-0.5.537 → code_coordinator-0.5.538}/tests/test_cli_status_provider.py

@@ -17,13 +17,18 @@ stays uncluttered — only a non-default backend earns the tag.
 
 from __future__ import annotations
 
+import logging
+from pathlib import Path
+
 import coord.network as network_mod
+import pytest
 from click.testing import CliRunner
 
 from coord.commands.status import status as status_cmd
 from coord.models import Assignment, Board
 from coord.network import MachineStatus, StatusResult
 from coord.state import save_board
+from tests.conftest import VALID_CONFIG
 
 
 def _work(
@@ -188,3 +193,46 @@ def test_busy_line_omits_provider_when_absent(valid_config_path, monkeypatch) ->
     )
     assert result.exit_code == 0, result.output
     assert "provider=" not in result.output, result.output
+
+
+# ── #2305: tier-named providers.definitions must resolve, not degrade ──────
+
+
+@pytest.fixture
+def tier_provider_config_path(tmp_path: Path) -> Path:
+    """`valid_config_path` plus a tier-named `providers.definitions` entry —
+    the real fleet shape #2305 is about (`oc-mid` etc.), not a builtin
+    provider *type* name."""
+    p = tmp_path / "coordinator.yml"
+    p.write_text(
+        VALID_CONFIG
+        + "\nproviders:\n"
+        "  definitions:\n"
+        "    oc-mid:\n"
+        "      type: opencode\n"
+    )
+    return p
+
+
+def test_status_resolves_tier_named_provider_without_warning(
+    tier_provider_config_path, monkeypatch, coord_db, caplog: pytest.LogCaptureFixture,
+) -> None:
+    """#2305 acceptance criterion: `coord status` against a board holding a
+    tier-named assignment (`oc-mid`, not a built-in `claude`/`claude-pty`/
+    `opencode` type name) must resolve the assignment's own provider
+    definition — no `get_provider: unknown provider_name` warning — because
+    `build_session_usage()` (feeding the burn-rate line) is now handed
+    `cfg`, which carries `providers.definitions`."""
+    save_board(Board(completed=[_work("w1", provider_name="oc-mid")]))
+    monkeypatch.setattr(network_mod, "check_all", lambda *a, **k: [])
+    runner = CliRunner()
+    with caplog.at_level(logging.WARNING, logger="coord.providers"):
+        result = runner.invoke(
+            status_cmd,
+            ["--config", str(tier_provider_config_path)],
+            catch_exceptions=False,
+        )
+    assert result.exit_code == 0, result.output
+    assert not any(
+        "unknown provider_name" in r.message for r in caplog.records
+    ), [r.message for r in caplog.records]

{code_coordinator-0.5.537 → code_coordinator-0.5.538}/tests/test_provider_seam.py

@@ -36,15 +36,42 @@ from pathlib import Path
 
 import pytest
 
+from coord.config import Config, ProviderDef, ProvidersConfig
 from coord.failure_class import ENVIRONMENTAL, WORK, classify_log
 from coord.progress import parse_progress
 from coord.providers import get_provider
 from coord.providers.base import Capabilities, Provider, WorkerSummary
 from coord.providers.claude import ClaudeProvider
+from coord.providers.opencode import OpenCodeProvider
 from coord.review import parse_review_from_log
 from coord.usage import parse_usage_from_log
 
 
+#: A real, verbatim opencode capture (#1703/#1704) — same fixture
+#: ``tests/test_providers.py`` pins ``OpenCodeProvider.parse_log()``'s exact
+#: field values against. Reused here (#2305) as the "vehicle" log for
+#: proving ``cfg``-based resolution of a **tier-named** provider definition
+#: (e.g. ``oc-mid``) actually reaches ``OpenCodeProvider.parse_log()`` at
+#: each of the four #2305 call sites, without depending on a real opencode
+#: binary — the fixture is a static capture, not a live run.
+_OPENCODE_FIXTURE = Path(__file__).parent / "fixtures" / "opencode_run_sample.jsonl"
+
+
+def _cfg_with_tier_provider(name: str, ptype: str) -> Config:
+    """A minimal :class:`~coord.config.Config` whose ``providers.definitions``
+    carries one entry keyed by a **tier name** (e.g. ``"oc-mid"``) rather
+    than a built-in provider *type* name — the #2305 shape: the name alone
+    doesn't match ``_BUILTIN_PROVIDER_TYPES``, so resolution only succeeds
+    when the caller actually threads ``cfg`` through to
+    :func:`coord.providers.get_provider`.
+    """
+    return Config(
+        repos=[],
+        machines=[],
+        providers=ProvidersConfig(definitions={name: ProviderDef(type=ptype)}),
+    )
+
+
 # ── The fake provider ───────────────────────────────────────────────────────
 
 
@@ -185,6 +212,30 @@ class TestGetProvider:
             "totally-unknown-provider" in r.message for r in caplog.records
         ), "unknown provider_name must produce a LOUD warning, not a silent fallback (#1710)"
 
+    def test_tier_named_definition_degrades_to_claude_without_cfg(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """#2305: this is the bug itself, pinned directly at the seam —
+        ``oc-mid`` is a real fleet tier name (see the issue), not a typo.
+        Without ``cfg`` there is no ``providers.definitions`` to consult, so
+        it degrades to :class:`ClaudeProvider`, loudly."""
+        with caplog.at_level(logging.WARNING, logger="coord.providers"):
+            provider = get_provider("oc-mid")
+        assert isinstance(provider, ClaudeProvider)
+        assert any("oc-mid" in r.message for r in caplog.records)
+
+    def test_tier_named_definition_resolves_via_cfg(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """#2305 fix: with ``cfg`` threaded through, the same tier name
+        resolves against ``cfg.providers.definitions`` — the *type* backing
+        it (``opencode``), not :class:`ClaudeProvider`, and with no warning."""
+        cfg = _cfg_with_tier_provider("oc-mid", "opencode")
+        with caplog.at_level(logging.WARNING, logger="coord.providers"):
+            provider = get_provider("oc-mid", cfg=cfg)
+        assert isinstance(provider, OpenCodeProvider)
+        assert not caplog.records
+
 
 # ── progress.py ──────────────────────────────────────────────────────────────
 
@@ -250,6 +301,23 @@ class TestProgressSeam:
         progress = parse_progress(log)
         assert progress.updates == ["Turn 1: Bash"]
 
+    def test_tier_named_definition_misparses_without_cfg(self) -> None:
+        """#2305 regression: `parse_progress`'s own `get_provider()` call
+        (the site at `coord/progress.py:150`) is never handed `cfg` here —
+        `oc-mid` degrades to ClaudeProvider, which has no idea how to read
+        opencode's `step_finish` events, so the real 4-turn run reads as 0."""
+        assert _OPENCODE_FIXTURE.exists(), "opencode_run_sample.jsonl fixture is missing"
+        progress = parse_progress(_OPENCODE_FIXTURE, provider_name="oc-mid")
+        assert progress.updates == ["Turn 0: edit"]
+
+    def test_tier_named_definition_parses_correctly_with_cfg(self) -> None:
+        """#2305 fix: threading `cfg` through resolves `oc-mid` to
+        `OpenCodeProvider` at the `coord/progress.py:150` site, and the real
+        4-turn count from the verbatim capture comes through."""
+        cfg = _cfg_with_tier_provider("oc-mid", "opencode")
+        progress = parse_progress(_OPENCODE_FIXTURE, provider_name="oc-mid", cfg=cfg)
+        assert progress.updates == ["Turn 4: edit"]
+
 
 # ── usage.py ─────────────────────────────────────────────────────────────────
 
@@ -314,6 +382,27 @@ class TestUsageSeam:
         assert usage is None
         assert not caplog.records
 
+    def test_tier_named_definition_misparses_without_cfg(self) -> None:
+        """#2305 regression: the `get_provider()` call at `coord/usage.py:182`
+        with no `cfg` degrades `oc-mid` to ClaudeProvider — the real 8392
+        input tokens in the verbatim opencode capture read as 0."""
+        u = parse_usage_from_log(_OPENCODE_FIXTURE, provider_name="oc-mid")
+        assert u is not None
+        assert u.input_tokens == 0
+        assert u.num_turns == 0
+
+    def test_tier_named_definition_parses_correctly_with_cfg(self) -> None:
+        """#2305 fix: `cfg` threaded through resolves `oc-mid` to
+        `OpenCodeProvider` at `coord/usage.py:182`, so the real numbers from
+        the verbatim capture come through (see
+        `test_opencode_parse_log_real_success_fixture` in
+        `tests/test_providers.py` for where these values are pinned)."""
+        cfg = _cfg_with_tier_provider("oc-mid", "opencode")
+        u = parse_usage_from_log(_OPENCODE_FIXTURE, provider_name="oc-mid", cfg=cfg)
+        assert u is not None
+        assert u.input_tokens == 8392
+        assert u.num_turns == 4
+
 
 # ── failure_class.py ─────────────────────────────────────────────────────────
 
@@ -354,6 +443,56 @@ class TestFailureClassificationSeam:
         assert c.failure_class == WORK
         assert any("nonexistent-provider" in r.message for r in caplog.records)
 
+    def test_tier_named_definition_misclassifies_without_cfg(
+        self, tmp_path: Path
+    ) -> None:
+        """#2305 regression: the `get_provider()` call at
+        `coord/failure_class.py:~511` with no `cfg` degrades `oc-mid` to
+        ClaudeProvider — ClaudeProvider's parser has no idea how to read
+        opencode's `type: "error"` event, so a genuine environmental 503
+        classifies as an unknown WORK failure instead."""
+        log = _write_fake_log(
+            tmp_path / "opencode-error.log",
+            [
+                json.dumps(
+                    {
+                        "type": "error",
+                        "error": {
+                            "name": "UnknownError",
+                            "data": {"message": "API Error: 503 overloaded_error"},
+                        },
+                    }
+                ),
+            ],
+        )
+        c = classify_log(log, provider_name="oc-mid")
+        assert c.failure_class == WORK
+
+    def test_tier_named_definition_classifies_correctly_with_cfg(
+        self, tmp_path: Path
+    ) -> None:
+        """#2305 fix: `cfg` threaded through resolves `oc-mid` to
+        `OpenCodeProvider` at the `coord/failure_class.py` site, so the same
+        log correctly classifies as ENVIRONMENTAL."""
+        log = _write_fake_log(
+            tmp_path / "opencode-error.log",
+            [
+                json.dumps(
+                    {
+                        "type": "error",
+                        "error": {
+                            "name": "UnknownError",
+                            "data": {"message": "API Error: 503 overloaded_error"},
+                        },
+                    }
+                ),
+            ],
+        )
+        cfg = _cfg_with_tier_provider("oc-mid", "opencode")
+        c = classify_log(log, provider_name="oc-mid", cfg=cfg)
+        assert c.failure_class == ENVIRONMENTAL
+        assert c.api_status == 503
+
 
 # ── review.py (unchanged code path — asserted for #1710's acceptance bar) ───
 

{code_coordinator-0.5.537 → code_coordinator-0.5.538}/tests/test_usage.py

@@ -13,6 +13,7 @@ from click.testing import CliRunner
 
 import coord.state as state_mod
 from coord.cli import main
+from coord.config import Config, ProviderDef, ProvidersConfig
 from coord.models import Assignment
 from coord.usage import (
     HIGH_BURN_RATE_USD_PER_HOUR,
@@ -60,6 +61,7 @@ def _assignment(
     model: str | None = None,
     dispatched_at: float | None = None,
     finished_at: float | None = None,
+    provider_name: str | None = None,
 ) -> Assignment:
     return Assignment(
         machine_name="m1",
@@ -71,6 +73,7 @@ def _assignment(
         model=model,
         dispatched_at=dispatched_at,
         finished_at=finished_at,
+        provider_name=provider_name,
     )
 
 
@@ -375,6 +378,41 @@ class TestCollectUsage:
         result = collect_usage([a], logs_dir=logs_dir)
         assert result[0].cost_unknown is False
 
+    def test_tier_named_provider_cost_unknown_wrong_without_cfg(
+        self, tmp_path: Path
+    ) -> None:
+        """#2305 regression: the `get_provider()` call at
+        `coord/usage.py:~286` (the "neither local log nor remote data"
+        fallback) has no `cfg` to consult here — a tier name that maps to a
+        non-cost-reporting backend (`claude-pty`) degrades to the built-in
+        `ClaudeProvider`, which *does* report cost, so this ghost-dispatch
+        row wrongly flags `cost_unknown=True` for a provider that was never
+        expected to report cost in the first place."""
+        logs_dir = tmp_path / "logs"  # empty — no local log
+        a = _assignment(assignment_id="ghost002", provider_name="interactive-tier")
+        result = collect_usage([a], logs_dir=logs_dir)  # no cfg
+        assert result[0].cost_unknown is True
+
+    def test_tier_named_provider_cost_unknown_correct_with_cfg(
+        self, tmp_path: Path
+    ) -> None:
+        """#2305 fix: `cfg` threaded through `collect_usage` ->
+        `_assignment_to_usage` -> `get_provider()` resolves
+        `interactive-tier` to `claude-pty` (`cost_reporting=False`), so the
+        ghost-dispatch row correctly stays `cost_unknown=False` — there was
+        never any cost to have captured."""
+        logs_dir = tmp_path / "logs"  # empty — no local log
+        a = _assignment(assignment_id="ghost002", provider_name="interactive-tier")
+        cfg = Config(
+            repos=[],
+            machines=[],
+            providers=ProvidersConfig(
+                definitions={"interactive-tier": ProviderDef(type="claude-pty")}
+            ),
+        )
+        result = collect_usage([a], logs_dir=logs_dir, cfg=cfg)
+        assert result[0].cost_unknown is False
+
 
 class TestBuildSessionUsage:
     def test_derives_started_at_from_dispatch_time(self, tmp_path: Path) -> None: