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

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

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

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

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

{code_coordinator-0.5.61 → code_coordinator-0.5.63}/coord/acceptance.py

@@ -886,6 +886,75 @@ def find_ms_manifest_for_issue_via_api(
     return None
 
 
+def missing_expected_red_warning(
+    repo_github: str, branch: str, issue_number: int, *, gh_ops: Any = None,
+) -> str | None:
+    """#2191 — the writer/gate seam: is *issue_number* the signature of an
+    unwritten ``expected_red`` registry on *branch*'s manifest? That
+    signature is checkable without ever running the suite: the manifest
+    maps at least one test id to *issue_number* (a slice was authored for
+    it) but records ZERO ``expected_red`` entries for it, and the issue is
+    still open. #2164 shipped a reader (:func:`apply_expected_red`), a
+    clearer (:func:`clear_expected_red_via_pr`) and a lister
+    (:func:`list_expected_red_via_api`) for this registry but no writer —
+    :data:`coord.test_author.TEST_AUTHOR_SYSTEM_PROMPT` step 4b is the
+    writer (the test-author records what it observed FAIL in its step-4
+    run). This function is the gate half: it does not trust the prompt was
+    followed, so it re-derives "was anything recorded" from the manifest
+    itself at slice-PR-open time (:func:`coord.merge_queue.process`'s
+    "Open PRs first" loop, gated on ``assignment_type == "test-author"``)
+    and flags exactly the case a skipped step 4b produces.
+
+    Returns ``None`` — nothing to flag — when: *branch*'s manifest doesn't
+    reference *issue_number* at all (no slice authored yet, out of scope);
+    ``expected_red`` already has a non-empty entry for it (the writer did
+    its job, or the slice is genuinely all-green and needs none); the issue
+    is closed (its slice already served its purpose — flagging it now is
+    stale noise, not #2191's live deadlock); or any lookup fails. The last
+    case is deliberate fail-open, matching every other best-effort API
+    sweep in this module (:func:`find_ms_manifest_for_issue_via_api`,
+    :func:`coord.merge_queue._issue_has_expected_red_entries`) — this check
+    is advisory (see the "refused or warned" phrasing in #2191's acceptance
+    criteria; callers choose which), so an unreachable API must degrade to
+    "say nothing," never to blocking a PR the check itself couldn't
+    evaluate.
+
+    Otherwise returns a human-readable warning naming the missing ids.
+    """
+    ops = gh_ops or _default_github_ops()
+    found = find_ms_manifest_for_issue_via_api(
+        repo_github, branch, issue_number, gh_ops=ops,
+    )
+    if found is None:
+        return None
+    path, _text, _blob_sha, data = found
+    if data.expected_red.get(issue_number):
+        return None
+    test_ids = test_ids_for_issue(data.tests, issue_number)
+    if not test_ids:
+        return None
+    live_state = getattr(ops, "get_issues_live_state", None)
+    if live_state is None:
+        return None
+    try:
+        states = live_state(repo_github, [issue_number])
+    except Exception:  # noqa: BLE001 — best-effort, fail open (see docstring)
+        return None
+    if states.get(issue_number) != "open":
+        return None
+    return (
+        f"#{issue_number}: {path} maps {len(test_ids)} test-id(s) to this "
+        f"issue ({', '.join(sorted(test_ids))}) but records no "
+        "`expected_red` entries for it — the #2191 signature of an "
+        "unwritten registry (the test-author's step 4b never ran, or was "
+        "skipped). If this slice is genuinely all-green already, ignore; "
+        "otherwise every red id here fails CI with nothing telling "
+        "`coord acceptance run --all --ci` that's expected, and `coord "
+        "merge` will need `--force-merge` or a hand-edited manifest to "
+        "land it."
+    )
+
+
 def list_expected_red_via_api(
     repo_github: str, branch: str, *, gh_ops: Any = None,
 ) -> "dict[str, dict[int, frozenset[str]]]":

{code_coordinator-0.5.61 → code_coordinator-0.5.63}/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.63}/coord/commands/drive_queue.py

@@ -43,6 +43,8 @@ from coord.drive_queue import (
     DEFAULT_MAX_ATTEMPTS,
     DEFAULT_MAX_PARALLEL_PER_REPO,
     HOLD_RELEASED,
+    HOLD_SCOPE_ENTRY,
+    HOLD_SCOPE_FLEET,
     QUEUE_ALERT_ISSUE,
     QUEUE_ALERT_REPO,
     QUEUE_ALERT_STAGE,
@@ -155,6 +157,19 @@ def drive_queue_group() -> None:
         "treated as a failure. Requires --hold-after."
     ),
 )
+@click.option(
+    "--scope",
+    "hold_scope",
+    type=click.Choice([HOLD_SCOPE_ENTRY, HOLD_SCOPE_FLEET]),
+    default=HOLD_SCOPE_ENTRY,
+    show_default=True,
+    help=(
+        "How far a fired gate reaches (#2186). `entry` holds only entries "
+        "whose own --after names THIS one. `fleet` is the whole-queue stop — "
+        "launch NOTHING anywhere, for the rare case (a rename, a schema "
+        "migration) where that is really what's needed. Requires --hold-after."
+    ),
+)
 @_CONFIG_OPTION
 def drive_queue_add(
     repo: str,
@@ -165,6 +180,7 @@ def drive_queue_add(
     hold_after: bool,
     hold_reason: str,
     resume_when: str,
+    hold_scope: str,
     config_path: Path,
 ) -> None:
     """Queue REPO ISSUE for `coord drive`, or update it if already queued.
@@ -175,14 +191,36 @@ def drive_queue_add(
     """
     from coord.state import enqueue_drive_queue, list_drive_queue  # noqa: PLC0415
 
+    existing_entries = entries_from_rows(list_drive_queue())
     try:
         after = parse_after_spec(after_specs, repo)
         validate_config_repo(config_path, repo)
-        validate_hold_flags(hold_after, hold_reason, resume_when)
-        validate_enqueue(entries_from_rows(list_drive_queue()), repo, issue, after)
+        validate_hold_flags(hold_after, hold_reason, resume_when, hold_scope)
+        validate_enqueue(existing_entries, repo, issue, after)
     except QueueError as exc:
         raise click.ClickException(str(exc)) from None
 
+    # #2186: the UPDATE path in `_enqueue_drive_queue_local` always writes
+    # whatever `hold_scope` THIS call passed (default `entry`) — so re-adding
+    # an already fleet-scoped gate without repeating `--scope fleet` silently
+    # narrows it. That fails toward the safer/narrower scope, not a
+    # correctness bug, but it is a real behaviour change an operator who only
+    # meant to touch `--machine`/`--after` would not expect, so it is echoed
+    # rather than left silent.
+    previous = next((e for e in existing_entries if e.key == entry_key(repo, issue)), None)
+    scope_downgrade_warning = ""
+    if (
+        previous is not None
+        and previous.hold_scope == HOLD_SCOPE_FLEET
+        and hold_after
+        and hold_scope != HOLD_SCOPE_FLEET
+    ):
+        scope_downgrade_warning = (
+            f"\nwarning: {entry_key(repo, issue)} was scope=fleet — this add did not "
+            f"repeat --scope {HOLD_SCOPE_FLEET}, so its gate is now scope={hold_scope} "
+            "(entries-only). Pass --scope fleet again if the fleet-wide stop was still needed."
+        )
+
     enqueue_drive_queue(
         repo,
         issue,
@@ -192,37 +230,51 @@ def drive_queue_add(
         hold_after=hold_after,
         hold_reason=hold_reason,
         resume_when=resume_when,
+        hold_scope=hold_scope,
     )
     suffix = f" after {', '.join(after)}" if after else ""
     pinned = f" on {machine}" if machine else ""
     gate = ""
     if hold_after:
         gate = " · holds the queue when done"
+        if hold_scope == HOLD_SCOPE_FLEET:
+            gate += " (fleet-wide — nothing anywhere launches)"
         if resume_when:
             gate += f" (auto-resume when `{resume_when}` passes)"
-    click.echo(f"queued {entry_key(repo, issue)}{pinned}{suffix}{gate}")
+    click.echo(f"queued {entry_key(repo, issue)}{pinned}{suffix}{gate}{scope_downgrade_warning}")
 
 
-def validate_hold_flags(hold_after: bool, hold_reason: str, resume_when: str) -> None:
-    """Refuse gate detail without a gate (#1757).
-
-    `--resume-when` / `--hold-reason` on an entry with no `--hold-after` would
-    be stored and then never read — a silent no-op on the ONE flag whose whole
-    job is to stop the queue.  An operator who mistyped that has no signal at
-    all that overnight sequencing will now blow straight through the deploy
-    step, so this is a usage error, not a warning.
+def validate_hold_flags(
+    hold_after: bool,
+    hold_reason: str,
+    resume_when: str,
+    hold_scope: str = HOLD_SCOPE_ENTRY,
+) -> None:
+    """Refuse gate detail without a gate (#1757, extended by #2186).
+
+    `--resume-when` / `--hold-reason` / a non-default `--scope` on an entry
+    with no `--hold-after` would be stored and then never read — a silent
+    no-op on the ONE flag whose whole job is to stop the queue (or narrow
+    what it stops).  An operator who mistyped that has no signal at all that
+    overnight sequencing will now blow straight through the deploy step, so
+    this is a usage error, not a warning.
     """
     if hold_after:
         return
     offenders = [
         flag
-        for flag, value in (("--resume-when", resume_when), ("--hold-reason", hold_reason))
+        for flag, value in (
+            ("--resume-when", resume_when),
+            ("--hold-reason", hold_reason),
+        )
         if value
     ]
+    if hold_scope == HOLD_SCOPE_FLEET:
+        offenders.append("--scope=fleet")
     if offenders:
         raise QueueError(
             f"{' and '.join(offenders)} require --hold-after "
-            "(without it there is no gate to resume or explain)"
+            "(without it there is no gate to resume, explain, or scope)"
         )
 
 
@@ -277,6 +329,8 @@ def drive_queue_list(repo: str | None, output_json: bool, config_path: Path) ->
             bits.append(f"deferrals={entry.deferrals}")
         if entry.hold_after:
             bits.append(f"hold={entry.hold_state or 'armed'}")
+            if entry.hold_scope == HOLD_SCOPE_FLEET:
+                bits.append("scope=fleet")
         click.echo("  ".join(bits))
         if entry.last_reason:
             click.echo(f"      last{_reason_age_suffix(entry, now)}: {entry.last_reason}")
@@ -325,7 +379,12 @@ def _hold_lines(entry: QueueEntry) -> list[str]:
     """
     if not entry.hold_after:
         return []
-    lines = [f"      hold-after: {entry.gate_reason}"]
+    scope_suffix = (
+        " [fleet-wide — holds everything, not just this entry's dependents]"
+        if entry.hold_scope == HOLD_SCOPE_FLEET
+        else ""
+    )
+    lines = [f"      hold-after: {entry.gate_reason}{scope_suffix}"]
     if entry.resume_when:
         probe = f"      resume-when: {entry.resume_when}"
         if entry.hold_probes:
@@ -416,6 +475,10 @@ def drive_queue_status(output_json: bool, config_path: Path) -> None:
                             "reason": e.gate_reason,
                             "resume_when": e.resume_when,
                             "probes": e.hold_probes,
+                            # #2186: typed, so a client reads what this gate
+                            # holds without parsing the `[fleet-wide ...]`
+                            # suffix back out of the rendered text.
+                            "scope": e.hold_scope,
                         }
                         for e in held
                     ],

{code_coordinator-0.5.61 → code_coordinator-0.5.63}/coord/db.py

@@ -401,6 +401,13 @@ def _ensure_schema(conn: sqlite3.Connection) -> None:
             hold_state    TEXT    NOT NULL DEFAULT '',
             hold_probes   INTEGER NOT NULL DEFAULT 0,
             launch_host   TEXT    NOT NULL DEFAULT '',
+            -- #2186: how far a FIRED gate reaches. 'entry' (the default) holds
+            -- only entries whose own after_json names this row's key; 'fleet'
+            -- is the pre-#2186 whole-queue stop, kept for an explicit
+            -- --scope=fleet. NOT NULL DEFAULT 'entry' so a row written before
+            -- this column existed reads as the narrower scope, never a silent
+            -- fleet-wide one — see coord.drive_queue.QueueEntry.hold_scope.
+            hold_scope    TEXT    NOT NULL DEFAULT 'entry',
             UNIQUE(repo_name, issue_number)
         );
 
@@ -717,6 +724,13 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
         # carries its age instead of rendering a stale snapshot as current
         # state. NULL for every row predating this migration.
         "ALTER TABLE drive_queue ADD COLUMN reason_at REAL",
+        # #2186: deploy-gate SCOPE — see the CREATE TABLE comment above and
+        # coord/drive_queue.py's HOLD_SCOPE_ENTRY/HOLD_SCOPE_FLEET. Every row
+        # predating this migration (and every armed-but-not-yet-fired gate)
+        # defaults to 'entry', the narrower reading — a fired gate on such a
+        # row holds only its own dependents rather than the whole queue, which
+        # is the #2186 fix itself, not just a schema detail.
+        "ALTER TABLE drive_queue ADD COLUMN hold_scope TEXT NOT NULL DEFAULT 'entry'",
     ]
     for sql in migrations:
         try:

{code_coordinator-0.5.61 → code_coordinator-0.5.63}/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.63}/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(