code-coordinator 0.5.120__tar.gz → 0.5.124__tar.gz

{code_coordinator-0.5.120 → code_coordinator-0.5.124}/PKG-INFO

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

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

@@ -784,7 +784,9 @@ tests/acceptance/ms-51/home-active.spec.ts
 tests/acceptance/ms-51/manifest.yml
 tests/acceptance/ms-51/tsconfig.json
 tests/acceptance/ms-51/mocks/home-active.html
+tests/acceptance/ms-65/board_tabs_2282.rs
 tests/acceptance/ms-65/contract.md
+tests/acceptance/ms-65/manifest.yml
 tests/acceptance/ms-65/mocks/board-baseline-no-tabs.screen
 tests/acceptance/ms-65/mocks/board-pinned-3-tabs.screen
 tests/acceptance/ms-65/mocks/board-preview-tab.screen

{code_coordinator-0.5.120 → code_coordinator-0.5.124}/code_coordinator.egg-info/scm_file_list.json

@@ -429,7 +429,9 @@
     "tests/acceptance/ms-51/manifest.yml",
     "tests/acceptance/ms-51/mocks/home-active.html",
     "tests/acceptance/ms-51/tsconfig.json",
+    "tests/acceptance/ms-65/board_tabs_2282.rs",
     "tests/acceptance/ms-65/contract.md",
+    "tests/acceptance/ms-65/manifest.yml",
     "tests/acceptance/ms-65/mocks/board-baseline-no-tabs.screen",
     "tests/acceptance/ms-65/mocks/board-pinned-3-tabs.screen",
     "tests/acceptance/ms-65/mocks/board-preview-tab.screen",

{code_coordinator-0.5.120 → code_coordinator-0.5.124}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.120",
+  "tag": "0.5.124",
   "distance": 0,
-  "node": "g73a6cc8774d10c7a9a405ba25bd93f772ff445ab",
+  "node": "g6db81a3b5b4ce09b2be4da91abbbe348a1fdebc7",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-17"

{code_coordinator-0.5.120 → code_coordinator-0.5.124}/coord/acceptance.py

@@ -361,7 +361,34 @@ def load_manifest(acceptance_root: Path) -> dict[str, int]:
     return mapping
 
 
-def load_expected_red(acceptance_root: Path) -> dict[str, int]:
+def _driver_kind_for_manifest_dir(ms_dir: Path) -> str | None:
+    """Best-effort LOCAL driver-kind lookup for one ``ms-NN``/``issue-NN``
+    acceptance directory, via its ``mocks/`` file extensions
+    (:data:`MOCK_EXT_TO_DRIVER_KIND`) — the filesystem counterpart of
+    :func:`resolve_for_path`'s GitHub-backed lookup, for callers that
+    already have a local checkout and don't want a network round trip.
+
+    Returns ``None`` (unknown) rather than guessing when ``mocks/`` is
+    absent, empty, or its files imply more than one kind — callers MUST
+    treat ``None`` as "don't exclude", never as "safe to skip": this feeds
+    a hard-failure check (:func:`load_expected_red`), and silently
+    dropping a manifest because its kind couldn't be determined would hide
+    the exact class of bug that check exists to catch.
+    """
+    mocks_dir = ms_dir / "mocks"
+    if not mocks_dir.is_dir():
+        return None
+    kinds = {
+        MOCK_EXT_TO_DRIVER_KIND[p.suffix]
+        for p in mocks_dir.iterdir()
+        if p.suffix in MOCK_EXT_TO_DRIVER_KIND
+    }
+    return next(iter(kinds)) if len(kinds) == 1 else None
+
+
+def load_expected_red(
+    acceptance_root: Path, *, driver_kind: str | None = None
+) -> dict[str, int]:
     """Merge every ``ms-NN/manifest.(yml|json)``'s ``expected_red:`` block
     under *acceptance_root* into one ``{test_id: issue_number}`` mapping
     (#2164) — the flat shape :func:`apply_expected_red` and the ``coord
@@ -369,9 +396,28 @@ def load_expected_red(acceptance_root: Path) -> dict[str, int]:
 
     Mirrors :func:`load_manifest`'s merge/empty-dict/last-writer-wins
     conventions exactly, just reading ``expected_red`` instead of ``tests``.
+
+    *driver_kind* (#2339): when given, a manifest whose own directory
+    resolves (via :func:`_driver_kind_for_manifest_dir`) to a DIFFERENT
+    driver kind is skipped entirely. A repo routes different milestones to
+    different drivers (``coord/**`` -> cli-pytest, ``tui/**`` ->
+    tui-tuidriver, ...), but a single ``coord acceptance run --for-path X
+    --all`` invocation only ever executes ONE of them — before this
+    parameter existed, the merged registry always spanned every driver, so
+    every milestone's ``expected_red`` ids that belonged to a DIFFERENT
+    driver than the one actually running were reported as
+    ``missing_expected_red_ids`` (a hard, un-waivable CI failure) on every
+    single run, for every repo with more than one routed driver kind, the
+    moment two milestones used different drivers. A directory whose kind
+    can't be determined (see above) is always included, matching the
+    unfiltered (``driver_kind=None``) behaviour this defaults to.
     """
     mapping: dict[str, int] = {}
     for path in _manifest_paths(acceptance_root):
+        if driver_kind is not None:
+            resolved = _driver_kind_for_manifest_dir(path.parent)
+            if resolved is not None and resolved != driver_kind:
+                continue
         try:
             data = parse_manifest_text(path.read_text(), source=str(path))
         except OSError as e:

{code_coordinator-0.5.120 → code_coordinator-0.5.124}/coord/agent.py

@@ -3186,6 +3186,17 @@ not apply to it.
 - If even the scoped run genuinely cannot finish in time, follow the \
 background-and-poll pattern in the ONE-SHOT section above — do not invent \
 a chunk-and-loop workaround.
+- #2192: check your own diff now — does it change user-visible behavior \
+AND add/modify zero test files? That exact pattern was 18.5% of this \
+repo's blocking reviews (#2132): the code was correct, but CLAUDE.md's \
+"Testing — black-box coverage is the acceptance bar" rule was skipped, so \
+the adversarial reviewer rejected it — costing a paid review leg plus a \
+fix + re-review round trip to catch something you can see for free right \
+now, in this same already-running session. If it fires, add the test \
+before declaring done. If this genuinely is a pure refactor / \
+internal-only change (CLAUDE.md's existing exemption), say so explicitly \
+in your final message instead — that already satisfies the reviewer, no \
+test required.
 
 #252: before exiting, emit a SMOKE_TESTS block telling the human what to \
 manually verify.  You changed the code; you know what's worth poking.

{code_coordinator-0.5.120 → code_coordinator-0.5.124}/coord/commands/acceptance.py

@@ -301,7 +301,16 @@ def acceptance_run(
         )
 
     if ci_mode:
-        expected_red = load_expected_red(cwd / ACCEPTANCE_DIRNAME)
+        # #2339: scope the expected_red registry to milestones this run's
+        # OWN driver could actually produce results for — a routed repo's
+        # `--all --ci` used to merge every milestone's expected_red
+        # regardless of which driver `--for-path` resolved, so every OTHER
+        # driver's ids always came back `missing_expected_red_ids` (a hard
+        # CI failure) the moment the repo had more than one driver kind in
+        # use. See coord.acceptance.load_expected_red's docstring.
+        expected_red = load_expected_red(
+            cwd / ACCEPTANCE_DIRNAME, driver_kind=driver_cfg.kind,
+        )
         verdict = apply_expected_red(verdict, set(expected_red))
         click.echo(json.dumps(verdict, indent=2))
         hard_failure = expected_red_failure_summary(verdict)

{code_coordinator-0.5.120 → code_coordinator-0.5.124}/coord/commands/plan_followup.py

@@ -787,8 +787,9 @@ def _fix_from_review(
 @click.command(
     help=(
         "Dispatch a headless same-branch fix worker.\n\n"
-        "ASSIGNMENT_ID is either a WORK assignment whose test gate FAILED (or "
-        "whose PR has red CI), or a REVIEW assignment whose verdict was "
+        "ASSIGNMENT_ID is either a WORK assignment whose test gate FAILED "
+        "(or whose PR has red CI, or whose oracle-loop acceptance trust "
+        "gate FAILED — #2344), or a REVIEW assignment whose verdict was "
         "request-changes. Either way the fix lands on the ORIGINAL branch and "
         "updates the ORIGINAL PR — no new issue-N-* branch, no orphan PR."
     )
@@ -802,12 +803,12 @@ def _fix_from_review(
     help=(
         "Override the #555 interactive-work exclusion when fixing a review of "
         "work that ran under claude-pty, or (#2051) dispatch a WORK-row fix "
-        "when neither the test verdict nor a live CI read shows a failure — "
-        "for when the caller knows the PR is red but the check missed it "
-        "(ci_store not configured, a transient read error). Since #2091 the "
-        "refusal names which of those it was, so check the `note:` line "
-        "before reaching for this. Does NOT override max_review_iterations "
-        "or the #522 terminal-work guard."
+        "when neither the test verdict, a live CI read, nor the acceptance "
+        "trust gate shows a failure — for when the caller knows the PR is red "
+        "but the check missed it (ci_store not configured, a transient read "
+        "error). Since #2091 the refusal names which of those it was, so "
+        "check the `note:` line before reaching for this. Does NOT override "
+        "max_review_iterations or the #522 terminal-work guard."
     ),
 )
 def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> None:
@@ -837,10 +838,27 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
     # `smoke_test=NULL` and must still be fixable.
     test_failed = assignment.test_state == "failed" or assignment.smoke_test == "fail"
 
+    # #2344: the oracle-loop TRUST GATE (docs/ORACLE_LOOP.md, #2199) is a
+    # fourth door onto this command. `_decide_acceptance_gate`
+    # (coord/drive.py) dispatches `coord fix <work_aid>` the instant the
+    # gate's coordinator-run re-run of the sealed suite comes back red — the
+    # same shape as `_decide_test` dispatching on a failed Test verdict.
+    # Before this, nothing here recognized that door: a milestone whose
+    # trust gate failed in isolation (Test not yet run, or already passed;
+    # CI green) hit the #2051 "expected a failed test verdict" refusal on
+    # every attempt — structurally unwinnable, not a transient miss — until
+    # the drive-queue entry parked after burning its retry budget (ms-65 /
+    # #2282, observed live 2026-08-17).
+    acceptance_failed = assignment.acceptance_state == "failed"
+
     # #1622 (part 3): red CI is the third trigger.  Only consulted when the
     # local test gate has NOT already failed, so the cheap in-DB path stays
-    # zero-I/O and the existing failure story keeps priority.
-    ci_read = CiRead() if test_failed else _read_ci(cfg, assignment)
+    # zero-I/O and the existing failure story keeps priority. #2344: same
+    # treatment for a failed trust gate — it is definitive evidence on its
+    # own, so skip the live CI read entirely rather than let a green CI read
+    # (which says nothing about the trust gate's sealed-suite re-run) shadow
+    # it below.
+    ci_read = CiRead() if (test_failed or acceptance_failed) else _read_ci(cfg, assignment)
     ci_story = ci_read.story
 
     # #2091: the stored Test verdict says PASSED while the branch's live CI
@@ -876,8 +894,9 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
             err=True,
         )
 
-    # #2051: none of the three doors (failed test verdict, red CI, or the
-    # review-id door handled above) is open.  `_read_ci` is read-only and
+    # #2051 (extended by #2344): none of the four doors (failed test
+    # verdict, red CI, a failed acceptance trust gate, or the review-id door
+    # handled above) is open.  `_read_ci` is read-only and
     # fail-quiet (see :class:`CiRead`) — a missing story means "no CI
     # evidence of a failure", never "CI is green" — so a caller who KNOWS
     # the PR is red (ci_store not configured for this repo, a transient
@@ -886,15 +905,16 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
     # that caller's release valve; it is NOT a way to skip the #555 / #522 /
     # max_review_iterations guards, which sit elsewhere.
     forced_without_evidence = False
-    if not test_failed and ci_story is None:
+    if not test_failed and not acceptance_failed and ci_story is None:
         if not force:
             click.echo(
                 f"error: assignment {assignment_id} test_state is "
                 f"{assignment.test_state!r} / smoke_test is "
-                f"{assignment.smoke_test!r}, expected a failed test verdict "
-                "(or red CI on its PR, or a request-changes review id). If "
-                "the PR is actually red and this check missed it, re-run "
-                "with --force.",
+                f"{assignment.smoke_test!r} / acceptance_state is "
+                f"{assignment.acceptance_state!r}, expected a failed test "
+                "verdict (or red CI on its PR, a failed acceptance trust "
+                "gate, or a request-changes review id). If the PR is "
+                "actually red and this check missed it, re-run with --force.",
                 err=True,
             )
             # #2091: say WHY there is no CI evidence.  Before this, six
@@ -940,6 +960,14 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
     test_output_file = COORD_DIR / "test_output" / f"{assignment_id}.txt"
     if ci_story is not None:
         test_output = ci_story
+    elif acceptance_failed and not test_failed:
+        # #2344: the trust gate's own recorded reason is the evidence for
+        # this door — `coord acceptance record` writes it to
+        # `acceptance_reason` at the same time it flips `acceptance_state`
+        # to "failed" (coord/state.py). Neither the CI-story nor the
+        # smoke/test-reason fallbacks below apply here: this door fires
+        # precisely when Test/CI are NOT what's red.
+        test_output = assignment.acceptance_reason or ""
     elif test_output_file.exists():
         test_output = test_output_file.read_text()
     elif assignment.smoke_test_reason or assignment.test_reason:
@@ -965,6 +993,9 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
             "red)"
         )
         _failure_heading = "Reported failure (--force, unverified)"
+    elif acceptance_failed and not test_failed and ci_story is None:
+        _what = "a failed oracle-loop acceptance trust gate (#2199)"
+        _failure_heading = "Acceptance trust-gate failure"
     else:
         _what = "red CI" if ci_story is not None else "a failed smoke test"
         _failure_heading = "CI failure" if ci_story is not None else "Test failure"

{code_coordinator-0.5.120 → code_coordinator-0.5.124}/coord/review.py

@@ -1273,6 +1273,108 @@ def _diff_paths_outside_sealed(diff_text: str, sealed_paths: list[str]) -> list[
     )
 
 
+# ── #2192: free pre-review "missing test" nudge ─────────────────────────────
+#
+# #2132 classified 27 request-changes verdicts on this repo and found 5/27
+# (18.5%) were "missing required black-box test only" — the code was correct,
+# but the diff changed user-visible behavior and shipped no test, which
+# CLAUDE.md's "Testing — black-box coverage is the acceptance bar" section
+# already requires. Each one cost a full paid review leg plus a fix +
+# re-review round trip to catch a pattern a static check can see for free.
+#
+# This is intentionally a coarse, path-only heuristic — no diff semantics, no
+# ``claude -p`` call, no LLM judgment, just the same cheap file-path
+# inspection ``_diff_file_paths``/``_diff_touched_sealed_paths`` already do
+# above. It is a NUDGE, not a gate: callers only ever log it, never act on it
+# to change dispatch behavior, so a false positive costs nothing (the
+# reviewer remains the sole authority and, per CLAUDE.md, already honors a
+# PR that says it's a pure refactor / internal-only change).
+#
+# The caller (``dispatch_review``) logs the result at ``log.warning``, not
+# ``log.info`` — this repo has no ``logging.basicConfig`` anywhere outside
+# tests, so the root logger stays at the default WARNING floor with no
+# handler attached and an INFO record never reaches anyone. WARNING clears
+# that floor and reaches Python's handler-of-last-resort (stderr) with zero
+# configuration. See the comment at the call site for the empirical check.
+
+_TEST_BASENAME_PREFIXES = ("test_",)
+_TEST_BASENAME_SUFFIXES = (
+    "_test.py", "_test.rs",
+    ".test.ts", ".test.tsx", ".spec.ts", ".spec.tsx",
+)
+_TEST_BASENAME_EXACT = ("conftest.py",)
+# Matched against the path with a leading "/" prepended, so both a
+# repo-root prefix ("tests/foo.py" -> "/tests/foo.py") and a nested
+# directory ("tui/tests/foo.rs" -> "/tui/tests/foo.rs") are caught by the
+# same substring check.
+_TEST_PATH_SEGMENTS = ("/tests/", "/test/", "/__tests__/", "/e2e/")
+
+# Paths under these prefixes are internal tooling/docs, never shipped
+# product behavior — CLAUDE.md's "internal-only changes are exempt" carve-out,
+# expressed as the only thing a pure diff inspection can see: file location.
+_NON_USER_VISIBLE_PATH_PREFIXES = (
+    "docs/", "scripts/", "deploy/", ".github/", ".claude/", "graphify-out/",
+)
+_USER_VISIBLE_SUFFIXES = (".py", ".rs", ".ts", ".tsx", ".js", ".jsx")
+
+
+def _is_test_path(path: str) -> bool:
+    """Does *path* look like a test file, by name/location alone?
+
+    NOTE (#2192 review follow-up): ``coord/split_work.py``'s ``_is_test_file``
+    answers a similarly-shaped question with a narrower, Python-only rule
+    set, for chunk-splitting rather than this module's review nudge. See
+    that function's docstring for why the two aren't unified yet.
+    """
+    lower = path.lower()
+    base = lower.rsplit("/", 1)[-1]
+    if base in _TEST_BASENAME_EXACT:
+        return True
+    if any(base.startswith(p) for p in _TEST_BASENAME_PREFIXES):
+        return True
+    if any(base.endswith(s) for s in _TEST_BASENAME_SUFFIXES):
+        return True
+    return any(seg in f"/{lower}" for seg in _TEST_PATH_SEGMENTS)
+
+
+def _is_user_visible_path(path: str) -> bool:
+    """Does *path* look like shipped source (not test, not internal tooling)?"""
+    lower = path.lower()
+    if _is_test_path(lower):
+        return False
+    if any(lower.startswith(p) for p in _NON_USER_VISIBLE_PATH_PREFIXES):
+        return False
+    return any(lower.endswith(s) for s in _USER_VISIBLE_SUFFIXES)
+
+
+def diff_missing_test_coverage(diff_text: str | None) -> bool:
+    """#2192: True when *diff_text* touches user-visible source and zero
+    test files, the pattern behind 18.5% of #2132's blocking reviews.
+
+    Pure, free, deterministic path inspection — reuses :func:`_diff_file_paths`.
+    Returns False (never flags) when the diff is empty, touches no recognized
+    source file (docs-only/internal-tooling-only diffs — CLAUDE.md's
+    internal-only exemption), or already includes a test-file change.
+
+    The CLAUDE.md exemption is honored only at the granularity a path-only
+    heuristic can see: whole file *types/locations* (``docs/``, ``scripts/``,
+    non-source suffixes, ...), not genuine behavior-preserving refactors of
+    shipped source. A true pure refactor of a ``.py``/``.rs``/``.ts`` file
+    (e.g. renaming a local variable) with no test changes still flags —
+    harmless today since the caller only ever logs this, never gates on it,
+    but worth knowing if a caller ever starts acting on the result: at that
+    point this function would honor a narrower exemption than CLAUDE.md's
+    own text, which is about intent ("pure refactor / internal-only"), not
+    file location.
+    """
+    if not diff_text or not diff_text.strip():
+        return False
+    paths = _diff_file_paths(diff_text)
+    if not any(_is_user_visible_path(p) for p in paths):
+        return False
+    return not any(_is_test_path(p) for p in paths)
+
+
 def build_review_briefing(
     *,
     pr_number: int | None,
@@ -2063,6 +2165,30 @@ def dispatch_review(
     fetch_body = issue_body_fetcher or _fetch_issue_body
     issue_body = fetch_body(repo.github, completed.issue_number)
 
+    # #2192: free pre-review nudge (see diff_missing_test_coverage docstring).
+    # Logged only, ahead of the paid reviewer dispatch below — never gates,
+    # never denies, never mutates `completed`. A false positive here must
+    # never cost a round trip, so nothing downstream reads this.
+    #
+    # Deliberately `log.warning`, not `log.info` (#2192 review follow-up):
+    # this repo has zero `logging.basicConfig`/`setLevel`/`addHandler` calls
+    # outside tests (see coord/interactive.py:888-898's #865 note on the same
+    # trap), so the root logger sits at Python's default WARNING floor with
+    # no handler attached — an `INFO` record is filtered before it reaches
+    # anywhere and is a silent no-op under every real entry point (`coord
+    # serve`, `coord notify`, `reconcile()`). `WARNING` clears that floor and
+    # is picked up by `logging`'s handler-of-last-resort, which prints
+    # straight to stderr with zero configuration — confirmed empirically:
+    # `logging.getLogger("coord.review").warning(...)` in a bare subprocess
+    # writes to stderr; `.info(...)` writes nothing.
+    if diff_missing_test_coverage(full_diff_text):
+        log.warning(
+            "[review] %s: diff touches user-visible source with zero test "
+            "files changed — matches #2132's 'missing test only' pattern "
+            "(free static check, non-blocking; dispatching review as normal)",
+            completed.assignment_id,
+        )
+
     # #1811: does the resolved review provider share the worker's model
     # family? ``completed.provider_name`` is the *resolved* name recorded at
     # work-dispatch time (spec > repo > providers.default); ``None`` means a
@@ -2834,6 +2960,13 @@ def dispatch_scoped_review(
     not the prior reviewer) so the scoped review stays independent of the
     code it's judging, mirroring :func:`dispatch_review`'s
     ``completed.machine_name`` contract.
+
+    Does NOT run the #2192 "missing test coverage" nudge that
+    :func:`dispatch_review` does ahead of its dispatch — intentional, not an
+    oversight: this path only fires after a conflict-fix rebase where a full
+    review (nudge included) already happened against the whole PR, and the
+    delta reviewed here is scoped to just the rebase's own resolution, not
+    the PR's original feature diff.
     """
     if not config.reviews.enabled or not config.reviews.auto_dispatch:
         return None

{code_coordinator-0.5.120 → code_coordinator-0.5.124}/coord/split_work.py

@@ -30,7 +30,19 @@ class WorkChunk:
 # ---------------------------------------------------------------------------
 
 def _is_test_file(f: str) -> bool:
-    """Return True if the file is a test file."""
+    """Return True if the file is a test file.
+
+    NOTE (#2192 review follow-up): ``coord/review.py``'s ``_is_test_path``
+    answers a similarly-shaped question (Rust/TS/JS suffixes, nested
+    ``tests/`` dirs, ``conftest.py``, ``__tests__/``/``e2e/``) but for a
+    different downstream consumer — that one gates a free pre-review nudge,
+    this one drives chunk assignment for large-diff splitting. Deliberately
+    NOT unified yet: broadening this classifier to match the other one would
+    change which files get treated as "test files" during chunk splitting,
+    a behavior change out of scope for #2192. Flagged per the repo's "one
+    question, one answer" rule (epic #2096) as worth consolidating into one
+    shared helper if the two questions ever turn out to be the same one.
+    """
     p = Path(f)
     return (
         len(p.parts) > 0 and p.parts[0] in ("tests", "test")