code-coordinator 0.5.267__tar.gz → 0.5.268__tar.gz

{code_coordinator-0.5.267 → code_coordinator-0.5.268}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.267",
+  "tag": "0.5.268",
   "distance": 0,
-  "node": "g1fa630fb3cebe560405cb33c1b2ce1e3fed742a4",
+  "node": "gf1fb3361f55813adaa28edcc31c2b9a1b6a20836",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-28"

{code_coordinator-0.5.267 → code_coordinator-0.5.268}/coord/drive.py

@@ -587,6 +587,14 @@ class Action:
     # the work row's own last attempt reported, or `_decide_merge` would
     # diagnose one PR using the other PR's gates.
     merge_scope: str = "work"
+    # #2871: an explicit ``(event_type, summary, details)`` for `Driver._loop`
+    # to write via `_record_drive_audit`, independent of whatever this Action
+    # otherwise does (WAIT/RUN/EXIT). `decide()` stays a pure function of its
+    # inputs — it hands back *what happened*, never writes the audit log
+    # itself — while still letting a poll that neither dispatches nor exits
+    # (e.g. bypassing a stale pre-dispatch refusal) leave a durable trail
+    # instead of only a run-log line nobody queries later.
+    audit_event: tuple[str, str, dict[str, Any]] | None = None
 
     @property
     def is_exit(self) -> bool:
@@ -605,6 +613,44 @@ def _die(message: str, exit_code: int = EXIT_TERMINAL_FAILURE) -> Action:
     return Action(kind=EXIT, message=message, exit_code=exit_code)
 
 
+def _format_age(seconds: float) -> str:
+    """Coarse human age ('38m', '15h', '1.2d') for a pre-dispatch audit note.
+
+    Deliberately not the CLI's full relative-time renderer — this is one
+    field inside an audit `summary`/`details`, not a UI surface, so a small
+    self-contained formatter is enough (#2871).
+    """
+    seconds = max(0.0, seconds)
+    if seconds < 3600:
+        return f"{int(seconds // 60)}m"
+    if seconds < 86400:
+        return f"{seconds / 3600:.0f}h"
+    return f"{seconds / 86400:.1f}d"
+
+
+def _refused_policy_is_stale(state: IssueState) -> bool:
+    """True when a terminal ``refused_policy`` work row no longer describes
+    the issue as it stands now (#2871).
+
+    A worker refuses pre-dispatch work exactly once, correctly, for the ask
+    it was shown — the refusal says nothing about a DIFFERENT ask on the same
+    issue number. If the issue was retargeted (title rewritten) after that
+    row finished, the branch it would have produced (workers name branches
+    ``issue-{N}-{slugify(title)}`` at dispatch time, see
+    ``coord.agent``'s ``branch_name`` construction) no longer matches what a
+    fresh dispatch would name — that mismatch is the signal a retarget
+    happened. Conservative on every uncertainty (no branch recorded, no
+    title resolved): returns ``False`` — i.e. still treated as blocking —
+    rather than risk waving a genuinely-unresolved refusal through.
+    """
+    if not state.work_branch or not state.issue_title:
+        return False
+    from coord.agent import _slugify  # noqa: PLC0415
+
+    expected_branch = f"issue-{state.issue}-{_slugify(state.issue_title)}"
+    return state.work_branch != expected_branch
+
+
 # ── oracle-loop JIT slice authoring (#1453) ─────────────────────────────────
 
 
@@ -2036,8 +2082,58 @@ def decide(
         # deliverable was a doc edit, which CLAUDE.md itself tells a worker
         # to refuse and stop rather than attempt). Unlike an ADVISORY 0-commit
         # exit, retrying changes nothing — the rule this worker cited is not
-        # going anywhere — so this is a `_die()` exactly like every other
-        # terminal branch here, but the message embeds
+        # going anywhere — UNLESS the issue itself has since changed.
+        #
+        # #2871: a refusal is a verdict on the ASK the worker was shown, not
+        # a standing veto on the issue NUMBER forever. `coord/claim.py`'s
+        # `find_work_claim` never even sees this row (it's terminal, so it
+        # lives in `board.completed`) — the reason a stale refusal blocks
+        # every later drive is entirely HERE: `work_aid`/`work_status` above
+        # are the latest work-like row for this issue regardless of how old
+        # or how differently-scoped it is, so a fresh `coord drive` launch
+        # reads the fossil row as "this run's" state before ever reaching
+        # `_dispatch_work_stage`. If the issue was retargeted (title
+        # rewritten) after this row finished, `_refused_policy_is_stale`
+        # detects it — the old refusal no longer describes what a fresh
+        # dispatch would even be asked to do — and this bypasses the veto
+        # instead of dying again on the SAME prose a fresh worker never
+        # produced this run (CC#916).
+        age_seconds = (
+            time.time() - state.work_finished_at
+            if state.work_finished_at is not None
+            else None
+        )
+        age = _format_age(age_seconds) if age_seconds is not None else "unknown age"
+        if _refused_policy_is_stale(state):
+            bypass_summary = (
+                f"pre-dispatch: bypassing stale refused_policy assignment "
+                f"{state.work_aid} ({age} old) on issue {state.repo}#{state.issue} "
+                f"— retargeted since (branch {state.work_branch!r} no longer "
+                "matches the issue's current title); dispatching fresh work (#2871)"
+            )
+            dispatch = _dispatch_work_stage(
+                state, opts, counters, machine, oracle, gate_checker, verifier
+            )
+            return replace(
+                dispatch,
+                audit_event=(
+                    "refused_policy_stale",
+                    bypass_summary,
+                    {
+                        "stale_assignment_id": state.work_aid,
+                        "stale_branch": state.work_branch,
+                        "age_seconds": age_seconds,
+                    },
+                ),
+            )
+        # Still genuinely blocking: `_die()` exactly like every other
+        # terminal branch here, but the message now says explicitly that
+        # THIS run refused pre-dispatch on an OLD row (naming it and its
+        # age) rather than reading as a fresh worker refusing again — and
+        # names the remedy that actually clears it (#2871: retargeting is
+        # what makes the branch above fire on the next drive; `coord
+        # drive-queue remove`+`add` alone does nothing, since the queue row
+        # was never what was blocking). The message still embeds
         # `POLICY_REFUSAL_MARKER`: `coord/drive_queue.py`'s
         # `_reconcile_running` recognises that marker in this run's own
         # `drive_exited` audit summary and parks the queue entry
@@ -2046,12 +2142,16 @@ def decide(
         # principle #1844 already applies pre-dispatch, applied here
         # post-dispatch.
         return _die(
-            f"work {state.work_aid} refused on a standing repo-rule "
-            "prohibition rather than doing the dispatched work — the worker "
-            "did the CORRECT thing (#2234). Needs the coordinator: do the "
-            "work directly (or re-scope the issue so its deliverable isn't "
-            f"coordinator-only), then `coord drive-queue remove {state.repo} "
-            f"{state.issue}` once handled.\n"
+            f"pre-dispatch refusal on assignment {state.work_aid} "
+            f"(refused_policy, {age} old) — work refused on a standing "
+            "repo-rule prohibition rather than doing the dispatched work; "
+            "the worker did the CORRECT thing (#2234). Needs the "
+            "coordinator: do the work directly, OR retarget the issue "
+            "(rewrite its title so the deliverable matches what should "
+            "actually be dispatched) — the next `coord drive` detects the "
+            "retarget and dispatches fresh work automatically (#2871), so "
+            f"`coord drive-queue remove {state.repo} {state.issue}` + `add` "
+            "then genuinely clears this once the issue is retargeted.\n"
             f"   inspect: coord log {state.work_aid} --machine "
             f"{state.work_machine or machine}\n"
             f"   {POLICY_REFUSAL_MARKER}"
@@ -4680,6 +4780,15 @@ class Driver:
             for warning in action.warnings:
                 self.warn(warning)
 
+            # #2871: `decide()` stays a pure function of its inputs — it
+            # cannot write the audit log itself — so an Action that carries
+            # its own audit note (e.g. bypassing a stale pre-dispatch
+            # refusal) gets recorded here, the one place this loop already
+            # writes durable `drive_*` audit rows.
+            if action.audit_event is not None:
+                event_type, summary, details = action.audit_event
+                self._record_drive_audit(event_type, summary, details=details)
+
             # #2443: self-heal — see `_self_heal_drift_message`. Tracked off
             # the Action's own `label`, NOT `fingerprint` above: a WAIT can
             # (and, in the #2286 shape, does) repeat the identical reason

{code_coordinator-0.5.267 → code_coordinator-0.5.268}/coord/drive_queue.py

@@ -3107,18 +3107,32 @@ def _reconcile_running(
     # _decide` marks a `refused_policy` work row with `POLICY_REFUSAL_
     # MARKER` (coord.models) rather than `EXIT_DISPATCH_REFUSED`, so this is
     # checked purely off `own_reason` text, independent of `exit_refused`.
-    # Unlike #2063 this NEVER self-clears — a policy refusal names a
-    # STANDING rule, not a pending verdict — so it deliberately does not get
-    # the "queue resumes it automatically" wording Gate-A's park does; see
-    # `plan_tick`'s pre-pass below, which recognises this same marker and
-    # leaves the entry parked rather than falling through to the CI-park
-    # auto-resume. An operator clears it exactly like a `blocked` entry:
-    # handle it, then `coord drive-queue remove`.
+    # Unlike #2063 this does not self-clear on its own timer — a policy
+    # refusal names a STANDING rule, not a pending verdict — so it
+    # deliberately does not get the "queue resumes it automatically" wording
+    # Gate-A's park does; see `plan_tick`'s pre-pass below, which recognises
+    # this same marker and leaves the entry parked rather than falling
+    # through to the CI-park auto-resume.
+    #
+    # #2871: the precondition IS an operator action, but it is a RETARGET
+    # (rewrite the issue so its deliverable isn't the coordinator-only thing
+    # that got refused), not queue surgery. Before #2871, `coord.drive.
+    # decide()` re-read the SAME stale `refused_policy` row on every relaunch
+    # regardless of what the issue said by then, so `remove`+`add` looked
+    # like the fix but did nothing — a fresh queue row, same blocking
+    # assignment. `decide()` now compares that row's branch against the
+    # issue's CURRENT title-derived slug (`_refused_policy_is_stale`) and
+    # bypasses a stale refusal instead of dying on it again, so `remove`+
+    # `add` (or any later relaunch) genuinely works — but only once the
+    # retarget has actually happened.
     if own_reason and is_policy_refusal_reason(own_reason):
         reason = (
             f"{own_reason} — parking without spending an attempt (#2234); "
-            "needs the coordinator, not a relaunch — `coord drive-queue "
-            "remove` once handled"
+            "needs the coordinator, not a relaunch — retarget the issue "
+            "(rewrite its title so the deliverable isn't coordinator-only), "
+            "then `coord drive-queue remove`+`add` (or just relaunch "
+            "`coord drive`) — it now detects the retarget and dispatches "
+            "fresh work automatically (#2871)"
         )
         return (
             Reconcile(

{code_coordinator-0.5.267 → code_coordinator-0.5.268}/coord/drive_state.py

@@ -111,6 +111,13 @@ class IssueState:
     work_acceptance_state: str = ""
     work_acceptance_reason: str = ""
     work_acceptance_sha: str = ""
+    # #2871: when the work row went terminal — ``None`` for a row still
+    # running/pending or predating this column. Paired with `issue_title`
+    # below so `decide()` can tell a genuinely-still-blocking
+    # `refused_policy` row apart from one whose issue was retargeted
+    # (title rewritten) after it finished, and can name the row's age in
+    # whatever it reports instead of silently re-quoting stale prose.
+    work_finished_at: float | None = None
 
     review_aid: str = ""
     review_status: str = ""
@@ -181,6 +188,13 @@ class IssueState:
     # `oracle:exempt`/`manifest.exempt` opt-out for the trust gate
     # (`AcceptanceGateChecker.is_issue_exempt`) without a second board scan.
     issue_labels: tuple[str, ...] = ()
+    # #2871: this issue's CURRENT GitHub title — resolved from the same
+    # `/board` `issues` row `issue_labels` is, no extra I/O. Compared
+    # against a terminal `refused_policy` work row's branch (workers name
+    # branches `issue-{N}-{slugify(title)}` at dispatch time) to detect a
+    # retarget: an issue whose deliverable was rewritten after the worker
+    # refused no longer matches the branch that refusal was about.
+    issue_title: str = ""
 
     # The JIT slice's own `type="test-author"` assignment (#1171: keyed on
     # `for_issue_number == issue`, NOT `issue_number` — that field is the
@@ -355,6 +369,13 @@ def project(payload: dict, repo: str, issue: int, config: Any) -> IssueState:
         return default if value is None else value
 
     exit_code = (work or {}).get("exit_code")
+    finished_at_raw = (work or {}).get("finished_at")
+    try:
+        work_finished_at = (
+            float(finished_at_raw) if finished_at_raw is not None else None
+        )
+    except (TypeError, ValueError):
+        work_finished_at = None
 
     # #1453: oracle-loop JIT slice resolution — both reads are over data
     # already published on /board, no extra I/O (see IssueState's docstring
@@ -368,10 +389,12 @@ def project(payload: dict, repo: str, issue: int, config: Any) -> IssueState:
     # instead of discovering a mismatch only when #1711's dispatch-time
     # guard refuses it. No extra I/O: `issues` is already part of *payload*.
     issue_labels: list[str] = []
+    issue_title = ""
     for oi in payload.get("issues") or []:
         if oi.get("repo_name") == repo and oi.get("number") == issue:
             milestone_number = oi.get("milestone_number")
             issue_labels = list(oi.get("labels") or [])
+            issue_title = oi.get("title") or ""
             break
 
     milestone_tracking_issue = None
@@ -451,6 +474,7 @@ def project(payload: dict, repo: str, issue: int, config: Any) -> IssueState:
         work_acceptance_state=g(work, "acceptance_state"),
         work_acceptance_reason=g(work, "acceptance_reason"),
         work_acceptance_sha=g(work, "acceptance_sha"),
+        work_finished_at=work_finished_at,
         review_aid=g(review, "assignment_id"),
         review_status=g(review, "status"),
         review_verdict=g(review, "review_verdict"),
@@ -472,6 +496,7 @@ def project(payload: dict, repo: str, issue: int, config: Any) -> IssueState:
         milestone_number=milestone_number,
         milestone_tracking_issue=milestone_tracking_issue,
         issue_labels=tuple(issue_labels),
+        issue_title=issue_title,
         # #2024: the per-issue Test-stage policy, off the labels already read
         # above (no extra I/O). `test_mode_from_labels` is the same function
         # `coord.state._get_issue_test_mode_local` uses, so the driver and the

{code_coordinator-0.5.267 → code_coordinator-0.5.268}/tests/test_drive.py

@@ -1840,6 +1840,71 @@ def test_refused_policy_work_is_terminal_and_carries_the_2234_marker():
     assert "needs the coordinator" in action.message.lower()
 
 
+def test_refused_policy_still_blocking_names_the_assignment_and_age():
+    """#2871: even the still-blocking case must stop reading as though a
+    FRESH worker just refused again — the message names the pre-dispatch
+    assignment it refused on and the row's age, not just generic prose."""
+    action = step(
+        state(
+            work_aid="w1",
+            work_status="refused_policy",
+            work_finished_at=1000.0,
+        )
+    )
+    assert action.is_exit
+    assert "pre-dispatch refusal on assignment w1" in action.message
+    assert "refused_policy" in action.message
+    assert POLICY_REFUSAL_MARKER in action.message
+
+
+def test_refused_policy_is_bypassed_when_the_issue_was_retargeted():
+    """#2871 / CC#916: a `refused_policy` row is a verdict on the ASK the
+    worker was shown, not a standing veto on the issue number forever.
+    `coord.claim.find_work_claim` never even sees this row (terminal rows
+    live in `board.completed`) — the reason a stale refusal vetoed every
+    later drive was entirely in `decide()` reading the fossil row as "this
+    run's" state before ever reaching dispatch. If the issue's title was
+    rewritten after the row finished, the branch it would have produced no
+    longer matches — that mismatch means the ask changed, so this must
+    dispatch fresh work instead of dying on the old refusal again."""
+    s = state(
+        work_aid="w1",
+        work_status="refused_policy",
+        work_branch="issue-1392-old-pre-retarget-title",
+        issue_title="A completely different retargeted deliverable",
+        work_finished_at=1000.0,
+    )
+    action = step(s)
+    assert action.kind == RUN
+    assert action.command[0] == "assign"
+    assert action.audit_event is not None
+    event_type, summary, details = action.audit_event
+    assert event_type == "refused_policy_stale"
+    assert "w1" in summary
+    assert details["stale_assignment_id"] == "w1"
+    assert details["stale_branch"] == "issue-1392-old-pre-retarget-title"
+
+
+def test_refused_policy_is_not_bypassed_when_the_title_is_unchanged():
+    """The inverse of the retarget test above: the branch still matches
+    `issue-{N}-{slugify(current title)}`, so nothing was retargeted — this
+    must still die rather than silently re-dispatch over a worker that
+    correctly refused."""
+    from coord.agent import _slugify  # noqa: PLC0415
+
+    title = "Exactly the title this branch was named from"
+    s = state(
+        work_aid="w1",
+        work_status="refused_policy",
+        work_branch=f"issue-{ISSUE}-{_slugify(title)}",
+        issue_title=title,
+    )
+    action = step(s)
+    assert action.is_exit
+    assert POLICY_REFUSAL_MARKER in action.message
+    assert action.audit_event is None
+
+
 def test_an_unknown_terminal_status_refuses_to_guess():
     """No terminal status may fall through to a bare wait (PR #1386)."""
     action = step(state(work_aid="w1", work_status="wat"))

{code_coordinator-0.5.267 → code_coordinator-0.5.268}/tests/test_drive_queue.py

@@ -2764,6 +2764,23 @@ def test_a_policy_refusal_parks_without_spending_an_attempt():
     assert POLICY_REFUSAL_REASON in reconcile.updates["last_reason"]
 
 
+def test_a_policy_refusal_park_reason_names_a_remedy_that_actually_clears_it():
+    """#2871: before this fix, the printed remedy (`coord drive-queue
+    remove` once handled) was misleading — `coord.drive.decide()` re-read
+    the SAME stale `refused_policy` row on every relaunch regardless of
+    what the issue said by then, so `remove`+`add` looked like the fix but
+    did nothing. The park reason must name the precondition that actually
+    matters (retargeting the issue) rather than pure queue surgery."""
+    entries = [entry(2195, position=3, state=STATE_RUNNING, attempts=0)]
+    plan = plan_tick(
+        entries, board(), capacity=1,
+        exit_reasons={entry_key(REPO, 2195): POLICY_REFUSAL_REASON},
+    )
+    reason = plan.reconciles[0].reason
+    assert "retarget the issue" in reason
+    assert "dispatches fresh work automatically" in reason
+
+
 def test_a_policy_refusal_parks_even_on_a_fresh_entrys_first_tick():
     entries = [entry(2195, state=STATE_RUNNING, attempts=0)]
     plan = plan_tick(

{code_coordinator-0.5.267 → code_coordinator-0.5.268}/tests/test_drive_state.py

@@ -142,6 +142,44 @@ def test_project_resolves_issue_labels_from_the_issues_list():
     assert state.issue_labels == ("oracle:exempt", "bug")
 
 
+def test_project_resolves_issue_title_from_the_issues_list():
+    """#2871: `decide()`'s retarget-detection compares a terminal
+    `refused_policy` row's branch against THIS — the issue's current
+    title — no extra I/O, same `/board` `issues` row `issue_labels` reads."""
+    payload = {
+        "assignments": [],
+        "issues": [
+            {"repo_name": REPO, "number": 1392, "title": "Rewritten deliverable"},
+        ],
+    }
+    state = project(payload, REPO, 1392, make_config())
+    assert state.issue_title == "Rewritten deliverable"
+
+
+def test_project_defaults_issue_title_empty_with_no_matching_issue():
+    payload = {"assignments": []}
+    state = project(payload, REPO, 1392, make_config())
+    assert state.issue_title == ""
+
+
+def test_project_reads_work_finished_at_from_the_work_row():
+    """#2871: paired with `issue_title` so `decide()` can name a
+    pre-dispatch refusal's age instead of leaving it unstated."""
+    payload = {
+        "assignments": [
+            row(assignment_id="w1", status="refused_policy", finished_at=12345.0)
+        ]
+    }
+    state = project(payload, REPO, 1392, make_config())
+    assert state.work_finished_at == 12345.0
+
+
+def test_project_defaults_work_finished_at_none_when_absent():
+    payload = {"assignments": [row(assignment_id="w1")]}
+    state = project(payload, REPO, 1392, make_config())
+    assert state.work_finished_at is None
+
+
 def test_project_refuses_an_unconfigured_repo():
     with pytest.raises(DriveStateError, match="not in coordinator.yml"):
         project({"assignments": []}, "nope", 1, make_config())