code-coordinator 0.5.61__tar.gz → 0.5.62__tar.gz

{code_coordinator-0.5.61/code_coordinator.egg-info → code_coordinator-0.5.62}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.61",
+  "tag": "0.5.62",
   "distance": 0,
-  "node": "g74884c7dae4507e48a87e147dbfae31765822fd5",
+  "node": "g84d64a795986ab501062308d9e29da81f86cfb79",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.61 → code_coordinator-0.5.62}/coord/agent.py

@@ -26,6 +26,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Iterable
 
 from coord import cargo_cache
+from coord.models import DELIVERABLE_ANALYSIS_LABEL
 from coord.platform_paths import default_coord_dir
 
 if TYPE_CHECKING:
@@ -604,6 +605,19 @@ class AssignmentSpec:
     # `AssignmentSpec(**body)` in agent_app.py 400s on those) unless the
     # operator has actually configured one.
     cost_ceiling_usd: float | None = None
+    # #2188: the issue's GitHub label names, mirroring `Proposal.issue_labels`
+    # (#1430) — carried on the wire so a reap running on a config-free agent
+    # (docs/EPHEMERAL_WORKERS.md; no local DB or GitHub token to ask) can
+    # still see `coord.models.DELIVERABLE_ANALYSIS_LABEL` without an extra
+    # round-trip. Only `coord/dispatch.py`'s `dispatch()` populates this (from
+    # `proposal.issue_labels`, itself only set for `type="work"` dispatches —
+    # see #1430's `model_for_labels`/`provider_for_labels` gating), and only
+    # when non-empty — an agent predating this field 400s on an unrecognized
+    # kwarg (`AssignmentSpec(**body)` in agent_app.py), same discipline as
+    # every other optional wire field above. Empty by default: a spec with no
+    # labels (or dispatched by a caller that never populated
+    # `Proposal.issue_labels`) behaves exactly as before this field existed.
+    issue_labels: list[str] = field(default_factory=list)
 
 
 class _GitError(RuntimeError):
@@ -2700,6 +2714,11 @@ class AgentAssignment:
     # #448: advisory reason when the worker exited cleanly (exit_code==0) but
     # pushed 0 commits.  None on all other status values.
     #
+    # #2188: also None (never set) for an issue labelled `deliverable:
+    # analysis` — that shape lands on `status == DONE`/`analysis_deliverable
+    # = True` below instead, since 0 commits is its SUCCESS condition, not
+    # something advisory.
+    #
     # #1323 used to *also* reuse this field (for "work"-type assignments,
     # see _ADVISORY_TYPES) to hold a reason when a configured artifact_paths
     # glob matched 0 files, downgrading DONE -> ADVISORY in the process.
@@ -2787,6 +2806,26 @@ class AgentAssignment:
     # ceiling kill is indistinguishable from a crash and the money is spent
     # again on the next pass.
     spend_ceiling_reason: str | None = None
+    # #2188: True when `_reap` classified a clean (exit_code==0), 0-commit
+    # exit as a DELIVERABLE — the issue was labelled
+    # `coord.models.DELIVERABLE_ANALYSIS_LABEL` (`spec.issue_labels`) — rather
+    # than the #448 "worker did nothing" ADVISORY. Only ever set alongside
+    # `status == DONE`; `False` on every other outcome, including a normal
+    # zero-commit ADVISORY (the label wasn't present) and a labelled issue
+    # whose worker actually pushed commits (that's an ordinary DONE, handled
+    # by the ordinary Test/Review/Merge pipeline — this flag is specifically
+    # "the deliverable IS the message, there is no diff").
+    analysis_deliverable: bool = False
+    # #2188: the worker's own final message — `result` off the last
+    # stream-json `result` event (`coord.worker_events.WorkerSummary.
+    # result_text`), captured here so the coordinator can post the actual
+    # deliverable (a diagnosis/audit's prose) to the issue instead of a bare
+    # "assignment complete" comment. The worker itself has no `gh` access to
+    # post this — see coord.notify.post_transition's EVENT_COMPLETION arm.
+    # Populated only when `analysis_deliverable` is True; `None` otherwise
+    # (a normal work assignment's deliverable is the diff itself, already
+    # visible on the PR — restating the transcript there would be noise).
+    result_text: str | None = None
 
     def to_dict(self) -> dict:
         d = asdict(self)
@@ -7209,6 +7248,16 @@ class AgentServer:
         # ("work",) to the full work-like set so `test-author`/`mock-author`
         # get the same downgrade; before that they could land on `done` with
         # an empty branch.
+        # #2188: an issue labelled `deliverable:analysis` inverts the #448
+        # reading — for it, a clean exit with 0 commits is the SUCCESS
+        # condition (the deliverable is the worker's own final message, not
+        # a diff), not the "worker did nothing" anomaly. Detected off
+        # `assignment.spec.issue_labels` (wire field, #2188) so this works on
+        # a config-free agent too — no DB or GitHub read required. Resolved
+        # in the SAME `_ahead == 0` branch as the advisory check below so
+        # the two can never disagree about what "0 commits" means for this
+        # assignment.
+        _analysis_deliverable = False
         _zero_commit_reason: str | None = None
         if (exit_code == 0 and assignment is not None
                 and assignment.worktree_path
@@ -7218,17 +7267,30 @@ class AgentServer:
                 _base = assignment.spec.branch or "main"
                 _ahead = self._commits_ahead(_wt_advisory, _base)
                 if _ahead == 0:
-                    _zero_commit_reason = (
-                        "worker exited cleanly but pushed 0 commits"
-                    )
-                    try:
-                        with open(assignment.log_path, "a") as reopen:
-                            reopen.write(
-                                "# reap: advisory — 0 commits ahead of "
-                                f"{_base}; status set to advisory\n"
-                            )
-                    except OSError:
-                        pass
+                    if DELIVERABLE_ANALYSIS_LABEL in (assignment.spec.issue_labels or []):
+                        _analysis_deliverable = True
+                        try:
+                            with open(assignment.log_path, "a") as reopen:
+                                reopen.write(
+                                    "# reap: analysis deliverable — 0 commits "
+                                    f"ahead of {_base}; issue labelled "
+                                    f"{DELIVERABLE_ANALYSIS_LABEL!r}, status "
+                                    "set to done (#2188)\n"
+                                )
+                        except OSError:
+                            pass
+                    else:
+                        _zero_commit_reason = (
+                            "worker exited cleanly but pushed 0 commits"
+                        )
+                        try:
+                            with open(assignment.log_path, "a") as reopen:
+                                reopen.write(
+                                    "# reap: advisory — 0 commits ahead of "
+                                    f"{_base}; status set to advisory\n"
+                                )
+                        except OSError:
+                            pass
 
         # This block MUST always run regardless of push outcome so that
         # the assignment transitions out of 'running'.
@@ -7296,6 +7358,22 @@ class AgentServer:
                         assignment.zero_commit_reason = _zero_commit_reason
                     else:
                         assignment.status = DONE
+                        if _analysis_deliverable:
+                            # #2188: 0 commits on a `deliverable:analysis`
+                            # issue is the success shape — capture the
+                            # worker's own final message (already parsed
+                            # into `_worker_summary` above) so the
+                            # coordinator can post the actual deliverable to
+                            # the issue instead of a bare "complete" comment.
+                            # Best-effort: a non-stream-json log (or one with
+                            # no terminal `result` event) just leaves
+                            # `result_text` `None` — the assignment is still
+                            # correctly `done`, only the auto-posted prose is
+                            # missing, same degradation as every other
+                            # best-effort log parse in this function.
+                            assignment.analysis_deliverable = True
+                            if _worker_summary is not None and _worker_summary.result_text:
+                                assignment.result_text = _worker_summary.result_text
                 else:
                     assignment.status = FAILED
                 # #1461: only ever attaches to a FAILED/ADVISORY transition —

{code_coordinator-0.5.61 → code_coordinator-0.5.62}/coord/dispatch.py

@@ -755,6 +755,14 @@ def dispatch(
     # field reject unknown payload keys with a 400.
     if getattr(proposal, "resume_session_id", None):
         payload["resume_session_id"] = proposal.resume_session_id
+    # #2188: the issue's GitHub labels, so the agent's own reap can see
+    # `coord.models.DELIVERABLE_ANALYSIS_LABEL` without a DB/GitHub round
+    # trip (config-free agent — docs/EPHEMERAL_WORKERS.md). Only sent when
+    # non-empty, same discipline as every optional wire field above — an
+    # agent predating `AssignmentSpec.issue_labels` 400s on an unrecognized
+    # kwarg.
+    if proposal.issue_labels:
+        payload["issue_labels"] = list(proposal.issue_labels)
     # #2131: per-leg spend ceiling, resolved here (CLI/daemon lane) and
     # carried on the wire so a config-free agent is covered too. Sent ONLY
     # when the operator has actually configured one — with no `budget:` block

{code_coordinator-0.5.61 → code_coordinator-0.5.62}/coord/drive.py

@@ -109,6 +109,7 @@ from coord.interactive import (
 )
 from coord.dead_end import DeadEnd, detect_dead_end
 from coord.failure_class import classify_failure, plan_usage_limit_resume
+from coord.models import DELIVERABLE_ANALYSIS_LABEL
 from coord.usage_limits import PlanLimits, evaluate_usage_gate, get_plan_limits
 # Lost in the #1584-onto-#1590 rebase: _decide_review() calls this, but the
 # import lived in a hunk #1590 rewrote, so the merge came out textually clean
@@ -1397,6 +1398,32 @@ def decide(
             f"{state.work_machine or machine}"
         )
 
+    # ---- analysis deliverable: done + 0 commits is the SUCCESS shape (#2188)
+    #
+    # An issue labelled `deliverable:analysis` inverts the read on a 0-commit
+    # exit: the deliverable is the worker's own final message (already
+    # posted to the issue by the coordinator — see coord.notify.
+    # post_transition's EVENT_COMPLETION arm), not a diff. `coord.agent.
+    # AgentServer._reap` only ever produces this shape on `status == "done"`
+    # (never "advisory" — see `AgentAssignment.analysis_deliverable`), so
+    # this only needs to guard the `done` arm above, and it runs BEFORE the
+    # "no branch"/dead-end/Test/Review/Merge machinery below: none of that
+    # applies when there is nothing to test, review, or merge. A labelled
+    # issue whose worker DID push commits (the label describes the common
+    # case, not a hard rule) falls through unchanged — `branch_has_commits`
+    # is False only for the genuine 0-commit shape.
+    if (
+        state.work_status == "done"
+        and DELIVERABLE_ANALYSIS_LABEL in state.issue_labels
+        and (not state.work_branch or not verifier.branch_has_commits(state))
+    ):
+        return _succeed(
+            f"✓ ANALYSIS DELIVERABLE — {state.work_aid} completed with 0 "
+            f"commits (issue labelled `{DELIVERABLE_ANALYSIS_LABEL}`); the "
+            "worker's final message is the deliverable and was posted to "
+            "the issue automatically — nothing to test, review, or merge."
+        )
+
     # A 'done' row with no branch never pushed anything either.
     if not state.work_branch:
         return _die(

{code_coordinator-0.5.61 → code_coordinator-0.5.62}/coord/models.py

@@ -354,6 +354,22 @@ def test_mode_from_labels(labels) -> str | None:
     return None
 
 
+# #2188: the per-issue DELIVERABLE policy label — mirrors `TEST_MODE_*_LABEL`'s
+# shape (cheapest fit, no body parsing). An issue whose deliverable is a
+# written artifact (a diagnosis, an audit, a spike/investigation writeup)
+# rather than a diff cannot succeed in the default pipeline: a worker that
+# does exactly what was asked ends with 0 commits by design, which the reap
+# otherwise reads as the #448 "worker did nothing" ADVISORY and `coord drive`
+# gives up on — discarding the whole deliverable (#2188's own worked example,
+# #2132, lost $1.65 of correct, on-topic analysis this way). Labelling the
+# issue `deliverable:analysis` inverts that reading: a clean exit with 0
+# commits is `coord.agent.AgentServer._reap`'s SUCCESS condition for this
+# issue, not its anomaly — see `_ZERO_COMMIT_TYPES`/`AgentAssignment.
+# analysis_deliverable` in coord/agent.py and the `decide()` short-circuit in
+# coord/drive.py that skips Test/Review/Merge for it.
+DELIVERABLE_ANALYSIS_LABEL = "deliverable:analysis"
+
+
 @dataclass
 class Assignment:
     machine_name: str

{code_coordinator-0.5.61 → code_coordinator-0.5.62}/coord/notify.py

@@ -2470,7 +2470,24 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
                 failure_reason=_failure_reason,
             )
     elif transition.event == EVENT_COMPLETION:
-        post_completion(exit_code=transition.exit_code or 0, **common)
+        # #2188: a `deliverable:analysis` issue that legitimately ended with
+        # 0 commits has no diff to point at — the deliverable IS the
+        # worker's own final message (`AgentAssignment.result_text`, see
+        # `coord.agent.AgentServer._reap`). Post it as the completion
+        # comment's summary so it reaches the issue automatically; the
+        # worker itself has no `gh` access to post it. Every other
+        # completion (the overwhelming majority) is unaffected — `entry.get
+        # ("analysis_deliverable")` is only ever truthy for this one shape.
+        _analysis_summary = (
+            entry.get("result_text") or ""
+            if entry.get("analysis_deliverable")
+            else ""
+        )
+        post_completion(
+            exit_code=transition.exit_code or 0,
+            summary=_analysis_summary,
+            **common,
+        )
         mark_notified(
             transition.assignment_id,
             transition.event,

{code_coordinator-0.5.61 → code_coordinator-0.5.62}/tests/test_agent_zero_commit.py

@@ -416,3 +416,169 @@ def test_advisory_counted_as_completed_in_health(
     assert h["active"] == 0, "ADVISORY must not count as active"
     assert h["completed"] >= 1, "ADVISORY must count as completed"
     server.shutdown()
+
+
+# ── `deliverable:analysis` inverts the 0-commit reading (#2188) ──────────────
+#
+# An issue whose deliverable is a written artifact (a diagnosis, an audit, a
+# spike) — not a diff — legitimately ends with 0 commits: that is the SUCCESS
+# condition, not the #448 "worker did nothing" anomaly. Labelling the issue
+# `deliverable:analysis` tells the reap to record `done`, not `advisory`, for
+# exactly that shape. An unlabelled issue with 0 commits must be completely
+# unaffected — this is the other half of the acceptance test the issue asks
+# for ("a normal (code) issue with zero commits still reports advisory
+# exactly as it does today").
+
+_RESULT_LINE = (
+    '{"type": "result", "subtype": "success", "is_error": false, '
+    '"result": "Diagnosis: 74 percent of blocking review findings were '
+    'real defects; zero were false positives or style nits."}'
+)
+
+
+def test_analysis_deliverable_zero_commit_is_done_not_advisory(
+    tmp_path: Path, repo_local_only: Path
+) -> None:
+    """#2188: `deliverable:analysis` + 0 commits + clean exit → DONE, not
+    ADVISORY — the core regression guard for the issue's acceptance
+    criteria."""
+    server = AgentServer(
+        machine_name="t",
+        repos=["api"],
+        repo_paths={"api": str(repo_local_only)},
+        state_dir=tmp_path / "state",
+        # Worker exits cleanly, writes nothing, but DOES emit a stream-json
+        # `result` event carrying its final diagnosis — exactly what
+        # `claude -p --output-format stream-json` produces.
+        worker_command=lambda spec: ["/bin/sh", "-c", f"printf '%s\\n' '{_RESULT_LINE}'"],
+    )
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(repo_local_only),
+        issue_number=2132,
+        issue_title="Diagnose the 29% request-changes rate",
+        briefing="b",
+        branch="main",
+        issue_labels=["deliverable:analysis"],
+    )
+    a = server.assign(spec)
+    final = server.wait_for(a.id, timeout=10)
+
+    assert final.status == DONE, (
+        f"expected DONE for a labelled analysis deliverable, got {final.status!r}"
+    )
+    assert final.exit_code == 0
+    assert final.zero_commit_reason is None, (
+        "must not carry the #448 advisory reason once relabelled done"
+    )
+    assert final.analysis_deliverable is True
+    assert final.result_text is not None
+    assert "74 percent" in final.result_text
+    server.shutdown()
+
+
+def test_analysis_deliverable_label_appears_in_log(
+    tmp_path: Path, repo_local_only: Path
+) -> None:
+    """The analysis-deliverable diagnosis is written to the assignment log,
+    mirroring the existing advisory-reason log guarantee."""
+    server = AgentServer(
+        machine_name="t",
+        repos=["api"],
+        repo_paths={"api": str(repo_local_only)},
+        state_dir=tmp_path / "state",
+        worker_command=lambda spec: ["/bin/true"],
+    )
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(repo_local_only),
+        issue_number=2133,
+        issue_title="noop analysis",
+        briefing="b",
+        branch="main",
+        issue_labels=["deliverable:analysis"],
+    )
+    a = server.assign(spec)
+    final = server.wait_for(a.id, timeout=10)
+
+    assert final.status == DONE
+    assert final.log_path is not None
+    log_text = Path(final.log_path).read_text()
+    assert "analysis deliverable" in log_text.lower(), (
+        f"expected 'analysis deliverable' in log, got:\n{log_text}"
+    )
+    server.shutdown()
+
+
+def test_unlabelled_zero_commit_is_still_advisory_exactly_as_before(
+    tmp_path: Path, repo_local_only: Path
+) -> None:
+    """#2188 acceptance: an ORDINARY (unlabelled) issue with 0 commits must
+    be completely unaffected by the new label — same ADVISORY status, same
+    reason, same `analysis_deliverable=False`/`result_text=None` as every
+    zero-commit work assignment before this feature existed."""
+    server = AgentServer(
+        machine_name="t",
+        repos=["api"],
+        repo_paths={"api": str(repo_local_only)},
+        state_dir=tmp_path / "state",
+        worker_command=lambda spec: ["/bin/sh", "-c", f"printf '%s\\n' '{_RESULT_LINE}'"],
+    )
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(repo_local_only),
+        issue_number=2134,
+        issue_title="ordinary no-op work",
+        briefing="b",
+        branch="main",
+        # No issue_labels at all — the common case.
+    )
+    a = server.assign(spec)
+    final = server.wait_for(a.id, timeout=10)
+
+    assert final.status == ADVISORY, (
+        f"unlabelled 0-commit issue must stay ADVISORY, got {final.status!r}"
+    )
+    assert final.zero_commit_reason is not None
+    assert "0 commits" in final.zero_commit_reason
+    assert final.analysis_deliverable is False
+    assert final.result_text is None
+    server.shutdown()
+
+
+def test_analysis_deliverable_survives_persist_load(
+    tmp_path: Path, repo_local_only: Path
+) -> None:
+    """`analysis_deliverable`/`result_text` round-trip through the agent
+    state JSON (persist → load), mirroring the existing advisory round-trip
+    guarantee."""
+    from coord.agent import AgentAssignment  # noqa: PLC0415
+
+    a = AgentAssignment(
+        id="analysis-001",
+        spec=AssignmentSpec(
+            repo_name="api",
+            repo_path="/tmp",
+            issue_number=1,
+            issue_title="t",
+            briefing="b",
+            issue_labels=["deliverable:analysis"],
+        ),
+        status=DONE,
+        analysis_deliverable=True,
+        result_text="the diagnosis",
+        exit_code=0,
+        finished_at=1234567890.0,
+    )
+    d = a.to_dict()
+    assert d["status"] == DONE
+    assert d["analysis_deliverable"] is True
+    assert d["result_text"] == "the diagnosis"
+
+    spec_data = d.pop("spec")
+    spec = AssignmentSpec(**spec_data)
+    a2 = AgentAssignment(spec=spec, **d)
+    assert a2.status == DONE
+    assert a2.analysis_deliverable is True
+    assert a2.result_text == "the diagnosis"
+    assert a2.spec.issue_labels == ["deliverable:analysis"]

{code_coordinator-0.5.61 → code_coordinator-0.5.62}/tests/test_dispatch.py

@@ -247,6 +247,41 @@ class TestDispatch:
         payload = mock_post.call_args.kwargs["json"]
         assert "target_branch" not in payload
 
+    @patch("coord.dispatch.httpx.post")
+    def test_payload_carries_issue_labels_when_set(
+        self, mock_post: MagicMock, config: Config,
+    ) -> None:
+        """#2188: `proposal.issue_labels` flows onto the wire so the agent's
+        own reap can see `deliverable:analysis` without a DB/GitHub round
+        trip (config-free agent)."""
+        mock_resp = MagicMock()
+        mock_resp.json.return_value = {"ok": True}
+        mock_post.return_value = mock_resp
+
+        p = Proposal(
+            id=1, machine_name="laptop", repo_name="api",
+            issue_number=2132, issue_title="Diagnose the 29% rate",
+            rationale="analysis",
+            issue_labels=["deliverable:analysis", "priority:high"],
+        )
+        dispatch(p, config)
+        payload = mock_post.call_args.kwargs["json"]
+        assert payload["issue_labels"] == ["deliverable:analysis", "priority:high"]
+
+    @patch("coord.dispatch.httpx.post")
+    def test_payload_omits_issue_labels_when_unset(
+        self, mock_post: MagicMock, config: Config, proposal: Proposal,
+    ) -> None:
+        """Older agents (pre-#2188) reject unknown kwargs in
+        AssignmentSpec(**body), so the field must be omitted when the
+        proposal carries no labels — matches `target_branch`'s discipline."""
+        mock_resp = MagicMock()
+        mock_resp.json.return_value = {"ok": True}
+        mock_post.return_value = mock_resp
+        dispatch(proposal, config)
+        payload = mock_post.call_args.kwargs["json"]
+        assert "issue_labels" not in payload
+
     @patch("coord.dispatch.httpx.post")
     def test_payload_carries_coordinator_only_files(
         self, mock_post: MagicMock, proposal: Proposal,

{code_coordinator-0.5.61 → code_coordinator-0.5.62}/tests/test_drive.py

@@ -1406,6 +1406,77 @@ def test_advisory_with_no_branch_at_all_is_terminal():
     assert "no commits on its branch" in action.message
 
 
+# ── analysis deliverable: done + 0 commits is a SUCCESS, not a dead end (#2188)
+
+
+def test_analysis_deliverable_done_with_no_commits_succeeds():
+    """#2188: `coord.agent.AgentServer._reap` never lands a `deliverable:
+    analysis` issue's 0-commit exit on `advisory` — it lands DONE. `coord
+    drive` must record that as a success instead of dying on 'no commits
+    on its branch'/'no branch' the way an ordinary work row would."""
+    action = step(
+        state(
+            work_aid="w1",
+            work_status="done",
+            work_branch="issue-2132-diagnose",
+            issue_labels=("deliverable:analysis",),
+        ),
+        verifier=FakeVerifier(has_commits=False),
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_OK
+    assert "ANALYSIS" in action.message
+    assert "deliverable:analysis" in action.message
+
+
+def test_analysis_deliverable_done_with_no_branch_at_all_succeeds():
+    """Same as above when the reap never captured a branch name at all
+    (e.g. the worktree was already gone) — `not state.work_branch` alone
+    must be enough to take the analysis-deliverable exit, without ever
+    calling `verifier.branch_has_commits` on an empty branch."""
+    verifier = FakeVerifier(has_commits=True)
+    action = step(
+        state(
+            work_aid="w1",
+            work_status="done",
+            work_branch="",
+            issue_labels=("deliverable:analysis",),
+        ),
+        verifier=verifier,
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_OK
+    assert verifier.commits_calls == 0
+
+
+def test_analysis_deliverable_done_with_commits_falls_through_unchanged():
+    """The label describes the common case, not a hard rule: a
+    `deliverable:analysis` issue whose worker DID push commits must reach
+    the ordinary Test/Review/Merge pipeline exactly like any other done
+    row, not the analysis short-circuit."""
+    action = step(
+        done_work(work_test_state="", issue_labels=("deliverable:analysis",)),
+        verifier=FakeVerifier(has_commits=True),
+    )
+    assert action.kind == WAIT  # waiting on coord to dispatch the Test stage
+
+
+def test_unlabelled_done_with_no_commits_is_unaffected_by_2188():
+    """#2188 acceptance: an ordinary (unlabelled) issue must be completely
+    unaffected by the analysis-deliverable short-circuit — `coord.agent.
+    AgentServer._reap` never puts an unlabelled 0-commit work row on
+    `done` in the first place (it stays `advisory`, covered by the tests
+    above), but this guards `decide()`'s own logic in case a `done` row
+    with no branch/commits reaches it some other way."""
+    action = step(
+        state(work_aid="w1", work_status="done", work_branch=""),
+        verifier=FakeVerifier(has_commits=False),
+    )
+    assert action.is_exit
+    assert "no branch" in action.message
+    assert "ANALYSIS" not in action.message
+
+
 # ═══════════════════════════════════════════════════════════════════════════
 # the TEST gate
 # ═══════════════════════════════════════════════════════════════════════════

{code_coordinator-0.5.61 → code_coordinator-0.5.62}/tests/test_notify.py

@@ -206,6 +206,66 @@ class TestRun:
         assert row is not None, "assignment row must exist"
         assert row["failure_reason"] == "remote: Invalid username or token."
 
+    def test_analysis_deliverable_completion_posts_final_message(
+        self, coord_dir: Path, config: Config
+    ) -> None:
+        """#2188: a `deliverable:analysis` issue's 0-commit completion has no
+        diff to point at — the deliverable IS the worker's own final message
+        (`AgentAssignment.result_text`). It must be posted automatically as
+        the completion comment's summary, since the worker itself has no
+        `gh` access to post it."""
+        _record("an1")
+        agent_status = {
+            "active": [],
+            "completed": [
+                _agent_completed(
+                    "an1",
+                    "done",
+                    analysis_deliverable=True,
+                    result_text=(
+                        "Diagnosis: 74% of blocking review findings were "
+                        "real defects; zero were false positives or style "
+                        "nits."
+                    ),
+                )
+            ],
+        }
+        with patch.object(notify_mod, "_agent_status", return_value=agent_status), \
+             patch("coord.dispatch.github_ops.post_issue_comment") as mock_post:
+            posted, _stuck, _attn, _stalled, _liveness = notify_mod.run(config)
+        assert len(posted) == 1
+        mock_post.assert_called_once()
+        body = mock_post.call_args.args[2]
+        assert "Coordinator: Assignment Complete" in body
+        assert "### Summary" in body
+        assert "74% of blocking review findings were real defects" in body
+
+    def test_ordinary_completion_has_no_summary_section(
+        self, coord_dir: Path, config: Config
+    ) -> None:
+        """#2188 acceptance: an ordinary (non-analysis) completion must be
+        unaffected — `result_text` is only ever folded into the posted
+        comment when `analysis_deliverable` is set on the same entry."""
+        _record("ord1")
+        agent_status = {
+            "active": [],
+            "completed": [
+                _agent_completed(
+                    "ord1",
+                    "done",
+                    analysis_deliverable=False,
+                    result_text="some unrelated final message",
+                )
+            ],
+        }
+        with patch.object(notify_mod, "_agent_status", return_value=agent_status), \
+             patch("coord.dispatch.github_ops.post_issue_comment") as mock_post:
+            notify_mod.run(config)
+        body = mock_post.call_args.args[2]
+        assert "Coordinator: Assignment Complete" in body
+        assert "### Summary" not in body
+        assert "some unrelated final message" not in body
+
 
 # ── #448: advisory (0-commit clean exit) notify ─────────────────────────────