code-coordinator 0.5.527__tar.gz → 0.5.529__tar.gz

{code_coordinator-0.5.527 → code_coordinator-0.5.529}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.527
+Version: 0.5.529
 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.529/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.529",
+  "distance": 0,
+  "node": "g3f472c582029adafcec0ee12c3abf4df1ccd9b88",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-28"
+}

{code_coordinator-0.5.527 → code_coordinator-0.5.529}/coord/conflict_fix.py

@@ -41,6 +41,18 @@ this same worker for that case, briefed narrowly (see
 rebase and refuse — rather than resolve — the instant a real conflict or a
 content change (a ``git patch-id --stable`` mismatch) shows up, since that
 would mean the "just stale" premise was wrong.
+
+#3462: a patch-id mismatch caught by the stale-rebase worker has TWO
+distinct causes, not one — a genuine overlapping edit against the moved
+base, OR the branch being SUPERSEDED (its content already landed on the
+target through another change, so ``git pull --rebase`` drops the now-
+empty commit, or the post-rebase diff is a strict subset of the original).
+:func:`build_stale_rebase_briefing` checks patch-equivalence against the
+target (``git merge-tree``, before and after the rebase) and emits a
+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.
 """
 
 from __future__ import annotations
@@ -514,6 +526,16 @@ def sealed_conflict_could_touch_manifest(files: list[str]) -> bool:
 # MARKER: a fixed, machine-parseable string, not prose.
 STALE_REBASE_MISMATCH_MARKER = "coord:conflict=stale-rebase-mismatch"
 
+# Marker a stale-rebase conflict-fix worker's log carries when it finds the
+# branch's content is already fully present on the target branch — a
+# patch-id (or diff) mismatch that comes from the branch being SUPERSEDED
+# (the same change landed via another issue, maybe with extra tests) rather
+# than from a real overlapping edit (#3462). This is the twin of
+# STALE_REBASE_MISMATCH_MARKER: both fire on a patch-id difference, but only
+# one of them means there is a genuine conflict to resolve — this one means
+# there is nothing left to land at all.
+ALREADY_UPSTREAM_MARKER = "coord:conflict=already-upstream"
+
 # Title prefix for a stale-rebase conflict-fix dispatch — visible in the TUI
 # Pipeline row so an operator can tell at a glance this used the narrower,
 # no-conflict-expected briefing rather than the ordinary one.
@@ -531,23 +553,40 @@ Rules:
 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).
-- Before pushing, confirm the rebase changed nothing: compare the branch's \
-content-addressed `git patch-id --stable` against the target branch BEFORE \
-and AFTER the rebase. They must match exactly.
+- BEFORE rebasing, check whether this branch's content is already fully \
+present on the target (the same change landed via another issue, maybe \
+with extra tests): compare `git merge-tree --write-tree origin/<target> \
+HEAD` against `git rev-parse origin/<target>^{tree}`. If they match, \
+merging this branch would add nothing — there is no conflict AND nothing \
+to rebase. Stop immediately (do not rebase, do not push) and end your turn \
+with a STUCK: line starting with the marker `coord:conflict=already-upstream`.
+- Otherwise, before pushing, confirm the rebase changed nothing: compare \
+the branch's content-addressed `git patch-id --stable` against the target \
+branch BEFORE and AFTER the rebase. They must match exactly.
+- AFTER rebasing, also check whether the branch ended up with zero commits \
+ahead of the target (`git rev-list origin/<target>..HEAD` empty) or an \
+empty diff (`git diff origin/<target> HEAD` empty) — `git pull --rebase` \
+silently drops a commit that turned out to already be applied. That is the \
+SAME already-upstream conclusion as the pre-rebase check, just caught \
+later: stop, do NOT push, and use the same `coord:conflict=already-upstream` \
+marker.
 - If a real conflict marker appears during the rebase, OR the before/after \
-patch-id differs, DO NOT resolve it and DO NOT push. This dispatch is only \
-authorized for a clean, content-preserving rebase — a real conflict means \
-the base's move genuinely overlaps this branch's own changes, which needs a \
-human judgment call, not a guess. Stop and end your turn with a STUCK: line \
+patch-id differs and the branch is NOT already-upstream by the checks \
+above, DO NOT resolve it and DO NOT push. This dispatch is only authorized \
+for a clean, content-preserving rebase — a real conflict means the base's \
+move genuinely overlaps this branch's own changes, which needs a human \
+judgment call, not a guess. Stop and end your turn with a STUCK: line \
 that starts with the marker `coord:conflict=stale-rebase-mismatch`, e.g.
   STUCK: coord:conflict=stale-rebase-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.
+The coordinator reads these markers from your transcript, not your process \
+exit code (which you cannot control), and escalates to a human either way \
+— `coord:conflict=already-upstream` gets accurate "nothing to merge" \
+text instead of being treated as a real conflict.
 
 Progress reporting:
-- After each significant step (rebase started, patch-id verified, tests \
-passed, pushed), output:
+- After each significant step (already-upstream checked, rebase started, \
+patch-id verified, tests passed, 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.\
@@ -594,35 +633,72 @@ def build_stale_rebase_briefing(
         "## Steps",
         "",
         "1. `git fetch origin`",
-        "2. Record the pre-rebase content fingerprint: "
+        "2. Check whether this branch is already fully upstream BEFORE "
+        "rebasing (#3462): `git merge-tree --write-tree "
+        f"origin/{entry.target_branch} HEAD` and compare its output tree "
+        f"hash against `git rev-parse origin/{entry.target_branch}^{{tree}}`. "
+        "If they match, merging this branch adds NOTHING — the same change "
+        "already landed on the target (e.g. via another issue). Stop here: "
+        "do not rebase, do not push — see \"When the branch is already "
+        "upstream\" below.",
+        "3. Record the pre-rebase content fingerprint: "
         f"`git diff origin/{entry.target_branch}...HEAD | git patch-id --stable`",
-        f"3. `git pull --rebase origin {entry.target_branch}`",
-        "4. If a conflict marker appears ANYWHERE, stop — see \"When NOT to "
+        f"4. `git pull --rebase origin {entry.target_branch}`",
+        "5. If a conflict marker appears ANYWHERE, stop — see \"When NOT to "
         "guess\" below. Do not resolve it.",
-        "5. Record the post-rebase fingerprint the same way: "
+        "6. Check again whether the branch is already upstream, this time "
+        "AFTER rebasing: `git rev-list "
+        f"origin/{entry.target_branch}..HEAD` is empty, or "
+        f"`git diff origin/{entry.target_branch} HEAD` is empty. "
+        "`git pull --rebase` silently drops a commit that turns out to "
+        "already be applied, so this catches the same already-upstream "
+        "case step 2 might have missed (e.g. a subset diff that only "
+        "becomes empty once the rebase itself replays it). If either is "
+        "empty, stop here too — see \"When the branch is already upstream\" "
+        "below. Do not push.",
+        "7. Record the post-rebase fingerprint the same way as step 3: "
         f"`git diff origin/{entry.target_branch}...HEAD | git patch-id --stable`. "
-        "It must EXACTLY match step 2's. If it doesn't, stop — see below.",
-        f"6. Run tests: `{test_cmd}`",
-        f"7. `git push --force-with-lease origin {entry.branch}`",
-        "8. Exit 0 if push succeeds; non-zero otherwise.",
+        "It must EXACTLY match step 3's. If it doesn't, stop — see \"When "
+        "NOT to guess\" below.",
+        f"8. Run tests: `{test_cmd}`",
+        f"9. `git push --force-with-lease origin {entry.branch}`",
+        "10. Exit 0 if push succeeds; non-zero otherwise.",
+        "",
+        "## When the branch is already upstream",
+        "",
+        "Steps 2 and 6 both exist to catch the SAME conclusion at different "
+        "points: this branch's content is already fully present on "
+        f"`{entry.target_branch}` — landed through another change, possibly "
+        "with extra tests added alongside it. There is nothing left to "
+        "merge, and this is NOT a conflict of any kind (mechanical or "
+        "genuine) — do not rebase further, do not resolve anything, and do "
+        "NOT push. Stop and end your turn with a `STUCK:` line that begins "
+        f"with the exact marker `{ALREADY_UPSTREAM_MARKER}` and names which "
+        "check caught it, e.g.",
+        "",
+        f"    STUCK: {ALREADY_UPSTREAM_MARKER} — merge-tree matches target, "
+        "branch adds nothing",
         "",
         "## When NOT to guess",
         "",
         "This dispatch is authorized for a PURE, content-preserving rebase "
         "only — not conflict resolution. If a conflict marker appears "
-        "during the rebase, or the patch-id from step 5 differs from step "
-        "2's, DO NOT resolve it and DO NOT push: that means the base "
-        "genuinely overlaps this branch's own changes, which is a human "
-        "judgment call, not this worker's. Stop and end your turn with a "
+        "during the rebase, or the patch-id from step 7 differs from step "
+        "3's, AND the branch is NOT already-upstream per steps 2/6 above, "
+        "DO NOT resolve it and DO NOT push: that means the base genuinely "
+        "overlaps this branch's own changes, which is a human judgment "
+        "call, not this worker's. Stop and end your turn with a "
         "`STUCK:` line that begins with the exact marker "
         f"`{STALE_REBASE_MISMATCH_MARKER}` and then names what happened, e.g.",
         "",
         f"    STUCK: {STALE_REBASE_MISMATCH_MARKER} patch-id before <hash>, "
         "after <hash> differ",
         "",
-        "The coordinator reads that marker from your transcript, not your",
+        "The coordinator reads these markers from your transcript, not your",
         "process exit code (which you cannot control), and escalates to a",
-        f"human on issue #{entry.issue_number}.",
+        f"human on issue #{entry.issue_number} either way — the "
+        f"`{ALREADY_UPSTREAM_MARKER}` marker gets accurate \"nothing to "
+        f"merge\" text instead of being treated as a real conflict.",
         "",
         "You will NOT use `gh` or `git push --force` — both are denied by",
         "the harness. The coordinator owns PR retries and issue posting.",
@@ -642,6 +718,22 @@ def stale_rebase_mismatch_verdict_in_text(text: str | None) -> bool:
     return STALE_REBASE_MISMATCH_MARKER in _decode_worker_text(text)
 
 
+def already_upstream_verdict_in_text(text: str | None) -> bool:
+    """True when a stale-rebase conflict-fix worker's log carries the
+    :data:`ALREADY_UPSTREAM_MARKER` — i.e. it found the branch's content
+    already fully present on the target (#3462), not a genuine conflict.
+
+    Deliberately does NOT also match :data:`STALE_REBASE_MISMATCH_MARKER` —
+    the two markers are distinct verdicts about the SAME underlying
+    patch-id difference, and callers need to tell them apart (see
+    :func:`detect_already_upstream`'s docstring for why order matters when
+    checking both).
+    """
+    if not text:
+        return False
+    return ALREADY_UPSTREAM_MARKER in _decode_worker_text(text)
+
+
 def build_conflict_fix_briefing(
     *,
     entry: QueuedMerge,
@@ -803,7 +895,7 @@ def detect_stale_rebase_mismatch(
 ) -> bool:
     """True when a finished stale-rebase conflict-fix worker refused to push
     because its rebase was not content-preserving (a real conflict, or a
-    patch-id mismatch it caught in step 5 of :func:`build_stale_rebase_briefing`).
+    patch-id mismatch it caught in step 7 of :func:`build_stale_rebase_briefing`).
 
     Mirrors :func:`detect_semantic_conflict` exactly (same local-log-then-
     agent-endpoint lookup, same best-effort ``False`` on any read/transport
@@ -838,6 +930,57 @@ def detect_stale_rebase_mismatch(
     return False
 
 
+def detect_already_upstream(
+    *,
+    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 stale-rebase conflict-fix worker found the
+    branch's content already fully present on the target (#3462) — the
+    ``git merge-tree``/empty-diff checks in :func:`build_stale_rebase_briefing`
+    steps 2/6 caught the branch being SUPERSEDED rather than in genuine
+    conflict.
+
+    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:`ALREADY_UPSTREAM_MARKER` via
+    :func:`already_upstream_verdict_in_text`.
+
+    Callers that check both this and :func:`detect_stale_rebase_mismatch`
+    against the same log MUST check this one first (#3462 fix) — an
+    already-upstream verdict must win over a bare "genuine content
+    conflict" framing, since the two questions ("is there anything left to
+    merge at all?" vs. "does the rebase conflict?") are answered by
+    distinct, mutually exclusive markers in the same transcript.
+    """
+    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 already_upstream_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 already_upstream_verdict_in_text(resp.text)
+        except (httpx.HTTPError, httpx.TimeoutException):
+            return False
+
+    return False
+
+
 def semantic_escalation_disabled(config: Config | None) -> bool:
     """True when a SEMANTIC give-up has nowhere to escalate to (#2566).
 
@@ -1383,9 +1526,11 @@ def dispatch_conflict_fix(
     conflict-fix path (same briefing/system-prompt/title as the plain
     ``else`` branch below — this is not a distinct dispatch kind, just a
     retry-cap carve-out) right after a stale-rebase worker's
-    ``stale-rebase-mismatch`` refusal: that verdict means the *just-stale*
-    premise was wrong — the rebase hit a genuine content conflict, so this
-    is an ordinary conflict that deserves the ordinary mechanical attempt,
+    ``stale-rebase-mismatch`` refusal (not to be confused with an
+    ``already-upstream`` verdict, #3462 — that one is NOT a conflict and
+    never reaches this function): that verdict means the *just-stale*
+    premise was wrong — the rebase was not content-preserving, so this may
+    be an ordinary conflict that deserves the ordinary mechanical attempt,
     not an immediate HUMAN_REQUIRED. Passes
     ``ignore_stale_rebase_attempts=True`` to :func:`has_prior_conflict_fix`
     so the just-failed stale-rebase attempt — which never even tried a

{code_coordinator-0.5.527 → code_coordinator-0.5.529}/coord/drive_queue.py

@@ -6462,6 +6462,29 @@ def plan_tick(
     # carries fresh, right below.
     effective_last_reason: dict[str, str] = {e.key: e.last_reason for e in ordered}
 
+    def _refresh_only(reason: str, current: str) -> dict[str, Any]:
+        """``{}`` unless *reason* is non-empty and differs from *current*.
+
+        #3461: a `counted=False` deferral must never bump `deferrals` or feed
+        the queue-level alert (see `Deferral`'s own docstring on that flag) —
+        but the descriptive TEXT still has to keep up with reality when the
+        walk re-derives it for an entry that isn't actually competing for a
+        slot this tick (the queue is at capacity, or this entry sits behind
+        an already-chosen launch in the report-only tail). Writing ONLY on a
+        real change means `reason_at` — stamped by
+        `coord.state._update_drive_queue_entry_local` whenever `last_reason`
+        is present in the same update, #2133 — only moves when the text
+        actually does, so the `(Nm ago)` age it powers keeps meaning "how
+        long this has been true" rather than "how long since some tick
+        happened to re-walk this row". An empty *reason* (the fully-eligible,
+        nothing-to-report shape `_Verdict(True)` returns) writes nothing —
+        overwriting a real reason with blank text would be a regression, not
+        a refresh.
+        """
+        if not reason or reason == current:
+            return {}
+        return {"last_reason": reason}
+
     reconciles: list[Reconcile] = []
     blocked: list[Blocked] = []
     deferrals: list[Deferral] = []
@@ -7102,11 +7125,41 @@ def plan_tick(
         )
 
     if capacity - occupied <= 0:
+        # #3461: at capacity is the NORMAL steady state of a deep queue, so
+        # this early return can fire for many ticks in a row. Before this, it
+        # produced no deferral at all, which meant a `waiting` entry's
+        # `last_reason` — e.g. "waiting on X (queued, blocked, ...)" — never
+        # got a chance to notice X had since flipped back to `waiting`, or
+        # landed. `_resolve_prereqs` is cheap (no I/O, just the cached board
+        # + this tick's `states`), so it still runs for every `waiting` entry
+        # here; only the TEXT is refreshed (`_refresh_only` below is a no-op
+        # unless it actually changed) and only via `counted=False` — no
+        # attempt is spent, `deferrals` does not move, and the queue-level
+        # alert (computed only in the launch walk below) is untouched, same
+        # as every other early return in this function.
+        for entry in ordered:
+            if states.get(entry.key) != STATE_WAITING:
+                continue
+            verdict = _resolve_prereqs(
+                entry,
+                board,
+                states,
+                cycle_keys,
+                held_gates,
+                live_prereq_terminal,
+                effective_last_reason,
+            )
+            updates = _refresh_only(verdict.reason, entry.last_reason)
+            if not updates:
+                continue
+            deferrals.append(
+                Deferral(entry.key, verdict.reason, counted=False, updates=updates)
+            )
         return TickPlan(
             **plan_base,
             reconciles=tuple(reconciles),
             blocked=tuple(blocked),
-            deferrals=(),
+            deferrals=tuple(deferrals),
             alert=None,
             launch=None,
         )
@@ -7237,17 +7290,35 @@ def plan_tick(
     for entry in waiting:
         if launch is not None:
             # Report-only pass over the tail of the queue.  The launch above
-            # already won this tick, so nothing here is mutated (see
-            # Deferral.counted) — this exists so `--dry-run` explains the rest
-            # of the queue instead of going silent after the first line.
+            # already won this tick, so `counted` stays `False` and neither
+            # `deferrals` nor the queue-level alert moves for anything found
+            # here — that part is unchanged. #3461: the descriptive TEXT is
+            # no longer left frozen just because this entry never got to
+            # compete for a slot — `_refresh_only` (defined near the top of
+            # this function) still folds a changed reading into `updates` so
+            # `--dry-run` AND a real tick both keep `last_reason` current for
+            # every entry the walk reaches, not only the one that launched.
             cooldown = _cooldown_reason(entry)
             if cooldown:
-                deferrals.append(Deferral(entry.key, cooldown, counted=False))
+                deferrals.append(
+                    Deferral(
+                        entry.key,
+                        cooldown,
+                        counted=False,
+                        updates=_refresh_only(cooldown, entry.last_reason),
+                    )
+                )
                 continue
             backoff = _backoff_reason(entry)
             if backoff:
                 deferrals.append(
-                    Deferral(entry.key, backoff, counted=False, backing_off=True)
+                    Deferral(
+                        entry.key,
+                        backoff,
+                        counted=False,
+                        backing_off=True,
+                        updates=_refresh_only(backoff, entry.last_reason),
+                    )
                 )
                 continue
             verdict = _resolve_prereqs(
@@ -7261,20 +7332,35 @@ def plan_tick(
             )
             if not verdict.satisfied:
                 deferrals.append(
-                    Deferral(entry.key, verdict.reason, counted=False)
+                    Deferral(
+                        entry.key,
+                        verdict.reason,
+                        counted=False,
+                        updates=_refresh_only(verdict.reason, entry.last_reason),
+                    )
                 )
                 continue
             cordoned = _cordon_reason(entry)
             if cordoned:
                 deferrals.append(
-                    Deferral(entry.key, cordoned, counted=False, cordoned=True)
+                    Deferral(
+                        entry.key,
+                        cordoned,
+                        counted=False,
+                        cordoned=True,
+                        updates=_refresh_only(cordoned, entry.last_reason),
+                    )
                 )
                 continue
             repo_limit = _repo_limit_reason(entry)
             if repo_limit:
                 deferrals.append(
                     Deferral(
-                        entry.key, repo_limit, counted=False, repo_limited=True
+                        entry.key,
+                        repo_limit,
+                        counted=False,
+                        repo_limited=True,
+                        updates=_refresh_only(repo_limit, entry.last_reason),
                     )
                 )
             continue

{code_coordinator-0.5.527 → code_coordinator-0.5.529}/coord/notify.py

@@ -3960,9 +3960,17 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
         # same way, without routing it through the SEMANTIC tier-2
         # escalation path — see `coord.reconcile.on_conflict_fix_done`'s
         # `stale_rebase_mismatch` docstring for why that's a separate arm.
+        # #3462: a patch-id mismatch alone doesn't distinguish a real
+        # overlap from a branch whose content already landed on the target
+        # through another change — check `ALREADY_UPSTREAM_MARKER` first
+        # (mutually exclusive with the plain mismatch marker, so only
+        # checked when semantic is False too) and route it to its own
+        # `already_upstream` arm, which never escalates to the ordinary
+        # conflict-fix path and never says "genuine content conflict".
         parent_id = record.get("review_of_assignment_id")
         if parent_id:
             from coord.conflict_fix import (  # noqa: PLC0415
+                detect_already_upstream,
                 detect_semantic_conflict,
                 detect_stale_rebase_mismatch,
             )
@@ -3979,16 +3987,30 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
             except Exception:  # noqa: BLE001 — best-effort, never break notify
                 semantic = False
 
+            # #3462: check the already-upstream marker BEFORE the plain
+            # mismatch marker — they're mutually exclusive per dispatch, but
+            # an already-upstream verdict must win the framing (superseded,
+            # not "genuine conflict") whenever both would otherwise apply.
+            already_upstream = False
             stale_rebase_mismatch = False
             if not semantic:
                 try:
-                    stale_rebase_mismatch = detect_stale_rebase_mismatch(
+                    already_upstream = detect_already_upstream(
                         log_path=log_path,
                         host=host,
                         assignment_id=transition.assignment_id,
                     )
                 except Exception:  # noqa: BLE001
-                    stale_rebase_mismatch = False
+                    already_upstream = False
+                if not already_upstream:
+                    try:
+                        stale_rebase_mismatch = detect_stale_rebase_mismatch(
+                            log_path=log_path,
+                            host=host,
+                            assignment_id=transition.assignment_id,
+                        )
+                    except Exception:  # noqa: BLE001
+                        stale_rebase_mismatch = False
 
             stuck_summary: str | None = None
             board = None
@@ -4013,6 +4035,19 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
                     config = _load_config()
                 except Exception:  # noqa: BLE001
                     board, config = None, None
+            elif already_upstream:
+                # #3462: no escalation dispatch happens for this verdict
+                # (it's not a conflict), so board/config aren't strictly
+                # needed — but grab the stuck summary the same way so
+                # `on_conflict_fix_done`'s HUMAN_REQUIRED text is specific.
+                progress = entry.get("progress") or {}
+                stuck_summary = progress.get("stuck")
+                if not stuck_summary and log_path:
+                    try:
+                        from coord.progress import parse_progress  # noqa: PLC0415
+                        stuck_summary = parse_progress(log_path).stuck
+                    except Exception:  # noqa: BLE001
+                        stuck_summary = None
             elif stale_rebase_mismatch:
                 # #3444: board/config ARE needed here now — a stale-rebase
                 # mismatch escalates to the ORDINARY conflict-fix path
@@ -4042,8 +4077,11 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
                 parent_assignment_id=parent_id,
                 fix_assignment_id=transition.assignment_id,
                 machine_name=transition.machine_name,
-                succeeded=not semantic and not stale_rebase_mismatch,
+                succeeded=not semantic
+                and not already_upstream
+                and not stale_rebase_mismatch,
                 semantic=semantic,
+                already_upstream=already_upstream,
                 stale_rebase_mismatch=stale_rebase_mismatch,
                 board=board,
                 config=config,