code-coordinator 0.5.289__tar.gz → 0.5.290__tar.gz

{code_coordinator-0.5.289 → code_coordinator-0.5.290}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.289",
+  "tag": "0.5.290",
   "distance": 0,
-  "node": "ga013df1e45f8ba2ece0ba26be923f8a107dbe654",
+  "node": "gd9ef2036c79e6b93ba2c92ee4c1a1756d509370f",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-29"

{code_coordinator-0.5.289 → code_coordinator-0.5.290}/coord/agent.py

@@ -4139,6 +4139,82 @@ and report back what you asked/proposed/filed/queued/linked (and any gap) \
 when done.\
 """
 
+# #2867: the ATTENDED posture. Appended to (never merged into)
+# DECOMPOSITION_CHAT_SYSTEM_PROMPT by `coord portal decompose-chat
+# --interactive` only — the headless dispatch
+# (`default_worker_command`'s `spec.type == "decomposition-chat"` branch)
+# must keep receiving the base prompt byte-for-byte, because it genuinely
+# has nobody to ask and its one-turn fire-and-forget shape is correct there.
+#
+# WHY this exists at all: #2750 shipped `--interactive` reusing the headless
+# prompt verbatim, so the attended session was written for an agent with
+# nobody to ask ("THIS iteration ends in EXACTLY ONE of three terminal
+# moves", each a command to run) and duly read the ledger, chose ASK, and
+# ran `enqueue-question` in the SAME turn — its whole output to the human
+# sitting there was a report of what it had already done. On a paid client
+# engagement where a round-trip takes days, that spent a day on questions
+# the operator may already have had answers to. The base prompt's
+# "summarize your plan before writing anything" was not enough: nothing
+# made it a STOP, and without a turn boundary a compliant session still
+# writes.
+DECOMPOSITION_CHAT_ATTENDED_ADDENDUM = """\
+
+── ATTENDED SESSION (`--interactive`) — OVERRIDES THE ABOVE ──
+
+An operator is sitting at this terminal RIGHT NOW, watching you type. That \
+changes the shape of this iteration, and where this section conflicts with \
+anything above, THIS SECTION WINS.
+
+**YOUR FIRST TURN WRITES NOTHING.** Not `coord portal enqueue-question`, not \
+`coord portal enqueue-status`, not `coord portal decision propose/reject/\
+supersede`, not `coord issue create`, not `coord milestone create`, not \
+`coord drive-queue add`, not `coord portal link`, not `coord issue edit`. \
+Read-only commands (`coord portal ledger`, `gh issue view`, reading files) \
+are fine and expected. The "EXACTLY ONE of three terminal moves" rule above \
+still decides WHICH exit this iteration takes — it just does not get to \
+happen until the operator has answered you.
+
+So your first turn is:
+
+1. State your READ — the MODE line verbatim (as always), then what RUNNING \
+CONTEXT already tells you, explicitly including any operator-supplied \
+background recorded there.
+2. State your PROPOSED EXIT — which of Ask / Propose / Decompose you intend, \
+the exact command(s) you would run (question text, decision text, issue \
+titles), and WHY that exit and not the other two.
+3. State what you are ASSUMING or MISSING — above all, anything you were \
+about to ask the CLIENT that the OPERATOR may simply know. The operator may \
+have spoken to the client since the last iteration; a client round-trip \
+costs days and an operator answer costs one line, so ask the human in front \
+of you FIRST.
+4. END YOUR TURN AND WAIT. Do not narrate a plan and then execute it in the \
+same turn — the turn boundary IS the confirmation.
+
+Then act on what the operator says: carry out the exit as proposed, or the \
+revised one they steer you to. If they confirm with no changes, run the \
+commands exactly as you stated them and report back. If they redirect you \
+into a different exit, take that one — it is still exactly one terminal \
+move per iteration.
+
+**Recording what the operator tells you.** Background the operator relays \
+("I spoke to her — it's just the two of them, and the calendar is a \
+nice-to-have") is durable, ledger-class context that every FUTURE session on \
+every machine should see. It is not a decision, so do NOT push it through \
+`coord portal decision propose`. Record it verbatim with:
+
+    coord portal note <submission_id> "<what the operator told you>"
+
+This is an ADDITIONAL write path you are permitted, on top of the ones the \
+Rules section above enumerates — and, being a write, it is also subject to \
+the first-turn rule: offer it, then record it once the operator agrees. \
+OFFER IT PROACTIVELY: the operator should not have to know this command \
+exists. Any time the operator gives you a substantive fact about the \
+client, the users, or the scope, say back what you would record and ask \
+whether to record it. Keep the wording theirs, not your paraphrase — the \
+ledger is verbatim by design, and the narrative (which is regenerable) is \
+where summarizing belongs.\
+"""
+
 # Deny list applied to decomposition-chat workers (#2533; extended #2750
 # IL-4 for the ask/propose/decompose intake loop). Unlike milestone-chat,
 # this type's WHOLE job is to write (issue create / issue edit / milestone

{code_coordinator-0.5.289 → code_coordinator-0.5.290}/coord/commands/portal.py

@@ -596,6 +596,7 @@ def _run_decompose_chat_interactive(
 
     from coord.agent import (  # noqa: PLC0415
         AssignmentSpec as _AssignmentSpecDc,
+        DECOMPOSITION_CHAT_ATTENDED_ADDENDUM,
         DECOMPOSITION_CHAT_DENY_COMMANDS,
         DECOMPOSITION_CHAT_SYSTEM_PROMPT,
         build_deny_prompt,
@@ -664,7 +665,8 @@ def _run_decompose_chat_interactive(
     if _board_service.resolve() is not None:
         click.secho(
             "note: this machine is a thin client — `coord portal decision`/"
-            "`ledger`/`link` route through the daemon (#2751), but `coord "
+            "`ledger`/`link`/`note` route through the daemon (#2751/#2867), "
+            "but `coord "
             "portal enqueue-question`/`enqueue-status` (the Ask move) do "
             "not yet and will refuse loudly if this iteration needs them. "
             "ssh to the daemon host for that case (#2750's own stated "
@@ -699,7 +701,9 @@ def _run_decompose_chat_interactive(
         f"Intake session for portal submission {submission_id} "
         f"(MODE: {mode_word} — {discuss_reason}): read the full context at "
         f"{brief_path} (submission fields, repo topology, and the running-"
-        "context ledger so far) and let's work through it."
+        "context ledger so far) and let's work through it. This is an "
+        "ATTENDED session: state your read and your PROPOSED exit, then stop "
+        "and wait for me — write nothing until I answer (#2867)."
     )
 
     spec = _AssignmentSpecDc(
@@ -719,15 +723,22 @@ def _run_decompose_chat_interactive(
     # internal branch table has no `"decomposition-chat"` case, so leaving
     # it implicit would silently fall through to the generic work-shaped
     # branch (full WORKER_SYSTEM_PROMPT + Edit/Write/Monitor), which is
-    # wrong for a no-worktree chat type. Passing these explicitly keeps
-    # this session byte-identical, on the system prompt, to the headless
-    # dispatch path (`coord.agent.default_worker_command`'s own
-    # `spec.type == "decomposition-chat"` branch).
+    # wrong for a no-worktree chat type.
+    #
+    # #2867: the attended addendum is appended HERE and only here — the
+    # headless dispatch path (`coord.agent.default_worker_command`'s own
+    # `spec.type == "decomposition-chat"` branch) keeps the base prompt
+    # byte-for-byte, so its one-turn fire-and-forget behaviour is unchanged.
+    # This session, by contrast, has a human in the pane: the addendum makes
+    # its first turn confirm-then-write (#2742's absorbed half, which #2750
+    # only ever wired into mode SELECTION, never into the posture itself).
     argv = provider.build_command(
         spec,
         resolved_model=resolved_model,
-        system_prompt=DECOMPOSITION_CHAT_SYSTEM_PROMPT + build_deny_prompt(
-            DECOMPOSITION_CHAT_DENY_COMMANDS
+        system_prompt=(
+            DECOMPOSITION_CHAT_SYSTEM_PROMPT
+            + DECOMPOSITION_CHAT_ATTENDED_ADDENDUM
+            + build_deny_prompt(DECOMPOSITION_CHAT_DENY_COMMANDS)
         ),
         allowed_tools="Read,Bash",
     )
@@ -1805,6 +1816,16 @@ def _render_ledger_text(payload: dict) -> str:
             f"{a['text']}  (by {a['actor'] or 'customer'})"
         )
 
+    # #2867: verbatim, attributed, in ledger seq order — its own heading so
+    # a later session can tell operator-relayed background from something
+    # the client actually wrote on the portal. `.get` (not `[...]`) because
+    # a thin client may be talking to a daemon that predates this key.
+    notes = payload.get("operator_notes") or []
+    if notes:
+        lines += ["", "## Operator notes"]
+        for n in notes:
+            lines.append(f"- [{n['seq']}] {n['text']}  (by {n['actor'] or 'operator'})")
+
     lines += ["", "## Decisions"]
     current = payload["decisions"]
     if not current:
@@ -1861,6 +1882,39 @@ def portal_ledger(submission_id: str, as_json: bool) -> None:
     click.echo(_render_ledger_text(payload))
 
 
+@portal_group.command("note")
+@click.argument("submission_id")
+@click.argument("text")
+def portal_note(submission_id: str, text: str) -> None:
+    """Record operator-supplied background about SUBMISSION_ID (#2867).
+
+    The ledger layer that holds what the OPERATOR knows — "spoke to the
+    client: household of two, no logins needed" — which before this had
+    nowhere durable to live and died with the tmux pane it was typed into.
+    Stored verbatim on the ledger, attributed to you, and rendered into
+    every future session's RUNNING CONTEXT on any machine.
+
+    Deliberately NOT `coord portal decision propose`: a relayed fact is not
+    a judgment call, has no proposed/confirmed lifecycle, and does not
+    belong in the decision archive.
+
+    Like `decision` and `link` (#2751) this is not thin-client-refused — it
+    routes through the daemon's `/portal-note` seam when `board_service` is
+    configured, so it works from wherever the operator happens to be.
+    """
+    from coord import portal_store  # noqa: PLC0415
+
+    try:
+        entry = portal_store.append_operator_note(submission_id, text, actor=_actor())
+    except ValueError as exc:
+        click.secho(f"error: {exc}", fg="red")
+        raise SystemExit(2) from exc
+    click.secho(
+        f"noted: {submission_id} #{entry.seq} (by {entry.actor}) — {entry.text}",
+        fg="green",
+    )
+
+
 @portal_group.group("decision")
 def portal_decision_group() -> None:
     """Propose / confirm / reject / supersede a decision (#2749).

{code_coordinator-0.5.289 → code_coordinator-0.5.290}/coord/decomposition_chat.py

@@ -278,6 +278,11 @@ def render_running_context_section(payload: dict[str, Any]) -> str:
     ones carrying why), and the current narrative. This is what lets a
     fresh iteration pick up exactly where the last one left off with no
     memory of the prior session (#2750's "the loop").
+
+    Since #2867 it also renders the ledger's operator-note layer — what a
+    human relayed out of band ("I spoke to her; it's just the two of them")
+    — attributed as operator-supplied so a session can tell it from
+    something the client wrote on the portal itself.
     """
     lines: list[str] = ["RUNNING CONTEXT (from the portal ledger):", "", "Q&A so far:"]
     qa = payload.get("qa") or []
@@ -301,6 +306,22 @@ def render_running_context_section(payload: dict[str, Any]) -> str:
             f"{a.get('text', '')}  (by {a.get('actor') or 'customer'})"
         )
 
+    # #2867: verbatim and attributed, so a session on a different machine
+    # with no shared transcript still sees what the operator was told out of
+    # band. Placed ahead of decisions because it is INPUT to them.
+    notes = payload.get("operator_notes") or []
+    if notes:
+        lines.append("")
+        lines.append(
+            "Operator-supplied background (relayed by a human, NOT written by "
+            "the client on the portal — treat as fact, do not re-ask it):"
+        )
+        for n in notes:
+            lines.append(
+                f"  - [{n.get('seq')}] {n.get('text')}  "
+                f"(by {n.get('actor') or 'operator'})"
+            )
+
     lines.append("")
     lines.append("Current decisions (proposed/confirmed — treat as live guidance):")
     current = payload.get("decisions") or []

{code_coordinator-0.5.289 → code_coordinator-0.5.290}/coord/portal_store.py

@@ -1739,6 +1739,44 @@ LEDGER_KIND_DRAFT_EDITED = "draft_edited"
 LEDGER_KIND_DRAFT_APPROVED = "draft_approved"
 LEDGER_KIND_DRAFT_REJECTED = "draft_rejected"
 
+#: #2867: background the OPERATOR relays — "I spoke to her; it's just the two
+#: of them and the calendar is a nice-to-have." Ledger-class, not
+#: decision-class: it is a FACT someone told the operator, not a judgment
+#: call with a proposed/confirmed lifecycle, so forcing it through
+#: `coord portal decision propose` would both lose the raw statement and
+#: pollute the decision archive. Still coord-observed in the sense this
+#: section's ownership note means — a human typed it at coord's own CLI,
+#: which is not "an agent's say-so about a fact it does not solely observe".
+#: Stored VERBATIM and never folded into the narrative (#2746: "a ledger that
+#: IS a narrative cannot be regenerated — that asymmetry is the design").
+LEDGER_KIND_OPERATOR_NOTE = "operator_note"
+
+#: Marks a ledger ``actor`` as a human at coord's CLI rather than the portal
+#: wire, so a later session can tell operator-relayed context from something
+#: the client actually wrote. See :func:`operator_actor`.
+OPERATOR_ACTOR_PREFIX = "operator:"
+
+
+def operator_actor(name: str = "") -> str:
+    """The ``actor`` string for an operator-authored ledger row.
+
+    ``"jane"`` → ``"operator:jane"``; empty → the bare ``"operator"``. Already
+    prefixed values pass through unchanged, so routing a note through the
+    daemon (which re-normalizes) can't produce ``operator:operator:jane``.
+    """
+    n = (name or "").strip()
+    if not n:
+        return "operator"
+    return n if n.startswith(OPERATOR_ACTOR_PREFIX) else f"{OPERATOR_ACTOR_PREFIX}{n}"
+
+
+def is_operator_actor(actor: str) -> bool:
+    """True when *actor* names a human at coord's CLI (:func:`operator_actor`'s
+    output) rather than the customer or an agent — what the briefing renders
+    attribute notes with."""
+    a = (actor or "").strip()
+    return a == "operator" or a.startswith(OPERATOR_ACTOR_PREFIX)
+
 
 @dataclass(frozen=True)
 class LedgerEntry:
@@ -1870,6 +1908,79 @@ def ledger_for_submission(submission_id: str) -> list[LedgerEntry]:
     return [_ledger_from_row(r) for r in rows]
 
 
+def operator_notes_for_submission(submission_id: str) -> list[LedgerEntry]:
+    """*submission_id*'s operator notes (#2867), oldest first — the ledger
+    rows a human typed, filtered out of :func:`ledger_for_submission`'s full
+    history by kind."""
+    return [
+        e
+        for e in ledger_for_submission(submission_id)
+        if e.kind == LEDGER_KIND_OPERATOR_NOTE
+    ]
+
+
+def _append_operator_note_local(
+    submission_id: str, text: str, *, actor: str = "", now: float | None = None
+) -> LedgerEntry:
+    """Write half of :func:`append_operator_note` — runs on the daemon host
+    (either directly, or via ``/portal-note`` on behalf of a thin client).
+
+    Validates the submission EXISTS here rather than in the CLI: on a thin
+    client the local ``portal_submissions`` table is empty by construction
+    (#2336), so a caller-side check would reject every id. Doing it here
+    means the "unknown submission" error is raised where the real table
+    lives, whichever machine the operator typed the command on.
+    """
+    if not submission_id or not submission_id.strip():
+        raise ValueError("operator note needs a submission_id")
+    if not text or not text.strip():
+        raise ValueError("operator note 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)"
+        )
+    return append_ledger_entry(
+        submission_id,
+        LEDGER_KIND_OPERATOR_NOTE,
+        text=text.strip(),
+        actor=operator_actor(actor),
+        now=now,
+    )
+
+
+def _route_note(payload: dict[str, Any]) -> dict[str, Any] | None:
+    """POST *payload* to the daemon's ``/portal-note`` seam, or ``None`` if
+    this process IS the daemon host — the note-shaped twin of
+    :func:`_route_decision`, and daemon-routed for exactly the same reason
+    (#2751): the operator may be sitting at any machine in the fleet, and a
+    note written into a thin client's own empty DB would be silently lost.
+    """
+    from coord import board_service  # noqa: PLC0415
+
+    svc = board_service.resolve()
+    return board_service.route_write(svc, "/portal-note", payload)
+
+
+def append_operator_note(
+    submission_id: str, text: str, *, actor: str = "", now: float | None = None
+) -> LedgerEntry:
+    """Append one operator-supplied background fact to *submission_id*'s
+    ledger (#2867) — routed to the daemon when ``board_service`` is
+    configured, else written locally.
+
+    Raises :class:`ValueError` for an unknown submission, empty text, or a
+    missing id. The stored text is VERBATIM (stripped of surrounding
+    whitespace only) and is never rewritten into the narrative.
+    """
+    routed = _route_note(
+        {"submission_id": submission_id, "text": text, "actor": actor}
+    )
+    if routed is not None:
+        return _ledger_from_row(routed["entry"])
+    return _append_operator_note_local(submission_id, text, actor=actor, now=now)
+
+
 # ── layer 2: decisions (agent-authored, operator-confirmed) ─────────────────
 
 DECISION_PROPOSED = "proposed"
@@ -2208,6 +2319,11 @@ def render_ledger_payload(submission_id: str) -> dict[str, Any]:
     :func:`coord.portal_sync._record_question_answer` never drops one just
     because it can't be paired) lands in ``unpaired_answers`` instead of
     being silently lost.
+
+    Operator notes (#2867) come back verbatim under their own
+    ``operator_notes`` key, in ledger ``seq`` order — deliberately NOT mixed
+    into ``qa`` (they answer no question) and NOT folded into ``narrative``
+    (they are ledger-class facts, and the narrative is regenerable).
     """
     ledger = ledger_for_submission(submission_id)
     decisions = decisions_for_submission(submission_id)
@@ -2215,8 +2331,11 @@ def render_ledger_payload(submission_id: str) -> dict[str, Any]:
 
     questions: dict[int | None, dict[str, Any]] = {}
     unpaired_answers: list[LedgerEntry] = []
+    operator_notes: list[LedgerEntry] = []
     for entry in ledger:
-        if entry.kind == LEDGER_KIND_QUESTION_PUSHED:
+        if entry.kind == LEDGER_KIND_OPERATOR_NOTE:
+            operator_notes.append(entry)
+        elif entry.kind == LEDGER_KIND_QUESTION_PUSHED:
             questions.setdefault(
                 entry.question_revision, {"question": entry, "answers": []}
             )
@@ -2252,6 +2371,19 @@ def render_ledger_payload(submission_id: str) -> dict[str, Any]:
             }
             for a in unpaired_answers
         ],
+        # #2867: verbatim, in ledger `seq` order (`ledger_for_submission` is
+        # seq-ordered and this list preserves that), carrying the operator
+        # `actor` so every renderer can attribute them rather than letting
+        # them read as something the client said.
+        "operator_notes": [
+            {
+                "seq": n.seq,
+                "text": n.text,
+                "actor": n.actor,
+                "recorded_at": n.recorded_at,
+            }
+            for n in operator_notes
+        ],
         "decisions": [
             {
                 "seq": d.seq,

{code_coordinator-0.5.289 → code_coordinator-0.5.290}/coord/serve_app.py

@@ -3283,6 +3283,41 @@ def openapi_spec() -> dict:
                 },
             },
         },
+        "/portal-note": {
+            "post": {
+                "summary": (
+                    "#2867: append one operator-supplied background fact to a "
+                    "submission's ledger, verbatim — the layer that holds what "
+                    "the OPERATOR knows (e.g. relayed from a phone call). "
+                    "Executed HERE on the daemon, same reason /portal-decision "
+                    "is — `coord portal note`"
+                ),
+                "requestBody": {
+                    "required": True,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "submission_id": {"type": "string"},
+                                    "text": {"type": "string"},
+                                    "actor": {"type": "string"},
+                                },
+                                "required": ["submission_id", "text"],
+                            }
+                        }
+                    },
+                },
+                "responses": {
+                    "200": {"description": "OK — {'entry': <serialized LedgerEntry>}"},
+                    "400": {
+                        "description": (
+                            "Missing submission_id, empty text, or unknown submission"
+                        )
+                    },
+                },
+            },
+        },
         "/portal-ledger": {
             "get": {
                 "summary": (
@@ -6191,6 +6226,60 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
             }
         )
 
+    async def post_portal_note(request: Request) -> Response:
+        # #2867: the ledger's operator-context layer. Same seam shape and
+        # same rationale as `/portal-decision` right above (#2751) — the
+        # operator relaying what a client told them may be sitting at any
+        # machine in the fleet, and a note written into a thin client's own
+        # empty `portal_ledger` would be silently lost. The unknown-
+        # submission check lives in `_append_operator_note_local`, i.e. HERE
+        # where the real `portal_submissions` table is, and surfaces as a
+        # 400 through the same ValueError branch.
+        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-note needs a 'submission_id'"}, status_code=400
+            )
+        try:
+            entry = portal_store._append_operator_note_local(
+                submission_id,
+                body.get("text") or "",
+                actor=body.get("actor") or "",
+            )
+        except ValueError as e:
+            return JSONResponse({"error": f"bad portal-note: {e}"}, status_code=400)
+        except Exception as e:  # noqa: BLE001
+            return JSONResponse(
+                {"error": "portal-note 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,
+                    # `_ledger_from_row` (which the client feeds this dict
+                    # back into) parses this key as a JSON *string*, exactly
+                    # as it comes off a DB row — not as a nested object.
+                    "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
@@ -9482,6 +9571,7 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
         Route("/portal-link", get_portal_link, methods=["GET"]),
         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-ledger", get_portal_ledger, methods=["GET"]),
         Route("/dispatched", post_dispatched, methods=["POST"]),
         Route("/test-verdict", post_test_verdict, methods=["POST"]),

{code_coordinator-0.5.289 → code_coordinator-0.5.290}/tests/test_cli_portal.py

@@ -1775,3 +1775,124 @@ def test_a_configured_ungated_kind_queues_straight_through(tmp_path, monkeypatch
 
     assert [r.seq for r in portal_store.pending_outbox()] == [1, 2]
     assert portal_store.draft_outbox() == []
+
+
+# ── #2867: `coord portal note` — the ledger's operator-context layer ─────────
+
+
+def test_note_is_registered_on_the_portal_group():
+    result = run("portal", "--help")
+    assert result.exit_code == 0
+    assert "note" in result.output
+
+
+def test_note_records_operator_background_verbatim_and_attributed(monkeypatch):
+    """The headline #2867 behaviour: what the operator knows gets a durable
+    home on the ledger, stored exactly as typed and attributed to a human."""
+    from coord import portal_store
+
+    portal_store.seed_revision("sub_1", 1)
+    monkeypatch.setattr("coord.commands.portal._actor", lambda: "jane")
+
+    text = (
+        "Spoke to client 2026-08-28: household of two, no logins needed; "
+        "calendar is a nice-to-have."
+    )
+    result = run("portal", "note", "sub_1", text)
+    assert result.exit_code == 0, result.output
+    assert "noted: sub_1 #1" in result.output
+
+    [entry] = portal_store.operator_notes_for_submission("sub_1")
+    assert entry.text == text  # verbatim — not summarized, not reworded
+    assert entry.actor == "operator:jane"
+    assert entry.kind == portal_store.LEDGER_KIND_OPERATOR_NOTE
+
+
+def test_note_rejects_an_unknown_submission_with_a_clear_error():
+    from coord import portal_store
+
+    result = run("portal", "note", "sub_nope", "background")
+    assert result.exit_code == 2
+    assert "unknown submission" in result.output
+    assert "sub_nope" in result.output
+    assert portal_store.ledger_for_submission("sub_nope") == []
+
+
+def test_note_rejects_empty_text():
+    from coord import portal_store
+
+    portal_store.seed_revision("sub_1", 1)
+    result = run("portal", "note", "sub_1", "   ")
+    assert result.exit_code == 2
+    assert "non-empty" in result.output
+    assert portal_store.ledger_for_submission("sub_1") == []
+
+
+def test_ledger_renders_operator_notes_attributed_and_in_seq_order(monkeypatch):
+    """#2867's acceptance bar for the read side: `coord portal ledger` shows
+    the note verbatim, under its own heading, attributed — and never as a
+    decision."""
+    from coord import portal_store
+
+    portal_store.seed_revision("sub_1", 1)
+    monkeypatch.setattr("coord.commands.portal._actor", lambda: "jane")
+    run("portal", "note", "sub_1", "Household of two.")
+    run("portal", "note", "sub_1", "Calendar is a nice-to-have.")
+
+    result = run("portal", "ledger", "sub_1")
+    assert result.exit_code == 0, result.output
+    assert "## Operator notes" in result.output
+    assert "[1] Household of two.  (by operator:jane)" in result.output
+    assert "[2] Calendar is a nice-to-have.  (by operator:jane)" in result.output
+    # Order is ledger seq order, notes never leak into the Decisions layer.
+    assert result.output.index("Household of two.") < result.output.index(
+        "Calendar is a nice-to-have."
+    )
+    decisions_section = result.output.split("## Decisions", 1)[1]
+    assert "Household of two." not in decisions_section
+
+    as_json = run("portal", "ledger", "sub_1", "--json")
+    assert as_json.exit_code == 0, as_json.output
+    payload = json.loads(as_json.output)
+    assert [n["text"] for n in payload["operator_notes"]] == [
+        "Household of two.",
+        "Calendar is a nice-to-have.",
+    ]
+    assert payload["decisions"] == []
+    assert payload["narrative"] == ""
+
+
+def test_note_routes_through_the_daemon_on_a_thin_client(thin_client, monkeypatch):
+    """Same #2751 exception `decision`/`ledger`/`link` get: the operator may
+    be sitting anywhere in the fleet, so this must POST `/portal-note`
+    rather than write a thin client's own (empty, wrong) local DB."""
+    from coord import client as cc
+
+    calls = []
+
+    def _fake_post_record(svc, path, payload, **kw):
+        calls.append((path, payload))
+        return {
+            "entry": {
+                "id": 1,
+                "submission_id": payload["submission_id"],
+                "seq": 7,
+                "kind": "operator_note",
+                "question_revision": None,
+                "text": payload["text"],
+                "actor": "operator:jane",
+                "source_event_id": None,
+                "payload_json": "{}",
+                "recorded_at": 100.0,
+            }
+        }
+
+    monkeypatch.setattr(cc, "post_record", _fake_post_record)
+
+    result = run("portal", "note", "sub_1", "Client prefers web-only")
+    assert result.exit_code == 0, result.output
+    assert "noted: sub_1 #7" in result.output
+    assert len(calls) == 1
+    assert calls[0][0] == "/portal-note"
+    assert calls[0][1]["submission_id"] == "sub_1"
+    assert calls[0][1]["text"] == "Client prefers web-only"