code-coordinator 0.5.184__tar.gz → 0.5.186__tar.gz

{code_coordinator-0.5.184 → code_coordinator-0.5.186}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.184",
+  "tag": "0.5.186",
   "distance": 0,
-  "node": "gea4dcf394483b237b6756e217d1187c0b24b598c",
+  "node": "g91a8fc0c07fd891a6a9c258c7f30aba6e090c865",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-20"

{code_coordinator-0.5.184 → code_coordinator-0.5.186}/coord/config.py

@@ -1617,11 +1617,15 @@ class HealthConfig:
     # None → ~/coord-web-dist — the symlink `deploy/coord-web-dist-build.timer`
     # atomically repoints at each new release (#1543).
     webapp_dist_path: str | None = None
-    # Directory holding the coord/dashboard/webapp/ sources the bundle was
-    # built from.  None → `<checkout>/coord/dashboard/webapp/src` for the
-    # first configured local checkout that has one.  Same `src/`-not-root
-    # reasoning as `tui_source_dir`: rooting at the webapp package root would
-    # sweep `node_modules`/`dist` were they not already skipped by name.
+    # Directory holding the `coord-web` sources the bundle was built from
+    # (#2470; before epic #2002 split the webapp out into its own repo, this
+    # was `coord/dashboard/webapp/` inside THIS repo).  None → `<checkout>/src`
+    # for this machine's `coord-web` checkout, discovered the same way
+    # `coord_web_checkout` is (see
+    # `coord.health.checks.coord_web_ci_pin.resolve_coord_web_checkout`).
+    # Same `src/`-not-root reasoning as `tui_source_dir`: rooting at the
+    # webapp package root would sweep `node_modules`/`dist` were they not
+    # already skipped by name.
     webapp_source_dir: str | None = None
     # Absolute path to the heartbeat coord-web-dist-build.sh writes on EVERY
     # invocation, whether or not there was anything to build (#2122). None →

{code_coordinator-0.5.184 → code_coordinator-0.5.186}/coord/deploy/coord-web-dist-build.service

@@ -4,13 +4,14 @@
 #
 # A systemd *user* unit, Type=oneshot, mirroring coord-drive-queue.service's
 # tick pattern (timer-fired, its own flock so a slow run can't stack).  Runs
-# deploy/coord-web-dist-build.sh, which:
+# deploy/coord-web-dist-build.sh, which (#2470: tracks the dedicated
+# `coord-web` repo, not `coord/dashboard/webapp/` inside THIS repo — see
+# docs/ADR_COORD_WEB_DIST.md; #2009: that used to be ~/src/code-coordinator,
+# back when the webapp was a subdirectory of this repo):
 #   - fetches origin/main into ~/src/coord-web (read-only — only
 #     `git fetch` + `rev-parse`, never touches that checkout's working tree
-#     or whatever branch an operator has it parked on). #2009: that used
-#     to be ~/src/code-coordinator, back when the webapp was a
-#     subdirectory of this repo,
-#   - builds that repo's ROOT at that SHA inside a DEDICATED worktree
+#     or whatever branch an operator has it parked on),
+#   - builds coord-web's repo root from that SHA inside a DEDICATED worktree
 #     (~/.coord-web-checkout, never shared with an operator or `coord drive`),
 #   - atomically repoints ~/coord-web-dist at the new build.
 #

{code_coordinator-0.5.184 → code_coordinator-0.5.186}/coord/deploy/coord-web-dist-build.timer

@@ -48,6 +48,18 @@
 # overlap the flock, in which case the next fire simply retries 10 minutes
 # later.
 #
+# #2470: this unit now tracks the dedicated `coord-web` repo's `main`
+# (deploy/coord-web-dist-build.sh's BASE_CHECKOUT/WEBAPP_CHECKOUT), not
+# `coord/dashboard/webapp/` inside THIS repo (docs/ADR_COORD_WEB_DIST.md).
+# The cadence measurement above predates that split and was taken against
+# this repo's merge history; it stays the right order-of-magnitude
+# justification for 10 minutes because `coord-web`, being a repo dedicated
+# entirely to the webapp, has EVERY merge to its `main` in-scope for a build
+# — there is no "does this commit touch webapp/ at all" filtering to do
+# anymore (the script never filtered by path either; it always rebuilt on
+# any `origin/main` SHA change, webapp-only or not — this just makes that
+# now-trivially-true for the repo it targets).
+#
 # Install: see deploy/coord-web-dist-build.sh's header, or
 # docs/PHONE_WEBAPP.md / docs/AGENT_OPERATIONS.md.
 

{code_coordinator-0.5.184 → code_coordinator-0.5.186}/coord/health/checks/deploy_lane_facts.py

@@ -38,10 +38,14 @@ wheel's version the way ``agent_venv``/``spawned_coord`` are —
 ``~/.coord-venv`` release cadence, so "is it on the released version?" is
 not a well-formed question for it. What *is* well-formed, and what this
 checks — mirroring ``tui_binary`` exactly — is whether the live bundle is
-older than the webapp source tree it claims to have been built from. Since
-#2009 (epic #2002) that source tree is a ``coord-web`` checkout rather than
-this repo's ``coord/dashboard/webapp/``; see
-:func:`resolve_webapp_source_dir` for how both layouts are located.
+older than the source tree it claims to have been built from: the
+`coord-web` repo's own checkout (#2470; retargeted from this repo's now-gone
+``coord/dashboard/webapp/`` once the webapp moved out under epic #2002 —
+see :func:`resolve_webapp_source_dir`, which shares its checkout-discovery
+convention with ``coord.health.checks.coord_web_ci_pin`` so the two checks
+can never disagree about which local checkout *is* `coord-web`, with a
+fallback to the pre-#2009 in-repo layout for a checkout still parked on a
+pre-split commit).
 """
 
 from __future__ import annotations
@@ -50,6 +54,7 @@ import subprocess
 
 from coord.dist_name import CANDIDATE_NAMES
 from coord.health.checks.agent_install import pip_show
+from coord.health.checks.coord_web_ci_pin import resolve_coord_web_checkout
 from coord.health.models import CheckResult, HealthContext, Severity
 from coord.health.registry import check
 from coord.health.units import expand, shorten_path
@@ -142,31 +147,30 @@ def resolve_webapp_build_heartbeat_path(ctx: HealthContext):
 def resolve_webapp_source_dir(ctx: HealthContext):
     """The webapp source tree in the first local checkout that has one.
 
-    Same convention as :func:`resolve_tui_source_dir`. Two layouts are
-    recognised, in this order:
-
-    1. ``<checkout>/src`` — a ``coord-web`` checkout, whose repo ROOT is the
-       webapp root (#2009, epic #2002). Gated on a sibling ``package.json``
-       so an unrelated repo that merely happens to have a top-level ``src/``
-       (any Rust or src-layout Python project in ``ctx.checkouts``) cannot be
-       mistaken for the webapp — grading the live bundle against the WRONG
-       tree would manufacture staleness rather than report it, which is the
-       exact failure ``resolve_tui_source_dir`` refuses to risk by not
-       guessing relative to the binary path.
-    2. ``<checkout>/coord/dashboard/webapp/src`` — the pre-#2009 in-repo
-       layout. Kept because a machine can legitimately still have an older
-       ``claude-coordinator`` checkout parked on a pre-split commit, and this
-       lane reporting UNKNOWN there would be a regression in signal for no
-       gain. It can only ever match a tree that genuinely is webapp source.
+    Prefers a `coord-web` checkout (#2470), discovered via
+    :func:`coord.health.checks.coord_web_ci_pin.resolve_coord_web_checkout`
+    — the same "checkout named ``coord-web``, else one carrying
+    ``playwright.acceptance.config.ts`` at its root" discovery that check
+    already uses — so `webapp_bundle` and `coord_web_ci_pin` can never
+    disagree about which local checkout is `coord-web`. That checkout's
+    ``src/`` is the webapp root (#2009, epic #2002).
+
+    Falls back to ``<checkout>/coord/dashboard/webapp/src`` — the pre-#2009
+    in-repo layout. Kept because a machine can legitimately still have an
+    older ``claude-coordinator`` checkout parked on a pre-split commit, and
+    this lane reporting UNKNOWN there would be a regression in signal for no
+    gain. Configured ``health.webapp_source_dir`` still wins outright, same
+    convention as every other path in this module.
     """
     configured = getattr(ctx.thresholds, "webapp_source_dir", None)
     if configured:
         return expand(configured, ctx.home)
+    checkout = resolve_coord_web_checkout(ctx)
+    if checkout is not None:
+        candidate = checkout / "src"
+        if candidate.is_dir():
+            return candidate
     for checkout in ctx.checkouts:
-        if (checkout.path / "package.json").is_file():
-            candidate = checkout.path / "src"
-            if candidate.is_dir():
-                return candidate
         candidate = checkout.path / "coord" / "dashboard" / "webapp" / "src"
         if candidate.is_dir():
             return candidate

{code_coordinator-0.5.184 → code_coordinator-0.5.186}/coord/health/checks/fleet_deploy_lanes.py

@@ -351,8 +351,8 @@ def probe_tui_binary(ctx: HealthContext) -> CheckResult:
     order=13,
     description=(
         "The dist/ bundle `coord web --dist` serves is not older than the "
-        "coord/dashboard/webapp/ source tree it was supposedly built from, "
-        "on every machine that has one (#1834 lane 5)."
+        "`coord-web` source tree it was supposedly built from, "
+        "on every machine that has one (#1834 lane 5, #2470)."
     ),
 )
 def probe_webapp_bundle(ctx: HealthContext) -> CheckResult:

{code_coordinator-0.5.184 → code_coordinator-0.5.186}/coord/release_verify.py

@@ -395,7 +395,7 @@ def findings_for_host(host: str, health: dict | None) -> list[Finding]:
                 )
             )
 
-    # ── webapp bundle vs coord/dashboard/webapp/ source (#1834 lane 5) ───
+    # ── webapp bundle vs coord-web's own source tree (#1834 lane 5, #2470) ─
     # Deliberately not a Lane/version comparison — see release_verify.py's
     # module docstring and coord.health.checks.fleet_deploy_lanes: the
     # bundle is versioned by origin/main's SHA on a continuous publish

{code_coordinator-0.5.184 → code_coordinator-0.5.186}/coord/reports.py

@@ -2623,6 +2623,13 @@ COMPLETED_COLUMNS = [
     "title",
     "started_at",
     "ended_at",
+    # #2472's four. Appended, never interleaved: the client addresses columns
+    # by INDEX for sorting (`reports_sort_by_column`), so inserting one in the
+    # middle would silently re-point a saved sort at a different column.
+    "legs",
+    "tokens_in",
+    "tokens_out",
+    "cost_total",
 ]
 
 # One entry per COMPLETED_COLUMNS entry, same order (#1760).
@@ -2633,14 +2640,109 @@ COMPLETED_COLUMNS = [
 # server-side report has no such screen context, and its `repo` param
 # defaults to *all repos*, so the pair has to be two real columns — which is
 # also what `issue-activity` already does, and what `RowIdentity` reads.
+#
+# #2472's spend columns reuse `_USAGE_COLUMN_META`'s labels/kinds verbatim
+# (`Legs`, `Tok In`, `Tok Out`, `Total $`) rather than inventing near-synonyms:
+# an operator reading `completed` and `usage` side by side is looking at the
+# same numbers out of the same rollup, and two spellings of "Tok In" would
+# imply otherwise.
+#
+# ONE cost column, not `usage`'s `cost_captured`/`cost_est` split. `usage`
+# splits because it is the dedicated cost report, where "some legs have no
+# captured cost, don't silently price at $0" (#1763) is the headline; here the
+# headline is still the time-range list, and a 5-column table growing to 11
+# would push `title` off a narrow pane. Both halves still ship as extra ROW
+# keys (see `_completed_spend`) — the wire contract allows row keys beyond
+# `columns`, so a client that wants the split has it without another column,
+# and `usage` remains the report to visit for it on screen.
 COMPLETED_COLUMN_META = [
     ColumnMeta(id="repo", label="Repo", kind="text"),
     ColumnMeta(id="issue", label="Issue", kind="int", align="right"),
     ColumnMeta(id="title", label="Title", kind="text", weight=3.0),
     ColumnMeta(id="started_at", label="Started", kind="timestamp"),
     ColumnMeta(id="ended_at", label="Ended", kind="timestamp"),
+    ColumnMeta(id="legs", label="Legs", kind="int", align="right", weight=0.6),
+    ColumnMeta(id="tokens_in", label="Tok In", kind="int", align="right"),
+    ColumnMeta(id="tokens_out", label="Tok Out", kind="int", align="right"),
+    ColumnMeta(id="cost_total", label="Total $", kind="money", align="right"),
 ]
 
+def _completed_spend(
+    assignment_rows: Sequence[Mapping[str, Any]], pricing: Any
+) -> dict[tuple[str, int], dict[str, Any]]:
+    """Per-issue ``legs``/tokens/cost, keyed ``(repo_name, issue_number)``.
+
+    A thin adapter over :func:`coord.usage_rollup.rollup`, **not** a second
+    cost calculator: the pricing rules, the captured-vs-estimated split and
+    the "never silently priced at $0" unknown-model rule all stay in
+    ``usage_rollup``, exactly as #1763 requires, and the numbers are shaped by
+    the same :func:`_usage_metrics` that builds a ``usage`` row.  ``legs``
+    therefore counts agent SESSIONS (every dispatch attempt and retry), which
+    is what ``GroupRollup.legs`` already means — no new arithmetic here.
+
+    One keying detail worth being explicit about: ``rollup``'s ``IssueKey``
+    books a leg to :func:`~coord.usage_rollup.row_issue_number`, i.e.
+    ``for_issue_number`` when the leg carries one (#1553's oracle-loop
+    attribution), while this fold's own ``first_dispatch``/``last_finish`` key
+    on the raw ``issue_number``.  That divergence is DELIBERATE: the whole
+    point of #2472 is that ``completed``'s cost for an issue equals what
+    ``usage`` reports for the same issue, so the cost columns must use
+    ``usage``'s attribution rule.  The timestamps keep #2454's, which is a
+    port of ``completed_rows``.
+    """
+    from coord.usage_rollup import IssueKey, TimeWindow, rollup  # noqa: PLC0415
+
+    # THE WINDOW IS UNBOUNDED — the spend figures are the issue's *lifetime*
+    # spend, not spend inside the report's own window.
+    #
+    # `completed`'s `since`/`until` filters on ENDED — "what finished in this
+    # range". An issue's legs routinely ran before that window opened (a 24h
+    # window over an issue dispatched a week ago is the normal case, not the
+    # edge case), so windowing the cost the same way would answer "what did
+    # this issue cost me *today*" under a column an operator reads as "what did
+    # finishing this issue cost me" — and would report a smaller number every
+    # time the window narrowed, for an issue whose true cost never changed.
+    # `usage` is where a windowed spend question belongs; it has a `window`
+    # param and this report does not.
+    #
+    # Consequence worth stating: an unbounded `TimeWindow` still drops a leg
+    # with NEITHER `dispatched_at` NOR `finished_at` (`leg_in_window` needs one
+    # of the two to be in range, and `contains(None)` is False). Such a row is
+    # not a session that ran — it is a row with no evidence it ever started —
+    # and `usage` excludes it on the same rule.
+    result = rollup(
+        [dict(a) for a in assignment_rows],
+        group_by="issue",
+        window=TimeWindow(),
+        pricing=pricing,
+    )
+    spend: dict[tuple[str, int], dict[str, Any]] = {}
+    for key, group in result.groups.items():
+        if not isinstance(key, IssueKey) or not key.repo_name:
+            continue
+        spend[(str(key.repo_name), int(key.issue_number))] = _usage_metrics(group)
+    return spend
+
+
+#: What a row gets when the rollup saw no legs at all for its issue — a real
+#: zero, not a missing key. An issue can be closed with no assignment ever
+#: dispatched against it (closed by hand, or fixed as a drive-by in someone
+#: else's PR), and that row's honest answer is "0 legs, $0", not a blank cell
+#: a client would have to guess the meaning of.
+_COMPLETED_NO_LEGS: dict[str, Any] = {
+    "legs": 0,
+    "tokens_in": 0,
+    "tokens_out": 0,
+    "cost_captured": 0.0,
+    "cost_est": 0.0,
+    "cost_total": 0.0,
+    "tokens_cache_read": 0,
+    "tokens_cache_creation": 0,
+    "duration_secs": 0.0,
+    "open_legs": 0,
+    "unknown_model_legs": 0,
+}
+
 
 def fold_completed(
     issues: Iterable[Mapping[str, Any]],
@@ -2650,6 +2752,8 @@ def fold_completed(
     *,
     repo: str = "",
     generated_at: float | None = None,
+    pricing: Any = None,
+    extra_notes: Sequence[str] = (),
 ) -> ReportResult:
     """Fold the board's own tables into one row per issue that *finished*
     inside ``window``.
@@ -2658,6 +2762,12 @@ def fold_completed(
     above is testable without a database (same posture as
     :func:`fold_issue_activity`).  Rows come back newest-ENDED first, which
     is #2405's default order; the client re-sorts by column head-click.
+
+    *pricing* left at ``None`` falls through to ``usage_rollup``'s built-in
+    default rates, which is correct for a unit test and **not** what the
+    runner does — :func:`run_completed` loads ``coordinator.yml`` and passes
+    the real ``pricing:`` block, the same seam :func:`fold_usage` uses and for
+    the same #1763 reason.
     """
     start, end = window
     generated_at = time.time() if generated_at is None else float(generated_at)
@@ -2719,6 +2829,8 @@ def fold_completed(
             if value is not None and value > last_finish.get(key, float("-inf")):
                 last_finish[key] = value
 
+    spend = _completed_spend(assignment_rows, pricing)
+
     rows: list[dict] = []
     no_end_time = 0
     for issue in issue_rows:
@@ -2752,6 +2864,10 @@ def fold_completed(
                 "title": str(issue.get("title") or "") or None,
                 "started_at": first_dispatch.get(key),
                 "ended_at": ended,
+                # #2472. `**` copies the pairs into this row's own dict, so
+                # the shared `_COMPLETED_NO_LEGS` constant can never end up
+                # aliased by two zero-leg rows.
+                **spend.get(key, _COMPLETED_NO_LEGS),
             }
         )
 
@@ -2760,7 +2876,7 @@ def fold_completed(
     # `sort_completed_rows` takes the same precaution for the same reason).
     rows.sort(key=lambda r: (-float(r["ended_at"]), r["repo"], r["issue"]))
 
-    notes: list[str] = []
+    notes: list[str] = list(extra_notes)
     if no_end_time:
         notes.append(
             f"{no_end_time} completed issue(s) have no end timestamp (no merged "
@@ -2774,6 +2890,27 @@ def fold_completed(
             f"No issue in this board belongs to repo {repo_filter!r} — check the "
             "coord-local repo name (the one in coordinator.yml), not the GitHub slug."
         )
+    # #1763's rule is "never silently priced at $0", and `cost_total` here is
+    # exactly the number that would go silently short. So it IS noted — but as
+    # ONE aggregate line rather than `fold_usage`'s line-per-issue: this report
+    # is a time-range list that can easily carry a hundred rows, and a hundred
+    # near-identical notes would bury the two above that are about the list
+    # itself. The per-issue breakdown is a question for `usage`, which the note
+    # names.
+    unpriced = sorted(
+        f"{r['repo']}#{r['issue']}" for r in rows if r.get("unknown_model_legs")
+    )
+    if unpriced:
+        shown = ", ".join(unpriced[:5])
+        more = f" (and {len(unpriced) - 5} more)" if len(unpriced) > 5 else ""
+        notes.append(
+            f"{len(unpriced)} issue(s) ran leg(s) on a model with no entry in "
+            f"the loaded `pricing:` config — {shown}{more}. Their tokens are "
+            "counted but that spend is NOT in `Total $` (never silently priced "
+            "at $0), so those rows read LOW. Add a rate for the model to "
+            "coordinator.yml, or run the `usage` report for the per-issue "
+            "breakdown."
+        )
 
     return ReportResult(
         report_id="completed",
@@ -2805,10 +2942,21 @@ def _default_completed_source() -> tuple[list[dict], list[dict], list[dict]]:
                 "SELECT repo_name, number, title, state FROM issues"
             ).fetchall()
         ]
+        # #2472 widens this one SELECT rather than adding a second source
+        # function: the spend columns fold out of the SAME assignment rows the
+        # timestamps do, so a second round trip would re-read the same table to
+        # get columns this one could have carried. Everything past
+        # `finished_at` is what `usage_rollup.rollup`/`leg_cost` read — token
+        # counts, the captured `cost_usd`, the `model` its estimate is keyed
+        # by, and `for_issue_number` for #1553's attribution. `type` is NOT
+        # selected: it only feeds `usage`'s per-stage drill-down, which this
+        # report does not emit.
         assignments = [
             dict(r)
             for r in conn.execute(
-                "SELECT repo_name, issue_number, dispatched_at, finished_at "
+                "SELECT repo_name, issue_number, for_issue_number, "
+                "dispatched_at, finished_at, input_tokens, output_tokens, "
+                "cache_read_tokens, cache_creation_tokens, cost_usd, model "
                 "FROM assignments"
             ).fetchall()
         ]
@@ -2834,9 +2982,10 @@ def run_completed(
         Sequence[Mapping[str, Any]],
         Sequence[Mapping[str, Any]],
     ]] | None = None,
+    pricing: Any = None,
 ) -> ReportResult:
-    """Read the board and fold it.  ``now``/``source`` are test seams
-    (mirrors :func:`run_issue_activity`); the report's own parameters are
+    """Read the board and fold it.  ``now``/``source``/``pricing`` are test
+    seams (mirrors :func:`run_issue_activity`); the report's own parameters are
     ``since``/``until``/``repo`` — the same three, with the same vocabulary
     and the same validators, that ``issue-activity`` uses."""
     generated_at = time.time() if now is None else float(now)
@@ -2844,6 +2993,15 @@ def run_completed(
     start = end - parse_duration(since)
     source_fn = _default_completed_source if source is None else source
     issues, assignments, merge_queue = source_fn()
+
+    # Same seam, same reason as `run_usage`: the estimated half of `cost_total`
+    # has to be priced off the fleet's OWN `pricing:` block, and a config that
+    # could not be loaded says so in a note instead of silently falling back
+    # (#1763).
+    extra_notes: list[str] = []
+    if pricing is None:
+        pricing, extra_notes = _load_pricing()
+
     return fold_completed(
         issues,
         assignments,
@@ -2851,6 +3009,8 @@ def run_completed(
         (start, end),
         repo=repo,
         generated_at=generated_at,
+        pricing=pricing,
+        extra_notes=extra_notes,
     )
 
 
@@ -2938,7 +3098,12 @@ COMPLETED = ReportDef(
         "merged (the PR closed it before the brain synced the close). ENDED is "
         "the merge timestamp, falling back to the last assignment to finish; "
         "STARTED is the first dispatch. Issues with no end timestamp at all "
-        "cannot be placed in a time range and are counted in a note instead."
+        "cannot be placed in a time range and are counted in a note instead. "
+        "Each row also carries what it cost: LEGS is how many agent sessions "
+        "(dispatches and retries) ran against the issue, and the token and "
+        "dollar figures are the issue's WHOLE-LIFE spend — not just the part "
+        "inside this window — so narrowing the range never shrinks them. Use "
+        "the `usage` report for windowed spend or the captured/estimated split."
     ),
     params=(
         # The same three params, the same vocabulary and the same validators

{code_coordinator-0.5.184 → code_coordinator-0.5.186}/deploy/coord-web-dist-build.service

@@ -4,13 +4,14 @@
 #
 # A systemd *user* unit, Type=oneshot, mirroring coord-drive-queue.service's
 # tick pattern (timer-fired, its own flock so a slow run can't stack).  Runs
-# deploy/coord-web-dist-build.sh, which:
+# deploy/coord-web-dist-build.sh, which (#2470: tracks the dedicated
+# `coord-web` repo, not `coord/dashboard/webapp/` inside THIS repo — see
+# docs/ADR_COORD_WEB_DIST.md; #2009: that used to be ~/src/code-coordinator,
+# back when the webapp was a subdirectory of this repo):
 #   - fetches origin/main into ~/src/coord-web (read-only — only
 #     `git fetch` + `rev-parse`, never touches that checkout's working tree
-#     or whatever branch an operator has it parked on). #2009: that used
-#     to be ~/src/code-coordinator, back when the webapp was a
-#     subdirectory of this repo,
-#   - builds that repo's ROOT at that SHA inside a DEDICATED worktree
+#     or whatever branch an operator has it parked on),
+#   - builds coord-web's repo root from that SHA inside a DEDICATED worktree
 #     (~/.coord-web-checkout, never shared with an operator or `coord drive`),
 #   - atomically repoints ~/coord-web-dist at the new build.
 #

{code_coordinator-0.5.184 → code_coordinator-0.5.186}/deploy/coord-web-dist-build.sh

@@ -1,19 +1,26 @@
 #!/usr/bin/env bash
 #
-# coord-web-dist-build.sh — build the `coord-web` webapp from its merged
-# `main` into a directory `coord web --dist` serves, WITHOUT touching
-# ~/.coord-venv (#1543).
+# coord-web-dist-build.sh — build the React webapp from the `coord-web`
+# repo's merged `main` into a directory `coord web --dist` serves, WITHOUT
+# touching ~/.coord-venv (#1543; retargeted at `coord-web` by #2470 once the
+# webapp moved out of THIS repo into its own, epic #2002 — see
+# docs/ADR_COORD_WEB_DIST.md for the decision. Before #2470 this built
+# `coord/dashboard/webapp` out of a `claude-coordinator` checkout; the
+# mechanism below is otherwise unchanged, only which repo it points at).
 #
 # Why this exists: coord-web, coord-agent and coord-serve all `ExecStart`
 # from the SAME ~/.coord-venv, so "ship a webapp change" used to mean
 # `pip install --upgrade code-coordinator` on that venv — which also
 # upgrades the board daemon and the agent runtime on that host, and
 # `coord agent update` is already known to kill running headless workers
-# (see the #1543 issue body). This script decouples the two: it keeps an
-# independent worktree of the webapp's repo, builds it from merged main into
-# a fresh release directory named after the SHA, and atomically repoints a
-# symlink at it. `coord web --dist ~/coord-web-dist` (see
-# deploy/coord-web.service) always points at that symlink.
+# (see the #1543 issue body). This script decouples the two: it keeps a
+# DEDICATED clone of the `coord-web` repo (never an operator's own
+# `~/src/coord-web` dev checkout's working tree — same "never the checkout
+# someone else is using" rule this script has always applied to the repo it
+# builds from), builds it from merged main into a fresh, timestamped release
+# directory, and atomically repoints a symlink at it. `coord web --dist
+# ~/coord-web-dist` (see deploy/coord-web.service) always points at that
+# symlink.
 #
 # #2009 (epic #2002) — WHICH repo this builds changed, nothing else did.
 # Until the split, `$BASE_CHECKOUT` was a checkout of *claude-coordinator*
@@ -28,11 +35,12 @@
 # file (#2122) all carry over untouched, because none of them ever depended
 # on which repo the source came from.
 #
-# ONE thing does still come from claude-coordinator: the health check boots a
-# real `coord web --fixture` and needs that repo's board fixture JSON, which
-# `coord-web` has no copy of. `$COORD_CHECKOUT` (default
-# `$SRC_ROOT/code-coordinator`) is where it is read from — set
-# `$HEALTH_CHECK_FIXTURE` directly on a host that keeps no such checkout.
+# The health check boots a real `coord web --fixture` and needs a board
+# fixture JSON for it — `coord-web` vendored its own copy of the one
+# `e2e/fixtureServer.ts` already uses (post-#2005 split, commit 7e0bf5b), so
+# this reads `$WEBAPP_CHECKOUT/e2e/fixtures/board-pipeline-basic.json` and
+# has no dependency on a claude-coordinator checkout being present. Set
+# `$HEALTH_CHECK_FIXTURE` directly to override.
 #
 # NO RESTART of coord-web is required after the first build. Starlette's
 # StaticFiles/FileResponse re-resolve the directory on every request (see
@@ -45,14 +53,21 @@
 # once, THEN start/enable coord-web.
 #
 # Safe to run unattended on a timer (see coord-web-dist-build.timer): it
-# never touches ~/.coord-venv, ~/src/coord-web's own checkout (it
-# uses a DEDICATED `git worktree`, so it can't collide with whatever branch
-# an operator has that checkout parked on — same reasoning as `coord drive`'s
-# worktree isolation), or any running coord-agent/coord-serve/coord-web
-# process. A `flock` guards against overlapping runs; a same-SHA re-run is a
-# fast no-op.
+# never touches ~/.coord-venv or $BASE_CHECKOUT's working tree (only
+# `git fetch`/`rev-parse` run there — the actual build happens in a
+# SEPARATE, DEDICATED `git worktree`, $WEBAPP_CHECKOUT, so it can't collide
+# with whatever branch an operator has $BASE_CHECKOUT parked on — same
+# reasoning as `coord drive`'s worktree isolation), or any running
+# coord-agent/coord-serve/coord-web process. A `flock` guards against
+# overlapping runs; a same-SHA re-run is a fast no-op.
 #
-# Install:
+# Install: $BASE_CHECKOUT (default ~/src/coord-web) must be a real, already-
+# cloned `coord-web` checkout before the first run — this script only
+# fetches/rev-parses/worktrees off it, it never `git clone`s one into
+# existence. Use a checkout dedicated to this deploy lane if the operator
+# also keeps their own `coord-web` dev checkout elsewhere on this box.
+#
+#   git clone <coord-web-remote> ~/src/coord-web   # one-time, if not already there
 #   cp deploy/coord-web-dist-build.sh ~/.local/bin/   # or run in place
 #   chmod +x ~/.local/bin/coord-web-dist-build.sh
 #   ~/.local/bin/coord-web-dist-build.sh               # first build, before
@@ -116,6 +131,12 @@
 
 set -uo pipefail
 
+# #2470: tracks the `coord-web` repo's main, not this repo's — see the
+# header. $BASE_CHECKOUT is read-only from this script's point of view (only
+# `git fetch`/`rev-parse`/`worktree add` ever touch it, never `checkout`), so
+# an operator's own `coord-web` dev checkout at the default path is safe in
+# principle, but a checkout dedicated to this deploy lane is still the
+# documented install step — see the header's "Install" section.
 SRC_ROOT="${SRC_ROOT:-$HOME/src}"
 # #2009: the webapp's repo, not claude-coordinator's. See the header.
 REPO_NAME="${REPO_NAME:-coord-web}"
@@ -126,10 +147,6 @@ BRANCH="${BRANCH:-main}"
 # hard-coded `coord/dashboard/webapp`, and stays configurable so a future
 # monorepo layout needs an env var rather than an edit here.
 WEBAPP_SUBDIR="${WEBAPP_SUBDIR:-}"
-# claude-coordinator's checkout — needed ONLY for the health-check fixture
-# below, which lives in that repo's tests/fixtures/ and has no coord-web
-# equivalent. Not fetched, not built, not written to.
-COORD_CHECKOUT="${COORD_CHECKOUT:-$SRC_ROOT/code-coordinator}"
 
 # A worktree DEDICATED to this script — never the same directory an operator
 # or `coord drive` worktree might be using, and never checked out over a
@@ -168,9 +185,20 @@ HEALTH_CHECK_PORT="${HEALTH_CHECK_PORT:-18434}"
 HEALTH_CHECK_TIMEOUT_SECS="${HEALTH_CHECK_TIMEOUT_SECS:-20}"
 # The reference seeded board (#1538) — deterministic, no DB/fleet/network, so
 # the scratch instance below never touches ~/.coord/coord.db or races the
-# real coord-web/coord-serve/coord-agent processes. Defaults to the fixture
-# AT THE SHA BEING DEPLOYED (via $WEBAPP_CHECKOUT), so the fixture schema
-# always matches the server code that will parse it.
+# real coord-web/coord-serve/coord-agent processes. Defaults to the copy
+# checked into $WEBAPP_CHECKOUT (the `coord-web` SHA being deployed) at
+# `e2e/fixtures/board-pipeline-basic.json` — that is where the fixture
+# actually lives in the `coord-web` repo (`git ls-tree -r --name-only
+# origin/main` has no `tests/` directory at all post-split). NOTE:
+# `coord-web`'s own `playwright.acceptance.config.ts` still has a stale
+# `DEFAULT_FIXTURE` pointing at the old `tests/fixtures/...` path (a
+# leftover `REPO_ROOT` miscalculation from before the repo split — see
+# docs/ADR_COORD_WEB_DIST.md) so do NOT use that config as the source of
+# truth for this path; this comment documents the real, verified location
+# instead (#2470). This is never a claim that the fixture matches the
+# INSTALLED `coord`'s server code, which post-#2002-split is versioned
+# independently (see docs/ADR_COORD_WEB_DIST.md, "Staleness across the
+# split").
 HEALTH_CHECK_FIXTURE="${HEALTH_CHECK_FIXTURE:-}"
 
 say() { echo "[$(date -Is)] $*" >&2; }
@@ -220,9 +248,7 @@ health_check_release() {
     return 1
   fi
 
-  # #2009: read from claude-coordinator's checkout, not $WEBAPP_CHECKOUT —
-  # the fixture is a coord *board* fixture and never moved to coord-web.
-  fixture="${HEALTH_CHECK_FIXTURE:-$COORD_CHECKOUT/tests/fixtures/board-pipeline-basic.json}"
+  fixture="${HEALTH_CHECK_FIXTURE:-$WEBAPP_CHECKOUT/e2e/fixtures/board-pipeline-basic.json}"
   if [[ ! -f "$fixture" ]]; then
     say "ERROR: health-check fixture missing: $fixture — cannot health-check $release_dir"
     return 1