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

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

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

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

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

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

@@ -55,6 +55,15 @@ machine can be briefed without a prior session's transcript, so ``ledger``
 ``POST /portal-decision`` — both through :mod:`coord.portal_store`, which
 checks ``board_service`` itself rather than calling
 :func:`_refuse_if_thin_client`. See that section below for the detail.
+
+**``note`` (#2867) and ``answer`` (#2986) are the ledger's two operator-only
+writes.** ``note`` records background with no pairing and no status effect;
+``answer`` records a client's answer that arrived OUT OF BAND — verbally, on
+a call, by email — pairs it to the open question's ``question_revision``
+exactly like an inbound ``question.answered`` event does, flags it relayed
+so it never reads as the client's own words, and folds the submission off
+``needs-input``. Same daemon-routed shape (``POST /portal-note`` /
+``POST /portal-answer``) and the same reason.
 """
 
 from __future__ import annotations
@@ -1792,6 +1801,25 @@ def portal_draft_reject(
 # it's set).
 
 
+def _render_answer_line(a: dict, *, indent: str) -> str:
+    """One rendered answer line — plain when it's the client's own words,
+    visibly RELAYED (source + date + operator actor) when it isn't (#2986's
+    acceptance bar: a relayed answer must never be presentable as something
+    the client typed themselves). ``.get`` throughout because a thin client
+    talking to a daemon that predates #2986 returns a payload with neither
+    key."""
+    if not a.get("relayed"):
+        return f"{indent}A: {a['text']}  (by {a['actor'] or 'customer'})"
+    when = datetime.datetime.fromtimestamp(
+        a["recorded_at"], tz=datetime.timezone.utc
+    ).strftime("%Y-%m-%d %H:%M UTC")
+    source = a.get("source") or "unknown"
+    return (
+        f"{indent}A [RELAYED via {source}, {when}, by {a['actor'] or 'operator'}]: "
+        f"{a['text']}"
+    )
+
+
 def _render_ledger_text(payload: dict) -> str:
     """The human-readable rendering of :func:`coord.portal_store.
     render_ledger_payload`'s dict shape — used identically whether *payload*
@@ -1807,12 +1835,13 @@ def _render_ledger_text(payload: dict) -> str:
         lines.append(f"- Q[{label}] {entry['question']}")
         if entry["answers"]:
             for a in entry["answers"]:
-                lines.append(f"    A: {a['text']}  (by {a['actor'] or 'customer'})")
+                lines.append(_render_answer_line(a, indent="    "))
         else:
             lines.append("    (unanswered — needs-input)")
     for a in unpaired:
+        tag = " RELAYED" if a.get("relayed") else ""
         lines.append(
-            f"- A (unpaired, question_revision={a['question_revision']}): "
+            f"- A{tag} (unpaired, question_revision={a['question_revision']}): "
             f"{a['text']}  (by {a['actor'] or 'customer'})"
         )
 
@@ -1995,3 +2024,90 @@ def portal_decision_supersede(submission_id: str, seq: int, by_seq: int) -> None
     click.secho(
         f"superseded: {submission_id} #{entry.seq} -> #{by_seq}", fg="green"
     )
+
+
+# ── #2986: `coord portal answer` — record an out-of-band answer ────────────
+
+
+@portal_group.command("answer")
+@_CONFIG_OPTION
+@click.argument("submission_id")
+@click.argument("text")
+@click.option(
+    "--source",
+    type=click.Choice(("verbal", "phone", "email")),
+    default="verbal",
+    show_default=True,
+    help="How the answer actually reached you.",
+)
+@click.option(
+    "--revision",
+    "revision",
+    type=int,
+    default=None,
+    help=(
+        "Target an older question's revision instead of the current open "
+        "one — backfills a question answered before this command existed."
+    ),
+)
+def portal_answer(
+    config_path, submission_id: str, text: str, source: str, revision: int | None
+) -> None:
+    """Record an answer SUBMISSION_ID's client gave OUT OF BAND — in
+    person, on a call, by email (#2986).
+
+    The ledger's own writer, ``coord/portal_sync.py:_record_question_
+    answer``, only ever fires off an inbound ``question.answered`` event —
+    so an answer that arrives any other way had nowhere to land as an
+    ANSWER, and the ledger kept rendering the question ``(unanswered —
+    needs-input)`` long after it was actually answered. This pairs TEXT to
+    the same open question (by ``question_revision``) that consumer pairs
+    to, flags it as relayed (never presentable as the client's own words —
+    see ``coord portal ledger``'s rendering), and nudges the submission off
+    ``needs-input`` the same way the inbound consumer does.
+
+    With no ``--revision``, targets whatever question is currently open. A
+    submission with no open question (everything already answered, or no
+    question ever pushed) is a clear error — pass ``--revision`` to backfill
+    an older, already-superseded question instead (SUB-1EA1D3's Q[11], asked
+    alongside Q[13] and answered before Q[13] was).
+
+    Like ``note``/``decision``/``link`` (#2751) this is not thin-client-
+    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.
+    """
+    from coord import portal_store  # noqa: PLC0415
+    from coord.board_service import resolve  # noqa: PLC0415
+
+    # Config is only needed for the "leave needs-input" fold nudge, and only
+    # when THIS process is the one that will actually run it — i.e. it is
+    # not a thin client (a thin client's write routes through
+    # `/portal-answer`, and the daemon folds status there with its OWN
+    # config; see `coord.serve_app`'s handler). Loading it unconditionally
+    # would cost a thin client an extra `fetch_remote_config` round trip for
+    # a value it would never use. Best-effort either way — a config that
+    # fails to resolve degrades to no fold nudge, same as passing `None`.
+    config = None
+    if resolve() is None:
+        try:
+            config = _load_config(config_path)
+        except Exception:  # noqa: BLE001 — the nudge is best-effort, not this command
+            config = None
+    try:
+        entry = portal_store.answer_question(
+            submission_id,
+            text,
+            source=source,
+            revision=revision,
+            actor=_actor(),
+            config=config,
+        )
+    except ValueError as exc:
+        click.secho(f"error: {exc}", fg="red")
+        raise SystemExit(2) from exc
+    click.secho(
+        f"answered: {submission_id} Q[{entry.question_revision}] via {source} "
+        f"(by {entry.actor}) — {entry.text}",
+        fg="green",
+    )

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

@@ -1775,13 +1775,27 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
     error raised for a duplicate column (SQLite's ``OperationalError``;
     Postgres's equivalent under ``sql.driver_errors()``, #2784) is silently
     swallowed.
+
+    #2982: Postgres aborts the whole transaction on a failed statement, so
+    without a ``conn.rollback()`` here the *first* duplicate ALTER (every
+    entry in ``_MIGRATE_ADD_COLUMNS`` is one, against a freshly-created
+    schema) leaves the connection unusable -- every statement after it,
+    including the remaining ALTERs and ``_set_schema_version``'s own
+    ``DELETE FROM schema_version``, fails with
+    ``psycopg.errors.InFailedSqlTransaction``. SQLite has no such concept
+    (a failed statement there doesn't touch the transaction), so the
+    rollback is a no-op on that backend -- and by this point in
+    ``_ensure_schema`` there is nothing uncommitted to lose on either
+    backend: the schema script already committed, and each successful ALTER
+    in this loop commits immediately, so a rollback can only ever discard
+    the one statement that just failed.
     """
     for ddl in _MIGRATE_ADD_COLUMNS:
         try:
             sql.execute(conn, ddl)
             conn.commit()
         except sql.driver_errors():
-            pass  # Column already exists
+            conn.rollback()  # Column already exists; Postgres needs the tx cleared
 
 
 # ── JSON migration ─────────────────────────────────────────────────────────────

{code_coordinator-0.5.318 → code_coordinator-0.5.320}/coord/decomposition_chat.py

@@ -37,6 +37,7 @@ posture every other dispatcher in this file already uses.
 """
 from __future__ import annotations
 
+import datetime
 import time
 import uuid
 from typing import TYPE_CHECKING, Any
@@ -271,6 +272,34 @@ def fetch_running_context(submission_id: str) -> dict[str, Any]:
     return portal_store.render_ledger_payload(submission_id)
 
 
+def _render_answer_line(a: dict[str, Any]) -> str:
+    """One rendered answer line — mirrors :func:`coord.commands.portal.
+    _render_answer_line` exactly (kept as a separate copy since the two
+    modules render different surrounding structure — a plain-text agent
+    briefing here, ``coord portal ledger``'s CLI output there).
+
+    #2986: a relayed (out-of-band) answer must never read as something the
+    client typed themselves — a session briefed from this text has no other
+    way to tell the difference, so the RELAYED tag, its source, and when it
+    was recorded are load-bearing here, not cosmetic. ``.get`` throughout
+    because a thin client's daemon may predate #2986 and never sets either
+    key."""
+    if not a.get("relayed"):
+        return f"A: {a.get('text', '')}  (by {a.get('actor') or 'customer'})"
+    recorded_at = a.get("recorded_at")
+    when = (
+        datetime.datetime.fromtimestamp(recorded_at, tz=datetime.timezone.utc)
+        .strftime("%Y-%m-%d %H:%M UTC")
+        if recorded_at
+        else "unknown date"
+    )
+    source = a.get("source") or "unknown"
+    return (
+        f"A [RELAYED via {source}, {when}, by {a.get('actor') or 'operator'}]: "
+        f"{a.get('text', '')}"
+    )
+
+
 def render_running_context_section(payload: dict[str, Any]) -> str:
     """Render *payload* (:func:`fetch_running_context`'s shape) as the
     briefing's RUNNING CONTEXT section — every question asked and its
@@ -295,14 +324,13 @@ def render_running_context_section(payload: dict[str, Any]) -> str:
         answers = entry.get("answers") or []
         if answers:
             for a in answers:
-                lines.append(
-                    f"      A: {a.get('text', '')}  (by {a.get('actor') or 'customer'})"
-                )
+                lines.append(f"      {_render_answer_line(a)}")
         else:
             lines.append("      (unanswered — needs-input)")
     for a in unpaired:
+        tag = " RELAYED" if a.get("relayed") else ""
         lines.append(
-            f"  - A (unpaired, question_revision={a.get('question_revision')}): "
+            f"  - A{tag} (unpaired, question_revision={a.get('question_revision')}): "
             f"{a.get('text', '')}  (by {a.get('actor') or 'customer'})"
         )
 

{code_coordinator-0.5.318 → code_coordinator-0.5.320}/coord/portal_store.py

@@ -39,6 +39,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+import logging
 import sqlite3
 import time
 from dataclasses import dataclass
@@ -46,6 +47,8 @@ from typing import Any, Mapping
 
 from coord import sql
 
+_log = logging.getLogger(__name__)
+
 #: A DB-API row as the three ``_*_from_row`` helpers below need it: index by
 #: column name (``row["col"]``). ``sqlite3.Row`` and psycopg's ``dict_row``
 #: rows (plain ``dict``s) both satisfy this, so the helpers name neither
@@ -1756,6 +1759,16 @@ LEDGER_KIND_OPERATOR_NOTE = "operator_note"
 #: the client actually wrote. See :func:`operator_actor`.
 OPERATOR_ACTOR_PREFIX = "operator:"
 
+#: #2986: how an out-of-band answer actually reached the operator —
+#: ``coord portal answer --source``. Recorded in the ledger row's
+#: ``payload`` (``{"relayed": True, "source": ...}``) so a renderer can
+#: attribute it as relayed rather than presenting it as the client's own
+#: words (this issue's acceptance bar). "verbal" (in person or a call the
+#: operator wasn't dialing in from, i.e. no better label applies) is the
+#: default — the common case for a small engagement.
+RELAYED_ANSWER_SOURCES = ("verbal", "phone", "email")
+DEFAULT_RELAYED_ANSWER_SOURCE = "verbal"
+
 
 def operator_actor(name: str = "") -> str:
     """The ``actor`` string for an operator-authored ledger row.
@@ -1981,6 +1994,198 @@ def append_operator_note(
     return _append_operator_note_local(submission_id, text, actor=actor, now=now)
 
 
+# ── layer 1b: relayed answers (#2986) ────────────────────────────────────────
+#
+# The one write path this issue adds: an answer the operator received OUT OF
+# BAND — in person, on a call, by email — and needs paired to the question's
+# own ``question_revision`` exactly the way an inbound ``question.answered``
+# event already is (:func:`coord.portal_sync._record_question_answer`). Still
+# ledger-class (see this section's ownership note above): a human relaying
+# what the customer told them is coord-observed the same way an operator note
+# (#2867) is, not an agent's say-so. Unlike a note, this DOES pair to a
+# question and DOES nudge the submission off ``needs-input`` — the two things
+# `note` deliberately does not do (see `append_operator_note`'s docstring).
+
+
+def _current_open_question_revision(submission_id: str) -> int | None:
+    """The most recently pushed question for *submission_id* that has no
+    ledgered answer yet, or ``None`` if every pushed question already has
+    one (or none has ever been pushed).
+
+    Mirrors the pairing :func:`render_ledger_payload` does for display —
+    keyed on ``question_revision``, oldest push first — but only needs the
+    "still open" half, not the full answers list.
+    """
+    pushed_revisions: list[int | None] = []
+    answered_revisions: set[int | None] = set()
+    for entry in ledger_for_submission(submission_id):
+        if entry.kind == LEDGER_KIND_QUESTION_PUSHED:
+            pushed_revisions.append(entry.question_revision)
+        elif entry.kind == LEDGER_KIND_QUESTION_ANSWERED:
+            answered_revisions.add(entry.question_revision)
+    open_revisions = [r for r in pushed_revisions if r not in answered_revisions]
+    if not open_revisions:
+        return None
+    return open_revisions[-1]
+
+
+def _fold_status_after_answer(config: Any, submission_id: str) -> None:
+    """Best-effort nudge off ``needs-input`` after a relayed answer lands
+    (#2986) — the same courtesy :func:`coord.portal_sync._record_question_
+    answer` performs for an inbound ``question.answered`` event, so an
+    out-of-band answer leaves ``needs-input`` on the same tick as the write
+    rather than waiting on the next unconditional status fold.
+
+    Never raises: a courtesy nudge, not the recorded fact itself. ``config``
+    is optional the same way :func:`coord.portal_sync._record_question_
+    answer`'s is — the CLI-local path always has one, but a test exercising
+    just the ledger write can omit it and get a no-op here instead of an
+    import-time failure.
+    """
+    if config is None:
+        return
+    try:
+        from coord import portal_sync  # noqa: PLC0415
+
+        link = get_link_by_submission(submission_id)
+        if link is None:
+            return
+        repo_cfg = config.repo(link.repo_name)
+        if repo_cfg is None:
+            return
+        if link.issue_number is not None:
+            portal_sync.fold_status_for_issue(config, link.repo_name, link.issue_number)
+        else:
+            portal_sync.fold_status_for_milestone(
+                config, link.repo_name, link.milestone_number
+            )
+    except Exception:  # noqa: BLE001 — a courtesy nudge, not the recorded fact itself
+        _log.warning(
+            "portal answer: could not fold status after relayed answer for %s",
+            submission_id,
+            exc_info=True,
+        )
+
+
+def _answer_question_local(
+    submission_id: str,
+    text: str,
+    *,
+    source: str = DEFAULT_RELAYED_ANSWER_SOURCE,
+    revision: int | None = None,
+    actor: str = "",
+    config: Any = None,
+    now: float | None = None,
+) -> LedgerEntry:
+    """Write half of :func:`answer_question` — runs on the daemon host
+    (either directly, or via ``/portal-answer`` on behalf of a thin client).
+
+    Same "validate the submission HERE" reasoning as
+    :func:`_append_operator_note_local`. ``revision=None`` targets whatever
+    :func:`_current_open_question_revision` currently considers open;
+    passing an explicit ``revision`` backfills an older, already-superseded
+    question (SUB-1EA1D3's Q[11] fixture case, #2986) and skips that lookup
+    entirely — even a revision with no matching pushed question is still
+    ledgered (it lands in ``unpaired_answers``, same tolerance
+    :func:`coord.portal_sync._record_question_answer` already has for a
+    malformed inbound event).
+    """
+    if not submission_id or not submission_id.strip():
+        raise ValueError("answer needs a submission_id")
+    if not text or not text.strip():
+        raise ValueError("answer needs non-empty text")
+    if get_submission(submission_id) is None:
+        raise ValueError(
+            f"unknown submission {submission_id!r} — no portal submission with "
+            "that id (check `coord portal status` for the current ids)"
+        )
+    src = (source or DEFAULT_RELAYED_ANSWER_SOURCE).strip().lower()
+    if src not in RELAYED_ANSWER_SOURCES:
+        raise ValueError(
+            f"unknown --source {source!r} — choose one of "
+            f"{', '.join(RELAYED_ANSWER_SOURCES)}"
+        )
+    target_revision = revision
+    if target_revision is None:
+        target_revision = _current_open_question_revision(submission_id)
+        if target_revision is None:
+            raise ValueError(
+                f"no open question on file for {submission_id!r} — nothing to "
+                "answer (pass --revision to backfill an older question)"
+            )
+    entry = append_ledger_entry(
+        submission_id,
+        LEDGER_KIND_QUESTION_ANSWERED,
+        question_revision=target_revision,
+        text=text.strip(),
+        actor=operator_actor(actor),
+        payload={"relayed": True, "source": src},
+        now=now,
+    )
+    _fold_status_after_answer(config, submission_id)
+    return entry
+
+
+def _route_answer(payload: dict[str, Any]) -> dict[str, Any] | None:
+    """POST *payload* to the daemon's ``/portal-answer`` seam, or ``None`` if
+    this process IS the daemon host — the relayed-answer twin of
+    :func:`_route_note`, daemon-routed for the same #2751 reason: the
+    operator relaying an out-of-band answer may be sitting at any machine in
+    the fleet, and a write into a thin client's own empty ``portal_ledger``
+    would be silently lost.
+    """
+    from coord import board_service  # noqa: PLC0415
+
+    svc = board_service.resolve()
+    return board_service.route_write(svc, "/portal-answer", payload)
+
+
+def answer_question(
+    submission_id: str,
+    text: str,
+    *,
+    source: str = DEFAULT_RELAYED_ANSWER_SOURCE,
+    revision: int | None = None,
+    actor: str = "",
+    config: Any = None,
+    now: float | None = None,
+) -> LedgerEntry:
+    """Record an answer the operator received OUT OF BAND (#2986) —
+    ``coord portal answer`` — routed to the daemon when ``board_service`` is
+    configured, else written (and folded) locally.
+
+    Raises :class:`ValueError` for an unknown submission, empty text, an
+    unknown ``source``, or (with no ``revision`` given) no open question on
+    file. The stored text is VERBATIM and flagged ``relayed`` in the ledger
+    row's payload, never presentable as the client's own words (see
+    :func:`render_ledger_payload`'s ``qa[*]["answers"][*]["relayed"]``). A
+    later inbound ``question.answered`` for the same revision
+    (:func:`coord.portal_sync._record_question_answer`) is additive, not a
+    conflict: the ledger is append-only, so both rows coexist under the same
+    ``question_revision`` in the order they were recorded.
+    """
+    routed = _route_answer(
+        {
+            "submission_id": submission_id,
+            "text": text,
+            "source": source,
+            "revision": revision,
+            "actor": actor,
+        }
+    )
+    if routed is not None:
+        return _ledger_from_row(routed["entry"])
+    return _answer_question_local(
+        submission_id,
+        text,
+        source=source,
+        revision=revision,
+        actor=actor,
+        config=config,
+        now=now,
+    )
+
+
 # ── layer 2: decisions (agent-authored, operator-confirmed) ─────────────────
 
 DECISION_PROPOSED = "proposed"
@@ -2356,7 +2561,18 @@ def render_ledger_payload(submission_id: str) -> dict[str, Any]:
                 "question_revision": revision,
                 "question": qa["question"].text,
                 "answers": [
-                    {"text": a.text, "actor": a.actor, "recorded_at": a.recorded_at}
+                    {
+                        "text": a.text,
+                        "actor": a.actor,
+                        "recorded_at": a.recorded_at,
+                        # #2986: attribution for an out-of-band answer — set
+                        # only by `answer_question`/`coord portal answer`, so
+                        # a renderer can tell "the client's own words" from
+                        # "the operator relayed this" rather than the two
+                        # looking identical.
+                        "relayed": bool(a.payload.get("relayed")),
+                        "source": a.payload.get("source", ""),
+                    }
                     for a in qa["answers"]
                 ],
             }
@@ -2368,6 +2584,8 @@ def render_ledger_payload(submission_id: str) -> dict[str, Any]:
                 "text": a.text,
                 "actor": a.actor,
                 "recorded_at": a.recorded_at,
+                "relayed": bool(a.payload.get("relayed")),
+                "source": a.payload.get("source", ""),
             }
             for a in unpaired_answers
         ],

{code_coordinator-0.5.318 → code_coordinator-0.5.320}/coord/serve_app.py

@@ -3419,6 +3419,53 @@ def openapi_spec() -> dict:
                 },
             },
         },
+        "/portal-answer": {
+            "post": {
+                "summary": (
+                    "#2986: record an answer received OUT OF BAND (verbal/"
+                    "phone/email) against a submission's open question, "
+                    "paired to its question_revision and flagged relayed. "
+                    "Executed HERE on the daemon, same reason /portal-note "
+                    "is — `coord portal answer`"
+                ),
+                "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": (
+                                            "Backfill an older question instead "
+                                            "of the current open one."
+                                        ),
+                                    },
+                                    "actor": {"type": "string"},
+                                },
+                                "required": ["submission_id", "text"],
+                            }
+                        }
+                    },
+                },
+                "responses": {
+                    "200": {"description": "OK — {'entry': <serialized LedgerEntry>}"},
+                    "400": {
+                        "description": (
+                            "Missing submission_id, empty text, unknown source, "
+                            "unknown submission, or no open question on file"
+                        )
+                    },
+                },
+            },
+        },
         "/portal-ledger": {
             "get": {
                 "summary": (
@@ -6459,6 +6506,69 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
             }
         )
 
+    async def post_portal_answer(request: Request) -> Response:
+        # #2986: record an out-of-band answer (verbal/phone/email) against a
+        # submission's open question. Same seam shape and same rationale as
+        # `/portal-note`/`/portal-decision` right above — the operator may be
+        # relaying this from any machine in the fleet — but unlike a note,
+        # this pairs to a question's own `question_revision` and folds the
+        # customer status off `needs-input` HERE, on the daemon, using this
+        # process's own `config` (the closure variable `build_app` sets up
+        # and `_refresh_config` keeps current) rather than anything the
+        # caller could hand over the wire.
+        import json as _json  # noqa: PLC0415
+
+        from coord import portal_store  # noqa: PLC0415
+
+        body = await _read_json(request)
+        if body is None:
+            return JSONResponse({"error": "invalid JSON body"}, status_code=400)
+        submission_id = body.get("submission_id")
+        if not isinstance(submission_id, str) or not submission_id:
+            return JSONResponse(
+                {"error": "portal-answer needs a 'submission_id'"}, status_code=400
+            )
+        revision = body.get("revision")
+        if revision is not None and not isinstance(revision, int):
+            return JSONResponse(
+                {"error": "portal-answer 'revision' must be an integer"},
+                status_code=400,
+            )
+        try:
+            entry = portal_store._answer_question_local(
+                submission_id,
+                body.get("text") or "",
+                source=body.get("source") or portal_store.DEFAULT_RELAYED_ANSWER_SOURCE,
+                revision=revision,
+                actor=body.get("actor") or "",
+                config=config,
+            )
+        except ValueError as e:
+            return JSONResponse({"error": f"bad portal-answer: {e}"}, status_code=400)
+        except Exception as e:  # noqa: BLE001
+            return JSONResponse(
+                {"error": "portal-answer write failed", "detail": str(e)},
+                status_code=503,
+            )
+        return JSONResponse(
+            {
+                "entry": {
+                    "id": entry.id,
+                    "submission_id": entry.submission_id,
+                    "seq": entry.seq,
+                    "kind": entry.kind,
+                    "question_revision": entry.question_revision,
+                    "text": entry.text,
+                    "actor": entry.actor,
+                    "source_event_id": entry.source_event_id,
+                    # Same reconstruction contract as `/portal-note` above —
+                    # `_ledger_from_row` parses this as a JSON *string*.
+                    "payload_json": _json.dumps(entry.payload, sort_keys=True),
+                    "recorded_at": entry.recorded_at,
+                }
+            }
+        )
+
     async def get_portal_ledger(request: Request) -> Response:
         # #2749 (IL-3): render one submission's running-context briefing on
         # the daemon and hand back the same JSON shape
@@ -9795,6 +9905,7 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
         Route("/portal-link", post_portal_link, methods=["POST"]),
         Route("/portal-decision", post_portal_decision, methods=["POST"]),
         Route("/portal-note", post_portal_note, methods=["POST"]),
+        Route("/portal-answer", post_portal_answer, methods=["POST"]),
         Route("/portal-ledger", get_portal_ledger, methods=["GET"]),
         Route("/dispatched", post_dispatched, methods=["POST"]),
         Route("/test-verdict", post_test_verdict, methods=["POST"]),