code-coordinator 0.5.161__tar.gz → 0.5.163__tar.gz

{code_coordinator-0.5.161 → code_coordinator-0.5.163}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.161",
+  "tag": "0.5.163",
   "distance": 0,
-  "node": "g2c9d3ac54cc47979d8229c26e8852ac4852dc577",
+  "node": "g6fa07c5850b078c8d3d43576ceee2b342698e255",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.161 → code_coordinator-0.5.163}/coord/_board_mapping.py

@@ -161,6 +161,12 @@ def row_to_assignment(row: object) -> Assignment:
         # #2316: raw terminal stop_reason; None for rows predating this
         # column or a worker whose log carried no such field.
         stop_reason=d.get("stop_reason"),
+        # #2417: the calling worker's own assignment id, when this row was
+        # dispatched from INSIDE another worker's turn (e.g. `coord
+        # acceptance author`/`coord fix` shelled out to from a `type="work"`
+        # session's own bash tool). None for a hand or coordinator/brain
+        # dispatch, and for rows predating this column.
+        dispatched_by_assignment_id=d.get("dispatched_by_assignment_id"),
     )
 
 

{code_coordinator-0.5.161 → code_coordinator-0.5.163}/coord/dashboard/webapp/src/api/generated.ts

@@ -174,4 +174,5 @@ export interface Assignment {
   for_issue_number: number | null
   driven_by: string | null
   stop_reason: string | null
+  dispatched_by_assignment_id: string | null
 }

{code_coordinator-0.5.161 → code_coordinator-0.5.163}/coord/db.py

@@ -926,6 +926,14 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
         # submission with no preview queued yet, same as `open_question`'s
         # own default.
         "ALTER TABLE portal_submissions ADD COLUMN preview_url TEXT NOT NULL DEFAULT ''",
+        # #2417: the CALLING assignment's id when this row was dispatched by
+        # a `coord` subcommand run from INSIDE another worker's own turn
+        # (e.g. `coord acceptance author`/`coord fix` shelled out to from a
+        # `type="work"` session's own bash tool) rather than typed by a
+        # human — see `coord.models.Assignment.dispatched_by_assignment_id`.
+        # NULL for a hand dispatch, a coordinator/brain-proposed dispatch,
+        # and every row predating this column.
+        "ALTER TABLE assignments ADD COLUMN dispatched_by_assignment_id TEXT",
     ]
     for sql in migrations:
         try:

{code_coordinator-0.5.161 → code_coordinator-0.5.163}/coord/models.py

@@ -723,6 +723,29 @@ class Assignment:
     # `advisory` — the same bucket as a worker that looked and correctly
     # found nothing to do — so nobody re-drove it.
     stop_reason: str | None = None
+    # #2417: the CALLING assignment's id when this row was dispatched by a
+    # `coord` subcommand run from INSIDE another worker's own turn (e.g. a
+    # `type="work"` session shelling out to `coord acceptance author repo ms
+    # --issue N` or `coord fix <other-id>`), as opposed to a human typing the
+    # same command in their own shell. Populated centrally in
+    # `coord.state.record_dispatched`/`record_dispatched_assignment` from the
+    # `COORD_ASSIGNMENT_ID` env var (see `coord.agent._build_worker_env`'s
+    # #2217 note — every headless worker's subprocess environment carries its
+    # own assignment id, so a `coord` CLI the worker shells out to inherits
+    # it automatically; a human's own shell never has it set). `None` for a
+    # hand dispatch, a coordinator/brain-proposed dispatch, and rows
+    # predating this column.
+    #
+    # This is the missing link #2417 reported: before this field, the only
+    # way to discover that a work row had dispatched an independent sibling
+    # assignment (and whether that sibling then succeeded) was grepping the
+    # worker's raw `claude -p` transcript for the printed "Dispatched ... to
+    # ..." line and manually cross-referencing a second `coord log` by hand.
+    # With this field, the ORIGIN row can be found by any consumer (the
+    # board, `coord audit`, the TUI) via a reverse lookup: "which assignment
+    # has `dispatched_by_assignment_id == this row's id`?" — see
+    # `coord.state.find_dispatched_children`.
+    dispatched_by_assignment_id: str | None = None
 
 
 def effective_issue_number(assignment: "Assignment | dict") -> int:
@@ -859,6 +882,15 @@ class Proposal:
     # through) carries durable provenance. `None` for every other caller
     # (brain-proposed, milestone dispatch, ...).
     driven_by: str | None = None
+    # #2417: mirrors `Assignment.dispatched_by_assignment_id` — see that
+    # field's docstring. Set here (rather than left for the caller to
+    # populate) by `coord.state.record_dispatched` reading
+    # `COORD_ASSIGNMENT_ID` from the environment at record time, so every
+    # `Proposal`-based dispatch path (`coord fix`/`coord pr`/`coord review`
+    # follow-ups via `_dispatch_followup`, `coord assign`,
+    # `coord/dispatch_workers.py`, ...) gets this for free without each call
+    # site threading it through by hand.
+    dispatched_by_assignment_id: str | None = None
 
 
 @dataclass

{code_coordinator-0.5.161 → code_coordinator-0.5.163}/coord/state.py

@@ -17,7 +17,7 @@ import os
 import sqlite3
 import time
 import warnings
-from dataclasses import asdict
+from dataclasses import asdict, replace
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -561,6 +561,10 @@ def _dispatched_dict_from_payload(a: dict) -> dict:
         "provider_name": a.get("provider_name"),
         # #1499: durable drive provenance; None for a hand `coord assign`.
         "driven_by": a.get("driven_by"),
+        # #2417: the calling worker's own assignment id, when this row was
+        # dispatched from INSIDE another worker's turn. None for a hand or
+        # coordinator/brain dispatch.
+        "dispatched_by_assignment_id": a.get("dispatched_by_assignment_id"),
     }
 
 
@@ -605,6 +609,10 @@ def _row_to_dispatched_dict(row: object) -> dict:
         "provider_name": d.get("provider_name"),
         # #1499: durable drive provenance; None for a hand `coord assign`.
         "driven_by": d.get("driven_by"),
+        # #2417: the calling worker's own assignment id, when this row was
+        # dispatched from INSIDE another worker's turn. None for a hand or
+        # coordinator/brain dispatch.
+        "dispatched_by_assignment_id": d.get("dispatched_by_assignment_id"),
     }
 
 
@@ -799,6 +807,21 @@ def _thin_client_local_board_guard(fn_name: str) -> None:
     _log.warning(msg)
 
 
+def _dispatched_by_from_env() -> str | None:
+    """The calling worker's own assignment id, if this process is running
+    INSIDE a headless worker's turn (#2417).
+
+    `COORD_ASSIGNMENT_ID` is set on a worker subprocess's own environment by
+    `coord.agent._build_worker_env` (#2217) — so a `coord` CLI invocation
+    the worker shells out to (e.g. `coord acceptance author` dispatching an
+    independent test-author sibling, `coord fix <other-id>` escalating an
+    unrelated assignment) inherits it automatically. A human typing the same
+    command in their own shell never has it set, so this correctly returns
+    `None` for a hand/coordinator dispatch.
+    """
+    return os.environ.get("COORD_ASSIGNMENT_ID") or None
+
+
 def record_dispatched(
     *,
     assignment_id: str,
@@ -807,6 +830,15 @@ def record_dispatched(
     provider_name: str | None = None,
 ) -> None:
     """Record a newly dispatched assignment — routes to the daemon when set."""
+    # #2417: stamp the calling worker's own assignment id (if any) BEFORE
+    # this crosses the HTTP boundary to a possibly-remote daemon — the env
+    # var only exists on the machine/process that is actually dispatching,
+    # never on the daemon host. Caller-supplied values (none of today's
+    # callers set one explicitly) are left alone.
+    if proposal.dispatched_by_assignment_id is None:
+        proposal = replace(
+            proposal, dispatched_by_assignment_id=_dispatched_by_from_env()
+        )
     svc = _board_service()
     resp = _route_write(
         svc,
@@ -874,8 +906,8 @@ def _record_dispatched_local(
             assignment_id, machine_name, repo_name, repo_github,
             issue_number, issue_title, status, type, briefing,
             files_allowed, model, dispatched_at, required_gates,
-            provider_name, branch, driven_by
-        ) VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            provider_name, branch, driven_by, dispatched_by_assignment_id
+        ) VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(assignment_id) DO NOTHING""",
         (
             assignment_id,
@@ -893,6 +925,7 @@ def _record_dispatched_local(
             provider_name,
             branch,
             proposal.driven_by,
+            proposal.dispatched_by_assignment_id,
         ),
     )
     conn.commit()
@@ -915,7 +948,16 @@ def _record_dispatched_local(
             # the audit log alone, after the driver process has exited.
             actor="drive" if proposal.driven_by else "coordinator",
             summary=f"Dispatched {proposal.type} to {proposal.machine_name}: "
-            f"{proposal.repo_name}#{proposal.issue_number}",
+            f"{proposal.repo_name}#{proposal.issue_number}"
+            # #2417: make the sibling-dispatch link visible in the default
+            # (non-`--json`) `coord audit` table, not just in `details` —
+            # this is what let coord-portal#119's dispatch of a test-author
+            # sibling go unnoticed without grepping the raw worker transcript.
+            + (
+                f" (dispatched by assignment {proposal.dispatched_by_assignment_id})"
+                if proposal.dispatched_by_assignment_id
+                else ""
+            ),
             repo=proposal.repo_name,
             issue=proposal.issue_number,
             assignment_id=assignment_id,
@@ -924,6 +966,11 @@ def _record_dispatched_local(
                 "type": proposal.type,
                 "branch": branch,
                 "driven_by": proposal.driven_by,
+                # #2417: surfaces "this was dispatched BY a worker's own
+                # turn" directly in `coord audit`, without cross-referencing
+                # the raw `claude -p` transcript for the printed "Dispatched
+                # ... to ..." line.
+                "dispatched_by_assignment_id": proposal.dispatched_by_assignment_id,
             },
         )
 
@@ -934,6 +981,12 @@ def record_dispatched_assignment(
     repo_github: str,
 ) -> None:
     """Record a dispatched assignment — routes to the daemon when set."""
+    # #2417: see record_dispatched's matching comment — must be stamped here,
+    # on the dispatching process's own env, before the daemon HTTP hop.
+    if assignment.dispatched_by_assignment_id is None:
+        assignment = replace(
+            assignment, dispatched_by_assignment_id=_dispatched_by_from_env()
+        )
     svc = _board_service()
     resp = _route_write(
         svc, "/dispatched", {"assignment": asdict(assignment), "repo_github": repo_github}
@@ -971,7 +1024,8 @@ def _record_dispatched_assignment_local(
             issue_number, issue_title, status, type, briefing,
             files_allowed, model, dispatched_at, review_of_assignment_id,
             review_target, required_gates, review_iteration,
-            provider_name, branch, for_issue_number, driven_by
+            provider_name, branch, for_issue_number, driven_by,
+            dispatched_by_assignment_id
         ) VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
             -- #1553: a follow-up dispatched off another assignment (review,
             -- smoke, [fix-N], retry, pr-helper) inherits that parent's
@@ -989,7 +1043,7 @@ def _record_dispatched_assignment_local(
                 SELECT p.for_issue_number FROM assignments p
                 WHERE p.assignment_id = ?
             )),
-            ?)
+            ?, ?)
         ON CONFLICT(assignment_id) DO UPDATE SET
             status = 'running',
             machine_name = excluded.machine_name,
@@ -1013,7 +1067,13 @@ def _record_dispatched_assignment_local(
             for_issue_number = COALESCE(excluded.for_issue_number, for_issue_number),
             -- #1499: COALESCE so a re-dispatch/reload doesn't clear the
             -- drive provenance already recorded for this assignment.
-            driven_by = COALESCE(excluded.driven_by, driven_by)""",
+            driven_by = COALESCE(excluded.driven_by, driven_by),
+            -- #2417: COALESCE so a re-dispatch/reload doesn't clear the
+            -- calling-worker provenance already recorded for this
+            -- assignment.
+            dispatched_by_assignment_id = COALESCE(
+                excluded.dispatched_by_assignment_id, dispatched_by_assignment_id
+            )""",
         (
             assignment.assignment_id or "",
             assignment.machine_name,
@@ -1039,6 +1099,7 @@ def _record_dispatched_assignment_local(
             # positional).
             assignment.review_of_assignment_id,
             assignment.driven_by,
+            assignment.dispatched_by_assignment_id,
         ),
     )
     conn.commit()
@@ -1051,7 +1112,13 @@ def _record_dispatched_assignment_local(
         # to a human `coord assign` (the exact gap #1499 reported).
         actor="drive" if assignment.driven_by else "coordinator",
         summary=f"Dispatched {assignment.type} to {assignment.machine_name}: "
-        f"{assignment.repo_name}#{assignment.issue_number}",
+        f"{assignment.repo_name}#{assignment.issue_number}"
+        # #2417: see the matching Proposal-path comment above.
+        + (
+            f" (dispatched by assignment {assignment.dispatched_by_assignment_id})"
+            if assignment.dispatched_by_assignment_id
+            else ""
+        ),
         repo=assignment.repo_name,
         issue=assignment.issue_number,
         assignment_id=assignment.assignment_id,
@@ -1062,6 +1129,8 @@ def _record_dispatched_assignment_local(
             "review_target": assignment.review_target,
             "review_iteration": assignment.review_iteration,
             "driven_by": assignment.driven_by,
+            # #2417: see record_dispatched's matching comment.
+            "dispatched_by_assignment_id": assignment.dispatched_by_assignment_id,
         },
     )
 

{code_coordinator-0.5.161 → code_coordinator-0.5.163}/tests/test_state.py

@@ -242,6 +242,163 @@ class TestStopReason:
         update_assignment_stop_reason("some-id", "")  # must not raise
 
 
+class TestDispatchedByAssignmentId:
+    """#2417: dispatched_by_assignment_id — the calling worker's own
+    assignment id, captured from $COORD_ASSIGNMENT_ID at dispatch time, so a
+    sibling assignment a worker's own turn spawns (`coord acceptance
+    author`, `coord fix <other-id>`) is traceable back to the origin row
+    instead of only discoverable by grepping the raw worker transcript.
+    """
+
+    def test_schema_has_dispatched_by_assignment_id_column(self, coord_db) -> None:
+        from coord.db import get_connection
+        conn = get_connection()
+        cols = {row[1] for row in conn.execute("PRAGMA table_info(assignments)").fetchall()}
+        assert "dispatched_by_assignment_id" in cols, (
+            "assignments table is missing dispatched_by_assignment_id column — "
+            "check _migrate_add_columns in coord/db.py"
+        )
+
+    def test_record_dispatched_captures_env_when_set(self, coord_db, monkeypatch) -> None:
+        """A Proposal-based dispatch (coord fix's `_dispatch_followup`, plain
+        `coord assign`, ...) picks up the calling worker's own assignment id
+        from $COORD_ASSIGNMENT_ID — i.e. this dispatch happened FROM INSIDE
+        that worker's own turn, not typed by a human."""
+        monkeypatch.setenv("COORD_ASSIGNMENT_ID", "origin-work-001")
+        proposal = Proposal(
+            id=1, machine_name="laptop", repo_name="api", issue_number=42,
+            issue_title="Fix auth", rationale="x",
+        )
+        record_dispatched(
+            assignment_id="sibling-001", proposal=proposal, repo_github="acme/api",
+        )
+
+        from coord.db import get_connection
+        conn = get_connection()
+        row = conn.execute(
+            "SELECT dispatched_by_assignment_id FROM assignments WHERE assignment_id=?",
+            ("sibling-001",),
+        ).fetchone()
+        assert row[0] == "origin-work-001"
+
+    def test_record_dispatched_none_when_env_unset(self, coord_db, monkeypatch) -> None:
+        """A human typing `coord assign`/`coord fix` in their own shell never
+        has $COORD_ASSIGNMENT_ID set — the column must stay NULL, not read as
+        a phantom dispatch-by-worker."""
+        monkeypatch.delenv("COORD_ASSIGNMENT_ID", raising=False)
+        proposal = Proposal(
+            id=1, machine_name="laptop", repo_name="api", issue_number=42,
+            issue_title="Fix auth", rationale="x",
+        )
+        record_dispatched(
+            assignment_id="sibling-002", proposal=proposal, repo_github="acme/api",
+        )
+
+        from coord.db import get_connection
+        conn = get_connection()
+        row = conn.execute(
+            "SELECT dispatched_by_assignment_id FROM assignments WHERE assignment_id=?",
+            ("sibling-002",),
+        ).fetchone()
+        assert row[0] is None
+
+    def test_record_dispatched_assignment_captures_env_when_set(
+        self, coord_db, monkeypatch
+    ) -> None:
+        """Mirrors the Proposal-path test above for the Assignment-based
+        dispatch path (`coord.test_author.dispatch_test_author`'s
+        `record_dispatched_assignment` call — the exact path coord-portal#119
+        went through: a work session shelling out to `coord acceptance
+        author`)."""
+        from coord.models import Assignment
+        from coord.state import record_dispatched_assignment
+
+        monkeypatch.setenv("COORD_ASSIGNMENT_ID", "b1b6f90ca426")
+        record_dispatched_assignment(
+            assignment=Assignment(
+                assignment_id="41249c1cebbd", machine_name="precision",
+                repo_name="coord-portal", issue_number=16,
+                issue_title="[test-author] ms-16 slice #10", type="test-author",
+            ),
+            repo_github="acme/coord-portal",
+        )
+
+        from coord.db import get_connection
+        conn = get_connection()
+        row = conn.execute(
+            "SELECT dispatched_by_assignment_id FROM assignments WHERE assignment_id=?",
+            ("41249c1cebbd",),
+        ).fetchone()
+        assert row[0] == "b1b6f90ca426"
+
+    def test_explicit_value_on_the_dataclass_wins_over_env(
+        self, coord_db, monkeypatch
+    ) -> None:
+        """A caller that already set dispatched_by_assignment_id explicitly
+        (none do today, but the seam supports it) is never clobbered by the
+        env-derived default."""
+        monkeypatch.setenv("COORD_ASSIGNMENT_ID", "some-other-worker")
+        proposal = Proposal(
+            id=1, machine_name="laptop", repo_name="api", issue_number=42,
+            issue_title="Fix auth", rationale="x",
+            dispatched_by_assignment_id="explicit-parent",
+        )
+        record_dispatched(
+            assignment_id="sibling-003", proposal=proposal, repo_github="acme/api",
+        )
+
+        from coord.db import get_connection
+        conn = get_connection()
+        row = conn.execute(
+            "SELECT dispatched_by_assignment_id FROM assignments WHERE assignment_id=?",
+            ("sibling-003",),
+        ).fetchone()
+        assert row[0] == "explicit-parent"
+
+    def test_audit_summary_names_the_dispatching_assignment(
+        self, coord_db, monkeypatch
+    ) -> None:
+        """#2417's other half: `coord audit`'s default (non-JSON) table must
+        show the link too, not just a --json details field — this is what
+        let coord-portal#119's dispatch go unnoticed without grepping the raw
+        transcript."""
+        from coord.state import list_audit_log
+
+        monkeypatch.setenv("COORD_ASSIGNMENT_ID", "origin-work-audit")
+        proposal = Proposal(
+            id=1, machine_name="laptop", repo_name="api", issue_number=42,
+            issue_title="Fix auth", rationale="x",
+        )
+        record_dispatched(
+            assignment_id="sibling-audit-001", proposal=proposal, repo_github="acme/api",
+        )
+
+        result = list_audit_log(assignment_id="sibling-audit-001")
+        entries = result["entries"]
+        assert len(entries) == 1
+        assert "dispatched by assignment origin-work-audit" in entries[0]["summary"]
+        assert entries[0]["details"]["dispatched_by_assignment_id"] == "origin-work-audit"
+
+    def test_load_dispatched_surfaces_the_field(self, coord_db, monkeypatch) -> None:
+        """The board-level reverse-lookup surface (`coord.state.load_dispatched`,
+        which both `coord sessions`/`coord log` and the TUI's board payload
+        read from) must carry the field so a consumer can find "which
+        assignment dispatched me" without a raw-log grep."""
+        from coord.state import load_dispatched
+
+        monkeypatch.setenv("COORD_ASSIGNMENT_ID", "origin-work-load")
+        proposal = Proposal(
+            id=1, machine_name="laptop", repo_name="api", issue_number=42,
+            issue_title="Fix auth", rationale="x",
+        )
+        record_dispatched(
+            assignment_id="sibling-load-001", proposal=proposal, repo_github="acme/api",
+        )
+
+        rows = {r["assignment_id"]: r for r in load_dispatched()}
+        assert rows["sibling-load-001"]["dispatched_by_assignment_id"] == "origin-work-load"
+
+
 class TestRecordDispatchedAssignmentBranch:
     """#557: record_dispatched_assignment must persist the branch column so
     coord reattach can find it for the remote push-back finalize."""

{code_coordinator-0.5.161 → code_coordinator-0.5.163}/tui/src/app/data.rs

@@ -1333,7 +1333,7 @@ pub(crate) fn load_data() -> BoardData {
              acceptance_total, acceptance_passed, \
              test_reason, review_state, pr_url, \
              audit_goals_json, audit_bottom_line, audit_run_number, \
-             for_issue_number, driven_by \
+             for_issue_number, driven_by, dispatched_by_assignment_id \
              FROM assignments ORDER BY dispatched_at DESC",
         ) {
             Ok(s) => s,
@@ -1423,6 +1423,11 @@ pub(crate) fn load_data() -> BoardData {
                 // #1499: durable drive provenance. unwrap_or(None) for the
                 // same graceful-degradation reason as the columns above.
                 driven_by: row.get::<_, Option<String>>(39).unwrap_or(None),
+                // #2417: calling-worker provenance. unwrap_or(None) for the
+                // same graceful-degradation reason as the columns above.
+                dispatched_by_assignment_id: row
+                    .get::<_, Option<String>>(40)
+                    .unwrap_or(None),
             })
         }) {
             Ok(r) => r,