code-coordinator 0.5.228__tar.gz → 0.5.230__tar.gz

{code_coordinator-0.5.228 → code_coordinator-0.5.230}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.228
+Version: 0.5.230
 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.228 → code_coordinator-0.5.230}/code_coordinator.egg-info/SOURCES.txt

@@ -541,6 +541,7 @@ tests/test_human_attended_437.py
 tests/test_init.py
 tests/test_integration.py
 tests/test_interactive_briefing_echo.py
+tests/test_interactive_pane_log_2541.py
 tests/test_interactive_prefill_state.py
 tests/test_interactive_session_relaunch.py
 tests/test_interactive_test_verdict_backstop.py

{code_coordinator-0.5.228 → code_coordinator-0.5.230}/code_coordinator.egg-info/scm_file_list.json

@@ -611,6 +611,7 @@
     "tests/test_init.py",
     "tests/test_integration.py",
     "tests/test_interactive_briefing_echo.py",
+    "tests/test_interactive_pane_log_2541.py",
     "tests/test_interactive_prefill_state.py",
     "tests/test_interactive_session_relaunch.py",
     "tests/test_interactive_test_verdict_backstop.py",

{code_coordinator-0.5.228 → code_coordinator-0.5.230}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.228",
+  "tag": "0.5.230",
   "distance": 0,
-  "node": "g3b4de74e0e15d89b4795d8a24a95465d2ac0b416",
+  "node": "g2e59935577bb8bd17362609676a470181e55ba5b",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-22"

{code_coordinator-0.5.228 → code_coordinator-0.5.230}/coord/agent.py

@@ -5762,7 +5762,8 @@ class AgentServer:
 
     @staticmethod
     def _tmux_session_alive(assignment_id: str) -> bool:
-        """Return True when a ``coord-<assignment_id>`` tmux session is up.
+        """Return True when a ``coord-<assignment_id>`` tmux session is
+        genuinely still in use — alive AND its pane is not dead.
 
         Load-bearing guard for :meth:`clean_worktrees` (#1295): an
         interactive Test/Review/Merge/Work pane keeps its tmux session
@@ -5772,11 +5773,16 @@ class AgentServer:
         is the only reliable "someone is still using this worktree"
         signal.
 
-        Uses ``tmux has-session -t coord-<assignment_id>``; exit 0 means
-        the session exists.  Delegates to
-        :func:`coord.interactive.tmux_session_alive` so a single
-        implementation handles the subprocess and error-swallowing
-        semantics.  When ``tmux`` is not installed / not running / the
+        Delegates to :func:`coord.interactive.tmux_session_running` (a bare
+        ``tmux has-session`` alone is NOT enough — #2541 set
+        ``remain-on-exit on`` on every freshly-created coord tmux session so
+        a crashed pane's screen stays inspectable, which means
+        ``has-session`` now stays ``True`` after ANY pane exit, clean
+        success or crash, until a reaper notices and kills it. Without the
+        pane-dead check this guard would keep protecting — and thus never
+        cleaning up — a worktree whose interactive session has already
+        finished, for as long as the now-longer-lived dead session
+        lingers). When ``tmux`` is not installed / not running / the
         subprocess errors, we return ``False`` — "no live session, keep
         sweeping" — rather than raising, so one broken tmux install
         never aborts a fleet sweep across the rest of an agent's
@@ -5788,15 +5794,15 @@ class AgentServer:
         try:
             from coord.interactive import (  # noqa: PLC0415
                 tmux_available,
-                tmux_session_alive,
                 tmux_session_name,
+                tmux_session_running,
             )
         except Exception:  # noqa: BLE001 — defensive; module missing → no guard
             return False
         try:
             if not tmux_available():
                 return False
-            return tmux_session_alive(tmux_session_name(assignment_id))
+            return tmux_session_running(tmux_session_name(assignment_id))
         except Exception:  # noqa: BLE001 — never propagate out of the sweep
             return False
 

{code_coordinator-0.5.228 → code_coordinator-0.5.230}/coord/agent_app.py

@@ -1231,11 +1231,41 @@ def build_app(
     async def logs(request: Request) -> Response:
         assignment_id = request.path_params["id"]
         assignment = server.get(assignment_id)
-        if assignment is None or assignment.log_path is None:
-            return JSONResponse(
-                {"error": f"unknown assignment {assignment_id}"}, status_code=404
-            )
-        log_path = Path(assignment.log_path)
+        status = assignment.status if assignment is not None else "unknown"
+        if assignment is not None and assignment.log_path is not None:
+            log_path = Path(assignment.log_path)
+        else:
+            # #2541: the human-attended ssh+tmux interactive launcher
+            # (`coord assign --interactive ...`) never goes through this
+            # agent's `/assign` — it SSHes in directly from the
+            # coordinator and drives `claude` inside a tmux session, so
+            # `server.get()` has no record of it. Those sessions still
+            # persist a best-effort pane-capture snapshot at the SAME
+            # conventional per-assignment path
+            # (`coord.interactive._persist_interactive_pane_log`) so a
+            # launch failure is diagnosable via `coord log <id>` without a
+            # manual SSH repro. Fall back to that path directly rather
+            # than 404ing just because this agent never tracked the
+            # assignment in memory.
+            # assignment_id is attacker-controllable (raw path param) and,
+            # unlike `assignment.log_path` above, is interpolated directly
+            # into a filesystem path here — reject anything that isn't the
+            # plain `[a-zA-Z0-9_-]+` shape every assignment_id generator in
+            # this codebase actually produces, so a `../` can't escape
+            # `logs/`.
+            if not re.fullmatch(r"[A-Za-z0-9_-]+", assignment_id):
+                return JSONResponse(
+                    {"error": f"invalid assignment id {assignment_id!r}"},
+                    status_code=400,
+                )
+
+            # `server.log_dir` (not the module-level `DEFAULT_STATE_DIR`
+            # default) so this honours a non-default `state_dir` exactly
+            # like every other lookup in this handler would if the
+            # assignment WERE tracked — production agents never override
+            # it, but this keeps the fallback truthful to what this
+            # specific server instance is actually configured with.
+            log_path = server.log_dir / f"{assignment_id}.log"
         if not log_path.exists():
             return JSONResponse(
                 {"error": f"no log file for assignment {assignment_id}"}, status_code=404
@@ -1255,7 +1285,7 @@ def build_app(
         total_size = log_path.stat().st_size
         headers = {
             "X-Coord-Log-Total": str(total_size),
-            "X-Coord-Log-Status": assignment.status,
+            "X-Coord-Log-Status": status,
         }
         return PlainTextResponse(body.decode("utf-8", errors="replace"), headers=headers)
 

{code_coordinator-0.5.228 → code_coordinator-0.5.230}/coord/block_log.py

@@ -35,6 +35,28 @@ cause later agreed with how the episode actually resolved
 one that abstains, which is why ``unknown`` is counted separately from
 ``disagreed`` and never folded into it.
 
+**#2540 fills the column that neither Phase counts: operator effort that never
+touched the queue's own command surface.**  ``human_acted`` was, until #2540,
+true only for the narrow set of releases the queue itself can attribute to a
+person — an operator's ``remove``, a Gate-A sign-off.  Real recovery routinely
+happens elsewhere entirely: a manual git rebase and force-with-lease push, a
+direct ``coord test``/``coord merge --only``/``coord pr``/``coord fix``
+against the assignment underneath an entry, a ``systemctl``/``coord agent
+update``/``coord diagnose --reset`` on the machine running it.  None of that
+is visible to a tick, so none of it was ever counted — a night of real manual
+recovery could read as ``0 needed a human``, which is the exact failure this
+module exists to prevent, just relocated one layer down.  This module cannot
+detect that kind of intervention after the fact (recording must not probe live
+state — see above), so :func:`intervention_event` gives an operator a place to
+say so, in real time or shortly after: ``coord drive-queue log-intervention``
+appends a record that :func:`episodes` folds onto whichever episode was open
+for that key, or — if it had already resolved by the time the operator got to
+logging it — the most recently closed one.  It flips ``human_acted`` to
+``True`` the same as an ``operator_resolution_event`` does, and is kept
+separately visible (``intervention_categories``) so the report can still say
+*how* it knows, rather than asserting a single flat "a human acted" with no
+paper trail behind it.
+
 **Recording must never change a decision.**  Every public entry point here is
 best-effort and swallows its own exceptions (:func:`record`), for the same
 reason :mod:`coord.audit` does: the tick's merge/dispatch/attempt accounting
@@ -95,7 +117,9 @@ __all__ = [
     "BY_DESIGN_CAUSES",
     "EVENT_DIAGNOSIS",
     "EVENT_ENTER",
+    "EVENT_INTERVENTION",
     "EVENT_RESOLVE",
+    "INTERVENTION_CATEGORIES",
     "OUTCOME_BUCKETS",
     "RESCUE_SOURCES",
     "STALL_STATES",
@@ -107,6 +131,7 @@ __all__ = [
     "episode_bucket",
     "episode_category",
     "episodes",
+    "intervention_event",
     "is_by_design",
     "log_location",
     "merge_only_event",
@@ -133,6 +158,11 @@ EVENT_RESOLVE = "resolve"
 #: no read-modify-write race, and a later diagnosis that contradicts an earlier
 #: one stays visible instead of overwriting it.
 EVENT_DIAGNOSIS = "diagnosis"
+#: #2540.  An operator saying, out of band, "I acted on this key" — the
+#: durable record for intervention that never touches the drive-queue command
+#: surface (`remove`/`resume`) and so was invisible to `human_acted` before
+#: this. See `intervention_event` and the module docstring's #2540 section.
+EVENT_INTERVENTION = "intervention"
 
 # Rotate at 4 MiB — comfortably more than two weeks at this fleet's rate
 # (single-digit stalls a night, ~400 bytes a record), and small enough that
@@ -615,6 +645,71 @@ def operator_resolution_event(
     return record
 
 
+#: Documented common buckets for `coord drive-queue log-intervention
+#: --category`.  Deliberately NOT a closed enum enforced anywhere — same
+#: reasoning as `episode_category`'s open vocabulary: a kind of intervention
+#: this build has never named must still be recordable as itself, not
+#: coerced into "other" and lost.  This tuple exists purely so the CLI help
+#: text and this module agree on the suggested starting set from #2540's own
+#: evidence (a manual git rebase/conflict-resolution/force-push, a direct
+#: `coord test`/`coord merge --only`/`coord pr`/`coord fix` against the
+#: assignment, and infra-level recovery like `systemctl`/`coord agent
+#: update`/`coord diagnose --reset`).
+INTERVENTION_CATEGORIES: tuple[str, ...] = (
+    "git-recovery",
+    "cli-recheck",
+    "infra",
+    "other",
+)
+
+
+def intervention_event(
+    *,
+    key: str,
+    category: str,
+    note: str = "",
+    host: str = "",
+    now: float | None = None,
+) -> dict[str, Any]:
+    """A #2540 record: a human acted on *key* outside the queue's own commands.
+
+    The other half of #2235's metric that :func:`operator_resolution_event`
+    cannot reach.  That function fires only from inside a command
+    (``remove``) that IS the resolution — a board mutation this process just
+    performed.  A manual git rebase, a direct ``coord test``/``coord merge
+    --only``/``coord pr``/``coord fix``, or a ``systemctl``/``coord agent
+    update`` on the host underneath an entry are real operator effort that
+    touches none of this process's own write paths, so nothing here can see
+    them happen.  What it CAN do is give the operator a place to say so —
+    this is that place, called from ``coord drive-queue log-intervention``.
+
+    Deliberately not a ``resolve``: unlike an operator's ``remove``, logging
+    an intervention does not by itself mean the stall is over — the entry may
+    still be blocked, may have already resolved by the time the operator gets
+    around to typing the command, or may resolve later still by an ordinary
+    auto mechanism.  :func:`episodes` folds this onto whichever episode was
+    open for *key* at the time, or, failing that, the most recently closed
+    one — never inventing an episode, and never guessing at *why* the entry
+    was stalled, the same restraint :func:`operator_resolution_event` already
+    keeps.
+
+    *category* is free text, not validated against
+    :data:`INTERVENTION_CATEGORIES` — the same "open vocabulary, never
+    coerced" contract :func:`episode_category` documents. An empty string
+    normalises to ``"other"`` so the report always has something to show
+    rather than a blank category column.
+    """
+    return {
+        "event": EVENT_INTERVENTION,
+        "ts": time.time() if now is None else now,
+        "key": key,
+        "category": str(category or "other"),
+        "note": note,
+        "host": host,
+        "source": "operator",
+    }
+
+
 # ── #2276 Phase 1: the diagnosis record, and scoring it ──────────────────────
 
 
@@ -806,6 +901,60 @@ def read_events(
 # ── reading (pairing + summary) ──────────────────────────────────────────────
 
 
+def _fold_intervention(
+    open_by_key: dict[str, dict[str, Any]],
+    out: list[dict[str, Any]],
+    key: str,
+    event: Mapping[str, Any],
+) -> None:
+    """Attach one #2540 ``intervention`` record to the episode it happened
+    during — mutating the episode dict in place, exactly like the
+    ``EVENT_DIAGNOSIS`` branch of :func:`episodes` does for ``true_cause``.
+
+    Preferred target is the OPEN episode for *key* — the common case, an
+    operator logging what they are doing while the entry is still stalled.
+    Failing that, the most recently CLOSED episode for *key* in *out*:
+    ``coord drive-queue log-intervention`` very often runs minutes AFTER the
+    fix already landed (the operator ran ``coord merge --only``, it worked,
+    then they typed the log line), and by then :func:`episodes` has already
+    popped that episode out of ``open_by_key``.  Searched from the end of
+    ``out`` because that list is built in the same time order *events* is
+    iterated in, so the last match for *key* is the most recent past episode
+    — never an older one a later re-block would make ambiguous.
+
+    A *key* with no episode at all yet (logged before this host ever recorded
+    a stall for it) is dropped, the same convention an orphan ``resolve`` or
+    ``diagnosis`` already follows: there is nothing here to attach evidence
+    to, and it is better to say so (`coord drive-queue log-intervention`
+    warns) than to silently fabricate one.
+    """
+    episode = open_by_key.get(key)
+    if episode is None:
+        for candidate in reversed(out):
+            if candidate.get("key") == key:
+                episode = candidate
+                break
+    if episode is None:
+        return
+    category = str(event.get("category") or "other")
+    episode.setdefault("interventions", []).append(
+        {
+            "ts": float(event.get("ts") or 0.0),
+            "category": category,
+            "note": str(event.get("note") or ""),
+            "host": str(event.get("host") or ""),
+        }
+    )
+    categories = episode.setdefault("intervention_categories", [])
+    if category not in categories:
+        categories.append(category)
+    # The whole point: this is the signal `human_acted` was blind to before
+    # #2540. Set unconditionally, whether the episode is still open (the
+    # eventual `resolve` branch above ORs it back in rather than clobbering
+    # it) or already closed (there is no later write to clobber it).
+    episode["human_acted"] = True
+
+
 def episodes(events: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]:
     """Pair ``enter`` records with the ``resolve`` that closed them.
 
@@ -828,6 +977,16 @@ def episodes(events: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]:
     resolution's own account of what happened and the derived one is kept
     beside it as ``diagnosed_cause``, so ``agreement`` scores two independent
     claims rather than one claim against itself.
+
+    An ``intervention`` (#2540) folds onto an episode the same way — see
+    :func:`_fold_intervention` — except it targets a CLOSED episode too, not
+    only an open one: unlike a diagnosis, an operator very often logs an
+    intervention after the fact, once the fix they made by hand has already
+    let the entry auto-resolve. It sets ``human_acted`` true and appends to
+    ``intervention_categories``/``interventions`` without touching
+    ``true_cause`` — what mechanically flipped the state is still whatever
+    the resolution said; #2540 only means the record also captures that a
+    human was in the loop, in a way the pre-#2540 log could not see at all.
     """
     open_by_key: dict[str, dict[str, Any]] = {}
     out: list[dict[str, Any]] = []
@@ -866,7 +1025,13 @@ def episodes(events: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]:
                 "diagnosis_evidence": [],
                 "diagnosis_contradicts_stated": False,
                 "agreement": "",
+                # #2540.  Populated only by `intervention_event` records
+                # folded on below — a fresh episode has neither.
+                "interventions": [],
+                "intervention_categories": [],
             }
+        elif kind == EVENT_INTERVENTION:
+            _fold_intervention(open_by_key, out, key, event)
         elif kind == EVENT_DIAGNOSIS:
             episode = open_by_key.get(key)
             if episode is None:
@@ -897,7 +1062,14 @@ def episodes(events: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]:
                     "resolved": True,
                     "resolution": event.get("resolution", ""),
                     "true_cause": resolution_cause,
-                    "human_acted": bool(event.get("human_acted")),
+                    # #2540: OR in whatever an earlier `intervention_event`
+                    # already set. Without the `or`, an ordinary auto
+                    # resolution's own `human_acted=False` would blindly
+                    # overwrite the `True` a logged intervention just
+                    # earned — exactly the undercount this issue is about,
+                    # relocated one line down instead of fixed.
+                    "human_acted": bool(event.get("human_acted"))
+                    or bool(episode.get("human_acted")),
                     "resolved_at": resolved_at,
                     "stalled_seconds": max(0.0, resolved_at - episode["entered_at"]),
                     "source": event.get("source", ""),
@@ -937,11 +1109,27 @@ def summarize(items: Sequence[Mapping[str, Any]]) -> dict[str, Any]:
     counts the episodes where the live evidence positively ruled the queue's
     stated reason out — the five-of-seven number, finally measured instead of
     reconstructed by hand.
+
+    ``human_acted_logged`` (#2540) is the subset of ``human_acted`` this build
+    can actually SHOW ITS WORK for: episodes carrying at least one
+    ``coord drive-queue log-intervention`` record.  The rest of ``human_acted``
+    still comes from the pre-#2540 queue-command surface (an operator's
+    ``remove``, a Gate-A sign-off) — real, but with no evidence trail beyond
+    "the resolve record said so".  Neither of those two is a claim that
+    *nothing else* happened: a night with ``human_acted_logged == 0`` means
+    no intervention was LOGGED, not that none occurred — this module still
+    cannot see a git rebase or a direct ``coord test`` call that nobody typed
+    the one extra command for.  That is the honest limit of what an
+    append-only log fed only by this process's own choke points can claim,
+    and it is why the CLI help for ``log-intervention`` asks operators to run
+    it as a matter of habit rather than treating the count as automatically
+    complete.
     """
     by_state: dict[str, int] = {}
     by_cause: dict[str, int] = {}
     seen_pairs: dict[tuple[str, str], int] = {}
     human = 0
+    human_logged = 0
     auto = 0
     still_open = 0
     diagnosed = 0
@@ -961,6 +1149,8 @@ def summarize(items: Sequence[Mapping[str, Any]]) -> dict[str, Any]:
             still_open += 1
         elif item.get("human_acted"):
             human += 1
+            if item.get("intervention_categories"):
+                human_logged += 1
         else:
             auto += 1
         cause = episode_category(item)
@@ -986,6 +1176,7 @@ def summarize(items: Sequence[Mapping[str, Any]]) -> dict[str, Any]:
         "by_state": by_state,
         "by_cause": by_cause,
         "human_acted": human,
+        "human_acted_logged": human_logged,
         "auto_released": auto,
         "open": still_open,
         "repeat_causes": repeats,

{code_coordinator-0.5.228 → code_coordinator-0.5.230}/coord/commands/dispatch_workers.py

@@ -141,8 +141,8 @@ def _dispatch_review_of(
         finalize_interactive_exit,
         launch_human_attended_interactive,
         tmux_available as _tmux_avail,
-        tmux_session_alive as _tmux_alive,
         tmux_session_name as _tmux_name,
+        tmux_session_running as _tmux_alive,
     )
 
     from coord.review import (  # noqa: PLC0415
@@ -648,8 +648,8 @@ def _dispatch_smoke_of(
         launch_human_attended_interactive,
         snapshot_live_checkout_for_smoke,
         tmux_available as _tmux_avail,
-        tmux_session_alive as _tmux_alive,
         tmux_session_name as _tmux_name,
+        tmux_session_running as _tmux_alive,
     )
 
     from coord.models import Assignment as _AssignmentSm  # noqa: PLC0415
@@ -1142,8 +1142,8 @@ def _dispatch_audit_of(
         finalize_interactive_exit,
         launch_human_attended_interactive,
         tmux_available as _tmux_avail,
-        tmux_session_alive as _tmux_alive,
         tmux_session_name as _tmux_name,
+        tmux_session_running as _tmux_alive,
     )
     from coord.models import Assignment as _AssignmentAu  # noqa: PLC0415
     from coord.state import record_dispatched_assignment as _record_au  # noqa: PLC0415
@@ -1486,8 +1486,8 @@ def _dispatch_milestone_chat_of(
         finalize_interactive_exit,
         launch_human_attended_interactive,
         tmux_available as _tmux_avail,
-        tmux_session_alive as _tmux_alive,
         tmux_session_name as _tmux_name,
+        tmux_session_running as _tmux_alive,
     )
     from coord.milestone_chat import resolve_milestone_chat_briefing  # noqa: PLC0415
     from coord.board_service import read_board as _read_board_mc  # noqa: PLC0415
@@ -1682,8 +1682,8 @@ def _run_troubleshoot_or_chat(
         finalize_interactive_exit,
         launch_human_attended_interactive,
         tmux_available as _tmux_avail,
-        tmux_session_alive as _tmux_alive,
         tmux_session_name as _tmux_name,
+        tmux_session_running as _tmux_alive,
     )
 
     from coord.board_service import read_board as _read_board_ts  # noqa: PLC0415
@@ -2044,8 +2044,8 @@ def _dispatch_fix_of(
         launch_human_attended_interactive,
         remote_worktree_exists as _remote_wt_exists,
         tmux_available as _tmux_avail,
-        tmux_session_alive as _tmux_alive,
         tmux_session_name as _tmux_name,
+        tmux_session_running as _tmux_alive,
     )
 
     from coord.auto_loop import (  # noqa: PLC0415
@@ -2731,8 +2731,8 @@ def _dispatch_rework_of(
         launch_human_attended_interactive,
         remote_worktree_exists as _remote_wt_exists,
         tmux_available as _tmux_avail,
-        tmux_session_alive as _tmux_alive,
         tmux_session_name as _tmux_name,
+        tmux_session_running as _tmux_alive,
     )
 
     from coord.agent import (  # noqa: PLC0415
@@ -3294,8 +3294,8 @@ def _dispatch_merge_of(
         launch_human_attended_interactive,
         remote_worktree_exists as _remote_wt_exists,
         tmux_available as _tmux_avail,
-        tmux_session_alive as _tmux_alive,
         tmux_session_name as _tmux_name,
+        tmux_session_running as _tmux_alive,
     )
 
     from coord.agent import (  # noqa: PLC0415
@@ -3932,8 +3932,8 @@ def _dispatch_interactive_work(
         launch_human_attended_interactive,
         remote_worktree_exists as _remote_wt_exists,
         tmux_available as _tmux_avail,
-        tmux_session_alive as _tmux_alive,
         tmux_session_name as _tmux_name,
+        tmux_session_running as _tmux_alive,
     )
 
     if _is_local: