code-coordinator 0.5.231__tar.gz → 0.5.232__tar.gz

{code_coordinator-0.5.231 → code_coordinator-0.5.232}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.231",
+  "tag": "0.5.232",
   "distance": 0,
-  "node": "g9bcc6d2ee8084e339463aeb3572a47a58b9b1657",
+  "node": "geaf0ae75fe41add5924a913f93d8c3a955bb2c8c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-22"

{code_coordinator-0.5.231 → code_coordinator-0.5.232}/coord/acceptance.py

@@ -199,17 +199,80 @@ class ManifestError(Exception):
     """Raised when a manifest file exists but is malformed."""
 
 
-def _manifest_paths(acceptance_root: Path) -> list[Path]:
-    """``ms-NN/manifest.(yml|yaml|json)`` paths under *acceptance_root*,
-    sorted for deterministic scan order. ``[]`` when the dir doesn't exist."""
-    if not acceptance_root.exists():
+# #2543: per-issue manifest fragments. Before this, every JIT test-author
+# slice appended its own `issues:`/`expected_red:` block to ONE shared
+# `ms-NN/manifest.yml` (`coord.test_author`'s "Later slices MERGE into this
+# file" convention) — two slices authored concurrently, or one authored
+# against a base that predates a sibling's already-merged slice, collide on
+# that single file even though their actual content never overlaps (each
+# writes a distinct, differently-keyed block). See coord-portal#122/#128/#132.
+#
+# The fix: each issue's `issues:`/`expected_red:` entries live in their OWN
+# file, `ms-NN/manifest.d/<issue>.(yml|yaml|json)` — two slices writing two
+# different files can never textually conflict, no matter how they're
+# scheduled. `manifest.yml` itself keeps carrying the MILESTONE-level blocks
+# (`gate_a:`, `exempt:`) that are rare, hand-edited, and not part of the
+# per-slice JIT-authoring hot path, so it stays a single shared file by
+# choice, not oversight.
+#
+# Backward compatible by construction: every reader below still accepts a
+# legacy single-file `ms-NN/manifest.(yml|json)` that ALSO carries
+# `issues:`/`tests:`/`expected_red:` (this repo's own already-merged
+# `tests/acceptance/ms-33/manifest.yml` and friends) — fragments and a
+# legacy file under the same `ms-NN/` dir are simply merged together, same
+# "later manifest wins on a bare collision" rule as across milestones. No
+# migration script is needed: existing manifests keep working as-is, and new
+# per-issue entries land in `manifest.d/` going forward.
+MANIFEST_FRAGMENTS_DIRNAME = "manifest.d"
+
+
+def _manifest_fragment_paths(ms_dir: Path) -> list[Path]:
+    """``<ms_dir>/manifest.d/*.(yml|yaml|json)`` fragment files, sorted for
+    deterministic scan order. ``[]`` when the fragments dir doesn't exist."""
+    frag_dir = ms_dir / MANIFEST_FRAGMENTS_DIRNAME
+    if not frag_dir.is_dir():
         return []
     return sorted(
-        p for p in acceptance_root.glob("*/manifest.*")
-        if p.suffix in (".yml", ".yaml", ".json")
+        p for p in frag_dir.iterdir()
+        if p.is_file() and p.suffix in (".yml", ".yaml", ".json")
     )
 
 
+def _manifest_paths(acceptance_root: Path) -> list[Path]:
+    """Every manifest SOURCE path under *acceptance_root*, sorted for
+    deterministic scan order: per ``ms-NN``/``issue-NN`` directory, the
+    legacy single-file ``manifest.(yml|yaml|json)`` (if present) followed by
+    each ``manifest.d/<issue>.(yml|yaml|json)`` fragment (#2543). ``[]`` when
+    *acceptance_root* doesn't exist.
+
+    Callers that need to know which owning directory a given path came from
+    (a fragment's is its grandparent, not its parent) should go through
+    :func:`_ms_dir_for_manifest_path` rather than assuming ``path.parent``.
+    """
+    if not acceptance_root.exists():
+        return []
+    paths: list[Path] = []
+    for ms_dir in sorted(p for p in acceptance_root.iterdir() if p.is_dir()):
+        paths.extend(
+            sorted(
+                p for p in ms_dir.glob("manifest.*")
+                if p.suffix in (".yml", ".yaml", ".json")
+            )
+        )
+        paths.extend(_manifest_fragment_paths(ms_dir))
+    return paths
+
+
+def _ms_dir_for_manifest_path(path: Path) -> Path:
+    """The owning ``ms-NN``/``issue-NN`` directory for a manifest source
+    *path* returned by :func:`_manifest_paths` — itself for a legacy
+    single-file manifest, or its grandparent for a
+    ``manifest.d/<issue>.(yml|json)`` fragment (#2543)."""
+    if path.parent.name == MANIFEST_FRAGMENTS_DIRNAME:
+        return path.parent.parent
+    return path.parent
+
+
 @dataclass(frozen=True)
 class ManifestData:
     """One manifest file's parsed contents: the test-id -> issue-number
@@ -329,6 +392,50 @@ def parse_manifest_text(text: str, *, source: str = "<manifest>") -> ManifestDat
     )
 
 
+def merge_manifest_data(*datas: ManifestData) -> ManifestData:
+    """Merge multiple :class:`ManifestData` instances into one, as if their
+    source files had been scanned together (#2543) — same "later source
+    wins on a bare collision" rule :func:`load_manifest`/:func:`_manifest_paths`
+    already apply across files, just operating on already-parsed data
+    instead of paths. Shared by both the local-checkout readers (which
+    merge ``_manifest_paths``' legacy-file-then-fragments per ``ms-NN``) and
+    the API-only dispatch-time reader
+    (:func:`coord.milestone_dispatch._fetch_manifest_data`, which fetches
+    the legacy file and one issue's fragment separately over ``gh`` and
+    needs to combine them the same way).
+
+    ``tests``/``exempt``/``expected_red`` union across every *datas* entry
+    (a later entry's ``tests`` mapping overwrites an earlier one's on an
+    exact test-id collision; ``exempt``/``expected_red`` union rather than
+    overwrite since those are naturally per-issue-keyed sets, not a flat
+    mapping that can collide). ``gate_a_exempt``/``gate_a_exempt_reason``
+    are milestone-level, not per-issue, so they come from whichever entry
+    sets ``gate_a_exempt=True`` last — in practice always the legacy shared
+    file, since only that carries the ``gate_a:`` block (#2543 keeps it
+    there by choice; per-issue fragments never set it).
+    """
+    tests: dict[str, int] = {}
+    exempt: set[int] = set()
+    expected_red: dict[int, frozenset[str]] = {}
+    gate_a_exempt = False
+    gate_a_exempt_reason = ""
+    for data in datas:
+        tests.update(data.tests)
+        exempt |= set(data.exempt)
+        for issue_number, test_ids in data.expected_red.items():
+            expected_red[issue_number] = expected_red.get(issue_number, frozenset()) | test_ids
+        if data.gate_a_exempt:
+            gate_a_exempt = True
+            gate_a_exempt_reason = data.gate_a_exempt_reason or gate_a_exempt_reason
+    return ManifestData(
+        tests=tests,
+        exempt=frozenset(exempt),
+        gate_a_exempt=gate_a_exempt,
+        gate_a_exempt_reason=gate_a_exempt_reason,
+        expected_red=expected_red,
+    )
+
+
 def _parse_manifest_file(path: Path) -> dict[str, int]:
     """Parse one manifest file into ``{test_id: issue_number}`` (the
     ``exempt:`` list, if any, is dropped — callers that need it use
@@ -415,7 +522,7 @@ def load_expected_red(
     mapping: dict[str, int] = {}
     for path in _manifest_paths(acceptance_root):
         if driver_kind is not None:
-            resolved = _driver_kind_for_manifest_dir(path.parent)
+            resolved = _driver_kind_for_manifest_dir(_ms_dir_for_manifest_path(path))
             if resolved is not None and resolved != driver_kind:
                 continue
         try:
@@ -441,7 +548,7 @@ def ms_dir_for_issue(acceptance_root: Path, issue_number: int) -> str | None:
     for path in _manifest_paths(acceptance_root):
         mapping = _parse_manifest_file(path)
         if test_ids_for_issue(mapping, issue_number):
-            return path.parent.name
+            return _ms_dir_for_manifest_path(path).name
     return None
 
 
@@ -873,16 +980,27 @@ def _default_github_ops():
     return github_ops
 
 
-def _fetch_ms_manifest_via_api(
-    repo_github: str, branch: str, ms_dir: str, get_file: Callable[..., "tuple[str, str]"],
+def _fetch_manifest_source_via_api(
+    repo_github: str,
+    branch: str,
+    dir_path: str,
+    filename_stem: str,
+    get_file: Callable[..., "tuple[str, str]"],
 ) -> "tuple[str, str, str, ManifestData] | None":
-    """One ms-dir's ``manifest.(yml|yaml|json)`` via *get_file* (a
-    ``get_repo_file_with_sha``-shaped callable), trying each extension in
-    turn like :func:`_manifest_paths` does on local disk. Returns ``(path,
-    text, blob_sha, data)`` for the first extension that exists and parses,
-    or ``None`` if none does / the one that exists is malformed."""
+    """One manifest source file — ``<dir_path>/<filename_stem>.(yml|yaml|
+    json)`` — via *get_file* (a ``get_repo_file_with_sha``-shaped callable),
+    trying each extension in turn like :func:`_manifest_paths` does on local
+    disk. Returns ``(path, text, blob_sha, data)`` for the first extension
+    that exists and parses, or ``None`` if none does / the one that exists is
+    malformed.
+
+    Shared primitive (#2543) behind both the legacy single-file fetch
+    (:func:`_fetch_ms_manifest_via_api`, ``filename_stem="manifest"``) and a
+    per-issue fragment fetch (:func:`_fetch_ms_manifest_fragment_via_api`,
+    ``filename_stem=str(issue_number)`` under ``<ms_dir>/manifest.d/``).
+    """
     for ext in (".yml", ".yaml", ".json"):
-        path = f"{ACCEPTANCE_DIRNAME}/{ms_dir}/manifest{ext}"
+        path = f"{dir_path}/{filename_stem}{ext}"
         try:
             text, blob_sha = get_file(repo_github, path, branch)
         except Exception:  # noqa: BLE001 — this extension doesn't exist, or a transient gh hiccup
@@ -895,13 +1013,52 @@ def _fetch_ms_manifest_via_api(
     return None
 
 
+def _fetch_ms_manifest_via_api(
+    repo_github: str, branch: str, ms_dir: str, get_file: Callable[..., "tuple[str, str]"],
+) -> "tuple[str, str, str, ManifestData] | None":
+    """One ms-dir's LEGACY single-file ``manifest.(yml|yaml|json)`` via
+    *get_file* — see :func:`_fetch_manifest_source_via_api`. Since #2543,
+    per-issue data more commonly lives in a ``manifest.d/<issue>.(yml|json)``
+    fragment instead (:func:`_fetch_ms_manifest_fragment_via_api`); this
+    still covers the milestone-level ``gate_a:``/``exempt:`` blocks (which
+    stay in the single shared file by choice, #2543) and any not-yet-migrated
+    milestone whose per-issue data is still all in one file."""
+    return _fetch_manifest_source_via_api(
+        repo_github, branch, f"{ACCEPTANCE_DIRNAME}/{ms_dir}", "manifest", get_file,
+    )
+
+
+def _fetch_ms_manifest_fragment_via_api(
+    repo_github: str,
+    branch: str,
+    ms_dir: str,
+    issue_number: int,
+    get_file: Callable[..., "tuple[str, str]"],
+) -> "tuple[str, str, str, ManifestData] | None":
+    """*issue_number*'s own ``ms-NN/manifest.d/<issue_number>.(yml|yaml|
+    json)`` fragment via *get_file* (#2543) — see
+    :func:`_fetch_manifest_source_via_api`. A targeted fetch by exact,
+    predictable filename, no directory listing required, since the caller
+    already knows the issue number it's looking for."""
+    return _fetch_manifest_source_via_api(
+        repo_github,
+        branch,
+        f"{ACCEPTANCE_DIRNAME}/{ms_dir}/{MANIFEST_FRAGMENTS_DIRNAME}",
+        str(issue_number),
+        get_file,
+    )
+
+
 def find_ms_manifest_for_issue_via_api(
     repo_github: str, branch: str, issue_number: int, *, gh_ops: Any = None,
 ) -> "tuple[str, str, str, ManifestData] | None":
     """API-only (no local checkout) equivalent of :func:`ms_dir_for_issue`:
-    search every ``tests/acceptance/ms-*/manifest.(yml|yaml|json)`` on
-    *branch* via the GitHub Contents API for the one whose ``tests``/
-    ``issues``/``expected_red`` mapping covers *issue_number*.
+    search every ``tests/acceptance/ms-*/`` on *branch* via the GitHub
+    Contents API for the one whose ``tests``/``issues``/``expected_red``
+    mapping covers *issue_number* — checking, per ms-dir, *issue_number*'s
+    own ``manifest.d/<issue_number>.(yml|json)`` fragment (#2543) FIRST
+    (a targeted, exact-filename fetch), then the legacy single-file
+    ``manifest.(yml|yaml|json)``.
 
     Returns ``(path, text, blob_sha, data)`` for the first match (ms-dirs
     scanned in sorted-name order for determinism), or ``None`` when nothing
@@ -923,6 +1080,15 @@ def find_ms_manifest_for_issue_via_api(
         return None
 
     for name in sorted(subdirs):
+        frag = _fetch_ms_manifest_fragment_via_api(
+            repo_github, branch, name, issue_number, get_file,
+        )
+        if frag is not None:
+            _path, _text, _blob_sha, data = frag
+            if issue_number in data.expected_red or test_ids_for_issue(
+                data.tests, issue_number
+            ):
+                return frag
         found = _fetch_ms_manifest_via_api(repo_github, branch, name, get_file)
         if found is None:
             continue
@@ -1014,10 +1180,19 @@ def list_expected_red_via_api(
     with at least one expected_red entry are included. ``{}`` on any
     listing failure or when nothing is expected-red anywhere (best-effort,
     matches the rest of this module's read paths).
+
+    #2543: merges BOTH the legacy single-file ``manifest.(yml|json)`` and
+    every ``manifest.d/<issue>.(yml|json)`` fragment for each ms-dir — a
+    milestone whose per-issue data has moved to fragments must not go dark
+    here just because ``list_repo_dir`` (needed to enumerate the fragments
+    dir) is unavailable on *gh_ops*: that case degrades to "legacy file
+    only", same fail-open posture as everywhere else in this module, not to
+    "nothing found."
     """
     ops = gh_ops or _default_github_ops()
     list_subdirs = getattr(ops, "list_repo_subdirs", None)
     get_file = getattr(ops, "get_repo_file_with_sha", None)
+    list_dir = getattr(ops, "list_repo_dir", None)
     if list_subdirs is None or get_file is None:
         return {}
     try:
@@ -1027,12 +1202,37 @@ def list_expected_red_via_api(
 
     out: dict[str, dict[int, frozenset[str]]] = {}
     for name in sorted(subdirs):
+        merged: dict[int, frozenset[str]] = {}
+
         found = _fetch_ms_manifest_via_api(repo_github, branch, name, get_file)
-        if found is None:
-            continue
-        _path, _text, _blob_sha, data = found
-        if data.expected_red:
-            out[name] = dict(data.expected_red)
+        if found is not None:
+            _path, _text, _blob_sha, data = found
+            for issue, ids in data.expected_red.items():
+                merged[issue] = merged.get(issue, frozenset()) | ids
+
+        if list_dir is not None:
+            frag_dir = f"{ACCEPTANCE_DIRNAME}/{name}/{MANIFEST_FRAGMENTS_DIRNAME}"
+            try:
+                filenames = list_dir(repo_github, frag_dir, branch)
+            except Exception:  # noqa: BLE001 — no fragments dir, or a transient hiccup
+                filenames = []
+            for filename in filenames:
+                if Path(filename).suffix not in (".yml", ".yaml", ".json"):
+                    continue
+                frag_path = f"{frag_dir}/{filename}"
+                try:
+                    text, _sha = get_file(repo_github, frag_path, branch)
+                except Exception:  # noqa: BLE001
+                    continue
+                try:
+                    frag_data = parse_manifest_text(text, source=frag_path)
+                except ManifestError:
+                    continue
+                for issue, ids in frag_data.expected_red.items():
+                    merged[issue] = merged.get(issue, frozenset()) | ids
+
+        if merged:
+            out[name] = merged
     return out
 
 
@@ -1101,7 +1301,11 @@ def clear_expected_red_via_pr(
     except Exception as exc:  # noqa: BLE001
         return f"warning: could not resolve {default_branch} tip: {exc}"
 
-    ms_dir = path.split("/")[-2] if "/" in path else "ms"
+    # #2543: for a manifest.d/<issue>.yml fragment, path.parent is the
+    # `manifest.d` directory itself, not the ms-NN dir — go through
+    # _ms_dir_for_manifest_path so a fragment-clear derives the SAME
+    # branch-name component a legacy-file clear would.
+    ms_dir = _ms_dir_for_manifest_path(Path(path)).name if "/" in path else "ms"
     branch_name = f"coord/clear-expected-red-{issue_number}-{ms_dir}"
     # #944-style idempotency: a prior attempt may have already created this
     # branch (e.g. a partial failure on a previous merge-queue tick) — a

{code_coordinator-0.5.231 → code_coordinator-0.5.232}/coord/commands/acceptance.py

@@ -209,7 +209,8 @@ def _scoped_verdict(
     "--ci", "ci_mode", is_flag=True,
     help=(
         "#2164: the CI wrapper. Only valid with --all. Honours each "
-        "ms-NN/manifest.yml's `expected_red:` registry — a listed test-id "
+        "ms-NN/manifest.yml AND manifest.d/<issue>.yml fragment's (#2543) "
+        "`expected_red:` registry — a listed test-id "
         "that FAILS does not fail the run (a sealed slice is red by design "
         "before its fix exists); one that PASSES is a hard, loud failure "
         "(the vacuous-assertion case #1965 cares about). Point your repo's "

{code_coordinator-0.5.231 → code_coordinator-0.5.232}/coord/conflict_fix.py

@@ -40,6 +40,7 @@ import uuid
 
 import httpx
 
+from coord.acceptance import MANIFEST_FRAGMENTS_DIRNAME
 from coord.config import Config
 from coord.dispatch import AGENT_PORT
 from coord.merge_queue import QueuedMerge
@@ -245,10 +246,13 @@ 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.
+purpose: resolving a merge conflict in a milestone's shared \
+`tests/acceptance/ms-NN/{SEALED_MANIFEST_FILENAME}` and/or a per-issue \
+`tests/acceptance/ms-NN/manifest.d/<issue>.(yml|json)` fragment (#2543 — \
+each issue's own manifest data lives in its own fragment file now, so a \
+DIFFERENT-issue collision mostly can't happen any more; this path is for a \
+legacy single-file milestone or a same-issue retry). You are explicitly \
+authorized to edit ONLY those manifest file(s), and only additively.
 
 Rules:
 - The coordinator denies `gh` and `git push --force` for this worker. \
@@ -256,21 +260,22 @@ 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.
+`{SEALED_MANIFEST_FILENAME}` or a `manifest.d/<issue>.(yml|json)` fragment \
+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.
+- If the conflict is NOT confined to a `{SEALED_MANIFEST_FILENAME}` or a \
+`manifest.d/<issue>.(yml|json)` fragment — it also touches a test body or \
+any other sealed file, OR the manifest 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 \
@@ -296,15 +301,17 @@ def build_sealed_manifest_conflict_briefing(
     :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.
+    edit the sealed manifest — the milestone's shared ``manifest.yml`` and/or
+    a per-issue ``manifest.d/<issue>.(yml|json)`` fragment (#2543) — because
+    those are mechanical, written-down-rule merges (an issue's own block, or
+    a legacy milestone's additive block), not semantic ones. Since #2543 the
+    common two-DIFFERENT-slices collision this was built for mostly can't
+    happen any more (each issue writes its own fragment file), but a legacy
+    milestone or a same-issue retry can still land here. 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] = [
@@ -316,8 +323,8 @@ def build_sealed_manifest_conflict_briefing(
         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}`.",
+        f"almost always an additive edit to a `{SEALED_MANIFEST_FILENAME}` "
+        "or a `manifest.d/<issue>.(yml|json)` fragment (#2543).",
         "",
         "## Where you are",
         "",
@@ -334,7 +341,8 @@ def build_sealed_manifest_conflict_briefing(
         "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 "
+        "or a `manifest.d/<issue>.(yml|json)` fragment 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.",
@@ -344,12 +352,13 @@ def build_sealed_manifest_conflict_briefing(
         "",
         "## When NOT to guess",
         "",
-        f"You are authorized to edit ONLY a `{SEALED_MANIFEST_FILENAME}` "
-        "under `tests/acceptance/`, and only additively. If the conflict "
+        f"You are authorized to edit ONLY a `{SEALED_MANIFEST_FILENAME}` or "
+        "a `manifest.d/<issue>.(yml|json)` fragment 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 "
+        "manifest 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.",
         "",
@@ -379,9 +388,29 @@ def sealed_scope_verdict_in_text(text: str | None) -> bool:
 
 
 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
+    """True when *path* is (any milestone's) shared ``manifest.yml`` OR a
+    per-issue ``manifest.d/<issue>.(yml|yaml|json)`` fragment (#2543) — the
+    files a sealed-author conflict-fix dispatch is authorized to touch.
+
+    #2543 moves the routine per-issue `issues:`/`expected_red:` traffic out
+    of the single shared file into per-issue fragments (two different
+    fragment files can't textually conflict at all — the collision this
+    whole sealed-conflict-fix mechanism exists to resolve mostly stops
+    happening by construction going forward), but a fragment path is still
+    recognized here for completeness — a legacy single-file milestone, or a
+    same-issue retry that manages to conflict with itself, still resolves
+    the same additive way.
+    """
+    parts = path.split("/")
+    name = parts[-1]
+    if name == SEALED_MANIFEST_FILENAME:
+        return True
+    return (
+        len(parts) >= 2
+        and parts[-2] == MANIFEST_FRAGMENTS_DIRNAME
+        and name.rsplit(".", 1)[-1] in ("yml", "yaml", "json")
+        and "." in name
+    )
 
 
 def sealed_conflict_is_manifest_only(files: list[str]) -> bool:

{code_coordinator-0.5.231 → code_coordinator-0.5.232}/coord/milestone_dispatch.py

@@ -259,30 +259,73 @@ def _default_fetch_repo_file(repo_github: str, path: str, branch: str) -> str |
 
 
 def _fetch_manifest_data(
-    repo_github: str, milestone_number: int, branch: str, fetch: ManifestFetch,
+    repo_github: str,
+    milestone_number: int,
+    branch: str,
+    fetch: ManifestFetch,
+    *,
+    issue_number: int | None = None,
 ):
+    """*milestone_number*'s manifest data via *fetch* (a raw-content GitHub
+    fetch, no local checkout, no directory listing) — the legacy single-file
+    ``manifest.(yml|yaml|json)`` (milestone-level ``gate_a:``/``exempt:``
+    blocks live here by choice, #2543), merged with *issue_number*'s own
+    ``manifest.d/<issue_number>.(yml|yaml|json)`` fragment
+    (:data:`coord.acceptance.MANIFEST_FRAGMENTS_DIRNAME`) when *issue_number*
+    is given.
+
+    #2543 review: before this, only the legacy file was ever fetched here,
+    so an issue whose JIT slice was authored under the new per-issue-
+    fragment convention (``coord.test_author``'s briefing writes ONLY to
+    the fragment, never the shared file) would read back
+    ``test_ids_for_issue(...) == set()`` forever — the #1138 hard gate
+    (:func:`issue_oracle_ready`) would refuse Work dispatch with "no
+    acceptance slice yet" even after the slice landed, and
+    :func:`coord.drive.AcceptanceGateChecker.has_authored_slice` (which
+    reads the same ``OracleReadiness.has_slice``) would keep believing no
+    slice was ever authored, re-dispatching a redundant ``test-author``
+    session — precisely the concurrent-JIT-authoring collision #2543 exists
+    to prevent, triggered by the fix itself. Fetching + merging the
+    fragment closes that gap. Callers that only need the milestone-level
+    blocks (:func:`gate_a_signoff_status`, which has no single issue in
+    scope) pass no *issue_number* and get exactly the legacy-only reads
+    this always did.
+    """
     from coord.acceptance import (  # noqa: PLC0415
         ACCEPTANCE_DIRNAME,
+        MANIFEST_FRAGMENTS_DIRNAME,
         ManifestData,
         ManifestError,
+        merge_manifest_data,
         ms_dirname,
         parse_manifest_text,
     )
 
+    def _fetch_one(dir_path: str, filename_stem: str) -> "ManifestData":
+        for ext in (".yml", ".yaml", ".json"):
+            path = f"{dir_path}/{filename_stem}{ext}"
+            content = fetch(repo_github, path, branch)
+            if content is None:
+                continue
+            try:
+                return parse_manifest_text(content, source=path)
+            except ManifestError:
+                # Malformed manifest degrades to "no slice authored" rather
+                # than crashing dispatch — same fail-soft posture as
+                # oracle_loop_contract_block (#945).
+                return ManifestData()
+        return ManifestData()
+
     ms_dir = ms_dirname(milestone_number)
-    for ext in (".yml", ".yaml", ".json"):
-        path = f"{ACCEPTANCE_DIRNAME}/{ms_dir}/manifest{ext}"
-        content = fetch(repo_github, path, branch)
-        if content is None:
-            continue
-        try:
-            return parse_manifest_text(content, source=path)
-        except ManifestError:
-            # Malformed manifest degrades to "no slice authored" rather
-            # than crashing dispatch — same fail-soft posture as
-            # oracle_loop_contract_block (#945).
-            return ManifestData()
-    return ManifestData()
+    legacy = _fetch_one(f"{ACCEPTANCE_DIRNAME}/{ms_dir}", "manifest")
+    if issue_number is None:
+        return legacy
+
+    fragment = _fetch_one(
+        f"{ACCEPTANCE_DIRNAME}/{ms_dir}/{MANIFEST_FRAGMENTS_DIRNAME}",
+        str(issue_number),
+    )
+    return merge_manifest_data(legacy, fragment)
 
 
 def _unsupported_driver_kinds(entry: "AcceptanceDriverConfig") -> tuple[str, ...]:
@@ -522,6 +565,7 @@ def issue_oracle_ready(
 
     manifest = _fetch_manifest_data(
         repo_cfg.github, milestone_number, repo_cfg.default_branch, fetch,
+        issue_number=issue_number,
     )
     has_slice = bool(test_ids_for_issue(manifest.tests, issue_number))
     exempt = issue_number in manifest.exempt or "oracle:exempt" in set(issue_labels)