code-coordinator 0.5.509__tar.gz → 0.5.510__tar.gz

{code_coordinator-0.5.509 → code_coordinator-0.5.510}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.509",
+  "tag": "0.5.510",
   "distance": 0,
-  "node": "gace3f38afa44e85a17064892c36412cab13d0d34",
+  "node": "gabffbb7b64a6328ecda34ff420009f23a1f7a96e",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-20"

{code_coordinator-0.5.509 → code_coordinator-0.5.510}/coord/commands/plans.py

@@ -41,6 +41,16 @@ declared children (:func:`coord.plans.find_stale_epics`, parsed from the
 epic's own cached body) are either unregistered (zero children) or all
 already closed in the cache. Like ``--lint-epics``, this only reports —
 never auto-closes the epic (out of scope per #3226).
+
+``--lint-epics`` also folds in :func:`coord.plans.find_unparseable_epics`
+(#3426): an open, ``"epic"``-labelled issue whose ``## Sub-issues`` checklist
+itself fails to parse — a genuinely different failure from "title reads as
+an epic but isn't labelled". Unlike every other lint here, a hit is not
+merely informational: the board-payload ``children`` projection and every
+other :class:`~coord.parentage.MarkdownParentage` consumer silently reports
+"zero children" for that epic (indistinguishable from one that genuinely has
+none — vimcode#1170), so this command exits non-zero when it finds one,
+naming the offending issue, repo and the unparseable line.
 """
 
 from __future__ import annotations
@@ -174,6 +184,7 @@ def plans_cmd(
     # milestones). Both flags share a single cache fetch when both are
     # passed, rather than reading the table twice.
     unlabelled_epics: list[dict] = []
+    unparseable_epics: list[dict] = []
     stale_epics: list[dict] = []
     if lint_epics or lint_stale_epics:
         from coord import state  # noqa: PLC0415
@@ -182,12 +193,25 @@ def plans_cmd(
         cached_issues = state.cached_open_issues(target_repo_names)
 
         if lint_epics:
-            from coord.plans import find_unlabelled_epics  # noqa: PLC0415
+            from coord.plans import (  # noqa: PLC0415
+                find_unlabelled_epics,
+                find_unparseable_epics,
+            )
 
             unlabelled_epics = sorted(
                 find_unlabelled_epics(cached_issues),
                 key=lambda i: (i.get("repo_name", ""), i.get("number", 0)),
             )
+            # #3426: a genuinely unparseable `## Sub-issues` checklist is a
+            # different, more serious failure than "title reads as an epic
+            # but isn't labelled" — every other consumer of this checklist
+            # (the board payload, find_stale_epics, github_ops's close-guard)
+            # silently reports "zero children" for it, so this is the one
+            # place it surfaces. Drives the non-zero exit below.
+            unparseable_epics = sorted(
+                find_unparseable_epics(cached_issues),
+                key=lambda i: (i.get("repo_name", ""), i.get("number", 0)),
+            )
 
         if lint_stale_epics:
             from coord.plans import find_stale_epics  # noqa: PLC0415
@@ -214,6 +238,15 @@ def plans_cmd(
                     }
                     for i in unlabelled_epics
                 ]
+                combined["unparseable_epics"] = [
+                    {
+                        "repo": i.get("repo_name"),
+                        "number": i.get("number"),
+                        "title": i.get("title"),
+                        "error": i.get("error"),
+                    }
+                    for i in unparseable_epics
+                ]
             if lint_stale_epics:
                 combined["stale_epics"] = [
                     {
@@ -229,6 +262,11 @@ def plans_cmd(
             click.echo(json.dumps(combined, indent=2))
         else:
             click.echo(json.dumps(payload, indent=2))
+        # #3426: a genuinely unparseable epic must not exit 0 — that's the
+        # whole reason this survived undetected on vimcode#1170 (every
+        # consumer failed open AND the lint printed nothing).
+        if unparseable_epics:
+            sys.exit(1)
         return
 
     # Human-readable table.
@@ -268,6 +306,21 @@ def plans_cmd(
         else:
             click.echo("No unlabelled epics found.")
 
+        click.echo("")
+        if unparseable_epics:
+            click.echo(
+                "Unparseable epics (`## Sub-issues` checklist fails to "
+                "parse — every child of this epic is invisible everywhere "
+                "until the line below is fixed by hand):"
+            )
+            for i in unparseable_epics:
+                click.echo(
+                    f"  {i.get('repo_name')}  #{i.get('number')}  {i.get('title')!r}\n"
+                    f"    {i.get('error')}"
+                )
+        else:
+            click.echo("No unparseable epics found.")
+
     if lint_stale_epics:
         click.echo("")
         if stale_epics:
@@ -283,3 +336,8 @@ def plans_cmd(
                 )
         else:
             click.echo("No stale epics found.")
+
+    # #3426: see the json_out branch above — same non-zero-exit rule for the
+    # human-readable path.
+    if unparseable_epics:
+        sys.exit(1)

{code_coordinator-0.5.509 → code_coordinator-0.5.510}/coord/milestone_order.py

@@ -181,7 +181,26 @@ _SUB_ISSUES_HEADING_RE = re.compile(r"^#{1,6}\s*Sub-issues\s*$", re.IGNORECASE)
 # grammar is migrating to drop it (`- #N {...}` instead of `- [ ] #N {...}`).
 # Both forms parse identically during the migration; `coord milestone sync`
 # is what rewrites existing bodies to the checkbox-free form.
-_ITEM_RE = re.compile(r"^-\s*(?:\[([ xX])\]\s*)?#(\d+)\s*(\{([^}]*)\})?")
+# #3426: a leading emphasis marker (`**`, `*`, `_`) between the checkbox and
+# `#N` is stripped before matching — `- [ ] **#1206 — tranche 2 of
+# #1191**: ...` is a reasonable thing for a human to type (bolding the lead
+# item is normal markdown) and used to raise `WorkOrderError` on the whole
+# section, silently voiding every sibling line too (vimcode#1170).
+#
+# A *closing* emphasis marker immediately after the digits (e.g.
+# `- [ ] **#765** {after: #762,#763}`, where only the issue number itself is
+# bolded) is also optionally consumed here, before the annotation. Without
+# this, `.match()` (not `.fullmatch()`) would still successfully match just
+# the `- [ ] **#765` prefix, silently dropping the `{after: ...}` annotation
+# instead of raising — trading a loud whole-block failure for a silent
+# wrong answer (review finding on #3426). The real vimcode#1170 shape
+# (`- [ ] **#1206 -- tranche 2 of #1191**: ...`, where the closing `**` is
+# not adjacent to the digits) is unaffected: there the digits are followed by
+# " -- tranche...", not `**`, so this optional group simply doesn't match
+# there and the rest of the line is still ignored by `.match`.
+_ITEM_RE = re.compile(
+    r"^-\s*(?:\[([ xX])\]\s*)?(?:\*\*|\*|_)?#(\d+)(?:\*\*|\*|_)?\s*(\{([^}]*)\})?"
+)
 # Splits `key: value` pairs on commas that precede the *next* key, so an
 # `after: #762,#763` value (itself comma-separated) isn't cut mid-list.
 _PAIR_RE = re.compile(r"(\w+)\s*:\s*(.*?)(?=,\s*\w+\s*:|$)")

{code_coordinator-0.5.509 → code_coordinator-0.5.510}/coord/plans.py

@@ -61,6 +61,17 @@ Design decisions (#974):
   the ``## Sub-issues``/``## Work order`` checklist's own ``[x]``/``[ ]`` box,
   which #1061 stopped keeping in sync with reality. The CLI command
   (``coord plans --lint-stale-epics``) is what reads the local cache.
+- **Unparseable-checklist lint (#3426)**.  :func:`find_unparseable_epics` is a
+  third read-only lint over the same locally-cached ``issues`` shape: an open,
+  ``"epic"``-labelled issue whose ``## Sub-issues`` checklist itself fails to
+  parse (:class:`~coord.milestone_order.WorkOrderError`) rather than merely
+  having zero/all-closed children. Every OTHER call site over the same
+  checklist (the board-payload ``children`` projection, :func:`find_stale_epics`
+  above, ``coord/github_ops.py``'s close-guard) catches that error and reports
+  "no children" — indistinguishable from an epic that genuinely has none, and
+  silent (vimcode#1170: three bold-prefixed lines hid all 24 real children with
+  no warning anywhere). This lint is what makes that failure visible: folded
+  into ``coord plans --lint-epics``, which exits non-zero when it finds one.
 """
 
 from __future__ import annotations
@@ -86,6 +97,7 @@ __all__ = [
     "PlanEntry",
     "find_tracking_issue",
     "find_unlabelled_epics",
+    "find_unparseable_epics",
     "find_stale_epics",
     "aggregate_plan",
     "aggregate_repo_plans",
@@ -275,6 +287,77 @@ def find_unlabelled_epics(issues: list[dict]) -> list[dict]:
     return hits
 
 
+# ── Unparseable-checklist lint (#3426) ──────────────────────────────────────
+
+
+def find_unparseable_epics(issues: list[dict]) -> list[dict]:
+    """Return open, ``TRACKING_ISSUE_LABEL``-labelled issues whose ``##
+    Sub-issues`` checklist fails to parse (#3426).
+
+    Every call site downstream of :class:`coord.parentage.MarkdownParentage`
+    (the board-payload ``children`` projection, :func:`find_stale_epics`
+    below, and ``coord/github_ops.py``'s close-guard) catches
+    :class:`~coord.milestone_order.WorkOrderError` and reports "zero
+    children" for the whole epic — indistinguishable from an epic that
+    genuinely has none. A single malformed line (e.g. an issue number
+    wrapped in ``**bold**``, before #3426 widened the grammar to strip a
+    leading emphasis marker) used to hide EVERY sibling line in the same
+    block too: vimcode#1170, three bold-prefixed lines hiding all 24
+    children while two were in flight, with nothing reporting it anywhere.
+
+    This lint is the one place that surfaces the failure instead of
+    swallowing it: it re-derives each epic's children through the exact same
+    seam the board payload uses — :class:`coord.parentage.MarkdownParentage`
+    .children(..., fallback_to_work_order=True) — and reports the ones that
+    still raise, each hit carrying the original issue dict plus an
+    ``"error"`` key with the exact :class:`~coord.milestone_order.
+    WorkOrderError` message (names the offending line).
+
+    Deliberately *not* a direct call to :func:`coord.milestone_order.
+    parse_sub_issues` (#3426 review finding): ``coord/serve_app.py``'s board
+    payload additionally falls back to ``## Work order`` when ``##
+    Sub-issues`` is absent/empty (common for epics that predate #1008, per
+    the #1197 fix-iteration finding), and that fallback parse can itself
+    raise. Calling ``parse_sub_issues`` alone here would let this lint and
+    the board payload disagree about whether the same epic is parseable —
+    the "one question, one answer" split-brain this repo's #2096 calls out.
+    Going through :class:`~coord.parentage.MarkdownParentage` with the same
+    ``fallback_to_work_order=True`` keeps the two consumers from being able
+    to diverge.
+
+    ``issues`` is the same local-cache shape :func:`find_unlabelled_epics` /
+    :func:`find_stale_epics` consume (``labels`` as a plain ``list[str]``,
+    plus ``"body"``). Read-only — flags only; the caller (``coord plans
+    --lint-epics``) is what turns a non-empty result into a non-zero exit
+    code.
+    """
+    parentage = MarkdownParentage()
+    hits: list[dict] = []
+    for issue in issues:
+        state = (issue.get("state") or "open").lower()
+        if state != "open":
+            continue
+        raw_labels = issue.get("labels") or []
+        label_names = {
+            lbl["name"] if isinstance(lbl, dict) else str(lbl) for lbl in raw_labels
+        }
+        if TRACKING_ISSUE_LABEL not in label_names:
+            continue
+        number = issue.get("number")
+        if number is None:
+            continue
+        try:
+            parentage.children(
+                issue.get("repo_name", ""),
+                int(number),
+                body=issue.get("body") or "",
+                fallback_to_work_order=True,
+            )
+        except Exception as exc:  # noqa: BLE001 — #3426: report it, don't swallow it
+            hits.append({**issue, "error": str(exc)})
+    return hits
+
+
 # ── Stale-tracker lint (#3228) ──────────────────────────────────────────────
 
 

{code_coordinator-0.5.509 → code_coordinator-0.5.510}/coord/serve_app.py

@@ -2785,6 +2785,32 @@ def _board_response_schema(components: dict) -> dict:
                     "required": ["repo_name", "tracking_issue", "children"],
                 },
             },
+            "children_errors": {
+                "type": "array",
+                "description": (
+                    "#3426: per-epic parse failures for the same `## "
+                    "Sub-issues`/`## Work order` checklist `children` above "
+                    "resolves — one entry per tracking issue whose checklist "
+                    "raised coord.milestone_order.WorkOrderError (e.g. a "
+                    "duplicate `#N`, an `after` edge to an undeclared issue, "
+                    "a dependency cycle) instead of yielding zero/some "
+                    "children. Surfaces the failure instead of the silent "
+                    "'zero children' `children` would otherwise report for "
+                    "the same epic (vimcode#1170)."
+                ),
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "repo_name": {"type": "string"},
+                        "tracking_issue": {"type": "integer"},
+                        "error": {
+                            "type": "string",
+                            "description": "the WorkOrderError message, naming the offending line",
+                        },
+                    },
+                    "required": ["repo_name", "tracking_issue", "error"],
+                },
+            },
         },
         "required": [
             "schema_version", "round_number", "assignments", "machines",
@@ -6672,6 +6698,7 @@ def build_app(
 
                 _parentage = _MarkdownParentage()
                 _epic_children: list[dict] = []
+                _epic_children_errors: list[dict] = []
                 for _ci_ti in projection.get("issues", []):
                     _ci_labels = _ci_ti.get("labels") or []
                     if _TRACKING_LABEL not in _ci_labels:
@@ -6684,7 +6711,19 @@ def build_app(
                             "", _ci_ti["number"], body=_ci_ti.get("body") or "",
                             fallback_to_work_order=True,
                         )
-                    except Exception:  # noqa: BLE001 — bad sub-issues block: skip this epic only
+                    except Exception as _ci_exc:  # noqa: BLE001 — #3426: surface, don't swallow
+                        # A malformed `## Sub-issues` (or, via the fallback,
+                        # `## Work order`) block on THIS epic must not blank
+                        # ITS children nor any sibling epic's — fail this one
+                        # epic open (report it, zero children) rather than
+                        # letting the exception mean "silently no children"
+                        # (vimcode#1170: three bad lines hid all 24 real
+                        # children with nothing reporting it anywhere).
+                        _epic_children_errors.append({
+                            "repo_name": _ci_repo_name,
+                            "tracking_issue": _ci_ti["number"],
+                            "error": str(_ci_exc),
+                        })
                         continue
                     if _ci_kids:
                         _epic_children.append({
@@ -6695,8 +6734,10 @@ def build_app(
                             ],
                         })
                 projection["children"] = _epic_children
+                projection["children_errors"] = _epic_children_errors
             except Exception:  # noqa: BLE001 — children failure must not blank the board
                 projection["children"] = []
+                projection["children_errors"] = []
             # #975: milestone plan-roster — reuse coord.plans.aggregate_repo_plans
             # server-side so the Plans TUI panel gets one row per milestone/epic
             # (ready / blocked / in-flight / done counts, needs_you attention

{code_coordinator-0.5.509 → code_coordinator-0.5.510}/tests/test_cli_plans.py

@@ -28,6 +28,7 @@ from coord.plans import (
     find_stale_epics,
     find_tracking_issue,
     find_unlabelled_epics,
+    find_unparseable_epics,
 )
 from coord.state import upsert_open_issues
 
@@ -865,6 +866,113 @@ class TestFindUnlabelledEpics:
         assert find_unlabelled_epics(issues) == []
 
 
+# ── find_unparseable_epics (#3426) ───────────────────────────────────────────
+
+
+class TestFindUnparseableEpics:
+    def test_malformed_sub_issues_block_is_flagged_with_error_message(self) -> None:
+        """The real vimcode#1170 shape: a bold-prefixed issue number used to
+        make the whole `## Sub-issues` block unparseable (before #3426
+        widened the grammar to strip a leading `**`/`*`/`_`). Pin an entry
+        that IS still genuinely malformed (a duplicate `#N`) so this lint
+        keeps a live regression even after the bold case itself stops
+        failing."""
+        issues = [
+            _cached_issue(
+                1170,
+                "Epic: vimcode integration",
+                labels=["epic"],
+                body="## Sub-issues\n- [ ] #10\n- [ ] #10\n",
+            )
+        ]
+        hits = find_unparseable_epics(issues)
+        assert [h["number"] for h in hits] == [1170]
+        assert "#10" in hits[0]["error"]
+        assert "more than once" in hits[0]["error"]
+
+    def test_bold_prefixed_issue_number_is_not_flagged(self) -> None:
+        """#3426's grammar widening means the common case (bolding the lead
+        item) is no longer even a hit for this lint."""
+        issues = [
+            _cached_issue(
+                1170,
+                "Epic: vimcode integration",
+                labels=["epic"],
+                body=(
+                    "## Sub-issues\n"
+                    "- [ ] **#1206 — tranche 2 of #1191**: the 8 remaining "
+                    "value options\n"
+                ),
+            )
+        ]
+        assert find_unparseable_epics(issues) == []
+
+    def test_well_formed_checklist_is_not_flagged(self) -> None:
+        issues = [_epic_with_sub_issues(700, "Epic: healthy", [701, 702])]
+        assert find_unparseable_epics(issues) == []
+
+    def test_no_sub_issues_block_is_not_flagged(self) -> None:
+        """No `## Sub-issues` heading at all just parses empty — that's a
+        different, non-error state from a present-but-broken block."""
+        issues = [_cached_issue(1, "Epic: no checklist yet", labels=["epic"])]
+        assert find_unparseable_epics(issues) == []
+
+    def test_non_epic_issue_is_not_flagged(self) -> None:
+        issues = [
+            _cached_issue(
+                1, "Fix flaky test", body="## Sub-issues\n- [ ] #10\n- [ ] #10\n"
+            )
+        ]
+        assert find_unparseable_epics(issues) == []
+
+    def test_closed_epic_is_not_flagged(self) -> None:
+        issues = [
+            _cached_issue(
+                2,
+                "Epic: closed",
+                labels=["epic"],
+                state="closed",
+                body="## Sub-issues\n- [ ] #10\n- [ ] #10\n",
+            )
+        ]
+        assert find_unparseable_epics(issues) == []
+
+    def test_malformed_work_order_fallback_is_flagged_when_sub_issues_absent(
+        self,
+    ) -> None:
+        """Non-blocking review finding on #3426: the board payload's
+        `MarkdownParentage.children(..., fallback_to_work_order=True)` falls
+        back to `## Work order` when `## Sub-issues` is absent/empty (#1197 —
+        common for epics that predate #1008), and that fallback parse can
+        itself raise. This lint must go through the same seam so it can't
+        report "clean" for an epic the board payload reports as broken."""
+        issues = [
+            _cached_issue(
+                1170,
+                "Epic: predates sub-issues",
+                labels=["epic"],
+                body="## Work order\n- [ ] #10\n- [ ] #10\n",
+            )
+        ]
+        hits = find_unparseable_epics(issues)
+        assert [h["number"] for h in hits] == [1170]
+        assert "more than once" in hits[0]["error"]
+
+    def test_one_malformed_epic_does_not_suppress_a_sibling_epic(self) -> None:
+        """The reason this bug survived: a parse failure used to hide
+        EVERYTHING for that epic, silently. The lint itself must not let one
+        bad epic blank out a well-formed sibling's result either."""
+        malformed = _cached_issue(
+            100,
+            "Epic: malformed checklist",
+            labels=["epic"],
+            body="## Sub-issues\n- [ ] #10\n- [ ] #10\n",
+        )
+        healthy = _epic_with_sub_issues(700, "Epic: healthy", [701, 702])
+        hits = find_unparseable_epics([malformed, healthy])
+        assert [h["number"] for h in hits] == [100]
+
+
 # ── find_stale_epics (#3228) ─────────────────────────────────────────────────
 
 
@@ -1085,6 +1193,111 @@ class TestLintEpicsCli:
         data = json.loads(result.output)
         assert data == []
 
+    def test_unparseable_sub_issues_block_exits_non_zero_and_names_the_line(
+        self, config_file: Path
+    ) -> None:
+        """#3426: this is the whole point of the lint — before this fix,
+        an epic body that couldn't be parsed (vimcode#1170) produced NO
+        output anywhere and exit 0, which is why the failure went
+        undetected. Now the offending issue, repo and line must all be
+        named, and the process must exit non-zero."""
+        upsert_open_issues(
+            "api",
+            [
+                {
+                    "number": 1170,
+                    "title": "Epic: vimcode integration",
+                    "body": "## Sub-issues\n- [ ] #10\n- [ ] #10\n",
+                    "labels": [{"name": "epic"}],
+                },
+            ],
+        )
+        with (
+            patch("coord.github_ops.get_repo_milestones", return_value=[]),
+            patch("coord.github_ops.get_open_issues", return_value=[]),
+            patch("coord.github_ops.get_closed_epics", return_value=[]),
+        ):
+            result = CliRunner().invoke(
+                main,
+                ["plans", "--lint-epics", "--config", str(config_file)],
+            )
+        assert result.exit_code != 0
+        assert "api" in result.output
+        assert "#1170" in result.output
+        assert "#10" in result.output
+        assert "more than once" in result.output
+
+    def test_unparseable_epic_does_not_suppress_an_unrelated_repo(
+        self, config_file: Path
+    ) -> None:
+        """Fail-open, per the acceptance bar: one malformed epic must not
+        blank another, well-formed epic's lint output (still non-zero exit,
+        but the healthy epic's absence from `unlabelled_epics`/other output
+        is unaffected, and it never appears in `unparseable_epics`)."""
+        upsert_open_issues(
+            "api",
+            [
+                {
+                    "number": 1170,
+                    "title": "Epic: vimcode integration",
+                    "body": "## Sub-issues\n- [ ] #10\n- [ ] #10\n",
+                    "labels": [{"name": "epic"}],
+                },
+                {
+                    "number": 900,
+                    "title": "Epic: healthy",
+                    "body": "## Sub-issues\n- [ ] #901\n",
+                    "labels": [{"name": "epic"}],
+                },
+            ],
+        )
+        with (
+            patch("coord.github_ops.get_repo_milestones", return_value=[]),
+            patch("coord.github_ops.get_open_issues", return_value=[]),
+            patch("coord.github_ops.get_closed_epics", return_value=[]),
+        ):
+            result = CliRunner().invoke(
+                main,
+                ["plans", "--lint-epics", "--json", "--config", str(config_file)],
+            )
+        assert result.exit_code != 0
+        data = json.loads(result.output)
+        assert [e["number"] for e in data["unparseable_epics"]] == [1170]
+
+    def test_bold_prefixed_issue_number_does_not_trip_the_lint(
+        self, config_file: Path
+    ) -> None:
+        """#3426's grammar widening: the common case (bolding the lead item)
+        must parse cleanly and exit 0 — it's the genuinely-malformed case
+        above that must fail."""
+        upsert_open_issues(
+            "api",
+            [
+                {
+                    "number": 1170,
+                    "title": "Epic: vimcode integration",
+                    "body": (
+                        "## Sub-issues\n"
+                        "- [ ] **#1206 — tranche 2 of #1191**: the 8 "
+                        "remaining value options\n"
+                    ),
+                    "labels": [{"name": "epic"}],
+                },
+            ],
+        )
+        with (
+            patch("coord.github_ops.get_repo_milestones", return_value=[]),
+            patch("coord.github_ops.get_open_issues", return_value=[]),
+            patch("coord.github_ops.get_closed_epics", return_value=[]),
+        ):
+            result = CliRunner().invoke(
+                main,
+                ["plans", "--lint-epics", "--json", "--config", str(config_file)],
+            )
+        assert result.exit_code == 0, result.output
+        data = json.loads(result.output)
+        assert data["unparseable_epics"] == []
+
 
 # ── coord plans --lint-stale-epics CLI integration (#3228) ──────────────────
 

{code_coordinator-0.5.509 → code_coordinator-0.5.510}/tests/test_milestone_order.py

@@ -551,6 +551,76 @@ class TestParseSubIssuesErrors:
             parse_sub_issues(body)
 
 
+class TestParseSubIssuesEmphasisMarkers:
+    """#3426: a leading `**`/`*`/`_` between the checkbox and `#N` is normal
+    markdown (bolding the lead item is a reasonable thing for a human to
+    type) and used to raise `WorkOrderError` for the whole line — and,
+    because `_parse_checklist_section` raises rather than skipping just that
+    line, silently voided every OTHER (well-formed) sibling line in the same
+    `## Sub-issues` block too. The fixture below pins the actual vimcode#1170
+    text: three bold-prefixed lines hid all 24 real children, 21 of which
+    parsed perfectly, until the three were corrected by hand.
+    """
+
+    # Real text from vimcode#1170 (trimmed to a representative slice — the
+    # exact three offending lines plus enough plain siblings to prove they
+    # stop being collateral damage).
+    VIMCODE_1170_BODY = """\
+Epic intro prose.
+
+## Sub-issues
+- [ ] #1201  {group: A}
+- [ ] #1202  {group: A}
+- [ ] #1203  {group: A}
+- [ ] **#1206 — tranche 2 of #1191**: the 8 remaining value options land here
+- [ ] **#1207 — tranche 3 of #1191**: another bold-prefixed line
+- [ ] **#1208 — tranche 4 of #1191**: a third bold-prefixed line
+- [ ] #1209  {group: B}
+"""
+
+    def test_bold_prefixed_lines_parse_alongside_plain_siblings(self) -> None:
+        wo = parse_sub_issues(self.VIMCODE_1170_BODY)
+        assert wo.issue_numbers == (1201, 1202, 1203, 1206, 1207, 1208, 1209)
+
+    def test_bold_prefixed_line_yields_the_same_node_as_a_plain_line(self) -> None:
+        bold = "## Sub-issues\n- [ ] **#42 — prose here**: more prose\n"
+        plain = "## Sub-issues\n- [ ] #42\n"
+        assert parse_sub_issues(bold).node(42) == parse_sub_issues(plain).node(42)
+
+    def test_single_asterisk_and_underscore_emphasis_also_strip(self) -> None:
+        assert parse_sub_issues("## Sub-issues\n- [ ] *#7 — prose*\n").issue_numbers == (7,)
+        assert parse_sub_issues("## Sub-issues\n- [ ] _#7 — prose_\n").issue_numbers == (7,)
+
+    def test_bold_wrapped_number_with_trailing_annotation_keeps_the_after_edge(
+        self,
+    ) -> None:
+        """Review finding on #3426: a line that bolds *only* the issue number
+        and then carries an annotation right after the closing `**` (e.g.
+        `- [ ] **#765** {after: #762,#763}`) must not silently drop the
+        `after` edge. Before the fix, `.match()` (not `.fullmatch()`) still
+        matched just the `- [ ] **#765` prefix and returned `after=()` —
+        parsing "successfully" while quietly discarding a real dependency
+        edge, which `ready_frontier` consumes for dispatch ordering."""
+        body = (
+            "## Work order\n"
+            "- [ ] #762\n"
+            "- [ ] #763\n"
+            "- [ ] **#765** {after: #762,#763}\n"
+        )
+        wo = parse_work_order(body)
+        assert wo.node(765).after == (762, 763)
+
+    def test_a_line_that_is_still_malformed_still_raises(self) -> None:
+        """Widening the grammar removes ONE failure class, not all of them —
+        a genuinely malformed line (no `#N` at all) still raises, and it
+        still voids the whole section (that fail-loud behavior at this
+        layer is unchanged; #3426's fix-open behavior lives one layer up,
+        at the callers of `parse_sub_issues`)."""
+        body = "## Sub-issues\n- [ ] #1\n- this is not a sub-issue item\n"
+        with pytest.raises(WorkOrderError, match="unparseable line"):
+            parse_sub_issues(body)
+
+
 class TestRenderSubIssues:
     def test_is_render_work_order(self) -> None:
         """render_sub_issues is an alias — heading-agnostic rendering means