code-coordinator 0.5.82__tar.gz → 0.5.83__tar.gz

{code_coordinator-0.5.82 → code_coordinator-0.5.83}/PKG-INFO

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

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

@@ -187,10 +187,10 @@ coord/dashboard/webapp/dist/index.html
 coord/dashboard/webapp/dist/manifest.webmanifest
 coord/dashboard/webapp/dist/sw.js
 coord/dashboard/webapp/dist/workbox-e4022e15.js
-coord/dashboard/webapp/dist/assets/Gallery-da3qNiIw.js
+coord/dashboard/webapp/dist/assets/Gallery-Cq84itDE.js
 coord/dashboard/webapp/dist/assets/Terminal-9CEnUXvW.css
-coord/dashboard/webapp/dist/assets/Terminal-skVFCxPU.js
-coord/dashboard/webapp/dist/assets/index-DltfZR5f.js
+coord/dashboard/webapp/dist/assets/Terminal-DOXLcMue.js
+coord/dashboard/webapp/dist/assets/index-DHn-RIJ8.js
 coord/dashboard/webapp/dist/assets/index-Dq4kwTdw.css
 coord/dashboard/webapp/dist/assets/workbox-window.prod.es5-BqEJf4Xk.js
 coord/dashboard/webapp/dist/icons/icon-192.png

{code_coordinator-0.5.82 → code_coordinator-0.5.83}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.82",
+  "tag": "0.5.83",
   "distance": 0,
-  "node": "g329c3981912cb4a0cb249010221980bd64ee12b4",
+  "node": "gc65c7e49837d7f4990a4606d987a975642e709ae",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.82 → code_coordinator-0.5.83}/coord/agent.py

@@ -82,6 +82,21 @@ CANCELLED = "cancelled"
 # would loop forever on "already implemented" reports); not a clean DONE
 # either. Human should review and decide whether to re-dispatch or close.
 ADVISORY = "advisory"
+# #2234: a NARROWER shape of the #448 zero-commit exit — the worker's own
+# final message shows it stopped because a STANDING repo rule (CLAUDE.md's
+# "only the coordinator writes docs", or similar) makes the dispatched
+# deliverable something no worker can complete, ever, on any attempt (see
+# `_looks_like_policy_refusal`). This is deliberately a status distinct from
+# ADVISORY, not a sub-case reported through it: every downstream consumer of
+# ADVISORY (`coord drive`'s bounded retry, the queue's attempt budget, the
+# terminal `blocked` bucket a human must `remove`) exists to handle "the
+# worker got stuck or found nothing to do" — a condition retrying might fix.
+# A policy refusal is the OPPOSITE: the worker did exactly the right thing,
+# and retrying is guaranteed to reproduce the identical, correct refusal.
+# Landing it in ADVISORY's bucket is what #2234 exists to stop — the #2195
+# incident spent two drive attempts ($0.11 x 2, plus the overnight slot) and
+# a terminal `blocked` rediscovering a rule that was never going to change.
+REFUSED_POLICY = "refused_policy"
 
 # #448: spec types that are expected to push commits, so a clean exit with
 # zero commits is interesting (advisory).  Review/smoke workers commit
@@ -167,6 +182,54 @@ _COMPLETED_HISTORY_CAP = 25
 # within an operator's normal polling cadence.
 _ADVISORY_TERMINAL_CHECK_COOLDOWN_S = 300.0
 
+# #2234: markers that show up when a worker's OWN final message explains
+# that it stopped because of a STANDING repo rule — not because it got stuck
+# or ran out of turns. Matched only against the worker's own account (see
+# `_looks_like_policy_refusal`), never against the briefing or issue body,
+# which quote the same rules on every single dispatch and would false-
+# positive on every assignment if matched directly. `claude.md` is the one
+# filename standing worker-facing rules live in across this repo (see
+# CLAUDE.md's own "Rules for workers" section, "Only the coordinator writes
+# docs"); the rest are lifted verbatim from that same rule's text, which is
+# the shape that triggered this issue (claude-coordinator#2195: an issue
+# whose entire deliverable was a doc edit, dispatched to a worker that
+# correctly refused and stopped). Deliberately permissive rather than
+# requiring an exact quote — a weak/cheap model's terse refusal ("Confirmed:
+# the rule exists verbatim at CLAUDE.md line 156...", the actual #2195
+# transcript) may cite the rule without repeating "must not"/"forbidden"
+# verbatim.
+_POLICY_REFUSAL_MARKERS = (
+    "claude.md",
+    "files_forbidden",
+    "repo rule",
+    "repo's rule",
+    "coordinator work",
+    "only the coordinator",
+    "coordinator-only",
+    "should never have been dispatched",
+)
+
+
+def _looks_like_policy_refusal(text: str | None) -> bool:
+    """#2234: does *text* — the worker's own final message — read as a
+    refusal grounded in a STANDING repo-rule prohibition, rather than a
+    stuck/incomplete session?
+
+    Only ever consulted on the zero-commit/clean-exit shape (`_reap` calls
+    this exactly where it would otherwise set `zero_commit_reason` — see
+    below): a worker that pushed real commits never reaches this check, so a
+    successful run that happens to mention `CLAUDE.md` in passing (e.g.
+    "per CLAUDE.md I ran the build before committing") carries no risk of
+    being reclassified. Within that already-narrow shape, an ordinary
+    `STUCK:`-style report (out of turns, couldn't find the code, a flaky
+    test) mentions none of :data:`_POLICY_REFUSAL_MARKERS`, so it is left
+    exactly as ADVISORY as it always was.
+    """
+    if not text:
+        return False
+    lowered = text.lower()
+    return any(marker in lowered for marker in _POLICY_REFUSAL_MARKERS)
+
 
 # ── Reap tuning ───────────────────────────────────────────────────────────────
 # claude-cli sometimes does not exit after emitting its final
@@ -2925,6 +2988,16 @@ class AgentAssignment:
     # (a normal work assignment's deliverable is the diff itself, already
     # visible on the PR — restating the transcript there would be noise).
     result_text: str | None = None
+    # #2234: the worker's own final message when `_reap` classifies a clean
+    # (exit_code==0), 0-commit exit as a policy refusal (`status ==
+    # REFUSED_POLICY`) rather than the #448 ADVISORY default — see
+    # `_looks_like_policy_refusal`. `None` on every other outcome, including
+    # an ordinary zero-commit ADVISORY (no marker matched) and the #2188
+    # analysis-deliverable success shape (mutually exclusive with this one:
+    # both are decided in the same `_ahead == 0` branch of `_reap`, and only
+    # one of `analysis_deliverable`/`zero_commit_reason`/this field is ever
+    # set for a given assignment).
+    policy_refusal_reason: str | None = None
 
     def to_dict(self) -> dict:
         d = asdict(self)
@@ -4162,7 +4235,7 @@ class AgentServer:
             completed = sum(
                 1
                 for a in self._assignments.values()
-                if a.status in (DONE, FAILED, CANCELLED, ADVISORY)
+                if a.status in (DONE, FAILED, CANCELLED, ADVISORY, REFUSED_POLICY)
             )
         worktree_bytes = self._cached_worktree_bytes()
         artifact_bytes = self._cached_artifact_bytes()
@@ -6105,17 +6178,28 @@ class AgentServer:
         ``zero_commit_reason`` when the reap already flagged ADVISORY, since
         that is the string `coord status`, the dashboard and the GitHub
         advisory comment all render) is what makes the loss visible.
+
+        #2234 fix-1: mirrors the same rewrite for a REFUSED_POLICY reap —
+        ``policy_refusal_reason`` (not ``zero_commit_reason``) is the string
+        the refused_policy GitHub comment and `coord status` render for that
+        status, so a dirty worktree left behind by an otherwise-correct
+        policy refusal needs the same visibility, on the field that surface
+        actually reads.
         """
         with self._lock:
             live = self._assignments.get(assignment.id, assignment)
             live.dirty_worktree_reason = reason
             if live.status == ADVISORY:
                 live.zero_commit_reason = reason
+            elif live.status == REFUSED_POLICY:
+                live.policy_refusal_reason = reason
             # Keep the caller's object in sync when it isn't the live one, so
             # a caller holding a detached copy still sees the outcome.
             assignment.dirty_worktree_reason = reason
             if assignment.status == ADVISORY:
                 assignment.zero_commit_reason = reason
+            elif assignment.status == REFUSED_POLICY:
+                assignment.policy_refusal_reason = reason
         self._persist()
 
     def _rescue_uncommitted_work(
@@ -7473,6 +7557,11 @@ class AgentServer:
         # assignment.
         _analysis_deliverable = False
         _zero_commit_reason: str | None = None
+        # #2234: set alongside (never together with) `_zero_commit_reason` —
+        # both are decided in the SAME `_ahead == 0` branch below so the two
+        # readings of "0 commits" can never disagree about which one applies
+        # to this assignment.
+        _policy_refusal_reason: str | None = None
         if (exit_code == 0 and assignment is not None
                 and assignment.worktree_path
                 and assignment.spec.type in _ZERO_COMMIT_TYPES):
@@ -7493,6 +7582,30 @@ class AgentServer:
                                 )
                         except OSError:
                             pass
+                    elif _worker_summary is not None and _looks_like_policy_refusal(
+                        _worker_summary.result_text
+                    ):
+                        # #2234: the worker's own final message cites a
+                        # standing repo-rule prohibition as the reason it
+                        # stopped — the #2195 shape. Distinct from the
+                        # ADVISORY fallback below: retrying this assignment
+                        # cannot change a rule that isn't going anywhere, so
+                        # it must not consume the queue's attempt budget or
+                        # land in the same bucket as a genuinely stuck
+                        # worker.
+                        _policy_refusal_reason = _worker_summary.result_text or (
+                            "worker cited a standing repo-rule prohibition"
+                        )
+                        try:
+                            with open(assignment.log_path, "a") as reopen:
+                                reopen.write(
+                                    "# reap: refused_policy — 0 commits ahead "
+                                    f"of {_base}; worker's final message cites "
+                                    "a standing repo-rule prohibition, status "
+                                    "set to refused_policy (#2234)\n"
+                                )
+                        except OSError:
+                            pass
                     else:
                         _zero_commit_reason = (
                             "worker exited cleanly but pushed 0 commits"
@@ -7566,6 +7679,17 @@ class AgentServer:
                         # shrug.
                         assignment.status = FAILED
                         assignment.push_failure_reason = _push_failure_reason
+                    elif _policy_refusal_reason is not None:
+                        # #2234: clean exit, no commits, and the worker's own
+                        # final message cites a standing repo-rule
+                        # prohibition — a distinct, permanent shape of "0
+                        # commits", not the generic #448 ADVISORY. Checked
+                        # BEFORE `_zero_commit_reason` (the two are mutually
+                        # exclusive by construction — see the `_reap`
+                        # computation above — so the order is never actually
+                        # load-bearing, kept parallel to it for readability).
+                        assignment.status = REFUSED_POLICY
+                        assignment.policy_refusal_reason = _policy_refusal_reason
                     elif _zero_commit_reason is not None:
                         # #448: clean exit but no commits → advisory, not done.
                         assignment.status = ADVISORY
@@ -7826,8 +7950,16 @@ class AgentServer:
             ):
                 return
             self._last_advisory_terminal_check = now
+            # #2234: REFUSED_POLICY joins ADVISORY here for the same reason
+            # — both are terminal, zero-commit statuses the agent would
+            # otherwise keep serving indefinitely from its own `/status`
+            # feed once GitHub confirms the work is done, forcing every
+            # downstream consumer (dashboard, TUI, any future client) to
+            # reimplement the same GitHub-terminality filter this method
+            # exists to spare them.
             candidates = [
-                a for a in self._assignments.values() if a.status == ADVISORY
+                a for a in self._assignments.values()
+                if a.status in (ADVISORY, REFUSED_POLICY)
             ]
         if not candidates:
             return
@@ -7899,7 +8031,14 @@ class AgentServer:
             ordered = list(self._assignments.values())
             superseded_ids: list[str] = []
             for i, a in enumerate(ordered):
-                if a.status != ADVISORY:
+                # #2234: REFUSED_POLICY joins ADVISORY here too — a refusal
+                # for issue X can be superseded the same way an advisory can
+                # (e.g. the coordinator re-scopes the issue so a later
+                # dispatch's deliverable is no longer coordinator-only, and
+                # that later attempt reaches DONE). Same in-memory
+                # comparison, same root cause as `_prune_terminal_advisory`
+                # above.
+                if a.status not in (ADVISORY, REFUSED_POLICY):
                     continue
                 key = (a.spec.repo_name, a.spec.issue_number)
                 for later in ordered[i + 1 :]:

{code_coordinator-0.5.82 → code_coordinator-0.5.83}/coord/claim.py

@@ -184,15 +184,19 @@ def superseding_work_row(board: Board, assignment) -> "Assignment | None":
 
     Ordering is by ``dispatched_at``, with the assignment id as a deterministic
     tie-break so two rows stamped in the same second still order stably. A
-    ``failed`` or ``advisory`` later row does not supersede — both are
-    terminal no-op outcomes (``_ZERO_COMMIT_TYPES`` in ``coord/agent.py``:
-    zero commits pushed, e.g. "already fixed" or a graceful usage-limit exit)
-    that leave the branch exactly as the earlier row left it, so the earlier
-    row is still the branch's author. Without excluding ``advisory`` here, a
-    `--fix-of` round that lands zero commits would falsely mark the row it
-    was fixing as superseded — and since an ``advisory`` row is itself never
-    a valid dispatch target (``dispatch_smoke`` requires ``status == "done"``),
-    the branch would then never get *any* Test dispatch.
+    ``failed``, ``advisory``, or ``refused_policy`` later row does not
+    supersede — all three are terminal no-op outcomes (``_ZERO_COMMIT_TYPES``
+    in ``coord/agent.py``: zero commits pushed, e.g. "already fixed", a
+    graceful usage-limit exit, or a #2234 policy refusal) that leave the
+    branch exactly as the earlier row left it, so the earlier row is still
+    the branch's author. Without excluding these here, a `--fix-of` round
+    that lands zero commits would falsely mark the row it was fixing as
+    superseded — and since none of ``advisory``/``refused_policy`` is itself
+    a valid dispatch target (``dispatch_smoke`` requires ``status ==
+    "done"``), the branch would then never get *any* Test dispatch. (#2234
+    added ``refused_policy`` to this exclusion — it's drawn from the same
+    ``_ZERO_COMMIT_TYPES`` gate as ``advisory`` in ``coord/agent.py``'s
+    ``_reap`` and reproduces the identical failure mode if left out.)
 
     Returns the (newest) superseding row so callers can name it in a log line,
     or ``None`` when *assignment* is the branch's current work row. Related but
@@ -213,7 +217,7 @@ def superseding_work_row(board: Board, assignment) -> "Assignment | None":
             continue
         if a.type not in WORK_LIKE_TYPES:
             continue
-        if a.status in ("failed", "advisory"):
+        if a.status in ("failed", "advisory", "refused_policy"):
             continue
         if a.repo_name != assignment.repo_name or a.branch != branch:
             continue

{code_coordinator-0.5.82 → code_coordinator-0.5.83}/coord/commands/dispatch.py

@@ -1800,6 +1800,22 @@ def retry(assignment_id: str, config_path: Path, acknowledge_cost: bool = False)
     if assignment is None:
         click.echo(f"error: assignment {assignment_id!r} not found in board", err=True)
         sys.exit(1)
+    if assignment.status == "refused_policy":
+        # #2234: name the reason instead of falling into the generic
+        # "not 'failed' or 'advisory'" message below — a policy refusal is
+        # correct behavior (the worker did the right thing refusing a
+        # CLAUDE.md-prohibited task), and retrying would just reproduce the
+        # identical refusal since the rule it cited isn't going anywhere.
+        click.echo(
+            f"error: assignment {assignment_id} is 'refused_policy' — the "
+            "worker correctly refused this work on a standing repo-rule "
+            "prohibition. Retrying cannot change that verdict. Needs the "
+            "coordinator: do the work directly, or re-scope the issue so "
+            "its deliverable isn't coordinator-only, then `coord "
+            "drive-queue remove` once handled (#2234).",
+            err=True,
+        )
+        sys.exit(1)
     if assignment.status not in ("failed", "advisory"):
         click.echo(
             f"error: assignment {assignment_id} is {assignment.status!r}, not "

{code_coordinator-0.5.82 → code_coordinator-0.5.83}/coord/commands/status.py

@@ -349,6 +349,23 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
                     done.status = "advisory"
                     if done.type == "work":
                         done.review_state = "advisory"
+            elif agent_status == "refused_policy":
+                # #2234: worker exited cleanly, pushed 0 commits, and its own
+                # final message cited a standing repo-rule prohibition (the
+                # #2195 shape). Mirror reconcile.py's `reconcile()`: preserve
+                # the distinct status rather than folding it into "advisory"
+                # — without this branch it falls to the `else` below and gets
+                # recorded FAILED, feeding `auto_reassign` on a condition
+                # retrying can never fix.
+                done = board.mark_done_by_id(
+                    a.assignment_id,
+                    finished_at=entry.get("finished_at"),
+                    branch=branch,
+                )
+                if done is not None:
+                    done.status = "refused_policy"
+                    if done.type == "work":
+                        done.review_state = "advisory"
             else:
                 board.mark_failed_by_id(
                     a.assignment_id,
@@ -435,6 +452,32 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
                 f"[{spec.get('repo_name', '?')}]  — {reason}"
             )
 
+    # #2234: surface a policy refusal in its OWN section rather than folding
+    # it into Advisory above — same #1472 "still live on GitHub" filter, but
+    # distinct wording: this is a routing decision for the coordinator, not
+    # a "did the worker get stuck" question.
+    policy_refusal_entries = _live_advisory_entries(
+        [
+            e for e in agent_completed.values()
+            if e.get("status") == "refused_policy" and not e.get("usage_limit_reason")
+        ],
+        cfg,
+    )
+    if policy_refusal_entries:
+        click.echo("")
+        click.echo(
+            "🚫 Needs the coordinator (worker refused on a standing repo-rule "
+            "prohibition):"
+        )
+        for e in policy_refusal_entries:
+            spec = e.get("spec", {})
+            reason = e.get("policy_refusal_reason") or "cited a repo-rule prohibition"
+            click.echo(
+                f"  #{spec.get('issue_number', '?')}: "
+                f"{spec.get('issue_title', '?')} "
+                f"[{spec.get('repo_name', '?')}]  — {reason}"
+            )
+
     blocked = compute_blocked(cfg.repos, board.active)
     if blocked:
         click.echo("")

{code_coordinator-0.5.82 → code_coordinator-0.5.83}/coord/comments.py

@@ -20,6 +20,16 @@ EVENT_FAILURE = "failure"
 EVENT_STUCK = "stuck"
 EVENT_PLAN = "plan"
 EVENT_ADVISORY = "advisory"
+# #2234: a worker exited cleanly (exit_code 0), pushed 0 commits, AND its
+# own final message cited a standing repo-rule prohibition (the #2195
+# shape — a doc-only deliverable CLAUDE.md tells every worker to refuse).
+# Modeled directly on EVENT_ADVISORY (same "0-commit clean exit" trigger)
+# but deliberately distinct: an advisory needs a human to look and decide;
+# a policy refusal already has its answer — retrying cannot change a rule
+# that isn't going anywhere. Posting a separate event (rather than folding
+# this into EVENT_ADVISORY) keeps the two legible on GitHub the same way
+# `coord.agent.REFUSED_POLICY` keeps them distinct on the board.
+EVENT_REFUSED_POLICY = "refused_policy"
 # #846: an assignment running past its wall-clock threshold, or thrashing
 # through fix/review rounds without converging. Distinct from EVENT_STUCK
 # (a worker self-reported STATUS/STUCK line) — this fires from time/round
@@ -649,6 +659,60 @@ def format_advisory(
     return "\n".join(lines)
 
 
+def format_refused_policy(
+    *,
+    assignment_id: str,
+    machine_name: str,
+    repo_name: str,
+    issue_number: int,
+    duration_seconds: float | None = None,
+    log_path: str | None = None,
+    reason: str = "",
+) -> str:
+    """Format a comment for a #2234 policy refusal — a 0-commit clean exit
+    whose worker cited a standing repo-rule prohibition (e.g. "only the
+    coordinator writes docs").
+
+    Distinct from `format_advisory`: an advisory means "a human needs to
+    look and decide"; this means "the worker already found the answer —
+    retrying will reproduce the identical refusal, because the rule isn't
+    going anywhere." No re-dispatch suggestion, and no ADVISORY framing —
+    this names the routing decision (needs the coordinator) rather than
+    presenting as an unresolved outcome.
+    """
+    marker = _marker(
+        EVENT_REFUSED_POLICY,
+        assignment=assignment_id,
+        machine=machine_name,
+        repo=repo_name,
+        issue=issue_number,
+    )
+    lines = [
+        "## Coordinator: Refused — Standing Repo-Rule Prohibition",
+        marker,
+        f"**Machine:** {machine_name}",
+        "**Status:** refused_policy",
+        f"**Duration:** {_fmt_duration(duration_seconds)}",
+    ]
+    if log_path:
+        lines.append(f"**Log:** `{log_path}`")
+    lines.append("")
+    lines.append(
+        "The worker exited cleanly (exit code 0) and pushed **no commits** "
+        "because it correctly refused work that a standing repo rule (e.g. "
+        "CLAUDE.md's \"only the coordinator writes docs\") prohibits it from "
+        "doing. This is not a failure — retrying will reproduce the same "
+        "refusal, since the rule it cited isn't going anywhere. Needs the "
+        "coordinator: do the work directly, or re-scope the issue so its "
+        "deliverable isn't coordinator-only."
+    )
+    if reason.strip():
+        lines.append("")
+        lines.append("### Worker note")
+        lines.append(reason.strip())
+    return "\n".join(lines)
+
+
 def format_plan(
     *,
     assignment_id: str,

{code_coordinator-0.5.82 → code_coordinator-0.5.83}/coord/dao.py

@@ -36,7 +36,11 @@ SCHEMA_VERSION = 1
 
 # #762: terminal assignment statuses.  Anything NOT in this set (running /
 # pending) is "in-flight" and always kept on the board projection.
-TERMINAL_STATUSES = frozenset({"done", "merged", "failed", "cancelled", "advisory"})
+# #2234: "refused_policy" is terminal exactly like "advisory" — see
+# coord.agent.REFUSED_POLICY.
+TERMINAL_STATUSES = frozenset(
+    {"done", "merged", "failed", "cancelled", "advisory", "refused_policy"}
+)
 
 # #762: how many days of *terminal* assignment history the /board projection
 # carries.  The board grew unbounded (1209 assignments / 4.37 MB) and overran

{code_coordinator-0.5.82 → code_coordinator-0.5.83}/coord/dashboard/server.py

@@ -80,6 +80,15 @@ ASSIGNMENT_CANCELLED = "assignment_cancelled"
 # red failure — it's a "needs attention" state.  Route it to a distinct
 # event so the dashboard can style it appropriately (warning, not failure).
 ASSIGNMENT_ADVISORY = "assignment_advisory"
+# #2234: refused_policy (0-commit clean exit whose worker cited a standing
+# repo-rule prohibition — `coord.agent.REFUSED_POLICY`) is the same shape as
+# ASSIGNMENT_ADVISORY above but a distinct verdict: the worker did the
+# CORRECT thing, not an undecided one. Without a distinct event it fell
+# into the `else` branch below (commented "'failed' and any other
+# unexpected terminal status") and was published to the phone dashboard as
+# ASSIGNMENT_FAILED — reproducing, on this surface, the exact "worker that
+# refused reads as a worker that failed" defect #2234 exists to fix.
+ASSIGNMENT_REFUSED_POLICY = "assignment_refused_policy"
 # #846: an assignment running past its wall-clock threshold, or thrashing
 # through fix/review rounds without converging (coord.notify.attention_signal
 # — same detection core as the coordinator's GitHub-comment backstop).
@@ -226,6 +235,9 @@ async def _poll_once(
             # Bug 1 fix: three-way branch — cancelled must not fire FAILED.
             # #448: advisory routes to a distinct event so the dashboard does
             # not paint a 0-commit clean exit as a failure.
+            # #2234: refused_policy gets the same treatment as advisory —
+            # checked BEFORE the `else` catch-all, or it falls into
+            # ASSIGNMENT_FAILED like any other unrecognised terminal status.
             if status == "done":
                 event_source.publish(ASSIGNMENT_COMPLETED, payload)
             elif status == "cancelled":
@@ -233,6 +245,9 @@ async def _poll_once(
             elif status == "advisory":
                 payload["zero_commit_reason"] = entry.get("zero_commit_reason")
                 event_source.publish(ASSIGNMENT_ADVISORY, payload)
+            elif status == "refused_policy":
+                payload["policy_refusal_reason"] = entry.get("policy_refusal_reason")
+                event_source.publish(ASSIGNMENT_REFUSED_POLICY, payload)
             else:  # "failed" and any other unexpected terminal status
                 payload["exit_code"] = entry.get("exit_code")
                 event_source.publish(ASSIGNMENT_FAILED, payload)

code_coordinator-0.5.82/coord/dashboard/webapp/dist/assets/Gallery-da3qNiIw.js → code_coordinator-0.5.83/coord/dashboard/webapp/dist/assets/Gallery-Cq84itDE.js

@@ -1,4 +1,4 @@
-import{c as Fe,j as s,a as I,d as ho,r as l,e as de,R as go,f as Pe,g as z,h as Je,i as Ke,P as G,k as P,l as vo,m as ge,n as xo,o as Ea,D as gn,p as bo,X as wo,q as Pa,s as Ma,C as Da,v as ja,w as _a,T as Ia,x as Aa,y as Oa,B as H,z as Na,A as Bt,E as ka}from"./index-DltfZR5f.js";/**
+import{c as Fe,j as s,a as I,d as ho,r as l,e as de,R as go,f as Pe,g as z,h as Je,i as Ke,P as G,k as P,l as vo,m as ge,n as xo,o as Ea,D as gn,p as bo,X as wo,q as Pa,s as Ma,C as Da,v as ja,w as _a,T as Ia,x as Aa,y as Oa,B as H,z as Na,A as Bt,E as ka}from"./index-DHn-RIJ8.js";/**
  * @license lucide-react v0.462.0 - ISC
  *
  * This source code is licensed under the ISC license.

code_coordinator-0.5.82/coord/dashboard/webapp/dist/assets/Terminal-skVFCxPU.js → code_coordinator-0.5.83/coord/dashboard/webapp/dist/assets/Terminal-DOXLcMue.js

@@ -1,4 +1,4 @@
-import{c as Bt,r as Ne,j as R,a as Vt,u as Zr,b as Qr,t as en}from"./index-DltfZR5f.js";/**
+import{c as Bt,r as Ne,j as R,a as Vt,u as Zr,b as Qr,t as en}from"./index-DHn-RIJ8.js";/**
  * @license lucide-react v0.462.0 - ISC
  *
  * This source code is licensed under the ISC license.