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

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

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

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

{code_coordinator-0.5.558 → code_coordinator-0.5.560}/coord/agent.py

@@ -3828,6 +3828,20 @@ gate (not posted to GitHub by you — never run `gh` commands): a `partial`/ \
 comment on the issue quoting what remains, instead of auto-closing work \
 that still has a reported bug live.
 
+#3522: if you are going to declare `partial` or `investigation`, your \
+commit messages must reference this issue with `Refs #N` — never `Fix \
+#N`/`Fixes #N`/`Closes #N`/`Resolves #N`, even when that is this repo's \
+own commit convention for a fully-resolving change. GitHub scans commit \
+messages for closing keywords independently of the PR body and auto-closes \
+the issue the moment the commit lands on the base branch, regardless of \
+what your `ISSUE_RESOLUTION:` line says — the coordinator's merge gate can \
+rewrite the PR body but cannot rewrite history in a `gh`-only wire layer, \
+so it refuses to merge a `partial`/`investigation` PR whose commits still \
+carry a closing keyword. If you already wrote a commit this way before \
+deciding on `partial`/`investigation`, reword it (`git commit --amend` for \
+the most recent commit, `git rebase -i` for an earlier one) to say `Refs \
+#N` before you push.
+
 #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.558 → code_coordinator-0.5.560}/coord/conflict_fix.py

@@ -53,6 +53,20 @@ distinct :data:`ALREADY_UPSTREAM_MARKER` for the superseded case, so
 :func:`coord.reconcile.on_conflict_fix_done` can park the entry with
 accurate "nothing to merge" text instead of escalating a conflict that
 does not exist.
+
+#3522: a fourth no-conflict-expected shape, dispatched directly by
+``coord.merge_queue.process()`` the moment its own
+``issue_resolution_closing_keyword_in_commit`` gate fires (#3502) — a
+commit message on the branch carries a GitHub closing keyword for this
+entry's own issue even though the PR is marked ``ISSUE_RESOLUTION:
+partial``/``investigation``. ``dispatch_conflict_fix(..., reword_commit=
+True)`` sends a worker authorized ONLY to reword that commit's wording
+(never its content), verified content-preserving the same way the
+stale-rebase worker verifies its own premise — see
+:func:`build_reword_commit_briefing`. Before this, nothing ever remedied
+that refusal: the merge gate correctly kept refusing forever, and the
+drive-queue's own resume sweep kept burning its budget relaunching into
+the identical, unfixable-by-relaunch block (claude-coordinator#3519).
 """
 
 from __future__ import annotations
@@ -734,6 +748,240 @@ def already_upstream_verdict_in_text(text: str | None) -> bool:
     return ALREADY_UPSTREAM_MARKER in _decode_worker_text(text)
 
 
+# ── #3522: reword-commit (issue_resolution_closing_keyword_in_commit) ──────
+#
+# `coord.merge_queue.process()`'s `issue_resolution_closing_keyword_in_commit`
+# gate refuses to merge a branch whose PR is marked `ISSUE_RESOLUTION:
+# partial`/`investigation` but whose commit message(s) still carry a
+# GitHub closing keyword (`Fix`/`Fixes`/`Closes`/`Resolves #N`) for that
+# SAME issue — GitHub auto-closes the issue from the commit message on
+# merge regardless of what the PR body or the coordinator's own
+# `close_issue()` chokepoint say. Unlike the PR-body half of the same gate
+# (#1196/#1318), there is no `gh`-only rewrite for a commit message already
+# on the branch — only a local rebase that REWORDS it can fix this, and
+# nothing ever dispatched that rebase, so every such PR deadlocked:
+# `coord merge` refuses every attempt, the drive-queue's own resume sweep
+# (`coord.drive_queue._reconcile_blocked`) saw the same unfixable refusal
+# and burned its resume budget relaunching into it, and only an operator
+# force-push ever cleared it (claude-coordinator#3519).
+#
+# This section gives that gate a remedy worker, dispatched by
+# `coord.merge_queue.process()` itself the moment the gate fires (see that
+# module): a message-only rewrite, narrower even than the stale-rebase
+# briefing above — it is authorized to change ONLY the wording of a commit
+# SUBJECT that references this entry's own issue with a closing keyword,
+# never the tree. Verified the same way the stale-rebase worker verifies a
+# "just stale" premise: a content-addressed `git patch-id --stable` (and
+# the working tree itself) must be byte-identical before and after the
+# reword — if it isn't, something touched content, not just the message,
+# and the worker refuses rather than force-push a silently-changed diff out
+# from under a review that already approved a different tree.
+
+# Marker a reword-commit worker's STUCK: line starts with when the rewrite
+# was not content-preserving — a patch-id or tree mismatch, or a rebase
+# conflict encountered while rewording. Same convention as
+# STALE_REBASE_MISMATCH_MARKER/SEALED_SCOPE_STUCK_MARKER: a fixed,
+# machine-parseable string, not prose.
+REWORD_MISMATCH_MARKER = "coord:conflict=reword-mismatch"
+
+# Title prefix for a reword-commit conflict-fix dispatch — visible in the
+# TUI Pipeline row so an operator can tell at a glance this used the
+# narrow, message-only briefing rather than the ordinary conflict-fix one.
+REWORD_COMMIT_FIX_TITLE_PREFIX = "[reword-commit-fix]"
+
+REWORD_COMMIT_FIX_SYSTEM_PROMPT = """\
+You are a Claude Code conflict-fix worker. This branch's PR is marked \
+`ISSUE_RESOLUTION: partial` or `ISSUE_RESOLUTION: investigation` — it does \
+NOT fully resolve its issue — but one of its own commit messages still \
+uses a GitHub closing keyword (`Fix`/`Fixes`/`Closes`/`Resolves #N`) for \
+that same issue. GitHub auto-closes the issue from the commit message on \
+merge, independent of the PR body, so this blocks the merge until the \
+wording is fixed. Your job is a MESSAGE-ONLY rewrite: change the wording, \
+never the content.
+
+Rules:
+- The coordinator denies `gh` and `git push --force` for this worker. \
+Don't try to use them — the harness will reject the call.
+- Stay on the worker's branch — do NOT push to main / develop / target.
+- Use git push --force-with-lease (NOT --force).
+- Rewrite ONLY the commit subject/body wording that uses a closing keyword \
+for this entry's own issue number — e.g. `Fix #N: ...` / `Fixes #N ...` / \
+`Closes #N` / `Resolves #N` becomes `Refs #N: ...` (same text otherwise). \
+Leave every other commit, and every other word of the ones you touch, \
+untouched.
+- Before rewriting, record the branch's content fingerprint: `git diff \
+<target-branch>...HEAD | git patch-id --stable`, and its tree: `git \
+diff <target-branch> HEAD` (expect no output — nothing ahead of the merge \
+base besides this branch's own already-landed changes).
+- Use `git rebase -i <target-branch>` with `reword` on the affected \
+commit(s) (or, for a simple one-commit rewrite, `git commit --amend`), \
+editing ONLY the wording described above.
+- After rewriting, confirm BOTH fingerprints are UNCHANGED: the patch-id \
+must match exactly, and `git diff <target-branch> HEAD` must produce the \
+IDENTICAL output as before. A rewording that changes either means \
+something touched content, not just the message — DO NOT push.
+- If a conflict marker appears during the rebase, or either fingerprint \
+differs after the reword, DO NOT push. Stop and end your turn with a \
+STUCK: line that starts with the exact marker \
+`coord:conflict=reword-mismatch`, e.g.
+  STUCK: coord:conflict=reword-mismatch — patch-id before <hash>, after \
+<hash> differ
+The coordinator reads that marker from your transcript, not your process \
+exit code (which you cannot control), and escalates to a human rather than \
+force-pushing a diff review never saw.
+
+Progress reporting:
+- After each significant step (fingerprint recorded, reword done, \
+fingerprint verified, pushed), output:
+  STATUS: [what you just did] → [what you're about to do] → [confidence]
+- If you stop, output the STUCK: line described above and wait for \
+guidance.\
+"""
+
+
+def build_reword_commit_briefing(
+    *,
+    entry: QueuedMerge,
+    repo_path: str,
+    test_command: str | None,
+) -> str:
+    """Briefing for a conflict-fix dispatched against the #3522
+    `issue_resolution_closing_keyword_in_commit` merge-gate refusal — a
+    message-only rewrite of whichever commit(s) use a GitHub closing
+    keyword for *entry.issue_number*, verified content-preserving (patch-id
+    and tree both unchanged) the same way :func:`build_stale_rebase_briefing`
+    verifies its "just stale" premise.
+
+    *test_command* is accepted for signature symmetry with the other
+    ``build_*_briefing`` functions, but a pure message rewrite changes no
+    code, so this briefing does not ask the worker to re-run it — unlike
+    :func:`build_conflict_fix_briefing`/:func:`build_stale_rebase_briefing`,
+    both of which DO change (or might change) tracked files.
+    """
+    lines: list[str] = [
+        f"# Reword commit for ISSUE_RESOLUTION: ambiguous closing keyword — "
+        f"{entry.repo_github} branch `{entry.branch}`",
+        "",
+        f"`{entry.branch}`'s PR is marked `ISSUE_RESOLUTION: partial` or "
+        "`ISSUE_RESOLUTION: investigation` — it does NOT fully resolve "
+        f"#{entry.issue_number} — but a commit message on this branch still "
+        f"uses a GitHub closing keyword for #{entry.issue_number}.",
+        f"Reason: {entry.error or 'issue_resolution_closing_keyword_in_commit'}",
+        "",
+        f"Issue: #{entry.issue_number} — {entry.issue_title}",
+        "",
+        "## Where you are",
+        "",
+        f"You are already in a dedicated git worktree checked out on "
+        f"`{entry.branch}` — the coordinator created it for you. Work HERE.",
+        "",
+        f"Do **NOT** `cd {repo_path}` (that is the machine's shared base "
+        "checkout) and do NOT `git checkout` / `git switch` anywhere. Leaving "
+        f"the base checkout parked on `{entry.branch}` breaks every later "
+        "dispatch against that branch on this machine (#1694).",
+        "",
+        "## Steps",
+        "",
+        "1. `git fetch origin`",
+        f"2. Record the pre-rewrite fingerprint: `git diff "
+        f"origin/{entry.target_branch}...HEAD | git patch-id --stable` and "
+        f"confirm `git diff origin/{entry.target_branch} HEAD` is what you "
+        "expect it to be (whatever it is now, it must be IDENTICAL after "
+        "the reword).",
+        f"3. Find the commit(s) whose subject or body references "
+        f"`#{entry.issue_number}` with a closing keyword — `Fix`/`Fixes`/"
+        f"`Fixed`/`Close`/`Closes`/`Closed`/`Resolve`/`Resolves`/`Resolved` "
+        f"immediately followed by `#{entry.issue_number}` — and reword ONLY "
+        "that wording to `Refs`, via `git rebase -i "
+        f"origin/{entry.target_branch}` (`reword` on each such commit) or "
+        "`git commit --amend` if it is the tip commit. Change nothing else "
+        "in the message and nothing in the diff.",
+        f"4. Re-check the fingerprint from step 2: `git diff "
+        f"origin/{entry.target_branch}...HEAD | git patch-id --stable` must "
+        f"match EXACTLY, and `git diff origin/{entry.target_branch} HEAD` "
+        "must be byte-identical to step 2's. If either differs, see "
+        '"When NOT to guess" below.',
+        f"5. `git push --force-with-lease origin {entry.branch}`",
+        "6. Exit 0 if push succeeds; non-zero otherwise.",
+        "",
+        "## When NOT to guess",
+        "",
+        "This dispatch is authorized for a MESSAGE-ONLY rewrite — never a "
+        "content change. If a conflict marker appears during the rebase, "
+        "or either fingerprint from step 4 differs from step 2's, DO NOT "
+        "push: something touched content, not just wording, and this "
+        "worker's narrow authorization does not cover resolving that. Stop "
+        "and end your turn with a `STUCK:` line that begins with the exact "
+        f"marker `{REWORD_MISMATCH_MARKER}` and then names what happened, "
+        "e.g.",
+        "",
+        f"    STUCK: {REWORD_MISMATCH_MARKER} — patch-id before <hash>, "
+        "after <hash> differ",
+        "",
+        "The coordinator reads that marker from your transcript, not your "
+        "process exit code (which you cannot control), and escalates to a "
+        f"human on issue #{entry.issue_number} rather than force-pushing a "
+        "diff the review that already approved this branch never saw.",
+        "",
+        "You will NOT use `gh` or `git push --force` — both are denied by "
+        "the harness. The coordinator owns PR retries and issue posting.",
+    ]
+    return "\n".join(lines)
+
+
+def reword_mismatch_verdict_in_text(text: str | None) -> bool:
+    """True when a reword-commit conflict-fix worker's log carries the
+    :data:`REWORD_MISMATCH_MARKER` — i.e. it refused to push because the
+    rewrite was not content-preserving (a real conflict, or a patch-id/tree
+    mismatch). Mirrors :func:`stale_rebase_mismatch_verdict_in_text`.
+    """
+    if not text:
+        return False
+    return REWORD_MISMATCH_MARKER in _decode_worker_text(text)
+
+
+def detect_reword_mismatch(
+    *,
+    log_path: str | None = None,
+    host: str | None = None,
+    assignment_id: str | None = None,
+    port: int = AGENT_PORT,
+    timeout: float = 15.0,
+) -> bool:
+    """True when a finished reword-commit conflict-fix worker refused to
+    push because its rewrite was not content-preserving (caught in step 4
+    of :func:`build_reword_commit_briefing`).
+
+    Mirrors :func:`detect_stale_rebase_mismatch` exactly (same
+    local-log-then-agent-endpoint lookup, same best-effort ``False`` on any
+    read/transport failure) but reads for :data:`REWORD_MISMATCH_MARKER` via
+    :func:`reword_mismatch_verdict_in_text`.
+    """
+    if log_path:
+        try:
+            from pathlib import Path  # noqa: PLC0415
+
+            p = Path(log_path)
+            if p.exists():
+                raw = p.read_text(encoding="utf-8", errors="replace")
+                if reword_mismatch_verdict_in_text(raw):
+                    return True
+        except OSError:
+            pass
+
+    if host and assignment_id:
+        try:
+            resp = httpx.get(
+                f"http://{host}:{port}/logs/{assignment_id}", timeout=timeout
+            )
+            resp.raise_for_status()
+            return reword_mismatch_verdict_in_text(resp.text)
+        except (httpx.HTTPError, httpx.TimeoutException):
+            return False
+
+    return False
+
+
 def build_conflict_fix_briefing(
     *,
     entry: QueuedMerge,
@@ -1418,6 +1666,7 @@ def dispatch_conflict_fix(
     stuck_summary: str | None = None,
     stale_rebase: bool = False,
     after_stale_rebase_mismatch: bool = False,
+    reword_commit: bool = False,
     status_fetcher: Callable[..., StatusResult] | None = None,
     machine_pick_out: "list[ConflictFixMachinePick] | None" = None,
 ) -> Assignment | None:
@@ -1540,6 +1789,26 @@ def dispatch_conflict_fix(
     unaffected: the stale-rebase worker itself still never resolves
     anything — only this ordinary worker (or its own semantic-escalation
     tier) may.
+
+    ``reword_commit=True`` (#3522) dispatches the remedy for a merge-gate
+    refusal recorded as ``issue_resolution_closing_keyword_in_commit``
+    (``coord.merge_queue.process()``'s own gate, fired the moment it sees
+    that refusal — no separate sweep call site needed) — a commit message
+    on the branch carries a GitHub closing keyword for this entry's own
+    issue even though the PR is marked ``ISSUE_RESOLUTION: partial``/
+    ``investigation``. Uses :func:`build_reword_commit_briefing` instead of
+    the ordinary briefing: narrower even than the stale-rebase one, it is
+    authorized ONLY to reword the offending commit message(s) — never to
+    change content — and verifies that with the same patch-id/tree
+    fingerprint technique :func:`build_stale_rebase_briefing` uses to prove
+    its own "just stale" premise. A mismatch (real content change, or a
+    rebase conflict) refuses — STUCK, retry cap consumed exactly like any
+    other conflict-fix failure — rather than force-pushing a diff the
+    review that already approved this branch never saw. Goes through the
+    SAME retry-cap check as the ordinary (non-``semantic``) path above — a
+    reword that recurs against the same error after a prior attempt
+    escalates to a human exactly like a recurring mechanical conflict
+    would.
     """
     if semantic:
         if has_prior_semantic_escalation(board, entry.assignment_id):
@@ -1555,6 +1824,7 @@ def dispatch_conflict_fix(
     sealed_author = (
         not semantic
         and not stale_rebase
+        and not reword_commit
         and entry.assignment_type in SEALED_PATH_AUTHOR_TYPES
     )
 
@@ -1610,6 +1880,14 @@ def dispatch_conflict_fix(
         )
         system_prompt = STALE_REBASE_FIX_SYSTEM_PROMPT
         title = f"{STALE_REBASE_FIX_TITLE_PREFIX} {entry.issue_title}"
+    elif reword_commit:
+        briefing = build_reword_commit_briefing(
+            entry=entry,
+            repo_path=repo_path,
+            test_command=repo.test_command,
+        )
+        system_prompt = REWORD_COMMIT_FIX_SYSTEM_PROMPT
+        title = f"{REWORD_COMMIT_FIX_TITLE_PREFIX} {entry.issue_title}"
     elif sealed_author:
         briefing = build_sealed_manifest_conflict_briefing(
             entry=entry,
@@ -1765,6 +2043,10 @@ def dispatch_conflict_fix(
             # worker's mismatch refusal — same title/briefing either way,
             # so this is the only durable trace of which path led here.
             "after_stale_rebase_mismatch": after_stale_rebase_mismatch,
+            # #3522: same reasoning — distinguishes the message-only reword
+            # remedy from every other conflict-fix flavour without
+            # re-deriving it from the title prefix.
+            "reword_commit": reword_commit,
         },
     )
 

{code_coordinator-0.5.558 → 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.558 → code_coordinator-0.5.560}/coord/drive_queue.py

@@ -329,7 +329,32 @@ PARK_STALE_SECONDS = 45 * 60.0
 # the narrower predicate `coord.commands.drive_queue` uses to also stop its
 # OWN independent auto-dispatch (the stale-rebase conflict-fix revalidation)
 # from re-firing against a row that has already given up this way.
-_PERMANENT_BLOCK_MARKERS: tuple[str, ...] = ("(#1844)", "(#2019)", "(#2972)")
+#
+# #3522: `(#3522)` joined this tuple for a FOURTH shape, distinct from the
+# three above in one way — it IS actively remedied, just never by relaunching
+# a whole drive session. `coord.merge_queue.process()`'s own
+# `issue_resolution_closing_keyword_in_commit` gate refuses to merge a branch
+# whose PR is marked `ISSUE_RESOLUTION: partial`/`investigation` but whose
+# commit message(s) still carry a GitHub closing keyword for that same issue
+# — and, since #3522, dispatches a message-only reword-commit worker
+# (`coord.conflict_fix.dispatch_conflict_fix(..., reword_commit=True)`) the
+# moment it fires. Before that worker existed, a drive that exhausted its
+# merge-attempt budget against this refusal (`_die`'s "merge attempted N
+# times without landing", embedding this module's own diagnostic text
+# verbatim) died into `blocked`, and this sweep's live-gate re-check — which
+# has no way to observe "a commit got reworded on another machine", only
+# whether the merge gate currently reads clear — kept reading the SAME
+# refusal as "unlucky, re-check later" and burned its resume budget
+# relaunching into it (claude-coordinator#3519's exact deadlock: three
+# identical refusals, `resumes=1/3`, `2/3`, `3/3`, then stuck). The actual
+# remedy runs entirely OUTSIDE this relaunch loop — a dedicated worker,
+# dispatched from the merge gate itself, that force-pushes once it has
+# verified the reword changed nothing but wording — so there is nothing for
+# a drive-session relaunch to contribute here either; it can only duplicate
+# spend while the real remedy is already in flight. See
+# `coord.merge_queue.process`'s `issue_resolution_closing_keyword_in_commit`
+# handling for where the marker's text originates.
+_PERMANENT_BLOCK_MARKERS: tuple[str, ...] = ("(#1844)", "(#2019)", "(#2972)", "(#3522)")
 
 
 def is_fix_round_ceiling_reason(reason: str | None) -> bool:
@@ -380,8 +405,13 @@ def is_fix_round_ceiling_blocked(state: str | None, last_reason: str | None) ->
 
 
 def is_permanent_block_reason(text: str | None) -> bool:
-    """Whether *text* names a PERMANENT cause of `blocked` — #2230's sweep
-    must never re-check these; relaunching cannot change either outcome.
+    """Whether *text* names a cause of `blocked` that #2230's sweep must
+    never re-check — **relaunching the drive session cannot change the
+    outcome**, whether that is because the block is truly permanent
+    (#1844/#2019/#2972) or because, #3522, the real remedy already runs
+    entirely outside this sweep's relaunch loop (a dedicated reword-commit
+    worker dispatched straight from the merge gate) and a resume here could
+    only duplicate that spend, never substitute for it.
 
     Marker-based, the same convention `coord.gate_a.is_gate_a_refusal_reason`
     uses for the analogous Gate-A classification: cheap, and correct even

{code_coordinator-0.5.558 → code_coordinator-0.5.560}/coord/merge_queue.py

@@ -7307,6 +7307,18 @@ def process(
     an ``epic_closing_keyword_in_commit_forced`` warning event is still
     emitted — the override is never silent.
 
+    #3522: the identical commit-message shape for THIS entry's own issue
+    (``issue_resolution_closing_keyword_in_commit`` — a `partial`/
+    `investigation` ``ISSUE_RESOLUTION:`` verdict contradicted by its own
+    commit message) is, unlike the epic case above, actually remedied: the
+    moment the refusal fires, *board* and *config* permitting, this
+    dispatches a message-only reword-commit worker
+    (:func:`coord.conflict_fix.dispatch_conflict_fix` with
+    ``reword_commit=True``) so a future `coord merge` attempt can clear the
+    refusal without an operator force-push. The merge itself still refuses
+    THIS attempt either way — the dispatch is fire-and-forget, never
+    awaited inline.
+
     Mutates `items` in place; the caller saves the queue after.
     """
     events: list[MergeEvent] = []
@@ -8558,7 +8570,9 @@ def process(
                     f"GitHub would auto-close the issue on merge regardless of the "
                     f"PR body (#3502). Reword the commit message(s) to 'refs #N' "
                     f"and push, or pass --force-merge to merge anyway (the issue "
-                    f"WILL still auto-close)."
+                    f"WILL still auto-close). The coordinator dispatches an "
+                    f"automatic reword-commit worker for this (#3522); resuming "
+                    f"a drive session cannot fix it on its own."
                 )
                 if force_merge:
                     events.append(MergeEvent(
@@ -8569,6 +8583,70 @@ def process(
                     events.append(MergeEvent(
                         entry, "issue_resolution_closing_keyword_in_commit", msg,
                     ))
+                    # #3522: nothing ever remedied this refusal before — a
+                    # worker's own commit convention (e.g. `Fix #N: ...`)
+                    # deadlocked every retry, and the drive-queue's own
+                    # resume sweep (`coord.drive_queue._reconcile_blocked`)
+                    # burned its resume budget relaunching into the
+                    # identical, unfixable-by-relaunch block
+                    # (claude-coordinator#3519). Dispatch the narrow,
+                    # message-only remedy the instant the gate fires, right
+                    # here — the SAME dispatcher #241/#3349 already use for
+                    # the mechanical/stale-CI shapes, so this is one more
+                    # caller of an existing worker, not a new mechanism.
+                    # Best-effort: *board*/*config* are only ``None`` for a
+                    # caller that never wired merge-gate state through in
+                    # the first place (dry runs, some unit tests), and a
+                    # dispatch failure (no machine, agent unreachable, …)
+                    # must never take down the merge refusal it's trying to
+                    # remedy.
+                    if board is not None and config is not None:
+                        # #3522 review (non-blocking): align with every other
+                        # `dispatch_conflict_fix` call site
+                        # (`commands/merge.py`'s `_machine_for_assignment`,
+                        # `notify.py`'s `prefer_machine=work.machine_name`) —
+                        # prefer the original worker's machine (it already
+                        # has the repo/branch checked out), opt into the
+                        # #3353 live-liveness check via `status_fetcher` (so
+                        # a machine that merely LOOKS idle because it's
+                        # offline isn't picked), and capture a rich decline
+                        # reason via `machine_pick_out` instead of the bare
+                        # `fix is None` the original code silently swallowed.
+                        from coord.conflict_fix import (  # noqa: PLC0415
+                            describe_conflict_fix_decline,
+                            dispatch_conflict_fix,
+                        )
+                        from coord.network import fetch_status  # noqa: PLC0415
+
+                        pick_out: list = []
+                        fix = None
+                        try:
+                            prefer = None
+                            target = board.find_by_id(entry.assignment_id)
+                            if target is not None:
+                                prefer = target.machine_name
+
+                            fix = dispatch_conflict_fix(
+                                entry, board, config, reword_commit=True,
+                                prefer_machine=prefer,
+                                status_fetcher=fetch_status,
+                                machine_pick_out=pick_out,
+                            )
+                        except Exception:  # noqa: BLE001
+                            fix = None
+                        if fix is not None:
+                            events.append(MergeEvent(
+                                entry, "issue_resolution_reword_dispatched",
+                                f"dispatched a reword-commit worker to "
+                                f"{fix.machine_name} for #{entry.issue_number} "
+                                f"(#3522)",
+                            ))
+                        else:
+                            events.append(MergeEvent(
+                                entry, "conflict_fix_dispatch_declined",
+                                "reword-commit dispatch declined: "
+                                + describe_conflict_fix_decline(pick_out),
+                            ))
                     continue  # #3502: refuse — never merge a branch that will
                     # auto-close an issue marked not-yet-resolved via a commit
                     # message we can't rewrite.