code-coordinator 0.5.757__tar.gz → 0.5.758__tar.gz

{code_coordinator-0.5.757 → code_coordinator-0.5.758}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.757",
+  "tag": "0.5.758",
   "distance": 0,
-  "node": "gc8dc449a130994d5bcdd25063904e4d0a736915f",
+  "node": "g8f42c93d4e44ab72667aba0b52cb6a7b0631535b",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-11-11"

{code_coordinator-0.5.757 → code_coordinator-0.5.758}/coord/agent.py

@@ -4521,6 +4521,22 @@ only re-propose the same split. Omit the marker entirely for every other \
 or a false/unmet premise that is NOT "already done") — those still read \
 off your prose exactly as before.
 
+With `needs-decomposition`, also put the split in your final message as \
+this block (one `## Child N:` per proposed issue, each with its own \
+`## Files` list); the coordinator files the children and supersedes this \
+issue automatically when it is well-formed:
+
+  SIZE_TRIAGE_VERDICT: split
+  ## Child 1: <title>
+  <one paragraph of scope>
+
+  ## Files
+  - path/a.py
+
+  ## Child 2: <title>
+  ...
+  END_SIZE_TRIAGE
+
 Progress reporting:
 - After each significant step (first build, test run, approach change), \
 output a status line in exactly this format:

{code_coordinator-0.5.757 → code_coordinator-0.5.758}/coord/decomposition_chat.py

@@ -1319,9 +1319,13 @@ def file_and_queue_split_proposal(
     proposal: "SplitProposal",
     verification: "SplitVerification",
     repo: "Repo",
+    origin: str = "preflight size-triage review",
 ) -> int:
     """File *proposal*'s chunks as a real epic + children and queue them.
 
+    *origin* names what proposed the split; it is quoted in the epic body
+    and in the comment closing the superseded original.
+
     Called only after :func:`coord.preflight_size.verify_split_proposal` has
     returned ``ok=True`` for *verification* — this function trusts
     ``verification.work_order`` and ``verification.epic_body`` without
@@ -1365,9 +1369,8 @@ def file_and_queue_split_proposal(
 
     epic_body = (
         f"{proposal.rationale}\n\n"
-        f"Split from #{proposal.issue_number} by the preflight "
-        "size-triage review. Children are filed below and queued in "
-        "overlap order."
+        f"Split from #{proposal.issue_number} by the {origin}. Children "
+        "are filed below and queued in overlap order."
     )
     epic = github_ops.create_issue(
         repo.github,
@@ -1419,8 +1422,7 @@ def file_and_queue_split_proposal(
         proposal.issue_number,
         comment=(
             f"Superseded by #{epic_number} — split into "
-            f"{len(proposal.chunks)} child issue(s) per the size-triage "
-            "review."
+            f"{len(proposal.chunks)} child issue(s) per the {origin}."
         ),
         force=True,
     )
@@ -1438,6 +1440,105 @@ def file_and_queue_split_proposal(
     return epic_number
 
 
+#: The ``origin`` text :func:`auto_split_needs_decomposition` passes to
+#: :func:`file_and_queue_split_proposal`.
+NEEDS_DECOMPOSITION_SPLIT_ORIGIN = "work leg's needs-decomposition split proposal"
+
+
+def auto_split_needs_decomposition(
+    final_message: str | None,
+    *,
+    config: "Config",
+    repo_name: str,
+    issue_number: int,
+) -> int | None:
+    """File the split a ``needs-decomposition`` work leg proposed, if it
+    proposed one in the machine-readable size-triage format.
+
+    *final_message* is the worker's own final message. The worker states its
+    split as a ``SIZE_TRIAGE_VERDICT: split`` / ``## Child N:`` /
+    ``## Files`` / ``END_SIZE_TRIAGE`` block — the same wire format the
+    size-triage agent uses, parsed by :func:`parse_size_triage_response` —
+    and the split then goes through the identical
+    :func:`coord.preflight_size.verify_split_proposal` gate and
+    :func:`file_and_queue_split_proposal` filer a size-triage SPLIT verdict
+    does: an epic plus chained children are filed and queued, and the
+    original is closed as superseded. The original's own (parked) drive-
+    queue row is then removed, since the issue it tracks is closed.
+
+    Returns the new epic's issue number, or ``None`` when nothing was filed:
+    the repo has not opted into the preflight decomposition guard
+    (:meth:`coord.config.Config.preflight_guard_enabled` — the same opt-in
+    that governs every other automatic split), the message carries no
+    complete split block (prose-only proposals stay with the coordinator,
+    exactly as before), the original issue is already closed (a replayed
+    transition, or someone already decomposed it), or the proposal fails the
+    verification gate — a broken epic is never filed. A failure *inside*
+    the filer propagates: by then real issues exist on GitHub.
+    """
+    text = final_message or ""
+    if not _SIZE_TRIAGE_VERDICT_RE.search(text):
+        return None
+    repo = config.repo(repo_name)
+    if repo is None or not config.preflight_guard_enabled(repo_name):
+        return None
+
+    from coord import github_ops
+    from coord.preflight_size import verify_split_proposal
+
+    issue_data = github_ops.get_issue(repo.github, issue_number)
+    if str(issue_data.get("state") or "").upper() == "CLOSED":
+        return None
+    issue_title = issue_data.get("title") or f"issue #{issue_number}"
+
+    try:
+        proposal = parse_size_triage_response(
+            text,
+            repo_name=repo_name,
+            issue_number=issue_number,
+            issue_title=issue_title,
+        )
+    except SizeTriageError as exc:
+        _log.info(
+            "auto_split_needs_decomposition: %s#%s split block unparseable: %s",
+            repo_name, issue_number, exc,
+        )
+        return None
+    if proposal is None:
+        return None
+    proposal.rationale = (
+        "a work leg concluded this issue needs decomposition and proposed "
+        "this split"
+    )
+
+    verification = verify_split_proposal(proposal)
+    if not verification.ok:
+        _log.info(
+            "auto_split_needs_decomposition: %s#%s split rejected: %s",
+            repo_name, issue_number, verification.reason,
+        )
+        return None
+
+    epic_number = file_and_queue_split_proposal(
+        proposal=proposal,
+        verification=verification,
+        repo=repo,
+        origin=NEEDS_DECOMPOSITION_SPLIT_ORIGIN,
+    )
+
+    from coord.state import dequeue_drive_queue
+
+    try:
+        dequeue_drive_queue(repo_name, issue_number, operator=False)
+    except Exception as exc:  # noqa: BLE001
+        _log.warning(
+            "auto_split_needs_decomposition: filed epic #%s but could not "
+            "dequeue superseded %s#%s: %s",
+            epic_number, repo_name, issue_number, exc,
+        )
+    return epic_number
+
+
 def dispatch_size_triage_review(
     *,
     repo_cfg: "Repo",

{code_coordinator-0.5.757 → code_coordinator-0.5.758}/coord/notify.py

@@ -2364,6 +2364,55 @@ def _capture_upstream_gaps(transition: Transition, entry: dict, record: dict) ->
         )
 
 
+def _capture_needs_decomposition_split(
+    transition: Transition, entry: dict, record: dict
+) -> None:
+    """File the split a ``needs-decomposition`` work leg proposed in the
+    machine-readable size-triage block — see
+    :func:`coord.decomposition_chat.auto_split_needs_decomposition`.
+
+    Reads the worker's final message from the row's
+    ``needs_decomposition_reason`` first, falling back to the final message
+    in the worker log. Best-effort: any failure is logged and the issue
+    stays parked for the coordinator, the same as a prose-only proposal.
+    """
+    from coord.decomposition_chat import (  # noqa: PLC0415
+        SIZE_TRIAGE_END_MARKER,
+        auto_split_needs_decomposition,
+    )
+
+    if (record.get("type") or "work") != "work" or not transition.issue_number:
+        return
+    try:
+        text = entry.get("needs_decomposition_reason") or ""
+        if SIZE_TRIAGE_END_MARKER not in text:
+            from coord.upstream_gaps import (  # noqa: PLC0415
+                final_message_from_log_text,
+            )
+
+            text = final_message_from_log_text(_worker_log_text(transition, entry))
+        if SIZE_TRIAGE_END_MARKER not in text:
+            return
+        from coord.config import load as _load_config  # noqa: PLC0415
+
+        epic_number = auto_split_needs_decomposition(
+            text,
+            config=_load_config(),
+            repo_name=transition.repo_name,
+            issue_number=transition.issue_number,
+        )
+        if epic_number is not None:
+            log.info(
+                "_capture_needs_decomposition_split: %s#%s split into epic #%s",
+                transition.repo_name, transition.issue_number, epic_number,
+            )
+    except Exception as exc:  # noqa: BLE001
+        log.warning(
+            "_capture_needs_decomposition_split: failed for %s: %s",
+            transition.assignment_id, exc,
+        )
+
+
 def _capture_smoke_tests(transition: Transition, entry: dict) -> None:
     """#252: parse the worker's SMOKE_TESTS block and persist it on the row.
 
@@ -4966,6 +5015,9 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
             transition.event,
             branch=entry.get("branch"),
         )
+        # Runs after `mark_notified` so a split that files issues and then
+        # fails partway can never be replayed into a duplicate epic.
+        _capture_needs_decomposition_split(transition, entry, record)
     else:
         # #1605/#1797: carry the agent's own diagnostic (a usage-limit kill,
         # a terminal API-error classification, or an auth-shaped push

{code_coordinator-0.5.757 → code_coordinator-0.5.758}/tests/test_decomposition_chat.py

@@ -2229,3 +2229,152 @@ class TestFileAndQueueSplitProposal:
                 proposal=self._proposal(), verification=self._verification(), repo=repo,
             )
         mock_close_issue.assert_not_called()
+
+
+class TestAutoSplitNeedsDecomposition:
+    """`auto_split_needs_decomposition` files a needs-decomposition work
+    leg's machine-readable split through the same verify + file + queue path
+    a size-triage SPLIT verdict uses, and files nothing otherwise."""
+
+    _SPLIT = (
+        "WORK_OUTCOME: needs-decomposition — two independent halves\n\n"
+        "SIZE_TRIAGE_VERDICT: split\n"
+        "## Child 1: Parser half\n"
+        "Add the parser.\n\n"
+        "## Files\n"
+        "- coord/parser_part.py\n\n"
+        "## Child 2: Wiring half\n"
+        "Wire it in.\n\n"
+        "## Files\n"
+        "- coord/wiring_part.py\n\n"
+        "END_SIZE_TRIAGE\n"
+    )
+
+    class _Config:
+        def __init__(self, enabled: bool = True) -> None:
+            from coord.models import Repo
+
+            self._repo = Repo(name="api", github="acme/api")
+            self._enabled = enabled
+
+        def repo(self, name: str):
+            return self._repo if name == "api" else None
+
+        def preflight_guard_enabled(self, repo_name: str) -> bool:
+            return self._enabled
+
+    @patch("coord.state.dequeue_drive_queue")
+    @patch("coord.decomposition_chat.file_and_queue_split_proposal", return_value=900)
+    @patch("coord.github_ops.get_issue")
+    def test_files_verified_split_and_dequeues_original(
+        self, mock_get_issue, mock_file, mock_dequeue,
+    ) -> None:
+        mock_get_issue.return_value = {"state": "OPEN", "title": "Big issue"}
+
+        epic = decomposition_chat.auto_split_needs_decomposition(
+            self._SPLIT, config=self._Config(), repo_name="api", issue_number=99,
+        )
+
+        assert epic == 900
+        kwargs = mock_file.call_args.kwargs
+        proposal = kwargs["proposal"]
+        assert proposal.issue_number == 99
+        assert proposal.issue_title == "Big issue"
+        assert [c.title for c in proposal.chunks] == ["Parser half", "Wiring half"]
+        assert proposal.chunks[0].files_likely == ["coord/parser_part.py"]
+        assert kwargs["verification"].ok is True
+        assert kwargs["repo"].github == "acme/api"
+        assert kwargs["origin"] == decomposition_chat.NEEDS_DECOMPOSITION_SPLIT_ORIGIN
+        mock_dequeue.assert_called_once_with("api", 99, operator=False)
+
+    @patch("coord.decomposition_chat.file_and_queue_split_proposal")
+    @patch("coord.github_ops.get_issue")
+    def test_prose_only_proposal_files_nothing(self, mock_get_issue, mock_file) -> None:
+        epic = decomposition_chat.auto_split_needs_decomposition(
+            "WORK_OUTCOME: needs-decomposition — split into auth and billing",
+            config=self._Config(), repo_name="api", issue_number=99,
+        )
+        assert epic is None
+        mock_get_issue.assert_not_called()
+        mock_file.assert_not_called()
+
+    @patch("coord.decomposition_chat.file_and_queue_split_proposal")
+    @patch("coord.github_ops.get_issue")
+    def test_repo_not_opted_in_files_nothing(self, mock_get_issue, mock_file) -> None:
+        epic = decomposition_chat.auto_split_needs_decomposition(
+            self._SPLIT, config=self._Config(enabled=False),
+            repo_name="api", issue_number=99,
+        )
+        assert epic is None
+        mock_get_issue.assert_not_called()
+        mock_file.assert_not_called()
+
+    @patch("coord.decomposition_chat.file_and_queue_split_proposal")
+    @patch("coord.github_ops.get_issue")
+    def test_closed_original_files_nothing(self, mock_get_issue, mock_file) -> None:
+        mock_get_issue.return_value = {"state": "CLOSED", "title": "Big issue"}
+        epic = decomposition_chat.auto_split_needs_decomposition(
+            self._SPLIT, config=self._Config(), repo_name="api", issue_number=99,
+        )
+        assert epic is None
+        mock_file.assert_not_called()
+
+    @patch("coord.decomposition_chat.file_and_queue_split_proposal")
+    @patch("coord.github_ops.get_issue")
+    def test_truncated_block_files_nothing(self, mock_get_issue, mock_file) -> None:
+        mock_get_issue.return_value = {"state": "OPEN", "title": "Big issue"}
+        truncated = self._SPLIT.replace("END_SIZE_TRIAGE\n", "")
+        epic = decomposition_chat.auto_split_needs_decomposition(
+            truncated, config=self._Config(), repo_name="api", issue_number=99,
+        )
+        assert epic is None
+        mock_file.assert_not_called()
+
+    @patch("coord.decomposition_chat.file_and_queue_split_proposal")
+    @patch("coord.preflight_size.verify_split_proposal")
+    @patch("coord.github_ops.get_issue")
+    def test_gate_rejected_split_files_nothing(
+        self, mock_get_issue, mock_verify, mock_file,
+    ) -> None:
+        from coord.preflight_size import SplitVerification
+
+        mock_get_issue.return_value = {"state": "OPEN", "title": "Big issue"}
+        mock_verify.return_value = SplitVerification(ok=False, reason="overlap")
+        epic = decomposition_chat.auto_split_needs_decomposition(
+            self._SPLIT, config=self._Config(), repo_name="api", issue_number=99,
+        )
+        assert epic is None
+        mock_file.assert_not_called()
+
+    @patch("coord.state.get_drive_queue_entry", return_value={"after_json": []})
+    @patch("coord.state.enqueue_drive_queue")
+    @patch("coord.github_ops.get_issue_state", return_value="closed")
+    @patch("coord.github_ops.close_issue")
+    @patch("coord.github_ops.update_issue_body")
+    @patch("coord.github_ops.create_issue")
+    def test_filer_origin_is_quoted_in_epic_and_close_comment(
+        self, mock_create_issue, mock_update_body, mock_close_issue,
+        mock_get_issue_state, mock_enqueue, mock_get_entry,
+    ) -> None:
+        from coord.milestone_order import WorkOrder, WorkOrderNode
+        from coord.models import Repo, SplitChunk, SplitProposal
+        from coord.preflight_size import SplitVerification
+
+        mock_create_issue.side_effect = [{"number": 500}, {"number": 501}]
+        decomposition_chat.file_and_queue_split_proposal(
+            proposal=SplitProposal(
+                id=0, repo_name="api", issue_number=99, issue_title="Big",
+                rationale="r", chunks=[
+                    SplitChunk(title="P1", scope="s", files_likely=["a.py"]),
+                ],
+            ),
+            verification=SplitVerification(
+                ok=True, reason=None, epic_body="e",
+                work_order=WorkOrder(nodes=(WorkOrderNode(issue_number=1, after=()),)),
+            ),
+            repo=Repo(name="api", github="acme/api"),
+            origin=decomposition_chat.NEEDS_DECOMPOSITION_SPLIT_ORIGIN,
+        )
+        origin = decomposition_chat.NEEDS_DECOMPOSITION_SPLIT_ORIGIN
+        assert origin in mock_create_issue.call_args_list[0].kwargs["body"]
+        assert origin in mock_close_issue.call_args.kwargs["comment"]

{code_coordinator-0.5.757 → code_coordinator-0.5.758}/tests/test_notify.py

@@ -931,6 +931,100 @@ class TestNeedsDecompositionNotify:
             "needs_decomposition comment"
         )
 
+    def test_structured_split_block_is_auto_filed(
+        self, coord_dir: Path, config: Config
+    ) -> None:
+        """A final message carrying a complete size-triage split block is
+        handed to the auto-split filer with the row's repo and issue."""
+        _record("ndc-run7")
+        reason = (
+            "WORK_OUTCOME: needs-decomposition — split in two\n\n"
+            "SIZE_TRIAGE_VERDICT: split\n"
+            "## Child 1: Part one\nscope one\n\n## Files\n- coord/a.py\n\n"
+            "## Child 2: Part two\nscope two\n\n## Files\n- coord/b.py\n\n"
+            "END_SIZE_TRIAGE\n"
+        )
+        agent_status = {
+            "active": [],
+            "completed": [
+                _agent_completed(
+                    "ndc-run7",
+                    "needs_decomposition",
+                    exit_code=0,
+                    needs_decomposition_reason=reason,
+                )
+            ],
+        }
+        with patch.object(notify_mod, "_agent_status", return_value=agent_status), \
+             patch("coord.dispatch.github_ops.post_issue_comment"), \
+             patch("coord.config.load", return_value=config), \
+             patch(
+                 "coord.decomposition_chat.auto_split_needs_decomposition",
+                 return_value=777,
+             ) as mock_split:
+            notify_mod.run(config)
+        mock_split.assert_called_once()
+        assert mock_split.call_args.args[0] == reason
+        assert mock_split.call_args.kwargs["repo_name"] == "api"
+        assert mock_split.call_args.kwargs["issue_number"] == 42
+        assert "ndc-run7" in state_mod.load_notified()
+
+    def test_prose_only_proposal_is_not_auto_filed(
+        self, coord_dir: Path, config: Config
+    ) -> None:
+        _record("ndc-run8")
+        agent_status = {
+            "active": [],
+            "completed": [
+                _agent_completed(
+                    "ndc-run8",
+                    "needs_decomposition",
+                    exit_code=0,
+                    needs_decomposition_reason="Split into auth and billing",
+                )
+            ],
+        }
+        with patch.object(notify_mod, "_agent_status", return_value=agent_status), \
+             patch.object(notify_mod, "_worker_log_text", return_value=""), \
+             patch("coord.dispatch.github_ops.post_issue_comment") as mock_post, \
+             patch(
+                 "coord.decomposition_chat.auto_split_needs_decomposition",
+             ) as mock_split:
+            notify_mod.run(config)
+        mock_split.assert_not_called()
+        mock_post.assert_called_once()
+
+    def test_auto_split_failure_still_notifies(
+        self, coord_dir: Path, config: Config
+    ) -> None:
+        _record("ndc-run9")
+        reason = (
+            "SIZE_TRIAGE_VERDICT: split\n## Child 1: A\nx\n\n## Files\n- a.py\n"
+            "END_SIZE_TRIAGE\n"
+        )
+        agent_status = {
+            "active": [],
+            "completed": [
+                _agent_completed(
+                    "ndc-run9",
+                    "needs_decomposition",
+                    exit_code=0,
+                    needs_decomposition_reason=reason,
+                )
+            ],
+        }
+        with patch.object(notify_mod, "_agent_status", return_value=agent_status), \
+             patch("coord.dispatch.github_ops.post_issue_comment") as mock_post, \
+             patch("coord.config.load", return_value=config), \
+             patch(
+                 "coord.decomposition_chat.auto_split_needs_decomposition",
+                 side_effect=RuntimeError("gh exploded"),
+             ) as mock_split:
+            notify_mod.run(config)
+        mock_split.assert_called_once()
+        mock_post.assert_called_once()
+        assert "ndc-run9" in state_mod.load_notified()
+
 
 class TestBranchCapture:
     def test_branch_stored_in_notified_ledger(self, coord_dir: Path, config: Config) -> None: