code-coordinator 0.5.205__tar.gz → 0.5.207__tar.gz

{code_coordinator-0.5.205 → code_coordinator-0.5.207}/PKG-INFO

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

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

@@ -316,6 +316,7 @@ scripts/codegen.py
 scripts/coord-test-runner.sh
 scripts/drive-batch.sh
 scripts/gen_board_fixture.py
+scripts/gen_mock_index.py
 scripts/next_release_tag.py
 scripts/run_tests_in_populated_home.sh
 scripts/run_tests_without_gh.sh
@@ -511,6 +512,7 @@ tests/test_gate_b.py
 tests/test_gate_snapshot_staleness.py
 tests/test_gates.py
 tests/test_gather_fleet_tmux_sessions.py
+tests/test_gen_mock_index.py
 tests/test_generated_types_fixture.py
 tests/test_github_ops.py
 tests/test_goal.py

{code_coordinator-0.5.205 → code_coordinator-0.5.207}/code_coordinator.egg-info/scm_file_list.json

@@ -320,6 +320,7 @@
     "scripts/coord-test-runner.sh",
     "scripts/drive-batch.sh",
     "scripts/gen_board_fixture.py",
+    "scripts/gen_mock_index.py",
     "scripts/next_release_tag.py",
     "scripts/run_tests_in_populated_home.sh",
     "scripts/run_tests_without_gh.sh",
@@ -573,6 +574,7 @@
     "tests/test_gate_snapshot_staleness.py",
     "tests/test_gates.py",
     "tests/test_gather_fleet_tmux_sessions.py",
+    "tests/test_gen_mock_index.py",
     "tests/test_generated_types_fixture.py",
     "tests/test_github_ops.py",
     "tests/test_goal.py",

{code_coordinator-0.5.205 → code_coordinator-0.5.207}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.205",
+  "tag": "0.5.207",
   "distance": 0,
-  "node": "g464b6f72ce8e60436c28ceba3d8453892108cb88",
+  "node": "gc33012740fef085a15f6c4a34f631d39225f18b3",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-21"

{code_coordinator-0.5.205 → code_coordinator-0.5.207}/coord/db.py

@@ -583,13 +583,35 @@ def _ensure_schema(conn: sqlite3.Connection) -> None:
         -- CHECK pins it to one row so "which cursor?" can never be a
         -- question).  `pull_cursor` is opaque to coord — it is whatever the
         -- portal handed back — and is the replay point on daemon restart.
+        --
+        -- `verdict_watermark_at` / `verdict_watermark_rowid` (#2509 review
+        -- fix): the verdict consumer's OWN read position into
+        -- `portal_events`, independent of the shared `handled_at` column.
+        -- `unhandled_events()`/`mark_event_handled()` are shared plumbing —
+        -- this consumer only stamps `handled_at` for a `changes_requested`
+        -- event it actually dispatched, leaving every other kind (a new
+        -- submission, an `approved` verdict, a Q&A answer) NULL by design so
+        -- a future consumer can still read it.  Scanning by `handled_at IS
+        -- NULL` therefore re-returns that growing, never-marked backlog
+        -- ahead of anything newer forever once it exceeds one page — a real
+        -- `changes-requested` event behind it would never surface.  A
+        -- private watermark sidesteps that: it advances past every event
+        -- this consumer has looked at, acted on or not, so a pile of
+        -- non-actionable events cannot block the ones behind it.
+        -- `(received_at, rowid)` mirrors `unhandled_events`'s own tiebreaker
+        -- ordering.
+        -- Both NULL until the first tick with this column runs (an empty
+        -- `~/.coord/coord.db` or one predating this migration), read as
+        -- `(0.0, 0)` — before every real event's `received_at`/`rowid`.
         CREATE TABLE IF NOT EXISTS portal_sync_state (
-            id                INTEGER PRIMARY KEY CHECK (id = 1),
-            pull_cursor       TEXT,
-            last_pull_at      REAL,
-            last_push_at      REAL,
-            last_heartbeat_at REAL,
-            last_error        TEXT NOT NULL DEFAULT ''
+            id                    INTEGER PRIMARY KEY CHECK (id = 1),
+            pull_cursor           TEXT,
+            last_pull_at          REAL,
+            last_push_at          REAL,
+            last_heartbeat_at     REAL,
+            last_error            TEXT NOT NULL DEFAULT '',
+            verdict_watermark_at    REAL,
+            verdict_watermark_rowid INTEGER
         );
 
         CREATE INDEX IF NOT EXISTS idx_assignments_status ON assignments(status);
@@ -942,6 +964,18 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
         # predating this migration, same as the column's own default for a
         # freshly-enqueued entry.
         "ALTER TABLE merge_queue ADD COLUMN ci_fix_dispatches INTEGER NOT NULL DEFAULT 0",
+        # #2509 review fix: the verdict consumer's own read position into
+        # `portal_events` — see the CREATE TABLE comment above for why it
+        # cannot reuse the shared `handled_at` column. NULL (read as
+        # `(0.0, 0)`, before every real event) for every database predating
+        # this migration, which replays the full existing inbox exactly once
+        # on upgrade — safe: re-scanning a non-actionable event is a no-op,
+        # and `_consume_verdicts` skips (never re-dispatches) any event
+        # whose `handled_at` is already set, so an already-consumed
+        # `changes_requested` event from before this migration is walked
+        # past, not re-sent — see `coord.portal_sync._consume_verdicts`.
+        "ALTER TABLE portal_sync_state ADD COLUMN verdict_watermark_at REAL",
+        "ALTER TABLE portal_sync_state ADD COLUMN verdict_watermark_rowid INTEGER",
     ]
     for sql in migrations:
         try:

{code_coordinator-0.5.205 → code_coordinator-0.5.207}/coord/gate_a.py

@@ -224,6 +224,19 @@ def make_record(
     ``verdict`` must be one of :data:`VERDICTS`; anything else is a
     programming error, not an operator error (the CLI's mutually-exclusive
     ``--approved``/``--changes`` flags already reject bad input).
+
+    **Open policy question (#2509, flagged for the operator, not resolved by
+    this call or any caller yet):** should an "approved" verdict on the
+    customer portal auto-call this with ``verdict=VERDICT_APPROVED`` — i.e.
+    does a client's portal sign-off record itself — or does an operator
+    still confirm separately via the existing CLI/TUI path? Today nothing
+    does the former: ``coord.portal_sync._consume_verdicts`` only acts on
+    `changes-requested` (auto-amending the contract) and deliberately leaves
+    `approved` events unconsumed rather than silently picking an answer here.
+    Whichever way this is eventually decided, an auto-recorded call MUST
+    pass ``actor="client via portal"`` (or similarly explicit) — never leave
+    ``actor`` to default such that a client's decision reads as if some
+    coord process made it.
     """
     if verdict not in VERDICTS:
         raise ValueError(f"unknown Gate A verdict {verdict!r}")

{code_coordinator-0.5.205 → code_coordinator-0.5.207}/coord/mock_author.py

@@ -49,6 +49,32 @@ from coord.milestone_dispatch import pick_machine
 from coord.models import Machine, Proposal
 
 
+def _wants_mock_index(driver_mock_glob: str) -> bool:
+    """#2512: the navigation-index post-render step only makes sense for
+    HTML mocks — an `index.html` full of `<a href>`s to `.screen` text-grid
+    dumps (tui-tuidriver) or whatever cli-pytest renders isn't navigable in
+    a browser anyway. Gate on the mock glob rather than the driver name so
+    this stays correct if a future driver also renders `.html`."""
+    return driver_mock_glob.strip().lower().endswith(".html")
+
+
+def _mock_index_instruction(ms_dir: str) -> str:
+    """#2512: the instruction text both briefing builders below hand the
+    mock-author worker, verbatim — a *provided script* the worker runs as
+    its last step before committing, not something it free-hands per
+    milestone (see `scripts/gen_mock_index.py`'s docstring for why: every
+    Gate-A mock set should look the same, and nothing should drift by
+    taste)."""
+    return (
+        f"As your LAST step before committing, run `python "
+        f"scripts/gen_mock_index.py {ms_dir}/mocks` to (re)generate "
+        f"`{ms_dir}/mocks/index.html` — a plain navigation page linking "
+        "every mock by its own `<title>` tag (#2512). Do not hand-write "
+        "this file yourself; the script is the single source of truth so "
+        "every milestone's mock set gets the same glue page."
+    )
+
+
 def build_mock_author_briefing(
     *,
     repo_slug: str,
@@ -94,6 +120,8 @@ def build_mock_author_briefing(
         "not authoring it from scratch — read it first and edit in place. "
         "Commit and push both to this branch when done."
     )
+    if _wants_mock_index(driver_mock_glob):
+        parts.append(_mock_index_instruction(ms_dir))
     return "\n".join(parts)
 
 
@@ -104,6 +132,7 @@ def build_mock_author_amend_briefing(
     milestone_number: int,
     tracking_issue_number: int,
     amend_text: str,
+    driver_mock_glob: str,
 ) -> str:
     """#1315: seed briefing for a *targeted* Gate-A contract amendment.
 
@@ -120,6 +149,15 @@ def build_mock_author_amend_briefing(
     the ``tests/acceptance/**`` sealing guard — see ``coord/dispatch.py``
     and #1315's ``_sealed_write_guard_tools`` in ``coord/agent.py``), so a
     contract correction never needs to fall back to ``type="work"`` again.
+
+    *driver_mock_glob* (#2512) is the repo's resolved acceptance-driver mock
+    glob (e.g. ``"*.html"``, ``"*.screen"``) — already resolved by the
+    caller (:func:`dispatch_acceptance_mock` always resolves ``driver_cfg``
+    before either briefing builder runs). Threaded through purely to gate
+    whether the mock-navigation-index instruction below is worth including;
+    an amendment that only touches ``contract.md`` still gets the
+    instruction, phrased conditionally, since this function has no way to
+    know in advance whether the correction will touch ``mocks/``.
     """
     ms_dir = f"tests/acceptance/{ms_dirname(milestone_number)}"
 
@@ -137,6 +175,16 @@ def build_mock_author_amend_briefing(
         f"do not touch any file outside `{ms_dir}/`. Commit and push both "
         "to this branch when done."
     )
+    if _wants_mock_index(driver_mock_glob):
+        parts.append(
+            f"If this correction touches any file under `{ms_dir}/mocks/`, "
+            f"regenerate `{ms_dir}/mocks/index.html` before committing by "
+            f"running `python scripts/gen_mock_index.py {ms_dir}/mocks` "
+            "(#2512) — a plain navigation page linking every mock by its "
+            "own `<title>` tag. Do not hand-write this file yourself; the "
+            "script is the single source of truth so every milestone's "
+            "mock set gets the same glue page."
+        )
     parts.append("")
     parts.append("--- Requested correction ---")
     parts.append(amend_text.strip())
@@ -260,6 +308,7 @@ def dispatch_acceptance_mock(
             milestone_number=milestone_number,
             tracking_issue_number=tracking_issue_number,
             amend_text=amend_briefing,
+            driver_mock_glob=driver_cfg.mock,
         )
         proposal = Proposal(
             id=0,

{code_coordinator-0.5.205 → code_coordinator-0.5.207}/coord/portal_store.py

@@ -206,6 +206,44 @@ def unhandled_events(limit: int = 100) -> list[PortalEvent]:
     return [_event_from_row(r) for r in rows]
 
 
+def events_after_verdict_watermark(
+    received_at: float, rowid: int, *, limit: int = 100
+) -> list[tuple[int, PortalEvent]]:
+    """Events strictly after ``(received_at, rowid)``, oldest first, with rowid.
+
+    The verdict consumer's (#2509) OWN scan, independent of the shared
+    ``handled_at`` column that :func:`unhandled_events` filters on. That
+    column is written by every consumer that ever gets added, but this one
+    only stamps it for a ``changes_requested`` event it actually dispatched —
+    every other kind is deliberately left ``handled_at IS NULL`` forever so a
+    future consumer can still read it. Scanning by ``handled_at IS NULL``
+    would therefore re-return that growing, never-marked backlog ahead of
+    anything newer on every call, and once it exceeds one page a genuinely
+    new ``changes_requested`` event behind it would never surface — see
+    :func:`coord.portal_sync._consume_verdicts`. A private, monotonic
+    watermark sidesteps that: it advances past every event this consumer has
+    *looked at*, whether or not it acted, so a pile of non-actionable events
+    cannot block the ones behind it.
+
+    Returns ``(rowid, event)`` pairs (not just events) so the caller can
+    advance the watermark to the exact row it stopped at without a second
+    query. ``rowid`` is SQLite's own implicit rowid — stable and unique
+    because ``portal_events``' primary key is the (non-integer) ``event_id``,
+    not ``rowid`` itself, so declaring the primary key never aliased it away.
+    """
+    rows = _conn().execute(
+        """
+        SELECT rowid, * FROM portal_events
+         WHERE received_at > ?
+            OR (received_at = ? AND rowid > ?)
+         ORDER BY received_at ASC, rowid ASC
+         LIMIT ?
+        """,
+        (received_at, received_at, rowid, limit),
+    ).fetchall()
+    return [(r["rowid"], _event_from_row(r)) for r in rows]
+
+
 def mark_event_handled(event_id: str, *, now: float | None = None) -> None:
     """Stamp an event as consumed. Idempotent — re-stamping is a plain UPDATE."""
     conn = _conn()
@@ -704,6 +742,8 @@ class SyncState:
     last_push_at: float | None = None
     last_heartbeat_at: float | None = None
     last_error: str = ""
+    verdict_watermark_at: float = 0.0
+    verdict_watermark_rowid: int = 0
 
 
 def get_sync_state() -> SyncState:
@@ -718,6 +758,8 @@ def get_sync_state() -> SyncState:
         last_push_at=row["last_push_at"],
         last_heartbeat_at=row["last_heartbeat_at"],
         last_error=row["last_error"] or "",
+        verdict_watermark_at=row["verdict_watermark_at"] or 0.0,
+        verdict_watermark_rowid=row["verdict_watermark_rowid"] or 0,
     )
 
 
@@ -748,6 +790,36 @@ def note_pull(*, now: float | None = None) -> None:
     _update_sync_state(last_pull_at=time.time() if now is None else now)
 
 
+def get_verdict_watermark() -> tuple[float, int]:
+    """The verdict consumer's own read position, ``(0.0, 0)`` if never set.
+
+    ``(0.0, 0)`` sorts before every real ``portal_events`` row (``received_at``
+    is a wall-clock epoch stamp, ``rowid`` starts at 1), so a fresh database
+    or one predating this column reads as "nothing scanned yet" and the next
+    scan starts from the very beginning of the inbox — see
+    :func:`events_after_verdict_watermark`.
+    """
+    row = _conn().execute(
+        "SELECT verdict_watermark_at, verdict_watermark_rowid "
+        "FROM portal_sync_state WHERE id = 1"
+    ).fetchone()
+    if row is None or row["verdict_watermark_at"] is None:
+        return (0.0, 0)
+    return (row["verdict_watermark_at"], row["verdict_watermark_rowid"] or 0)
+
+
+def set_verdict_watermark(received_at: float, rowid: int) -> None:
+    """Advance the verdict consumer's read position past ``(received_at, rowid)``.
+
+    Called after a scan has looked at that row — regardless of whether it was
+    acted on — so a run of non-actionable events cannot make this consumer
+    re-scan them forever (#2509 review fix). Independent of
+    :func:`mark_event_handled`, which is shared, per-event bookkeeping for
+    whatever future consumer looks at ``handled_at`` next.
+    """
+    _update_sync_state(verdict_watermark_at=received_at, verdict_watermark_rowid=rowid)
+
+
 def note_push(*, now: float | None = None) -> None:
     _update_sync_state(last_push_at=time.time() if now is None else now)
 
@@ -894,3 +966,21 @@ def list_milestone_links() -> list[PortalLink]:
 
     links = [PortalLink.from_dict(raw) for raw in state.list_portal_links()]
     return [link for link in links if link is not None]
+
+
+def get_link_by_submission(submission_id: str) -> PortalLink | None:
+    """Reverse lookup: the milestone link for a portal ``submission_id``, if any.
+
+    :func:`link_milestone` / :func:`get_milestone_link` only index the
+    forward direction (milestone → submission_id), which is all PDR-3's
+    auto-push needs. PDR-4's verdict consumer needs the other direction —
+    an inbound event carries only ``submission_id`` and must resolve back to
+    the ``(repo_name, milestone_number)`` coord dispatches against. Links are
+    few enough (one per submission a customer has ever been sent to) that a
+    linear scan of :func:`list_milestone_links` is simply the read path — no
+    new index, no new table.
+    """
+    for link in list_milestone_links():
+        if link.submission_id == submission_id:
+            return link
+    return None