code-coordinator 0.5.320__tar.gz → 0.5.322__tar.gz

{code_coordinator-0.5.320 → code_coordinator-0.5.322}/PKG-INFO

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

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

@@ -526,6 +526,7 @@ tests/test_coordinator_machine.py
 tests/test_cross_platform_imports.py
 tests/test_dao.py
 tests/test_dashboard.py
+tests/test_dashboard_api.py
 tests/test_dashboard_fixture.py
 tests/test_dashboard_terminal.py
 tests/test_dashboard_terminal_live.py

{code_coordinator-0.5.320 → code_coordinator-0.5.322}/code_coordinator.egg-info/scm_file_list.json

@@ -552,6 +552,7 @@
     "tests/test_cross_platform_imports.py",
     "tests/test_dao.py",
     "tests/test_dashboard.py",
+    "tests/test_dashboard_api.py",
     "tests/test_dashboard_fixture.py",
     "tests/test_dashboard_terminal.py",
     "tests/test_dashboard_terminal_live.py",

{code_coordinator-0.5.320 → code_coordinator-0.5.322}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.320",
+  "tag": "0.5.322",
   "distance": 0,
-  "node": "g83f3ac495a1b16e3129d8654f1f061934acdc32c",
+  "node": "gc65d3bfc2f39f921d5d2df163c46505669a2a629",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-31"

{code_coordinator-0.5.320 → code_coordinator-0.5.322}/coord/client.py

@@ -872,6 +872,68 @@ def fetch_portal_ledger(
     return resp.json()["payload"]
 
 
+def fetch_portal_needs_input(
+    svc: ServiceConfig, *, timeout: float = _DEFAULT_TIMEOUT
+) -> list[dict]:
+    """GET ``/portal-needs-input`` from the daemon *svc* points at — the
+    list :func:`coord.portal_store.needs_input_submissions` builds locally,
+    routed through the daemon for a thin client (#2990).
+
+    Backs the dashboard's ``GET /api/portal/needs-input`` when
+    ``coord web`` is running off the daemon host: `coord/portal_store.py`'s
+    own module docstring is explicit that its tables are only correct on
+    the daemon host, so a thin client's local read would silently answer
+    "nothing pending" instead — the exact 2026-08-16 incident
+    `coord/commands/portal.py` cites for the CLI's own thin-client guard.
+
+    Deliberately does **not** fail-soft to ``[]`` on a transport/HTTP
+    error, same reasoning as :func:`fetch_portal_ledger`: an empty list on
+    a daemon hiccup is indistinguishable from "genuinely nothing pending",
+    which is actively misleading rather than merely unavailable. Raises
+    ``httpx.HTTPError`` on a transport/HTTP failure and ``KeyError``/
+    ``ValueError`` on a malformed body; callers let the failure surface.
+    """
+    resp = httpx.get(
+        f"{svc.url}/portal-needs-input",
+        headers=_headers(svc),
+        timeout=timeout,
+    )
+    resp.raise_for_status()
+    return resp.json()["submissions"]
+
+
+def fetch_portal_answer_preflight(
+    svc: ServiceConfig, submission_id: str, *, timeout: float = _DEFAULT_TIMEOUT
+) -> dict | None:
+    """GET ``/portal-answer-preflight`` from the daemon *svc* points at —
+    the gating reads :func:`coord.portal_store._answer_preflight_local`
+    builds locally (current open question revision + previously-recorded
+    relayed answers), routed through the daemon for a thin client (#2990).
+
+    Backs the dashboard's ``POST /api/portal/answer`` existence/idempotency/
+    stale-revision checks off the daemon host, same reasoning as
+    :func:`fetch_portal_needs_input` right above.
+
+    Returns ``None`` for an unknown *submission_id* (the daemon's 404) —
+    the caller's own signal to answer with a 404, mirroring
+    :func:`coord.portal_store._answer_preflight_local`'s local contract.
+    Any other HTTP error raises, same as :func:`fetch_portal_ledger`: a
+    stale-revision or idempotency check evaluated against a silently
+    substituted "empty" result would be actively misleading, not merely
+    unavailable.
+    """
+    resp = httpx.get(
+        f"{svc.url}/portal-answer-preflight",
+        params={"submission_id": submission_id},
+        headers=_headers(svc),
+        timeout=timeout,
+    )
+    if resp.status_code == 404:
+        return None
+    resp.raise_for_status()
+    return resp.json()["preflight"]
+
+
 def fetch_milestone_gate(
     svc: ServiceConfig,
     repo_name: str,

{code_coordinator-0.5.320 → code_coordinator-0.5.322}/coord/commands/portal.py

@@ -1838,6 +1838,13 @@ def _render_ledger_text(payload: dict) -> str:
                 lines.append(_render_answer_line(a, indent="    "))
         else:
             lines.append("    (unanswered — needs-input)")
+        # #2987: `.get` — a thin client may be talking to a daemon that
+        # predates this key.
+        for c in entry.get("confirmations") or []:
+            when = datetime.datetime.fromtimestamp(
+                c["recorded_at"], tz=datetime.timezone.utc
+            ).strftime("%Y-%m-%d %H:%M UTC")
+            lines.append(f"    [CONFIRMED by {c['actor'] or 'customer'}, {when}]")
     for a in unpaired:
         tag = " RELAYED" if a.get("relayed") else ""
         lines.append(
@@ -2076,6 +2083,14 @@ def portal_answer(
     refused — it routes through the daemon's ``/portal-answer`` seam when
     ``board_service`` is configured, so it works from wherever the operator
     happens to be.
+
+    Also queues the answer OUTBOUND to the portal (#2987, coord-portal#159,
+    best-effort) — draft-gated like a question or design round under the
+    default ``portal.approval`` policy, so it sits in ``coord portal
+    drafts`` until approved. Once sent, the client sees exactly what was
+    recorded and can confirm or correct it in one tap; a confirm marks this
+    ledger row client-confirmed, a correction lands as a normal answer
+    alongside it.
     """
     from coord import portal_store  # noqa: PLC0415
     from coord.board_service import resolve  # noqa: PLC0415

{code_coordinator-0.5.320 → code_coordinator-0.5.322}/coord/config.py

@@ -2173,7 +2173,12 @@ class PortalProjectRepo:
 #: imports ``coord.db``, and config must stay importable by everything.
 #: ``tests/test_portal_config.py`` pins the two lists together so the copy
 #: cannot silently drift.
-PORTAL_OUTBOX_KINDS = ("status", "design_round", "question", "preview")
+PORTAL_OUTBOX_KINDS = (
+    "status", "design_round", "question", "preview",
+    # #2987: a relayed answer (#2986) pushed outbound for the client to
+    # confirm/correct — see `coord.portal_sync.KIND_RELAYED_ANSWER`.
+    "relayed_answer",
+)
 
 #: The draft gate's default policy (#2903, phase 1 of #2902): the two kinds
 #: that carry **agent-authored prose to a customer** are held for an
@@ -2184,11 +2189,16 @@ PORTAL_OUTBOX_KINDS = ("status", "design_round", "question", "preview")
 #: read and rewrite, and gating them would produce a rubber-stamp queue of
 #: "In progress" ×N that trains the operator to approve without reading,
 #: which is the failure mode this gate exists to prevent (see epic #2902).
+#: #2987: a relayed answer is prose an operator typed on the client's
+#: behalf — "the most worth reading before it sends" (the issue's own
+#: framing) — so it is gated like the other two prose kinds, not left
+#: ungated like `status`/`preview`.
 DEFAULT_PORTAL_APPROVAL: dict[str, bool] = {
     "status": False,
     "design_round": True,
     "question": True,
     "preview": False,
+    "relayed_answer": True,
 }
 
 

{code_coordinator-0.5.320 → code_coordinator-0.5.322}/coord/dashboard/server.py

@@ -577,6 +577,37 @@ def openapi_spec() -> dict:
             "pane_dead": {"type": "boolean", "description": "claude has exited but the tmux session is still up"},
         },
     }
+    # #2990: the dashboard's expose of #2986's `coord portal answer` write
+    # path. `portal_ledger_entry` mirrors `coord/serve_app.py`'s own
+    # `/portal-note`/`/portal-answer` response shape byte-for-byte — a
+    # client that talks to either surface parses one schema.
+    portal_ledger_entry = {
+        "type": "object",
+        "properties": {
+            "id": {"type": "integer"},
+            "submission_id": {"type": "string"},
+            "seq": {"type": "integer"},
+            "kind": {"type": "string"},
+            "question_revision": {"type": ["integer", "null"]},
+            "text": {"type": "string"},
+            "actor": {"type": "string"},
+            "source_event_id": {"type": ["string", "null"]},
+            "payload_json": {
+                "type": "string",
+                "description": "JSON-encoded object, e.g. {\"relayed\": true, \"source\": \"phone\"}",
+            },
+            "recorded_at": {"type": "number"},
+        },
+    }
+    portal_needs_input_item = {
+        "type": "object",
+        "properties": {
+            "submission_id": {"type": "string"},
+            "question_revision": {"type": "integer"},
+            "question": {"type": "string"},
+        },
+        "required": ["submission_id", "question_revision", "question"],
+    }
     paths = {
         "/": {
             "get": {
@@ -912,6 +943,106 @@ def openapi_spec() -> dict:
                 },
             }
         },
+        "/api/portal/needs-input": {
+            "get": {
+                "summary": (
+                    "#2990: submissions currently sitting in needs-input, "
+                    "each with its open question text and revision"
+                ),
+                "description": (
+                    "Thin read wrapper over #2986's ledger pairing rule — a "
+                    "submission is included only while it both (a) has "
+                    "last_status == 'needs-input' and (b) still has a "
+                    "currently open (unanswered) question on file."
+                ),
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "properties": {
+                                        "submissions": {
+                                            "type": "array",
+                                            "items": portal_needs_input_item,
+                                        }
+                                    },
+                                    "required": ["submissions"],
+                                }
+                            }
+                        },
+                    }
+                },
+            }
+        },
+        "/api/portal/answer": {
+            "post": {
+                "summary": (
+                    "#2990: record a client's out-of-band answer — thin "
+                    "wrapper over #2986's portal_store.answer_question"
+                ),
+                "requestBody": {
+                    "required": True,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "submission_id": {"type": "string"},
+                                    "text": {"type": "string"},
+                                    "source": {
+                                        "type": "string",
+                                        "enum": ["verbal", "phone", "email"],
+                                    },
+                                    "revision": {
+                                        "type": "integer",
+                                        "description": (
+                                            "The question_revision this answers. "
+                                            "Must be the submission's CURRENT open "
+                                            "question — a stale/wrong revision is "
+                                            "rejected (409)."
+                                        ),
+                                    },
+                                    "actor": {"type": "string"},
+                                },
+                                "required": ["submission_id", "text", "source", "revision"],
+                            }
+                        }
+                    },
+                },
+                "responses": {
+                    "200": {
+                        "description": (
+                            "OK — recorded, or converged on an already-"
+                            "recorded identical answer (idempotent retry)"
+                        ),
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "properties": {"entry": portal_ledger_entry},
+                                    "required": ["entry"],
+                                }
+                            }
+                        },
+                    },
+                    "400": {
+                        "description": (
+                            "Missing/invalid submission_id, text, source or "
+                            "revision, or an unknown --source-equivalent value"
+                        )
+                    },
+                    "404": {"description": "Unknown submission"},
+                    "409": {
+                        "description": (
+                            "revision is not the submission's current open "
+                            "question"
+                        )
+                    },
+                },
+            }
+        },
         "/events": {
             "get": {
                 "summary": "Server-sent-event stream of board/assignment events",
@@ -2450,6 +2581,153 @@ def build_app(
                 {"error": f"unknown action: {action!r}"}, status_code=400
             )
 
+    def _serialize_ledger_entry(entry) -> dict:  # noqa: ANN001
+        """The wire shape for a :class:`coord.portal_store.LedgerEntry` — same
+        field set ``coord/serve_app.py``'s ``/portal-note``/``/portal-answer``
+        responses already use, so a client that talks to either surface parses
+        one shape. Delegates to :func:`coord.portal_store.ledger_entry_wire`
+        — the one place that shape is defined, rather than a fourth
+        near-verbatim copy.
+        """
+        from coord import portal_store  # noqa: PLC0415
+
+        return portal_store.ledger_entry_wire(entry)
+
+    async def api_portal_needs_input(request: Request) -> JSONResponse:
+        """GET /api/portal/needs-input — submissions currently awaiting a
+        relayed answer, each with its open question text and revision (#2990).
+
+        Routed through :func:`coord.portal_store.needs_input_submissions`,
+        which resolves ``board_service`` itself and GETs the daemon's
+        ``/portal-needs-input`` when this ``coord web`` process is a thin
+        client — reading ``portal_store``'s tables directly here would
+        silently answer "nothing pending" off the daemon host, per that
+        module's own docstring ("this module runs on the daemon host, where
+        the local DB is canonical").
+        """
+        from coord import portal_store  # noqa: PLC0415
+
+        submissions = portal_store.needs_input_submissions()
+        return JSONResponse({"submissions": submissions})
+
+    def _matching_relayed_answer(
+        preflight: dict, revision: int, text: str, source: str
+    ):
+        """An already-recorded relayed answer identical to this request, or
+        ``None`` — scanned from *preflight*'s already-routed
+        ``relayed_answers`` (:func:`coord.portal_store.answer_preflight`,
+        #2990) rather than a fresh direct ledger read.
+
+        #2990 acceptance: a browser client retrying on a flaky phone
+        connection must converge on the one ledger row, not append a second.
+        ``relayed_answers`` only ever contains ``relayed`` rows (this
+        endpoint's own writes) — never an inbound customer answer that
+        happens to share the same text, which would be a coincidence, not a
+        retry.
+        """
+        norm_text = text.strip()
+        norm_source = (source or "").strip().lower()
+        for entry in preflight["relayed_answers"]:
+            try:
+                payload = json.loads(entry["payload_json"])
+            except (ValueError, TypeError):
+                payload = {}
+            if (
+                entry["question_revision"] == revision
+                and payload.get("source") == norm_source
+                and entry["text"] == norm_text
+            ):
+                return entry
+        return None
+
+    async def api_portal_answer(request: Request) -> JSONResponse:
+        """POST /api/portal/answer — record a client's out-of-band answer
+        (#2990), thin wrapper over #2986's ``portal_store.answer_question``.
+
+        Body: {"submission_id", "text", "source", "revision"} — ``source``
+        and ``revision`` are both required (unlike the CLI, which defaults
+        source to "verbal" and revision to whatever question is currently
+        open): a browser client always knows exactly which question it is
+        answering, from the GET above, so a missing revision here is a bug
+        in the caller, not a normal default to paper over.
+
+        The stated ``revision`` must be the submission's CURRENT open
+        question — a stale or wrong revision is rejected (409) rather than
+        silently recorded against the wrong question, one tick before this
+        check would otherwise have to race #2986's own fold nudge. Checked
+        AFTER the idempotency match below, so a retry of an already-recorded
+        answer still converges even though its revision closed the moment
+        the first attempt landed.
+
+        The existence check, the idempotency scan, and the 409 check all
+        read via :func:`coord.portal_store.answer_preflight` — routed to the
+        daemon exactly like the write below already was, so all three agree
+        with the actual write even when this process is a thin client. Only
+        the write itself (``portal_store.answer_question``) reaches the real
+        daemon-canonical data when this dashboard is running there directly.
+        """
+        try:
+            body = await request.json()
+        except ValueError:
+            return JSONResponse({"error": "invalid JSON"}, status_code=400)
+
+        submission_id = body.get("submission_id")
+        text = body.get("text")
+        source = body.get("source")
+        revision = body.get("revision")
+
+        if not isinstance(submission_id, str) or not submission_id.strip():
+            return JSONResponse(
+                {"error": "submission_id is required"}, status_code=400
+            )
+        if not isinstance(text, str) or not text.strip():
+            return JSONResponse({"error": "text is required"}, status_code=400)
+        if not isinstance(source, str) or not source.strip():
+            return JSONResponse({"error": "source is required"}, status_code=400)
+        if not isinstance(revision, int) or isinstance(revision, bool):
+            return JSONResponse(
+                {"error": "revision is required and must be an integer"},
+                status_code=400,
+            )
+
+        from coord import portal_store  # noqa: PLC0415
+
+        preflight = portal_store.answer_preflight(submission_id)
+        if preflight is None:
+            return JSONResponse(
+                {"error": f"unknown submission {submission_id!r}"}, status_code=404
+            )
+
+        existing = _matching_relayed_answer(preflight, revision, text, source)
+        if existing is not None:
+            return JSONResponse({"entry": existing})
+
+        current_open = preflight["current_open_revision"]
+        if current_open != revision:
+            return JSONResponse(
+                {
+                    "error": (
+                        f"revision {revision} is not {submission_id!r}'s current "
+                        f"open question (open revision is {current_open!r})"
+                    )
+                },
+                status_code=409,
+            )
+
+        try:
+            entry = portal_store.answer_question(
+                submission_id,
+                text,
+                source=source,
+                revision=revision,
+                actor=body.get("actor") or "",
+                config=config,
+            )
+        except ValueError as exc:
+            return JSONResponse({"error": str(exc)}, status_code=400)
+
+        return JSONResponse({"entry": _serialize_ledger_entry(entry)})
+
     async def terminal_ws(websocket: WebSocket) -> None:
         """Human-attended PTY<->WebSocket bridge for a live tmux session (#1065).
 
@@ -2574,6 +2852,8 @@ def build_app(
         Route("/api/chat", api_chat, methods=["POST"]),
         Route("/api/pipeline", api_pipeline, methods=["GET"]),
         Route("/api/pipeline/action", api_pipeline_action, methods=["POST"]),
+        Route("/api/portal/needs-input", api_portal_needs_input, methods=["GET"]),
+        Route("/api/portal/answer", api_portal_answer, methods=["POST"]),
         build_events_route(event_source),
         WebSocketRoute("/ws/terminal/{session_id}", terminal_ws),
     ]

{code_coordinator-0.5.320 → code_coordinator-0.5.322}/coord/db.py

@@ -591,7 +591,10 @@ def retry_on_locked(
 #
 # #2786: bumped 5 -> 6 for the `assignments.num_turns` column appended to
 # `_migrate_add_columns` below.
-_DB_SCHEMA_VERSION = 6
+#
+# #2987: bumped 6 -> 7 for the two `portal_sync_state.relayed_answer_
+# watermark_*` columns appended to `_migrate_add_columns` below.
+_DB_SCHEMA_VERSION = 7
 
 
 def _read_schema_version(conn: sqlite3.Connection) -> int:
@@ -1237,7 +1240,17 @@ _SCHEMA_SQL = """
             verdict_watermark_at    REAL,
             verdict_watermark_rowid TEXT,
             question_watermark_at    REAL,
-            question_watermark_rowid TEXT
+            question_watermark_rowid TEXT,
+            -- #2987: the relayed-answer CONFIRMATION consumer's own read
+            -- position — same shape and same reason as
+            -- `question_watermark_at`/`question_watermark_rowid` just above
+            -- (a private watermark, independent of `handled_at`, so the
+            -- never-marked backlog every OTHER event kind leaves behind
+            -- cannot starve this consumer of a `relayed_answer.confirmed`
+            -- event newer than it). See
+            -- `coord.portal_sync._consume_relayed_answer_confirmations`.
+            relayed_answer_watermark_at    REAL,
+            relayed_answer_watermark_rowid TEXT
         );
 
         -- #2749 (IL-3, epic #2746): the running-context ledger — the record
@@ -1755,6 +1768,18 @@ _MIGRATE_ADD_COLUMNS: list[str] = [
     # `question_answered` event a no-op rather than a duplicate ledger row.
     "ALTER TABLE portal_sync_state ADD COLUMN question_watermark_at REAL",
     "ALTER TABLE portal_sync_state ADD COLUMN question_watermark_rowid TEXT",
+    # #2987: the relayed-answer confirmation consumer's own read position
+    # into `portal_events` — same reason and same shape as
+    # `question_watermark_at`/`question_watermark_rowid` above. NULL (read
+    # as `(0.0, "")`, before every real event) for every database predating
+    # this migration, which replays the full existing inbox exactly once on
+    # upgrade — safe for the same reason replaying it is safe for the
+    # question consumer: `append_ledger_entry`'s `(submission_id, kind,
+    # source_event_id)` dedupe makes a re-observed event a no-op rather than
+    # a duplicate ledger row. See
+    # `coord.portal_sync._consume_relayed_answer_confirmations`.
+    "ALTER TABLE portal_sync_state ADD COLUMN relayed_answer_watermark_at REAL",
+    "ALTER TABLE portal_sync_state ADD COLUMN relayed_answer_watermark_rowid TEXT",
     # #2786: worker-reported turn count, parsed off the final stream-json
     # `result` event into `WorkerSummary.num_turns` (coord/worker_events.py)
     # alongside the four token columns above, but never persisted until now.

{code_coordinator-0.5.320 → code_coordinator-0.5.322}/coord/portal_bridge.py

@@ -95,6 +95,10 @@ COORD_OWNED_FIELDS = (
     "artifacts",
     "onhold_since",
     "preview_url",
+    # #2987: a relayed answer coord recorded on the client's behalf
+    # (`coord portal answer`, #2986), pushed OUT so the client can see and
+    # confirm/correct it — the wire shape coord-portal#159 specifies.
+    "relayed_answer",
 )