code-coordinator 0.5.227__tar.gz → 0.5.228__tar.gz

{code_coordinator-0.5.227 → code_coordinator-0.5.228}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.227",
+  "tag": "0.5.228",
   "distance": 0,
-  "node": "g4d72834d6806b7c52ef9e25a887a4ddd33fc5427",
+  "node": "g3b4de74e0e15d89b4795d8a24a95465d2ac0b416",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-22"

{code_coordinator-0.5.227 → code_coordinator-0.5.228}/coord/conflict_fix.py

@@ -18,6 +18,19 @@ On success, the coordinator re-enqueues the original merge entry so
 Why a separate module: same reason :mod:`coord.review` lives apart from
 ``coord.dispatch`` — conflict-fix is triggered by a merge_queue event, not
 by a planner proposal, so it shares little with the work-dispatch shape.
+
+#2555: a merge conflict on a :data:`coord.models.SEALED_PATH_AUTHOR_TYPES`
+branch (``test-author``/``mock-author``) is a special case — this repo's own
+CLAUDE.md tells every worker to never touch ``tests/acceptance/**``, so the
+*ordinary* conflict-fix worker above structurally refuses the only edit
+that would resolve it (almost always another slice's additive block in the
+milestone's ``manifest.yml``) and no-ops. ``dispatch_conflict_fix`` detects
+this from ``entry.assignment_type`` and dispatches a differently-briefed
+worker instead — see :func:`build_sealed_manifest_conflict_briefing` — that
+is explicitly authorized to resolve a ``manifest.yml`` conflict additively
+and nothing else. It refuses (and the entry escalates to a human exactly
+like any other conflict-fix failure) the moment the conflict reaches beyond
+that one file.
 """
 
 from __future__ import annotations
@@ -30,7 +43,13 @@ import httpx
 from coord.config import Config
 from coord.dispatch import AGENT_PORT
 from coord.merge_queue import QueuedMerge
-from coord.models import Assignment, Board, Machine
+from coord.models import (
+    SEALED_MANIFEST_FILENAME,
+    SEALED_PATH_AUTHOR_TYPES,
+    Assignment,
+    Board,
+    Machine,
+)
 
 
 CONFLICT_FIX_SYSTEM_PROMPT = """\
@@ -183,6 +202,248 @@ def build_semantic_conflict_briefing(
     return "\n".join(lines)
 
 
+# ── #2555: sealed-author (test-author/mock-author) conflict resolution ─────
+#
+# An ordinary conflict-fix worker (the briefing above) is dispatched with the
+# generic CONFLICT_FIX_SYSTEM_PROMPT — no mention of `tests/acceptance/` at
+# all — and every worker session, regardless of `system_prompt`, still gets
+# this repo's own CLAUDE.md loaded, which tells it to never touch
+# `tests/acceptance/**`. For a SEALED_PATH_AUTHOR_TYPES branch that IS almost
+# always exactly where the conflict lives (another slice's block in the
+# milestone's `manifest.yml`), so the ordinary worker structurally refuses
+# the only edit that would resolve it and no-ops — the gap #2555 exists to
+# close. This section gives that class of entry a differently-briefed worker
+# that is explicitly, narrowly authorized to resolve a `manifest.yml`
+# conflict additively, and told to refuse (STUCK, no guessing) the instant
+# the conflict reaches beyond that one file — mirroring the existing
+# mechanical/semantic self-classification pattern above, not a new
+# escalation tier: a sealed-scope refusal has no stronger-model retry,
+# since the file stays sealed regardless of which model resolves it.
+
+# Marker a sealed conflict-fix worker's STUCK: line starts with when the
+# conflict reaches outside the one file it's authorized to touch (a test
+# body, contract.md, a mock, a fixture, an entry-point registration, or a
+# manifest.yml edit that isn't a clean additive case). Same shape as
+# SEMANTIC_STUCK_MARKER above — a fixed, machine-parseable string, not prose
+# — but deliberately a DIFFERENT marker: `detect_semantic_conflict`/
+# `semantic_verdict_in_text` must not mistake this for a mechanical/semantic
+# verdict and route it into the (not sealed-aware) stronger-model escalation
+# path, which would just reproduce the same self-refusal one level up.
+SEALED_SCOPE_STUCK_MARKER = "coord:conflict=sealed-scope"
+
+# Title prefix for a sealed-author conflict-fix dispatch — visible in the TUI
+# Pipeline row so an operator can tell at a glance that this conflict-fix
+# used the narrower, sealed-aware briefing rather than the ordinary one.
+SEALED_CONFLICT_FIX_TITLE_PREFIX = "[sealed-conflict-fix]"
+
+SEALED_MANIFEST_CONFLICT_SYSTEM_PROMPT = f"""\
+You are a Claude Code conflict-fix worker for a SEALED acceptance-oracle \
+branch (a test-author/mock-author slice under `tests/acceptance/`). The \
+merge of this branch into its target failed because the branch is out of \
+date or conflicts with another slice.
+
+This repo's CLAUDE.md tells every ordinary worker to never touch \
+`tests/acceptance/**` — that rule keeps the acceptance oracle independent \
+of the workers it grades. It does NOT apply to you for this one narrow \
+purpose: resolving a merge conflict in a milestone's \
+`tests/acceptance/ms-NN/{SEALED_MANIFEST_FILENAME}`, the file every slice \
+under that milestone appends its own block to. You are explicitly \
+authorized to edit ONLY that file, and only additively.
+
+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).
+- Rebase onto the target branch. If the ONLY conflict is inside a \
+`{SEALED_MANIFEST_FILENAME}` under `tests/acceptance/`, resolve it \
+ADDITIVELY: keep BOTH sides' issue blocks, without reordering or rewriting \
+any block that isn't yours. Never delete or rewrite another issue's block \
+— this mirrors the "one block per issue, later slices merge in" rule the \
+manifest files document in their own header comment.
+- Do NOT create, edit, or delete ANY OTHER file under `tests/acceptance/` \
+— not a test body, not `contract.md`, not a mock, not a fixture, not an \
+entry-point registration. Those stay sealed even for you.
+- If the conflict is NOT confined to a `{SEALED_MANIFEST_FILENAME}` — it \
+also touches a test body or any other sealed file, OR the \
+`{SEALED_MANIFEST_FILENAME}` conflict itself is not a clean additive case \
+(e.g. the same issue's own block was edited two different ways) — DO NOT \
+GUESS and do NOT touch it. Exit non-zero with a STUCK: line that starts \
+with the exact marker `{SEALED_SCOPE_STUCK_MARKER}` and then names the \
+file(s) in conflict, e.g.
+  STUCK: {SEALED_SCOPE_STUCK_MARKER} tests/acceptance/ms-33/audit.rs:1-40 \
+— conflict is in a test body, not {SEALED_MANIFEST_FILENAME}
+The coordinator reads that marker and hands this off to a human — there is \
+no stronger-model retry for this class of conflict, since the file stays \
+sealed regardless of which model resolves it.
+
+Progress reporting:
+- After each significant step (rebase started, manifest conflict resolved, \
+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.\
+"""
+
+
+def build_sealed_manifest_conflict_briefing(
+    *,
+    entry: QueuedMerge,
+    repo_path: str,
+    test_command: str | None,
+) -> str:
+    """Briefing for a conflict-fix dispatched against a
+    :data:`coord.models.SEALED_PATH_AUTHOR_TYPES` branch (#2555).
+
+    Unlike :func:`build_conflict_fix_briefing`, this worker IS authorized to
+    edit one specific sealed file — the milestone's ``manifest.yml`` —
+    because that is the one file every acceptance slice under a milestone
+    appends an additive block to (see e.g.
+    ``tests/acceptance/ms-33/manifest.yml``'s own header comment), so a
+    two-slice collision there is a mechanical, written-down-rule merge, not
+    a semantic one. Everything else under ``tests/acceptance/`` stays
+    off-limits — see :data:`SEALED_MANIFEST_CONFLICT_SYSTEM_PROMPT`'s
+    "Rules" for the exact boundary and :data:`SEALED_SCOPE_STUCK_MARKER`,
+    the marker the worker uses to escalate when the conflict crosses it.
+    """
+    test_cmd = test_command or "echo '(no test command configured)'"
+    lines: list[str] = [
+        f"# Sealed conflict fix: {entry.repo_github} branch `{entry.branch}`",
+        "",
+        f"The merge of `{entry.branch}` → `{entry.target_branch}` failed.",
+        f"Reason: {entry.error or 'unknown conflict'}",
+        "",
+        f"Issue: #{entry.issue_number} — {entry.issue_title}",
+        f"Assignment type: `{entry.assignment_type}` — this branch's whole "
+        "job was authoring under `tests/acceptance/`, so its conflict is "
+        f"almost always another slice's additive edit to the same "
+        f"milestone's `{SEALED_MANIFEST_FILENAME}`.",
+        "",
+        "## 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. `git pull --rebase origin {entry.target_branch}`",
+        f"3. If a conflict marker appears in a `{SEALED_MANIFEST_FILENAME}` "
+        "under `tests/acceptance/`, resolve it by keeping BOTH sides' issue "
+        "blocks (additive — see the system prompt's rules). If a conflict "
+        "marker appears ANYWHERE ELSE, stop — see \"When NOT to guess\" "
+        "below.",
+        f"4. Run tests: `{test_cmd}`",
+        f"5. `git push --force-with-lease origin {entry.branch}`",
+        "6. Exit 0 if push succeeds; non-zero otherwise.",
+        "",
+        "## When NOT to guess",
+        "",
+        f"You are authorized to edit ONLY a `{SEALED_MANIFEST_FILENAME}` "
+        "under `tests/acceptance/`, and only additively. If the conflict "
+        "touches a test body, `contract.md`, a mock, a fixture, an "
+        "entry-point registration, or anything else sealed — or the "
+        f"`{SEALED_MANIFEST_FILENAME}` conflict is not a clean additive "
+        "case — DO NOT touch it. Exit non-zero with a `STUCK:` line "
+        f"starting with the exact marker `{SEALED_SCOPE_STUCK_MARKER}` and "
+        "the file(s)/reason, e.g.",
+        "",
+        f"    STUCK: {SEALED_SCOPE_STUCK_MARKER} tests/acceptance/ms-33/"
+        "audit.rs:1-40 — conflict is in a test body, not "
+        f"{SEALED_MANIFEST_FILENAME}",
+        "",
+        "The coordinator reads that marker and hands this off to a human — "
+        "there is no stronger-model retry for this class of conflict, since "
+        "the file stays sealed regardless of which model resolves it.",
+        "",
+        "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 sealed_scope_verdict_in_text(text: str | None) -> bool:
+    """True when a sealed conflict-fix worker's log carries the
+    :data:`SEALED_SCOPE_STUCK_MARKER` — i.e. it refused because the conflict
+    reached outside the one ``manifest.yml`` it was authorized to touch.
+    Mirrors :func:`semantic_verdict_in_text`.
+    """
+    if not text:
+        return False
+    return SEALED_SCOPE_STUCK_MARKER in _decode_worker_text(text)
+
+
+def _is_sealed_manifest_path(path: str) -> bool:
+    """True when *path* is (any milestone's) ``manifest.yml`` — the one file
+    a sealed-author conflict-fix dispatch is authorized to touch."""
+    return path.rsplit("/", 1)[-1] == SEALED_MANIFEST_FILENAME
+
+
+def sealed_conflict_is_manifest_only(files: list[str]) -> bool:
+    """True when every path in *files* is a milestone acceptance
+    ``manifest.yml`` — exactly the shape :func:`dispatch_conflict_fix`'s
+    sealed-author branch (#2555) is authorized to resolve.
+
+    *files* is expected to already be confirmed confined to a repo's sealed
+    acceptance paths (e.g. via ``coord.notify._conflict_confined_to_sealed_
+    paths``, a GitHub-compare-API best-effort check) — this function only
+    narrows that further, from "somewhere under the sealed tree" to
+    "nowhere but a manifest.yml". A conflict that also touches a test body,
+    ``contract.md``, a mock, or any other sealed file returns ``False`` —
+    out of this resolver's authority, still needs a human. An empty list
+    also returns ``False`` (nothing to confirm as manifest-only).
+
+    NOTE (#2555 review): this is an EXACT-match test, and *files* coming
+    from a whole-branch compare (as opposed to the actual git-conflicting
+    subset) is normally a SUPERSET of what is really in conflict — a real
+    test-author/mock-author slice's own diff almost always also contains
+    the spec/test file(s) it authored alongside its ``manifest.yml`` edit.
+    Do not use this function to GATE a dispatch decision against a whole-
+    branch-diff file list — it will reject the common, textbook-compliant
+    case outright. Use :func:`sealed_conflict_could_touch_manifest` for
+    that; this function stays as the precise "IS it manifest-only" test for
+    a caller that already has the true conflicting-file set (e.g. a future
+    local ``git merge-tree``-based check — #2555 review, fix direction b).
+    """
+    return bool(files) and all(_is_sealed_manifest_path(f) for f in files)
+
+
+def sealed_conflict_could_touch_manifest(files: list[str]) -> bool:
+    """True when at least one path in *files* is a milestone acceptance
+    ``manifest.yml`` — i.e. the sealed-aware conflict-fix branch (#2555)
+    MIGHT have something to resolve here.
+
+    Unlike :func:`sealed_conflict_is_manifest_only` (which requires EVERY
+    file to be a manifest.yml), *files* here is expected to be a branch's
+    WHOLE changed-file list (``coord.notify._conflict_confined_to_sealed_
+    paths``'s three-dot compare) — a SUPERSET of whatever is actually in
+    git-merge conflict, since GitHub's compare API has no notion of "which
+    files conflict", only "which files differ between two refs". Requiring
+    every file in that superset to be a manifest.yml rejects the common,
+    textbook-compliant test-author/mock-author shape outright: such a
+    branch's own diff almost always also contains the new spec/test file(s)
+    it authored alongside its ``manifest.yml`` edit (#2555 review finding).
+
+    Requiring only that a manifest.yml appears SOMEWHERE in the branch's
+    diff is still a sound negative filter: a file can only be in conflict
+    if this branch's diff touches it too, so when no manifest.yml appears
+    in *files* at all, no manifest.yml conflict is possible and dispatching
+    the sealed-aware resolver is a guaranteed no-op — safe to skip. When a
+    manifest.yml IS present (whether alongside other sealed files or not),
+    dispatch and let the worker's own additive-only restriction
+    (:data:`SEALED_MANIFEST_CONFLICT_SYSTEM_PROMPT`) do the PRECISE
+    filtering at rebase time — it refuses via
+    :data:`SEALED_SCOPE_STUCK_MARKER` the instant the actual conflict
+    reaches beyond that one file, exactly as designed.
+    """
+    return any(_is_sealed_manifest_path(f) for f in files)
+
+
 def build_conflict_fix_briefing(
     *,
     entry: QueuedMerge,
@@ -522,6 +783,25 @@ def dispatch_conflict_fix(
     while another conflict-fix is in flight.  Because the escalated attempt
     is itself a ``conflict-fix`` row, its failure consumes the ordinary
     retry cap and the entry goes HUMAN_REQUIRED — no loop.
+
+    #2555: when *entry.assignment_type* is a
+    :data:`coord.models.SEALED_PATH_AUTHOR_TYPES` member (``test-author``/
+    ``mock-author``) — captured on the entry at ``enqueue()`` time, so no
+    extra board lookup is needed — and *semantic* is ``False``, this
+    dispatches the sealed-aware briefing (see
+    :func:`build_sealed_manifest_conflict_briefing`) instead of the ordinary
+    one. The ordinary briefing is a guaranteed no-op for this branch class:
+    its worker gets no authorization to touch ``tests/acceptance/**`` and
+    this repo's own CLAUDE.md, loaded into every session regardless of
+    ``system_prompt``, tells it never to. The sealed-aware briefing narrowly
+    authorizes exactly the one file (a milestone's ``manifest.yml``) most of
+    these conflicts actually live in, and refuses (STUCK, retry cap consumed
+    exactly like any other conflict-fix failure) the moment the conflict
+    reaches beyond it — same retry-cap and machine-selection logic as
+    everywhere else in this function, only the briefing/system-prompt/title
+    differ. Not wired into the ``semantic=True`` escalation path: a sealed
+    entry's refusal is a scope boundary, not a call for a stronger model —
+    the file stays sealed regardless of which model resolves it.
     """
     if semantic:
         if has_prior_semantic_escalation(board, entry.assignment_id):
@@ -533,6 +813,8 @@ def dispatch_conflict_fix(
     ):
         return None
 
+    sealed_author = not semantic and entry.assignment_type in SEALED_PATH_AUTHOR_TYPES
+
     repo = config.repo(entry.repo_name)
     if repo is None:
         return None
@@ -561,6 +843,14 @@ def dispatch_conflict_fix(
         title = f"{SEMANTIC_FIX_TITLE_PREFIX} {entry.issue_title}"
         if model:
             title = f"{SEMANTIC_FIX_TITLE_PREFIX}[{model}] {entry.issue_title}"
+    elif sealed_author:
+        briefing = build_sealed_manifest_conflict_briefing(
+            entry=entry,
+            repo_path=repo_path,
+            test_command=repo.test_command,
+        )
+        system_prompt = SEALED_MANIFEST_CONFLICT_SYSTEM_PROMPT
+        title = f"{SEALED_CONFLICT_FIX_TITLE_PREFIX} {entry.issue_title}"
     else:
         briefing = build_conflict_fix_briefing(
             entry=entry,
@@ -683,6 +973,10 @@ def dispatch_conflict_fix(
             "merge_entry_id": entry.assignment_id,
             "semantic": semantic,
             "model": model,
+            # #2555: lets the audit trail (and anyone diffing it) tell a
+            # narrowly-authorized sealed-manifest dispatch apart from the
+            # ordinary conflict-fix without re-deriving it from the title.
+            "sealed_author": sealed_author,
         },
     )
 

{code_coordinator-0.5.227 → code_coordinator-0.5.228}/coord/models.py

@@ -292,6 +292,16 @@ WORK_LIKE_TYPES: frozenset[str] = frozenset({"work", "mock-author", "test-author
 # needs to be added in one place.
 SEALED_PATH_AUTHOR_TYPES: frozenset[str] = frozenset({"test-author", "mock-author"})
 
+# #2555: filename of the one sealed-acceptance file a `type="conflict-fix"`
+# dispatch is ever authorized to edit for a SEALED_PATH_AUTHOR_TYPES branch —
+# every milestone's `tests/acceptance/ms-NN/manifest.yml`, which every slice
+# under that milestone additively appends its own issue block to (see e.g.
+# `tests/acceptance/ms-33/manifest.yml`'s own header comment: "Merged (never
+# clobbered) across issues"). `coord.conflict_fix`'s sealed-author dispatch
+# branch and `coord.notify`'s stalled-pipeline confinement check both key off
+# this exact name, kept here as a single shared constant so they can't drift.
+SEALED_MANIFEST_FILENAME = "manifest.yml"
+
 # #1077: subset of WORK_LIKE_TYPES whose ``issue_number`` is the issue the PR
 # actually *resolves* — i.e. merging it should auto-close that issue. "work"
 # qualifies. "mock-author" (Gate A) is WORK_LIKE (it flows through the same

{code_coordinator-0.5.227 → code_coordinator-0.5.228}/coord/notify.py

@@ -993,14 +993,22 @@ class StalledDispatchAction:
       (#602).
     - ``"skipped_human_required"``  — the conflict-fix retry cap was already
       hit; surfacing to a human, not auto-retrying.
-    - ``"skipped_sealed_conflict"`` (#2537) — ``merge_conflict_unresolved``
-      on a :data:`coord.models.SEALED_PATH_AUTHOR_TYPES` row whose conflict
-      was confirmed (:func:`_conflict_confined_to_sealed_paths`) to be
-      confined to the repo's sealed acceptance-oracle paths — a
-      conflict-fix worker is guaranteed to self-restrict and push nothing
-      there, so the dispatch was skipped rather than spending a worker
-      session on a known no-op; needs a sealed-path-aware rebase dispatcher
-      (a follow-up issue, not yet implemented).
+    - ``"skipped_sealed_conflict"`` (#2537, narrowed by #2555) —
+      ``merge_conflict_unresolved`` on a
+      :data:`coord.models.SEALED_PATH_AUTHOR_TYPES` row whose conflict was
+      confirmed (:func:`_conflict_confined_to_sealed_paths`) to be confined
+      to the repo's sealed acceptance-oracle paths AND (#2555:
+      :func:`coord.conflict_fix.sealed_conflict_could_touch_manifest`) NO
+      file in that (whole-branch-diff) list is even a milestone
+      ``manifest.yml`` — i.e. a manifest.yml conflict is provably
+      impossible, so the sealed-aware conflict-fix branch is guaranteed to
+      have nothing to resolve. Whenever a manifest.yml DOES appear in that
+      list — whether alone or alongside other sealed files the branch also
+      authored, the realistic common shape — this no longer skips here: it
+      falls through to :func:`coord.conflict_fix.dispatch_conflict_fix`,
+      whose sealed-author branch (#2555) attempts it and lets the worker's
+      own additive-only restriction do the precise, per-file filtering at
+      rebase time.
     - ``"disabled"``                — ``pipeline.auto_dispatch_stalled`` is
       off; detection/narration still happened, dispatch did not.
     """
@@ -1150,11 +1158,20 @@ def dispatch_stalled_pipeline_action(
       :data:`coord.models.SEALED_PATH_AUTHOR_TYPES` row AND the conflict can
       be confirmed (via :func:`_conflict_confined_to_sealed_paths`, a
       compare-API-only check) to be confined to the repo's sealed
-      acceptance-oracle paths — a conflict-fix worker is REQUIRED by
-      CLAUDE.md's own sealed-path rule to self-restrict from editing those,
-      so it is guaranteed to push nothing; that case returns
-      ``"skipped_sealed_conflict"`` instead of spending a worker session on
-      a known no-op.
+      acceptance-oracle paths AND (#2555:
+      :func:`coord.conflict_fix.sealed_conflict_could_touch_manifest`) that
+      confined, whole-branch-diff file list contains no manifest.yml at
+      all — a manifest.yml conflict is then provably impossible, and a
+      conflict-fix worker is REQUIRED by CLAUDE.md's own sealed-path rule to
+      self-restrict from editing any OTHER sealed file, so it is guaranteed
+      to push nothing; that case returns ``"skipped_sealed_conflict"``
+      instead of spending a worker session on a known no-op. When a
+      manifest.yml IS present in that list (even alongside other sealed
+      files the branch also authored — the realistic common shape), this
+      falls through to the ordinary dispatch, whose sealed-author branch
+      (#2555) resolves a genuine manifest-only conflict and self-refuses,
+      exactly like any other conflict-fix failure, the instant the actual
+      conflict reaches beyond that file.
     - ``review_failed_no_verdict`` (#1584) → :func:`coord.review.dispatch_review`
       again, the SAME call as ``done_no_review`` — the failed review left no
       verdict behind, so recovery is identical to "no review was ever
@@ -1479,6 +1496,7 @@ def dispatch_stalled_pipeline_action(
         from coord.conflict_fix import (  # noqa: PLC0415
             dispatch_conflict_fix,
             has_prior_conflict_fix,
+            sealed_conflict_could_touch_manifest,
         )
         from coord.merge_queue import load_queue  # noqa: PLC0415
 
@@ -1496,35 +1514,51 @@ def dispatch_stalled_pipeline_action(
                 kind="skipped_human_required",
                 detail="conflict-fix already active or its retry cap was already hit",
             )
-        # #2537: dispatch_conflict_fix is guaranteed to no-op on a conflict
-        # confined to the repo's sealed acceptance-oracle paths — the
-        # conflict-fix worker is REQUIRED by CLAUDE.md's own sealed-path
-        # rule to self-restrict from editing them (the additive carve-out
-        # applies only to test-author/mock-author dispatches, never
-        # conflict-fix), so it pushes nothing and the entry just re-stalls
-        # next tick. Confirmed live on coord-portal#132/#135: a manually
-        # forced dispatch_conflict_fix restored its worktree clean and
-        # pushed nothing. Skip the known-wasted dispatch when we can
-        # confirm confinement in advance; resolving it for real needs a
-        # sealed-path-aware re-dispatch (tracked as a follow-up issue, not
-        # yet implemented) — dispatch_conflict_fix stays the fallback for
-        # every other case (can't confirm confinement, or genuinely not
-        # confined).
+        # #2537/#2555: dispatch_conflict_fix used to be guaranteed to no-op on
+        # a conflict confined to the repo's sealed acceptance-oracle paths —
+        # an ordinary conflict-fix worker is required by CLAUDE.md's own
+        # sealed-path rule to self-restrict from editing them (the additive
+        # carve-out applied only to test-author/mock-author dispatches, never
+        # conflict-fix) — so it pushed nothing and the entry just re-stalled
+        # next tick (confirmed live on coord-portal#132/#135). #2555 gave
+        # `dispatch_conflict_fix` a sealed-aware branch (keyed off
+        # `entry.assignment_type`, the same field checked below) that CAN
+        # resolve the one shape that guarantee doesn't hold for: a conflict
+        # confined to a milestone's `manifest.yml` — the file every slice
+        # under that milestone additively appends its own block to.
+        #
+        # `sealed_files` here is `entry`'s WHOLE branch diff (the three-dot
+        # compare), not the actual conflicting subset — GitHub's compare API
+        # cannot report "which files conflict", only "which files differ".
+        # A real test-author/mock-author slice's own diff almost always ALSO
+        # contains the spec/test file(s) it authored alongside its
+        # `manifest.yml` edit, so gating on "every file in this superset is
+        # a manifest.yml" (`sealed_conflict_is_manifest_only`) rejected the
+        # common, textbook-compliant case outright (#2555 review finding).
+        # Gate on "a manifest.yml appears somewhere in the superset" instead
+        # (`sealed_conflict_could_touch_manifest`) — still a sound negative
+        # filter (a file can only conflict if this branch touches it too, so
+        # NO manifest.yml anywhere in the diff means a manifest.yml conflict
+        # is impossible and dispatch would be a guaranteed no-op) — and let
+        # the worker's own additive-only restriction do the PRECISE
+        # filtering at rebase time, refusing via `SEALED_SCOPE_STUCK_MARKER`
+        # the instant the actual conflict reaches beyond that one file.
         if work.type in SEALED_PATH_AUTHOR_TYPES:
             sealed_files = _conflict_confined_to_sealed_paths(entry, config)
             if sealed_files is not None:
-                return StalledDispatchAction(
-                    kind="skipped_sealed_conflict",
-                    detail=(
-                        "conflict is confined to sealed acceptance paths ("
-                        + ", ".join(sealed_files)
-                        + ") — a conflict-fix worker is required to "
-                        "self-restrict from editing them (CLAUDE.md's "
-                        "sealed-path rule) and would push nothing; needs a "
-                        "sealed-path-aware rebase dispatcher (follow-up "
-                        "issue), not dispatch_conflict_fix"
-                    ),
-                )
+                if not sealed_conflict_could_touch_manifest(sealed_files):
+                    return StalledDispatchAction(
+                        kind="skipped_sealed_conflict",
+                        detail=(
+                            "conflict is confined to sealed acceptance paths ("
+                            + ", ".join(sealed_files)
+                            + ") and none of them is a manifest.yml — the "
+                            "sealed conflict-fix branch (#2555) is only "
+                            "authorized to resolve a manifest.yml conflict, "
+                            "so a worker would push nothing here; needs a "
+                            "human"
+                        ),
+                    )
         fix = dispatch_conflict_fix(entry, board, config, prefer_machine=work.machine_name)
         if fix is None:
             return StalledDispatchAction(