"""F007 — the unchanged-PR re-submit loop-stopper is root-only; ``submit_up`` (cell→root) had no head_sha guard, so a weak cell PM could re-submit the unchanged cell PR and loop ``awaiting_pr_review`` → ``pr_fail`` forever (the cell-level analogue of the 2026-06-27 root loop F016 closes). ``pr_fail`` stamps the assembled PR's head SHA into ``notes_structured.pr_review.head_sha`` for BOTH cell and root gate tasks (``pr_gate._capture_pr_head_sha`` / ``_record_gate_verdict`` are gate-verb-level, not root-level). So the same structural refusal applies to ``submit_up``: if the cell PR's current head SHA equals the SHA the last ``pr_fail`` recorded, no new dev work landed on the cell branch ⇒ the diff is byte-identical ⇒ refuse, do not re-open the gate. Every ambiguous case FAILS OPEN, identical to the root guard (shared ``_current_pr_head_sha``). """ from __future__ import annotations from datetime import UTC, datetime from typing import Any from unittest.mock import AsyncMock, MagicMock from uuid import uuid4 import pytest from roboco.services.gateway.choreographer import Choreographer, ChoreographerDeps SHA_OLD = "aaaa1111bbbb2222cccc3333dddd4444eeee5555" SHA_NEW = "9999888877776666555544443333222211110000" def _make_deps(**overrides: Any) -> ChoreographerDeps: base: dict[str, Any] = { "task": AsyncMock(), "work_session": AsyncMock(), "git": AsyncMock(), "a2a": AsyncMock(), "journal": AsyncMock(), "audit": AsyncMock(), "evidence_repo": AsyncMock(), } base.update(overrides) base["journal"].has_decision_for_task.return_value = True base["journal"].latest_decision_at.return_value = datetime.now(UTC) base["journal"].has_reflect_for_task.return_value = True return ChoreographerDeps(**base) def _resubmit_cell( *, notes_structured: dict[str, Any] | None, pr_number: int | None = 132, ) -> tuple[Choreographer, Any, Any]: """A cell-PM task re-submitted from ``in_progress`` after a ``pr_fail``. Mirrors a live cell re-submit: the cell task is back in ``in_progress`` (re-claimed out of ``needs_revision``), carries the prior ``pr_fail`` verdict in ``notes_structured.pr_review``, and the cell→root PR is still open. The ``_submit_up_guard`` preflight is satisfied (owned by the cell PM, journal decision, subtasks terminal, branch present, notes long enough) so the unchanged-PR gate is the thing under test. """ cell_pm_id = uuid4() cell_task_id = uuid4() in_prog = MagicMock( id=cell_task_id, status="in_progress", assigned_to=cell_pm_id, pr_number=pr_number, branch_name="feature/backend/cell-task", parent_task_id=uuid4(), batch_id=None, team="backend", notes_structured=notes_structured, ) gated = MagicMock(**{**in_prog.__dict__, "status": "awaiting_pr_review"}) task_svc = AsyncMock() task_svc.get.return_value = in_prog task_svc.submit_for_review.return_value = gated task_svc.all_subtasks_terminal.return_value = True task_svc.uncovered_parent_acceptance_criteria.return_value = [] task_svc.agent_for.return_value = MagicMock(role="cell_pm", team="backend") task_svc.session.begin_nested = MagicMock( return_value=MagicMock(__aenter__=AsyncMock(), __aexit__=AsyncMock()) ) c = Choreographer(_make_deps(task=task_svc, git=AsyncMock())) cc: Any = c cc._project_slug_for = AsyncMock(return_value="proj-slug") return c, cell_pm_id, cell_task_id @pytest.mark.asyncio async def test_submit_up_refuses_unchanged_pr_after_pr_fail() -> None: """The loop-stopper: prior pr_fail stamped head SHA X, the cell PR head is still X (no new dev work on the cell branch) → refuse, do not re-open the gate.""" c, cell_pm_id, cell_task_id = _resubmit_cell( notes_structured={ "pr_review": {"verdict": "failed", "head_sha": SHA_OLD, "summary": "..."} } ) c.git.get_pr_head_sha = AsyncMock(return_value=SHA_OLD) env = await c.submit_up( cell_pm_id, cell_task_id, notes="re-submitting the cell after the fix" ) assert env.error is not None, env.as_dict() assert env.error == "invalid_state", env.as_dict() assert "unchanged" in (env.message or "").lower() remediate = env.remediate or "" assert "submit_up" in remediate # The cell PR was NOT re-opened / re-pushed — the runner never ran. c.task.submit_for_review.assert_not_awaited() @pytest.mark.asyncio async def test_submit_up_allows_after_cell_branch_advanced() -> None: """A different current head SHA ⇒ dev work landed on the cell branch ⇒ the diff changed ⇒ allow the re-submit into the gate.""" c, cell_pm_id, cell_task_id = _resubmit_cell( notes_structured={ "pr_review": {"verdict": "failed", "head_sha": SHA_OLD, "summary": "..."} } ) c.git.get_pr_head_sha = AsyncMock(return_value=SHA_NEW) env = await c.submit_up( cell_pm_id, cell_task_id, notes="re-submitting after the dev re-assembly" ) assert env.error is None, env.as_dict() assert env.status == "awaiting_pr_review" c.task.submit_for_review.assert_awaited_once() @pytest.mark.asyncio async def test_submit_up_fail_open_when_no_prior_pr_fail_verdict() -> None: """No pr_review (first submit) ⇒ nothing to compare ⇒ allow.""" c, cell_pm_id, cell_task_id = _resubmit_cell(notes_structured=None) env = await c.submit_up( cell_pm_id, cell_task_id, notes="first cell submit; nothing to compare yet" ) assert env.error is None, env.as_dict() assert env.status == "awaiting_pr_review" # --------------------------------------------------------------------------- # F122: when submit_for_review returns None (a concurrent state change moved # the task out of in_progress AFTER the create_pr pre-side-effect already # opened the cell→root PR), the invalid_state remediate must TELL the cell PM # the PR is already open. The old remediate ('must be in_progress with PR # ready') hid that the PR exists — so the agent could not tell an orphaned PR # was sitting on GitHub. The orphan is inherent to the correct pre-side-effect # ordering (submit_for_review's pr_created gate requires create_pr first, see # lifecycle.py:1338-1343) and is recoverable via create_pr's idempotent re-issue # — but only if the agent KNOWS the PR is open. Mirrors submit_root's F016 # remediate (_impl.py:6305-6310). # --------------------------------------------------------------------------- @pytest.mark.asyncio async def test_submit_up_none_remediate_names_the_already_open_pr() -> None: """F122: submit_for_review returns None (raced out of in_progress) AFTER create_pr already opened the cell→root PR. The rejection remediate must name the open PR and point the PM at re-fetching + reconciling, not the misleading 'must be in_progress with PR ready' that hides the PR exists.""" c, cell_pm_id, cell_task_id = _resubmit_cell(notes_structured=None) # A concurrent transition (stale-heartbeat reaper unclaim, or a racing # i_am_blocked) moved the task out of in_progress between the precondition # gate and the runner's composed action → submit_for_review returns None. c.task.submit_for_review.return_value = None env = await c.submit_up( cell_pm_id, cell_task_id, notes="submitting the assembled cell scope" ) assert env.error == "invalid_state", env.as_dict() remediate = (env.remediate or "").lower() # The create_pr pre-side-effect ran BEFORE the None transition, so the PR # is open on GitHub — the remediate must say so. The old 'PR ready' hint # hid this. assert "pr" in remediate and "open" in remediate, env.as_dict() # The misleading old hint is gone. assert "pr ready" not in remediate, env.as_dict() # And the PR really was opened (pre-side-effect ran before the None). c.git.create_pr.assert_awaited_once()