code-coordinator 0.5.328__tar.gz → 0.5.330__tar.gz

{code_coordinator-0.5.328 → code_coordinator-0.5.330}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.328",
+  "tag": "0.5.330",
   "distance": 0,
-  "node": "g96977c771489f05d7c30eb4cc2696206c872072b",
+  "node": "g1b5009cd9bd233460972d0e1bfca11135eb4058b",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-31"

{code_coordinator-0.5.328 → code_coordinator-0.5.330}/coord/agent.py

@@ -4282,7 +4282,41 @@ exists. Any time the operator gives you a substantive fact about the \
 client, the users, or the scope, say back what you would record and ask \
 whether to record it. Keep the wording theirs, not your paraphrase — the \
 ledger is verbatim by design, and the narrative (which is regenerable) is \
-where summarizing belongs.\
+where summarizing belongs.
+
+**Confirming a decision on the operator's instruction (#2998).** The base \
+prompt above says never to run `coord portal decision confirm` — that rule \
+was written for a session with nobody to ask. You have someone to ask: the \
+operator sitting at this terminal, who is exactly who that command is \
+reserved for. What never changes, headless or attended, is that YOU may \
+never confirm your own proposal on your own initiative — inferring consent, \
+or treating agreement about something else as consent to confirm, is \
+exactly the self-approval the base rule exists to prevent.
+
+But when the operator gives you an EXPLICIT, PRESENT-TURN instruction to \
+confirm a specific decision ("confirm decision 8", "yes, confirm that"), you \
+MAY act on it, in this order:
+
+1. Quote the operator's instruction back, verbatim, so the transcript makes \
+unambiguous that this was ordered, not inferred.
+2. Record the attribution on the ledger BEFORE confirming, so a later \
+session (or a human reading the ledger) can see this was operator-\
+instructed rather than session-initiated:
+
+    coord portal note <submission_id> "Operator instructed: confirm decision #<seq> (\"<their exact words>\")"
+
+3. Only then run:
+
+    coord portal decision confirm <submission_id> <seq>
+
+Do not collapse this into one step, and do not run it on a vague or implied \
+go-ahead — if you are not sure which decision the operator means, ask for \
+the seq before running anything. This carve-out covers `decision confirm` \
+ONLY. Every other entry on the deny list stays forbidden in this session \
+exactly as it is headlessly (raw `gh` mutations, `git push`, `git commit`, \
+destructive git, `coord approve`, `coord merge`, `coord assign`) — an \
+operator being present changes who may authorize a RESERVED command, it \
+does not change whether a DANGEROUS one is safe.\
 """
 
 # Deny list applied to decomposition-chat workers (#2533; extended #2750
@@ -4296,6 +4330,13 @@ where summarizing belongs.\
 # confirm` (the OPERATOR's move, never this session's own — #2750's "Propose"
 # terminal move must not self-confirm), while every write path this session
 # actually needs is allowed by omission.
+#
+# This is the HEADLESS list — used verbatim by `default_worker_command`'s
+# `spec.type == "decomposition-chat"` branch below, where the session
+# genuinely has nobody to ask, so `decision confirm` stays hard-denied. The
+# `--interactive` posture has an operator in the room; see
+# DECOMPOSITION_CHAT_ATTENDED_DENY_COMMANDS below (#2998) for its own,
+# narrower carve-out of exactly this one entry.
 DECOMPOSITION_CHAT_DENY_COMMANDS: list[str] = [
     "Bash(gh issue edit *)",
     "Bash(gh issue create *)",
@@ -4324,6 +4365,23 @@ DECOMPOSITION_CHAT_DENY_COMMANDS: list[str] = [
     "Bash(coord portal decision confirm *)",
 ]
 
+# #2998: the ATTENDED counterpart to the list above — every entry the same
+# EXCEPT `coord portal decision confirm`. An attended session has an
+# operator sitting at the terminal, and `decision confirm` is RESERVED for
+# the operator (not DANGEROUS the way `git push`/`coord merge`/destructive
+# git are) — the question in that posture is who authorised it, not whether
+# it's safe. DECOMPOSITION_CHAT_ATTENDED_ADDENDUM spells out the condition
+# under which the session may actually run it (an explicit, present-turn
+# operator instruction, quoted back and attributed on the ledger via `coord
+# portal note` before confirming) — this list only stops blanket-denying it
+# so that addendum isn't fighting a FORBIDDEN COMMANDS entry telling the
+# session the opposite. Every genuinely dangerous entry stays denied,
+# unchanged, in both postures.
+DECOMPOSITION_CHAT_ATTENDED_DENY_COMMANDS: list[str] = [
+    cmd for cmd in DECOMPOSITION_CHAT_DENY_COMMANDS
+    if cmd != "Bash(coord portal decision confirm *)"
+]
+
 MOCK_AUTHOR_SYSTEM_PROMPT = """\
 You are an independent mock-author agent for Gate A of a milestone \
 (#930, docs/ORACLE_LOOP.md) — the pre-work architecture gate. You have \

{code_coordinator-0.5.328 → code_coordinator-0.5.330}/coord/commands/drive_queue.py

@@ -80,9 +80,12 @@ from coord.drive_queue import (
     find_cycle,
     fired_holds,
     is_dispatch_failure_reason,
+    is_merge_gate_block_reason,
     is_permanent_block_reason,
     is_pre_dispatch_block_reason,
     is_unsatisfiable_prereq_reason,
+    merge_gate_remedy_command,
+    merge_plan_inspect_command,
     parse_after_spec,
     parse_key,
     pending_probe_targets,
@@ -4526,6 +4529,30 @@ def _requeue_command(entry: QueueEntry | None, key: str) -> str:
     )
 
 
+def _blocked_escalation_command(entry: QueueEntry | None, key: str, reason: str) -> str:
+    """The command a `blocked`/`oscillating` escalation should propose
+    (#3016) — `_requeue_command` ONLY for a genuinely never-dispatched entry;
+    a gate-specific remedy (or the safe read-only inspect fallback) whenever
+    *reason* already names a merge-gate block.
+
+    `_requeue_command` is right exactly once: nothing was ever dispatched
+    for this row (or every dispatch attempt died before an assignment
+    existed), so there is nothing left to lose by dropping and re-adding it.
+    But `is_merge_gate_block_reason` names the other shape — Work/Test/
+    Review already completed and it is the MERGE stage that is stuck — where
+    the same requeue would discard that completed cycle instead of fixing
+    the one gate actually blocking it. `merge_gate_remedy_command` is the
+    one place that maps a merge-gate reason to its safe one-line fix (or, if
+    none is known blind, the inspect command); this only decides WHICH of
+    the two families applies.
+    """
+    if is_merge_gate_block_reason(reason):
+        parsed = parse_key(key)
+        if parsed is not None:
+            return merge_gate_remedy_command(reason, parsed[0], parsed[1])
+    return _requeue_command(entry, key)
+
+
 @drive_queue_group.command("tick")
 @click.option(
     "--max-parallel",
@@ -5071,7 +5098,7 @@ def drive_queue_tick(
                     f"{entry.position if entry else '?'} | after="
                     f"{','.join(entry.after) if entry and entry.after else '(none)'}"
                 ),
-                command=_requeue_command(entry, item.key),
+                command=_blocked_escalation_command(entry, item.key, item.reason),
             )
 
         # #2230: an entry #2230's sweep would have resumed, but has already
@@ -5098,7 +5125,7 @@ def drive_queue_tick(
                     f"/{MAX_BLOCKED_RESUMES} | position="
                     f"{entry.position if entry else '?'}"
                 ),
-                command=_requeue_command(entry, item.key),
+                command=_blocked_escalation_command(entry, item.key, item.reason),
             )
 
         # #2806: a `blocked` entry #2230's sweep targeted this tick, but whose
@@ -5117,6 +5144,14 @@ def drive_queue_tick(
             if parsed is None:
                 continue
             entry = by_key.get(item.key)
+            # #3016: NEVER the `remove && add` requeue here — `item.reason`
+            # already says "the next tick re-probes rather than guessing"
+            # (#2806); a destructive requeue directly contradicts that, and
+            # would additionally discard a completed Work/Test/Review cycle
+            # for no reason connected to what actually failed (a probe, not
+            # a gate). The read-only inspect command is the only thing safe
+            # to propose when the tick itself does not yet know what shape
+            # this block is.
             _escalate(
                 parsed[0],
                 parsed[1],
@@ -5125,7 +5160,7 @@ def drive_queue_tick(
                     f"queue_state=blocked | gate_reading=unreadable | "
                     f"position={entry.position if entry else '?'}"
                 ),
-                command=_requeue_command(entry, item.key),
+                command=merge_plan_inspect_command(parsed[0]),
             )
 
         if plan.alert is not None:

{code_coordinator-0.5.328 → code_coordinator-0.5.330}/coord/commands/portal.py

@@ -723,7 +723,7 @@ def _run_decompose_chat_interactive(
     from coord.agent import (  # noqa: PLC0415
         AssignmentSpec as _AssignmentSpecDc,
         DECOMPOSITION_CHAT_ATTENDED_ADDENDUM,
-        DECOMPOSITION_CHAT_DENY_COMMANDS,
+        DECOMPOSITION_CHAT_ATTENDED_DENY_COMMANDS,
         DECOMPOSITION_CHAT_SYSTEM_PROMPT,
         build_deny_prompt,
     )
@@ -854,13 +854,21 @@ def _run_decompose_chat_interactive(
     # This session, by contrast, has a human in the pane: the addendum makes
     # its first turn confirm-then-write (#2742's absorbed half, which #2750
     # only ever wired into mode SELECTION, never into the posture itself).
+    #
+    # #2998: the deny list here is the ATTENDED one — identical to the
+    # headless DECOMPOSITION_CHAT_DENY_COMMANDS except it does not blanket-
+    # forbid `coord portal decision confirm`, because DECOMPOSITION_CHAT_
+    # ATTENDED_ADDENDUM spells out the (narrow, operator-instruction-gated)
+    # condition under which this session may run it. The headless path above
+    # keeps using the unmodified list, so a headless session still cannot
+    # confirm, self-confirm, or be talked into confirming.
     argv = provider.build_command(
         spec,
         resolved_model=resolved_model,
         system_prompt=(
             DECOMPOSITION_CHAT_SYSTEM_PROMPT
             + DECOMPOSITION_CHAT_ATTENDED_ADDENDUM
-            + build_deny_prompt(DECOMPOSITION_CHAT_DENY_COMMANDS)
+            + build_deny_prompt(DECOMPOSITION_CHAT_ATTENDED_DENY_COMMANDS)
         ),
         allowed_tools="Read,Bash",
     )

{code_coordinator-0.5.328 → code_coordinator-0.5.330}/coord/drive_queue.py

@@ -94,6 +94,7 @@ from coord.gate_a import is_gate_a_refusal_reason
 from coord.github_ops import is_throttle_skip_reason, parse_throttle_skip_until
 from coord.issues_sync_status import STALENESS_WARN_SECONDS as ISSUE_CACHE_STALE_CEILING_S
 from coord.merge_queue import (
+    CI_STALE_PREFIX,
     PLAN_READY,
     ci_rollup_all_clear,
     is_ci_flaky_reason,
@@ -2746,6 +2747,74 @@ def _is_merge_gate_block_reason(reason: str | None) -> bool:
     return "merge_status=" in lowered
 
 
+def merge_plan_inspect_command(repo: str) -> str:
+    """The read-only ``coord merge --plan`` fallback (#3016) — safe to
+    propose whenever no specific, blind-runnable remedy is known, because it
+    never mutates anything. Used both as :func:`merge_gate_remedy_command`'s
+    own fallback and directly by callers escalating a #2806 ``gate_unreadable``
+    outcome, whose reason text already says "the next tick re-probes" — the
+    destructive `remove && add` requeue would directly contradict that.
+    """
+    return f"coord merge --plan --repo {repo}"
+
+
+def merge_gate_remedy_command(reason: str | None, repo: str, issue: int) -> str:
+    """The gate-specific one-line fix for a `_is_merge_gate_block_reason`
+    block (#3016) — never the blanket ``drive-queue remove && add`` requeue
+    a synthetic escalation writer would otherwise reach for by default.
+
+    A requeue is not merely useless for a merge-gate block, it is actively
+    destructive: it discards a completed Work/Test/Review cycle to re-run it
+    from scratch, when the real fix is a single, targeted merge-lane command
+    — exactly the misdirection `_is_merge_gate_block_reason`'s own docstring
+    already names two live escalations (claude-coordinator#2405, coord-web#2)
+    as having produced, and #2424 only fixed on the prose (``reason``) side,
+    leaving this — the field a one-click "Run proposed fix" menu actually
+    executes — untouched.
+
+    Only the CI-stale / stale-but-passed-smoke shape has a remedy that is
+    both KNOWN and SAFE to run blind: ``coord merge --revalidate --only
+    <repo>#<issue>``, the exact command :func:`coord.merge_queue.
+    ci_stale_reason`'s own prose already tells the operator to run (matched
+    textually here — via :data:`coord.merge_queue.CI_STALE_PREFIX` and
+    :func:`is_stale_smoke_reason` — rather than re-derived, so the two can
+    never diverge on what "CI stale" means).
+
+    Every other shape this matches — red CI (``checks failed``), a
+    review/smoke gate divergence (``review_required —``/``smoke_required
+    —``), an opaque terminal ``merge_status=`` — has no single command that
+    is always both correct and safe to run without a human first reading
+    the actual gate state (fixing a named CI check, recovering or re-running
+    a review, deciding a UAT verdict). Guessing wrong there is worse than
+    not guessing: the menu this feeds runs the command on one click. So
+    every one of those falls back to the read-only inspect command instead
+    — see #3016's design note ("a wrong 'Recommended' is worse than no
+    recommendation").
+
+    Callers are expected to gate on :func:`_is_merge_gate_block_reason`
+    first; called on a reason that ISN'T a merge-gate block at all, this
+    still returns the safe inspect fallback rather than raising — there is
+    no reason this text-matching helper needs to enforce that precondition
+    itself when a wrong answer here is never destructive.
+    """
+    if reason and (
+        CI_STALE_PREFIX.lower() in reason.lower() or is_stale_smoke_reason(reason)
+    ):
+        return f"coord merge --revalidate --only {entry_key(repo, issue)}"
+    return merge_plan_inspect_command(repo)
+
+
+def is_merge_gate_block_reason(reason: str | None) -> bool:
+    """Public alias for :func:`_is_merge_gate_block_reason` (#3016).
+
+    Same convention as ``is_empty_branch_death_reason``/
+    ``is_unsatisfiable_prereq_reason``: the classifier is shared with the
+    synthetic escalation writers in ``coord.commands.drive_queue``, so it
+    gets a non-underscored name rather than a second copy of the text match.
+    """
+    return _is_merge_gate_block_reason(reason)
+
+
 def _is_empty_branch_death_reason(reason: str | None) -> bool:
     """#2363: does *reason* name the "claimed success, wrote nothing"
     signature — an acceptance-author or plain work session that exited

{code_coordinator-0.5.328 → code_coordinator-0.5.330}/tests/test_cli_drive_queue.py

@@ -1987,6 +1987,78 @@ def test_a_dead_drives_own_exit_reason_reaches_the_queue_row(
     assert state._get_drive_escalation_local(REPO, 1762) is not None
 
 
+def test_exhausted_ci_stale_escalation_proposes_revalidate_not_a_requeue(
+    cli, seed, launches, coord_db, config_file
+):
+    """#3016 regression fixture — the exact claude-coordinator#2983 shape
+    (2026-08-31), rendered end-to-end through the real `coord drive-queue
+    tick` -> escalation write -> `coord escalate list` path: a merge-gate
+    death whose OWN reason already names `coord merge --revalidate` as the
+    fix must not have the escalation's `proposed_command` — the ONE field a
+    one-click "Run proposed fix" menu actually runs — propose the blanket
+    `drive-queue remove && add` requeue instead. #2424 already fixed the
+    parallel misdirection in the `reason` prose; this pins the field that
+    executes.
+    """
+    from coord.audit import record_audit
+
+    seed(issues={2983: "open"})
+    cli("add", REPO, "2983")
+    cli("tick")
+
+    def _own_reason(n: int) -> str:
+        return (
+            f"drive exited for {REPO}#2983 (exit_code=1): merge attempted "
+            f"3 times without landing.\n"
+            "   Last board state: status='PENDING' reason='CI stale: checks "
+            "predate the current base (...); auto-rerun budget exhausted "
+            "(2/2) — re-run CI (`coord merge --revalidate`) before merging'"
+            f" (attempt {n})"
+        )
+
+    launched_at = queued(2983)["launched_at"]
+    _backdate(2983, DRIVE_STARTUP_GRACE_SECONDS + 60)
+    record_audit(
+        tier="business", category="drive", event_type="drive_exited",
+        actor="drive", summary=_own_reason(1), repo=REPO, issue=2983,
+        ts=launched_at + 5,
+    )
+    cli("tick")
+
+    _backdate_reason(coord_db, 2983, DRIVE_STARTUP_GRACE_SECONDS + 60)
+    relaunch = cli("tick")
+    assert relaunch.exit_code == 0, relaunch.output
+    assert queued(2983)["state"] == "running"
+
+    launched_at = queued(2983)["launched_at"]
+    _backdate(2983, DRIVE_STARTUP_GRACE_SECONDS + 60)
+    record_audit(
+        tier="business", category="drive", event_type="drive_exited",
+        actor="drive", summary=_own_reason(2), repo=REPO, issue=2983,
+        ts=launched_at + 5,
+    )
+    second_retry = cli("tick")
+    assert second_retry.exit_code == 0, second_retry.output
+
+    entry = queued(2983)
+    assert entry["state"] == "blocked"
+
+    listing = CliRunner().invoke(
+        main, ["escalate", "list", "--config", str(config_file)]
+    )
+    assert listing.exit_code == 0, listing.output
+    assert f"{REPO} #2983" in listing.output
+    assert "coord merge --revalidate" in listing.output
+    assert f"--only {REPO}#2983" in listing.output
+    assert "drive-queue remove" not in listing.output
+    assert "drive-queue add" not in listing.output
+
+    escalation = state._get_drive_escalation_local(REPO, 2983)
+    assert escalation is not None
+    proposed = escalation["proposed_command"]
+    assert proposed == f"coord merge --revalidate --only {REPO}#2983"
+
+
 def test_a_permanent_dispatch_refusal_blocks_on_the_first_tick_no_attempt_spent(
     cli, seed, launches,
 ):

{code_coordinator-0.5.328 → code_coordinator-0.5.330}/tests/test_decomposition_chat.py

@@ -10,6 +10,7 @@ import pytest
 from coord import decomposition_chat
 from coord.agent import (
     AssignmentSpec,
+    DECOMPOSITION_CHAT_ATTENDED_DENY_COMMANDS,
     DECOMPOSITION_CHAT_DENY_COMMANDS,
     DECOMPOSITION_CHAT_SYSTEM_PROMPT,
     WRITE_CAPABLE_SPEC_TYPES,
@@ -1108,6 +1109,116 @@ def test_deny_list_blocks_self_confirming_a_proposal():
     assert "Bash(coord portal decision confirm *)" in DECOMPOSITION_CHAT_DENY_COMMANDS
 
 
+# ── #2998: attended sessions may confirm on explicit operator instruction ──
+
+
+def test_attended_deny_list_omits_only_decision_confirm():
+    """The attended deny list is the headless one minus exactly one entry —
+    `coord portal decision confirm`. Every genuinely dangerous entry (raw
+    `gh` mutations, `git push`/`commit`, destructive git, `coord approve`/
+    `merge`/`assign`) must stay denied in both postures."""
+    assert (
+        "Bash(coord portal decision confirm *)"
+        not in DECOMPOSITION_CHAT_ATTENDED_DENY_COMMANDS
+    )
+    removed = set(DECOMPOSITION_CHAT_DENY_COMMANDS) - set(
+        DECOMPOSITION_CHAT_ATTENDED_DENY_COMMANDS
+    )
+    assert removed == {"Bash(coord portal decision confirm *)"}
+    # Nothing was added that wasn't already on the headless list.
+    assert set(DECOMPOSITION_CHAT_ATTENDED_DENY_COMMANDS) <= set(
+        DECOMPOSITION_CHAT_DENY_COMMANDS
+    )
+
+
+def test_headless_deny_list_is_untouched_by_the_attended_carve_out():
+    """Acceptance bar: "the headless posture is unchanged" — the constant the
+    headless dispatch path actually uses still hard-denies confirm."""
+    assert "Bash(coord portal decision confirm *)" in DECOMPOSITION_CHAT_DENY_COMMANDS
+
+
+def test_attended_addendum_permits_confirm_on_explicit_operator_instruction():
+    from coord.agent import DECOMPOSITION_CHAT_ATTENDED_ADDENDUM
+
+    assert "#2998" in DECOMPOSITION_CHAT_ATTENDED_ADDENDUM
+    assert "coord portal decision confirm" in DECOMPOSITION_CHAT_ATTENDED_ADDENDUM
+    # Requires an explicit, present-turn instruction — never inferred assent.
+    assert "EXPLICIT, PRESENT-TURN instruction" in DECOMPOSITION_CHAT_ATTENDED_ADDENDUM
+    assert "own initiative" in DECOMPOSITION_CHAT_ATTENDED_ADDENDUM
+    # Attribution: a ledger note recorded BEFORE the confirm runs.
+    assert "coord portal note" in DECOMPOSITION_CHAT_ATTENDED_ADDENDUM
+    assert "Operator instructed" in DECOMPOSITION_CHAT_ATTENDED_ADDENDUM
+    confirm_section = DECOMPOSITION_CHAT_ATTENDED_ADDENDUM.split(
+        "Confirming a decision on the operator's instruction"
+    )[1]
+    assert confirm_section.index("coord portal note") < confirm_section.index(
+        "coord portal decision confirm <submission_id> <seq>"
+    )
+    # The dangerous entries are called out as staying forbidden regardless.
+    assert "coord approve" in confirm_section
+    assert "coord merge" in confirm_section
+    assert "git push" in confirm_section
+
+
+def test_cli_interactive_dry_run_permits_confirm_but_keeps_dangerous_entries_denied():
+    """The system prompt `_run_decompose_chat_interactive` actually builds
+    must not list `coord portal decision confirm` under FORBIDDEN COMMANDS
+    (the addendum, not a blanket deny, governs it) while every dangerous
+    entry stays listed."""
+    from click.testing import CliRunner
+
+    from coord.commands.portal import portal_group
+
+    runner = CliRunner()
+    local = _machine("here", ["api"])
+    cfg = Config(repos=[_repo("api")], machines=[local])
+    with patch("coord.commands.portal._load_config", return_value=cfg), patch(
+        "coord.decomposition_chat.resolve_approved_submission", return_value=SUBMISSION
+    ), patch("coord.test_orchestrator.local_machine", return_value=local), patch(
+        "coord.board_service.resolve", return_value=None
+    ), patch("coord.state.record_dispatched_assignment"), patch(
+        "coord.interactive.launch_human_attended_interactive"
+    ):
+        result = runner.invoke(
+            portal_group,
+            ["decompose-chat", "sub_2f6a1c", "--interactive", "--discuss", "--dry-run"],
+        )
+    assert result.exit_code == 0, result.output
+    forbidden_section = result.output.split("FORBIDDEN")[-1]
+    assert "coord portal decision confirm" not in forbidden_section
+    assert "coord approve" in forbidden_section
+    assert "coord merge" in forbidden_section
+    assert "git push" in forbidden_section
+    assert "rm -rf" in forbidden_section
+    # ...but the addendum's own gated carve-out is present elsewhere in the
+    # prompt, spelling out how confirm may be used.
+    assert "#2998" in result.output
+    assert "coord portal note" in result.output
+
+
+def test_default_worker_command_decomposition_chat_still_forbids_confirm():
+    """Headless-unchanged regression guard: the actual argv the headless
+    dispatch path builds still lists `coord portal decision confirm` under
+    FORBIDDEN COMMANDS, with no operator-instruction carve-out text at all
+    (that text lives only in DECOMPOSITION_CHAT_ATTENDED_ADDENDUM, which the
+    headless path never appends — see
+    test_headless_decomposition_chat_prompt_has_no_attended_posture)."""
+    spec = AssignmentSpec(
+        repo_name="r",
+        repo_path="/tmp/r",
+        issue_number=0,
+        issue_title="decomposition: sub_2f6a1c",
+        briefing="b",
+        type="decomposition-chat",
+    )
+    argv = default_worker_command(spec)
+    idx = argv.index("--system-prompt")
+    system_prompt = argv[idx + 1]
+    forbidden_section = system_prompt.split("FORBIDDEN")[-1]
+    assert "coord portal decision confirm" in forbidden_section
+    assert "#2998" not in system_prompt
+
+
 # ── #2750 (IL-4): `coord portal decompose-chat` CLI — --discuss/--interactive ──
 
 

{code_coordinator-0.5.328 → code_coordinator-0.5.330}/tests/test_drive_queue.py

@@ -46,6 +46,9 @@ from coord.drive_queue import (
     entry_key,
     find_cycle,
     is_empty_branch_death_reason,
+    is_merge_gate_block_reason,
+    merge_gate_remedy_command,
+    merge_plan_inspect_command,
     parse_after_spec,
     parse_key,
     plan_tick,
@@ -5468,3 +5471,82 @@ def test_detect_unreachable_waits_reproduces_the_ms5_incident_shape():
         assert dep.key not in alert.reason
     assert "8 dependent entries" in alert.reason
     assert "self-heal" in alert.reason
+
+
+# ── #3016: the escalation-time remedy for a merge-gate block must be the ──
+# gate-specific fix, never the blanket `drive-queue remove && add` requeue —
+# a requeue discards a completed Work/Test/Review cycle instead of fixing
+# the one gate actually stuck. `merge_gate_remedy_command` is the mapping;
+# `is_merge_gate_block_reason` (already exercised elsewhere via #2424) is
+# what a caller gates on before reaching for it.
+
+
+def test_merge_gate_remedy_command_is_the_2983_regression_fixture():
+    """The exact claude-coordinator#2983 shape (2026-08-31): a `merge
+    attempted N times without landing` death whose OWN reason already names
+    `coord merge --revalidate` as the fix must map to a scoped revalidate
+    command, never a requeue."""
+    reason = (
+        "drive exited (exit_code=1): merge attempted 3 times without "
+        "landing.\n   Last board state: status='PENDING' reason='CI stale: "
+        "checks predate the current base (...); auto-rerun budget exhausted "
+        "(2/2) — re-run CI (`coord merge --revalidate`) before merging'"
+    )
+    assert is_merge_gate_block_reason(reason) is True
+    command = merge_gate_remedy_command(reason, REPO, 2983)
+    assert command == f"coord merge --revalidate --only {REPO}#2983"
+    assert "drive-queue remove" not in command
+    assert "drive-queue add" not in command
+
+
+def test_merge_gate_remedy_command_handles_a_stale_smoke_verdict():
+    """The #1479 staleness race — `is_stale_smoke_reason` matches even
+    without the `CI stale:` prefix at all — same remedy, same reasoning."""
+    reason = "smoke test verdict is stale: recorded against base abc123, base is now def456"
+    assert is_merge_gate_block_reason(reason) is True
+    command = merge_gate_remedy_command(reason, REPO, 1650)
+    assert command == f"coord merge --revalidate --only {REPO}#1650"
+
+
+def test_merge_gate_remedy_command_falls_back_to_inspect_for_red_ci():
+    """`checks failed` (red CI) has no safe one-line auto-fix — the correct
+    remedy is "fix the named check", which is not a command this can hand
+    an operator to run blind. Falls back to the read-only inspect command
+    rather than a requeue or a guess."""
+    reason = "checks failed: build (exit 1)"
+    assert is_merge_gate_block_reason(reason) is True
+    command = merge_gate_remedy_command(reason, REPO, 1650)
+    assert command == merge_plan_inspect_command(REPO)
+    assert "revalidate" not in command
+    assert "drive-queue remove" not in command
+
+
+def test_merge_gate_remedy_command_falls_back_to_inspect_for_review_required():
+    reason = (
+        "review_required — coord merge's own gate reports 'review missing', "
+        "but this driver's OWN view already shows review_verdict='approved'"
+    )
+    assert is_merge_gate_block_reason(reason) is True
+    assert merge_gate_remedy_command(reason, REPO, 1650) == merge_plan_inspect_command(REPO)
+
+
+def test_merge_gate_remedy_command_falls_back_to_inspect_for_smoke_required():
+    reason = "smoke_required — coord merge's own gate reports 'no verdict'"
+    assert is_merge_gate_block_reason(reason) is True
+    assert merge_gate_remedy_command(reason, REPO, 1650) == merge_plan_inspect_command(REPO)
+
+
+def test_merge_gate_remedy_command_falls_back_to_inspect_for_opaque_merge_status():
+    reason = "merge_status=NEEDS_ATTENTION — no number of retries changes this"
+    assert is_merge_gate_block_reason(reason) is True
+    assert merge_gate_remedy_command(reason, REPO, 1650) == merge_plan_inspect_command(REPO)
+
+
+def test_merge_gate_remedy_command_is_the_safe_inspect_fallback_for_none_and_non_block_reasons():
+    """Never raises — called on a reason that isn't a merge-gate block at
+    all (or is missing entirely), it still returns the safe, read-only
+    fallback rather than asserting a precondition on its caller."""
+    assert merge_gate_remedy_command(None, REPO, 1650) == merge_plan_inspect_command(REPO)
+    ordinary = "no candidate machine available for claude-coordinator#1650"
+    assert is_merge_gate_block_reason(ordinary) is False
+    assert merge_gate_remedy_command(ordinary, REPO, 1650) == merge_plan_inspect_command(REPO)