code-coordinator 0.5.559__tar.gz → 0.5.560__tar.gz

{code_coordinator-0.5.559 → code_coordinator-0.5.560}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.559",
+  "tag": "0.5.560",
   "distance": 0,
-  "node": "gdb53efc5211a6f969b2f3a6c6686b3b561821626",
+  "node": "g5666afa7cb4eb204e33eebc0db6a4970b8c18242",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-02"

{code_coordinator-0.5.559 → code_coordinator-0.5.560}/coord/drive.py

@@ -1006,16 +1006,19 @@ class OracleDecision:
     — the argument :func:`_decide_acceptance_author` needs to build ``coord
     acceptance author <repo> <tracking_issue> --issue <N>``.
 
-    #2199: ``issue_exempt`` — resolved alongside ``active`` (same one-shot
-    GitHub fetch budget: ``AcceptanceGateChecker.is_issue_exempt`` reuses the
-    #1138 hard gate's own manifest read) — is *this issue*'s
-    ``manifest.exempt``/``oracle:exempt`` opt-out from the sealed suite.
-    :func:`_decide_acceptance_gate` (the trust gate) skips entirely when
-    this is ``True``: an exempt issue has no authored slice for `coord
-    acceptance record` to re-run, so treating its absence as a red verdict
-    would be exactly the "acquire a new blocking gate it never opted into"
-    regression #2199's acceptance criteria rule out. Always ``False`` when
-    ``active`` is ``False`` — meaningless outside the oracle loop.
+    #2199/#2171: ``issue_exempt`` — resolved alongside ``active`` (same
+    one-shot GitHub fetch budget: ``AcceptanceGateChecker.is_issue_exempt``
+    reuses the #1138 hard gate's own manifest read) — is *this issue*'s
+    ``manifest.exempt``/``oracle:exempt`` opt-out from the sealed suite. An
+    exempt issue makes :func:`resolve_oracle_decision` return ``active=False``
+    (#2171 — it has no slice for a `test-author` session to write, so
+    JIT-authoring must not run either), with ``issue_exempt=True`` and
+    ``reason`` naming the exemption for the preflight banner. ``True`` only
+    ever coincides with ``active=False`` by construction; kept as its own
+    field (rather than inferred from ``reason``) so
+    :func:`_decide_acceptance_gate` and :func:`_dispatch_work_stage` can
+    check it directly and defensively, without parsing prose. ``False``
+    when the issue is not exempt, whatever ``active`` is.
     """
 
     active: bool
@@ -1094,6 +1097,24 @@ def resolve_oracle_decision(
     issue_exempt = gate_checker.is_issue_exempt(
         state.repo, state.milestone_number, state.issue, state.issue_labels,
     )
+    if issue_exempt:
+        # #2171: an issue in `manifest.exempt`/labelled `oracle:exempt` has
+        # no sealed slice for a `type="test-author"` session to write — the
+        # #1138 hard gate (`issue_oracle_ready`) would never block its Work
+        # dispatch on one either. Returning INACTIVE here (not just setting
+        # `issue_exempt=True` on an active decision) means BOTH downstream
+        # gates fall through to a normal drive: `_dispatch_work_stage`
+        # dispatches Work directly instead of authoring first, and
+        # `_decide_acceptance_gate`'s trust gate never fires. Before this,
+        # `active` stayed True for an exempt issue, so the JIT-authoring
+        # step ran anyway — burning a metered dispatch for guaranteed-zero
+        # output and then dead-ending with nothing left to dispatch Work.
+        return OracleDecision(
+            False,
+            f"#{state.issue} is exempt in ms-{state.milestone_number}'s "
+            "manifest — normal drive",
+            issue_exempt=True,
+        )
     return OracleDecision(
         True,
         f"ORACLE DRIVE — ms-{state.milestone_number}'s Gate-A contract is "
@@ -1102,7 +1123,6 @@ def resolve_oracle_decision(
         f"{state.milestone_tracking_issue} --issue {state.issue}`) before "
         "dispatching work",
         tracking_issue=state.milestone_tracking_issue,
-        issue_exempt=issue_exempt,
     )
 
 
@@ -2997,7 +3017,13 @@ def _dispatch_work_stage(
     *counters* is threaded in for the slice's own merge budget (#2079 —
     ``DriveCounters.acceptance``); every other decision here is stateless.
     """
-    if oracle is not None and oracle.active:
+    if oracle is not None and oracle.active and not oracle.issue_exempt:
+        # #2171: `oracle.active` alone already excludes an exempt issue
+        # (`resolve_oracle_decision` returns `active=False` for one) — the
+        # explicit `not oracle.issue_exempt` here is belt-and-suspenders,
+        # mirroring `_decide_acceptance_gate`'s own guard below, so this
+        # call site asks the SAME direct question rather than relying on
+        # `active`'s meaning to carry it transitively.
         assert gate_checker is not None and verifier is not None, (
             "oracle.active implies resolve_oracle_decision ran with a real "
             "gate_checker; decide()/Driver always thread one through"

{code_coordinator-0.5.559 → code_coordinator-0.5.560}/tests/test_drive.py

@@ -654,9 +654,14 @@ def test_resolve_oracle_decision_is_active_when_everything_lines_up():
     assert "ms-38" in decision.reason
 
 
-def test_resolve_oracle_decision_resolves_issue_exempt_when_active():
-    """#2199: `issue_exempt` is resolved alongside `active` — one GitHub
-    fetch budget, not a second one paid later by the trust gate."""
+def test_resolve_oracle_decision_is_inactive_for_an_exempt_issue():
+    """#2171: an issue in `manifest.exempt` (or labelled `oracle:exempt`)
+    has no sealed slice for a `type="test-author"` session to write — the
+    same #1138 hard gate (`issue_oracle_ready`) would never block its Work
+    dispatch on one either. `resolve_oracle_decision` must say so with
+    `active=False` (not merely flag `issue_exempt=True` on an otherwise
+    active decision) so `_dispatch_work_stage` dispatches Work directly
+    instead of dead-ending on a test-author with nothing to author."""
     checker = FakeGateChecker(exists=True, exempt=True)
     decision = resolve_oracle_decision(
         oracle_state(issue_labels=("bug",)),
@@ -664,8 +669,10 @@ def test_resolve_oracle_decision_resolves_issue_exempt_when_active():
         make_config_with_acceptance_driver(),
         checker,
     )
-    assert decision.active is True
+    assert decision.active is False
     assert decision.issue_exempt is True
+    assert "exempt" in decision.reason
+    assert "ms-38" in decision.reason
     assert checker.exempt_calls == [(REPO, 38, ISSUE, ("bug",))]
 
 
@@ -871,6 +878,41 @@ def test_oracle_inactive_dispatches_work_directly_as_before():
     )
 
 
+def test_oracle_exempt_issue_dispatches_work_directly_no_test_author():
+    """#2171: `resolve_oracle_decision` returns `active=False` for an exempt
+    issue (see the regression test above), so `_dispatch_work_stage` must
+    skip the JIT-authoring branch entirely and dispatch Work straight away
+    — never a `coord acceptance author ...` for an issue with nothing to
+    author."""
+    oracle = OracleDecision(
+        False,
+        "#1392 is exempt in ms-38's manifest — normal drive",
+        issue_exempt=True,
+    )
+    action = step(state(), oracle=oracle)
+    assert action.kind == RUN
+    assert action.command == (
+        "assign", "precision", REPO, "1392",
+        "--driven-by", f"drive:{REPO}#1392",
+    )
+
+
+def test_dispatch_work_stage_also_guards_on_issue_exempt_defensively():
+    """Belt-and-suspenders (mirrors `_decide_acceptance_gate`'s own guard):
+    even if something ever constructed an `active=True, issue_exempt=True`
+    decision, the work-stage dispatch must still skip authoring rather than
+    trust `active` alone."""
+    oracle = OracleDecision(
+        True, "ORACLE DRIVE", tracking_issue=1120, issue_exempt=True,
+    )
+    action = step(state(), oracle=oracle)
+    assert action.kind == RUN
+    assert action.command == (
+        "assign", "precision", REPO, "1392",
+        "--driven-by", f"drive:{REPO}#1392",
+    )
+
+
 def test_oracle_active_authors_the_slice_before_dispatching_work():
     oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
     action = step(state(), oracle=oracle)