code-coordinator 0.5.210__tar.gz → 0.5.213__tar.gz

code_coordinator-0.5.213/.gitignore

@@ -0,0 +1,44 @@
+__pycache__/
+*.pyc
+.env
+.venv/
+*.egg-info/
+build/
+dist/
+board_state.json
+agent_setup.json
+coordinator.yml
+
+# Rust build artifacts (coord-tui)
+tui/target/
+tui/*.err
+tui/*.out
+
+# scripts/coord-test-runner.sh scratch output, written into the worktree it
+# is pointed at. Harmless in the throwaway worktree the Test stage uses, but
+# a worker who runs the runner against its own checkout and then `git add -A`
+# commits ~3k lines of log noise — and, worse, leaves the tree permanently
+# `git status`-dirty, which makes setuptools-scm stamp a `.dYYYYMMDD` local
+# version and flips tests/test_release_verify.py::
+# test_spawned_identity_ignores_the_caller_cwd red for reasons that have
+# nothing to do with the branch under test.
+.pytest.out
+.pytest.rerun.out
+.pytest.baseline.out
+.pytest-acceptance.out
+.pytest-populated-home.out
+.cargo.out
+.cargo.rerun.out
+.cargo-acceptance.out
+.fallback.out
+.coord-ci-home/
+
+# #1973: opt-in local quadraui path override (see
+# tui/cargo-config-local-quadraui.toml.example) — never commit a
+# machine-local co-development override.
+tui/.cargo/config.toml
+
+# scratch $HOME created inside disposable worktrees by the CI-mode
+# acceptance runner (scripts/coord-test-runner.sh) — never meant to
+# leave the throwaway worktree, let alone land in git history (#2527).
+.coord-ci-home/

{code_coordinator-0.5.210 → code_coordinator-0.5.213}/PKG-INFO

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

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

@@ -734,6 +734,12 @@ tests/acceptance/ms-65/mocks/board-tab-context-menu.screen
 tests/acceptance/ms-65/mocks/board-tabs-help-overlay.screen
 tests/acceptance/ms-65/mocks/board-tabs-overflow.screen
 tests/acceptance/ms-65/mocks/pipeline-tabs-independent.screen
+tests/acceptance/ms-67/contract.md
+tests/acceptance/ms-67/mocks/approved-items-chat-opened.screen
+tests/acceptance/ms-67/mocks/approved-items-context-menu.screen
+tests/acceptance/ms-67/mocks/approved-items-detail.screen
+tests/acceptance/ms-67/mocks/approved-items-empty.screen
+tests/acceptance/ms-67/mocks/approved-items-populated.screen
 tests/acceptance/ms-example/mocks/home-active.html
 tests/fixtures/board-pipeline-basic.json
 tests/fixtures/board-pipeline-terminal-gates.json

{code_coordinator-0.5.210 → code_coordinator-0.5.213}/code_coordinator.egg-info/scm_file_list.json

@@ -377,6 +377,12 @@
     "tests/acceptance/ms-65/pipeline_tabs_2284.rs",
     "tests/acceptance/ms-65/tabs_discoverability_2287.rs",
     "tests/acceptance/ms-65/tabs_persistence_2286.rs",
+    "tests/acceptance/ms-67/contract.md",
+    "tests/acceptance/ms-67/mocks/approved-items-chat-opened.screen",
+    "tests/acceptance/ms-67/mocks/approved-items-context-menu.screen",
+    "tests/acceptance/ms-67/mocks/approved-items-detail.screen",
+    "tests/acceptance/ms-67/mocks/approved-items-empty.screen",
+    "tests/acceptance/ms-67/mocks/approved-items-populated.screen",
     "tests/acceptance/ms-example/mocks/home-active.html",
     "tests/conftest.py",
     "tests/fixtures/board-pipeline-basic.json",

{code_coordinator-0.5.210 → code_coordinator-0.5.213}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.210",
+  "tag": "0.5.213",
   "distance": 0,
-  "node": "gd5dc3b7d2bb67fd517cd7ac495abb3076f2017e4",
+  "node": "ga9e3937295f13339509408e4a07ca7e7028b9987",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-21"

{code_coordinator-0.5.210 → code_coordinator-0.5.213}/coord/commands/drive_queue.py

@@ -2350,6 +2350,162 @@ def _run_merge_only_candidates(plan: TickPlan, config_path: Path | None) -> None
         click.echo(f"merge-only: {reason}")
 
 
+def _run_auto_revalidate_checks_stale(config_path: Path | None) -> None:
+    """#2535: best-effort auto-fire of the CI-staleness rerun for merge-queue
+    entries blocked SOLELY on stale CI checks against an already-approved
+    review — closing the gap where nothing periodic ever calls a live
+    ``coord merge`` or ``coord merge --revalidate`` on such an entry's
+    behalf, so it just sits until an operator notices ``--dry-run``'s
+    ``checks_stale`` line and reruns by hand (the trigger: #2530's Gate-A
+    PR #2534 sat blocked 2026-08-21 on nothing but 210 unrelated merges
+    having landed since its CI last ran).
+
+    Deliberately narrow — this is NOT ``merge.auto_drain`` reopened (that
+    flag stays ``False`` by design; see ``docs/DRIVE_QUEUE.md`` and the
+    2026-06-07 incident it guards against). This step never merges anything
+    and never touches an entry blocked on review, a real CI failure, or a
+    conflict — it only triggers a ``gh run rerun`` for the exact shape
+    :func:`coord.merge_queue.ci_revalidation_candidates` already scopes
+    ``--revalidate``'s CI arm to (#1851/#1925): ``PENDING``, review
+    approved, smoke fresh, CI checks green but predating the current base.
+
+    BOUNDED, shared with the live path. Draws from the SAME
+    ``ci_stale_reruns``/``MAX_CI_STALE_RERUNS`` budget
+    :func:`coord.merge_queue.process`'s own #2197 auto-rerun already spends
+    from — a live ``coord merge`` attempt and this tick share one ceiling,
+    never two independent ones that could double the effective retry count.
+    An entry that has already exhausted the budget (on a prior live attempt
+    or a prior tick) is left for a human exactly as #2197 already leaves it;
+    this function never fires a further rerun past the cap, though it does
+    keep recording the escalation (below) for as long as the entry stays
+    stuck, so a human watching the audit trail sees it, not just the first
+    tick that hit the ceiling.
+
+    Cost-visible (#1632's posture): every triggered rerun is a real CI run
+    on GitHub's own runners, recorded via :func:`coord.audit.record_audit`
+    (operational tier) so an operator can see the auto-fired count — same
+    spirit as the notifier being advisory rather than silent, never a
+    silent background spend.
+
+    Deliberately NOT behind a new config flag — this reuses exactly the
+    bound and the counter #2197 already established for "an automatic CI
+    rerun triggered by staleness"; the only thing new here is a periodic
+    caller for the case nothing was already about to call ``process()``
+    live. If that judgment turns out to be wrong in practice, the fix is a
+    ``merge.auto_revalidate_stale_ci`` off-switch, not removing the
+    dedicated budget this already shares.
+
+    Best-effort like every other optional step in this tick (conflict
+    reconciliation in ``_auto_drain_tick``, the merge-only fast path above):
+    a failure here must never abort the rest of the tick. Skipped entirely
+    on a thin client — this daemon-host tick is the only place it ever
+    runs, same guard :func:`_fetch_live_ci_gate`/
+    :func:`_run_merge_only_candidates` use.
+    """
+    from coord.board_service import resolve as resolve_board_service  # noqa: PLC0415
+
+    if resolve_board_service() is not None:
+        return
+
+    try:
+        from coord import github_ops as _gh_ops  # noqa: PLC0415
+        from coord import merge_queue as _mq  # noqa: PLC0415
+        from coord.audit import record_audit  # noqa: PLC0415
+        from coord.ci_store import build_ci_store  # noqa: PLC0415
+        from coord.commands._common import _load_config  # noqa: PLC0415
+        from coord.state import load_board as _load_board  # noqa: PLC0415
+
+        cfg = _load_config(config_path)
+        board = _load_board()
+        ci_store = build_ci_store(
+            cfg.ci_store.type, host=cfg.ci_store.host, token_env=cfg.ci_store.token_env,
+        )
+        if ci_store is None or not ci_store.is_available:
+            return
+        items = _mq.load_queue()
+        candidates = _mq.ci_revalidation_candidates(items, board, cfg, ci_store, _gh_ops)
+    except Exception:  # noqa: BLE001 — best-effort, see docstring
+        return
+
+    if not candidates:
+        return
+
+    touched: list = []
+    for entry in candidates:
+        label = f"{entry.repo_name} #{entry.issue_number} ({entry.branch})"
+        if entry.ci_stale_reruns >= _mq.MAX_CI_STALE_RERUNS:
+            # Budget already spent (on a previous tick, or a previous live
+            # `coord merge` attempt) — #2197's own terminal wording is
+            # already on the entry from whichever call last evaluated it.
+            # Nothing new to trigger; still worth one audit row per tick so
+            # an operator watching the trail sees this has been sitting
+            # exhausted, not silently forgotten.
+            record_audit(
+                tier="operational", category="merge",
+                event_type="merge_checks_stale_auto_revalidate_exhausted",
+                actor="drive-queue-tick",
+                summary=(
+                    f"auto-revalidate: {label} still checks_stale after "
+                    f"{entry.ci_stale_reruns}/{_mq.MAX_CI_STALE_RERUNS} "
+                    "auto-reruns — needs a human (`coord merge --revalidate` "
+                    "or `coord merge --only`)"
+                ),
+                repo=entry.repo_name, issue=entry.issue_number,
+                assignment_id=entry.assignment_id,
+                details={
+                    "pr_number": entry.pr_number,
+                    "ci_stale_reruns": entry.ci_stale_reruns,
+                },
+            )
+            continue
+        try:
+            reran = ci_store.rerun_for_pr(entry.repo_github, entry.pr_number)
+        except Exception as exc:  # noqa: BLE001 — one entry's failure must not sink the rest
+            click.echo(
+                f"auto-revalidate: could not re-run CI for {label}: {exc}", err=True
+            )
+            continue
+        entry.ci_stale_reruns += 1
+        entry.error = (
+            f"{_mq.CI_PENDING_PREFIX} re-run triggered for CI checks that "
+            "predate the current base (#2535 auto-revalidate "
+            f"{entry.ci_stale_reruns}/{_mq.MAX_CI_STALE_RERUNS} "
+            f"{'triggered' if reran else 'failed to trigger'})"
+        )
+        touched.append(entry)
+        click.echo(
+            f"auto-revalidate: {'triggered' if reran else 'FAILED to trigger'} "
+            f"a CI re-run for {label} (checks_stale, review already approved) "
+            f"— {entry.ci_stale_reruns}/{_mq.MAX_CI_STALE_RERUNS}"
+        )
+        record_audit(
+            tier="operational", category="merge",
+            event_type="merge_checks_stale_auto_revalidate",
+            actor="drive-queue-tick",
+            summary=(
+                f"auto-revalidate: {'triggered' if reran else 'FAILED to trigger'} "
+                f"a CI re-run for {label} — {entry.ci_stale_reruns}/"
+                f"{_mq.MAX_CI_STALE_RERUNS}"
+            ),
+            repo=entry.repo_name, issue=entry.issue_number,
+            assignment_id=entry.assignment_id,
+            details={"pr_number": entry.pr_number, "reran": reran},
+        )
+
+    if not touched:
+        return
+
+    try:
+        from coord import merge_queue as _mq  # noqa: PLC0415
+
+        fresh = _mq.load_queue()
+        by_id = {e.assignment_id: e for e in touched}
+        merged = [by_id.get(item.assignment_id, item) for item in fresh]
+        _mq.save_queue(merged)
+    except Exception:  # noqa: BLE001 — best-effort persistence; next tick recomputes
+        pass
+
+
 def _run_resume_probe(entry: QueueEntry) -> ProbeResult:
     """Run one entry's ``--resume-when`` probe with a hard timeout.
 
@@ -2730,6 +2886,15 @@ def drive_queue_tick(
         if not reconcile_only:
             _run_merge_only_candidates(plan, config_path)
 
+        # #2535: independent of the drive-queue plan above (this scans the
+        # MERGE queue directly, not drive-queue rows) — a bounded, best-effort
+        # CI re-run for any entry blocked solely on stale-but-green checks
+        # with an already-approved review. Same `not reconcile_only` posture
+        # as the merge-only fast path just above: a `gh run rerun` is a real
+        # external action that mode promises not to take.
+        if not reconcile_only:
+            _run_auto_revalidate_checks_stale(config_path)
+
         # #2235 Phase 0: record every entry this tick moved INTO or OUT OF
         # `blocked`/`parked`, with the reason the queue stated and — for a
         # release — what the release itself reveals about the true cause.

{code_coordinator-0.5.210 → code_coordinator-0.5.213}/coord/commands/portal.py

@@ -284,6 +284,189 @@ def portal_link(
     )
 
 
+# ── #2513 (PDR-5): manual "publish mocks to portal" ─────────────────────────
+
+
+@portal_group.command("publish-mocks")
+@_CONFIG_OPTION
+@click.argument("repo")
+@click.argument("tracking_issue", type=int)
+def portal_publish_mocks(config_path, repo: str, tracking_issue: int) -> None:
+    """Publish REPO's local Gate-A mock bundle for TRACKING_ISSUE's milestone now.
+
+    The on-demand counterpart to PDR-3's merge-triggered auto-push
+    (``coord.merge_queue._maybe_push_design_round``): that path only fires
+    once a `type="mock-author"` PR actually merges, which leaves a real gap
+    for iterating on a local ``coord acceptance mock ... --amend`` before
+    it's merged, or re-publishing after a manual edit. This uploads whatever
+    is currently on THIS machine's local checkout under
+    ``tests/acceptance/ms-NN/`` — ``contract.md`` plus every ``mocks/*.html``
+    fixture, uncommitted changes included — no merge required. That's the
+    whole point of "on demand".
+
+    Reuses PDR-3's shared upload+enqueue helper
+    (:func:`coord.portal_sync.push_design_round_bundle`) as-is — only where
+    the files come from differs.
+
+    Unlike the merge-triggered path (which fails OPEN: no portal link on
+    file for the milestone is silently "nothing to do yet, run `coord portal
+    link`"), this is an operator-invoked command and fails LOUD — a missing
+    link, missing portal config, or an empty local mock bundle is a clear
+    error naming the fix, never a silent no-op.
+    """
+    _refuse_if_thin_client("publish-mocks")
+
+    cfg = _load_config(config_path)
+    repo_cfg = cfg.repo(repo)
+    if repo_cfg is None:
+        click.secho(f"error: unknown repo {repo!r}", fg="red")
+        raise SystemExit(2)
+    client = client_from_config(cfg.portal)
+    if client is None:
+        click.secho(
+            "portal is not enabled — nothing to do (see `coord portal status`)",
+            fg="yellow",
+        )
+        raise SystemExit(1)
+
+    from coord import github_ops, portal_store  # noqa: PLC0415
+    from coord.portal_sync import PortalSyncError, push_design_round_bundle  # noqa: PLC0415
+    from coord.test_orchestrator import find_local_repo_path  # noqa: PLC0415
+
+    try:
+        issue_data = github_ops.get_issue(repo_cfg.github, tracking_issue)
+    except Exception as exc:  # noqa: BLE001 — surface as a clear CLI error, not a traceback
+        click.secho(f"could not fetch tracking issue #{tracking_issue}: {exc}", fg="red")
+        raise SystemExit(1) from exc
+
+    milestone = (issue_data or {}).get("milestone") or {}
+    milestone_number = milestone.get("number")
+    if milestone_number is None:
+        click.secho(
+            f"#{tracking_issue} is not scoped to a milestone — nothing to publish",
+            fg="red",
+        )
+        raise SystemExit(1)
+
+    link = portal_store.get_milestone_link(
+        repo_name=repo_cfg.name, milestone_number=milestone_number
+    )
+    if link is None:
+        click.secho(
+            f"{repo_cfg.name} ms-{milestone_number} has no portal submission linked — "
+            f"run `coord portal link {repo_cfg.name} {milestone_number} <submission_id>` "
+            "first",
+            fg="red",
+        )
+        raise SystemExit(1)
+
+    repo_dir = find_local_repo_path(repo_cfg.name, cfg)
+    if repo_dir is None or not repo_dir.exists():
+        click.secho(
+            f"no local repo checkout found for {repo_cfg.name!r} on this machine "
+            "(repo_paths in coordinator.yml)",
+            fg="red",
+        )
+        raise SystemExit(1)
+
+    try:
+        files = _collect_local_mock_bundle_files(repo_dir, milestone_number)
+    except _MockBundleReadError as exc:
+        click.secho(f"could not read local mock bundle: {exc}", fg="red")
+        raise SystemExit(1) from exc
+    if not files:
+        click.secho(
+            f"no mock bundle found under {repo_dir}/tests/acceptance/"
+            f"ms-{milestone_number}/ — nothing to publish",
+            fg="red",
+        )
+        raise SystemExit(1)
+
+    try:
+        bundle_key, row = push_design_round_bundle(
+            client,
+            link.submission_id,
+            files,
+            milestone_title=milestone.get("title") or f"ms-{milestone_number}",
+            tracking_issue_title=issue_data.get("title") or "",
+            tracking_issue_body=issue_data.get("body") or "",
+        )
+    except PortalBridgeError as exc:
+        click.secho(f"bundle upload failed: {exc}", fg="red")
+        raise SystemExit(1) from exc
+    except PortalSyncError as exc:
+        click.secho(f"enqueue failed: {exc}", fg="red")
+        raise SystemExit(1) from exc
+
+    click.secho(
+        f"published: {repo_cfg.name} ms-{milestone_number} -> "
+        f"submission {link.submission_id} (seq={row.seq}, bundle_key={bundle_key}, "
+        f"{len(files)} file(s): {', '.join(sorted(files))})",
+        fg="green",
+    )
+
+
+class _MockBundleReadError(Exception):
+    """A file under the local `ms-NN` acceptance dir could not be read as text.
+
+    Raised by `_collect_local_mock_bundle_files` in place of a raw
+    `UnicodeDecodeError` — mocks are machine-rendered HTML so this is
+    low-probability, but a stray non-UTF-8 file dropped in `mocks/` should
+    surface as a named CLI error like every other checked failure in this
+    command, not an unhandled traceback.
+    """
+
+
+def _collect_local_mock_bundle_files(repo_dir, milestone_number: int) -> dict:
+    """Read a rendered Gate-A bundle off the LOCAL checkout at *repo_dir*.
+
+    PDR-5's on-demand counterpart to
+    :func:`coord.mock_author.collect_mock_bundle_files`, which reads a
+    *merged* branch off GitHub's Contents API — this reads whatever is
+    currently on disk, uncommitted changes included.
+
+    Same ``{relative_path: content}`` shape: ``"contract.md"`` plus every
+    ``mocks/*.html`` fixture — which, if #2512 (master index page) has
+    landed, automatically picks up ``mocks/index.html`` too, since this
+    globs everything under ``mocks/`` rather than naming files. The suffix
+    match is case-INSENSITIVE (``SCREEN.HTML`` counts) so that this stays
+    aligned with the TUI's `gate_a_mocks_dir_exists_for` enablement gate
+    (#2513 review follow-up) — a file that lights the menu item up must be
+    a file this command actually publishes, or the operator gets an
+    enabled button whose dispatch dies with "nothing to publish". Empty when
+    the ``ms-NN`` acceptance directory doesn't exist locally at all —
+    callers treat that as an error (unlike the merge-triggered path's
+    "nothing to push", this command is operator-invoked and should say why
+    it did nothing rather than no-op quietly).
+    """
+    from pathlib import Path  # noqa: PLC0415
+
+    from coord.acceptance import ms_dirname  # noqa: PLC0415
+
+    ms_dir = Path(repo_dir) / "tests" / "acceptance" / ms_dirname(milestone_number)
+    files: dict = {}
+    contract_path = ms_dir / "contract.md"
+    if contract_path.is_file():
+        files["contract.md"] = _read_text_or_raise(contract_path)
+    mocks_dir = ms_dir / "mocks"
+    if mocks_dir.is_dir():
+        for p in sorted(mocks_dir.iterdir()):
+            if p.is_file() and p.suffix.lower() == ".html":
+                files[f"mocks/{p.name}"] = _read_text_or_raise(p)
+    return files
+
+
+def _read_text_or_raise(path) -> str:
+    """`Path.read_text(encoding="utf-8")`, wrapping a decode failure in the
+    named `_MockBundleReadError` instead of letting a raw
+    `UnicodeDecodeError` traceback reach the operator.
+    """
+    try:
+        return path.read_text(encoding="utf-8")
+    except UnicodeDecodeError as exc:
+        raise _MockBundleReadError(f"{path} is not valid UTF-8 text ({exc})") from exc
+
+
 # ── #1982: the sync loop's operator surface ─────────────────────────────────
 
 

{code_coordinator-0.5.210 → code_coordinator-0.5.213}/coord/merge_queue.py

@@ -5074,9 +5074,9 @@ def _maybe_push_design_round(
         # the whole point of the fail-open posture (see docstring above).
         return None
 
-    from coord.mock_author import build_design_round, collect_mock_bundle_files  # noqa: PLC0415
+    from coord.mock_author import collect_mock_bundle_files  # noqa: PLC0415
     from coord.portal_bridge import PortalBridgeError, client_from_config  # noqa: PLC0415
-    from coord.portal_sync import PortalSyncError, enqueue_design_round  # noqa: PLC0415
+    from coord.portal_sync import PortalSyncError, push_design_round_bundle  # noqa: PLC0415
 
     client = client_from_config(portal_cfg)
     if client is None:
@@ -5099,18 +5099,16 @@ def _maybe_push_design_round(
         )
 
     try:
-        bundle_key = client.upload_bundle(link.submission_id, files)
+        bundle_key, row = push_design_round_bundle(
+            client,
+            link.submission_id,
+            files,
+            milestone_title=milestone.get("title") or f"ms-{milestone_number}",
+            tracking_issue_title=issue_data.get("title") or "",
+            tracking_issue_body=issue_data.get("body") or "",
+        )
     except PortalBridgeError as e:
         return MergeEvent(entry, "design_round_push_failed", f"bundle upload failed: {e}")
-
-    design_round = build_design_round(
-        milestone_title=milestone.get("title") or f"ms-{milestone_number}",
-        tracking_issue_title=issue_data.get("title") or "",
-        tracking_issue_body=issue_data.get("body") or "",
-        bundle_key=bundle_key,
-    )
-    try:
-        row = enqueue_design_round(link.submission_id, design_round)
     except PortalSyncError as e:
         return MergeEvent(entry, "design_round_push_failed", f"enqueue failed: {e}")
 

{code_coordinator-0.5.210 → code_coordinator-0.5.213}/coord/portal_sync.py

@@ -242,6 +242,67 @@ def enqueue_design_round(
     )
 
 
+def push_design_round_bundle(
+    client: Any,
+    submission_id: str,
+    files: dict[str, str],
+    *,
+    milestone_title: str,
+    tracking_issue_title: str,
+    tracking_issue_body: str,
+    round_number: int = 1,
+    now: float | None = None,
+) -> tuple[str, portal_store.OutboxRow]:
+    """Upload *files* as a design round bundle, then queue its D1 metadata.
+
+    The shared tail of the "publish a Gate-A mock bundle to the portal"
+    story — extracted (#2513/PDR-5) so the two callers that need it never
+    duplicate the upload → reshape → enqueue sequence:
+
+    * :mod:`coord.merge_queue`'s post-merge hook (PDR-3/#2508), which reads
+      *files* off a just-merged ``mock-author`` branch via GitHub's Contents
+      API (:func:`coord.mock_author.collect_mock_bundle_files`) and calls
+      this automatically, fail-open, the moment that branch lands.
+    * ``coord portal publish-mocks`` (PDR-5, :mod:`coord.commands.portal`),
+      which reads *files* straight off the operator's local checkout — no
+      merge required — and calls this on demand, fail-loud.
+
+    Only the *source* of ``files`` differs between the two; everything from
+    "here are the files" downstream — upload, build the design-round
+    payload, queue it — is identical, which is the whole point of not
+    duplicating it (the previous shape had this sequence inlined in
+    ``coord.merge_queue._maybe_push_design_round``).
+
+    Three steps, each able to fail independently — callers keep whatever
+    try/except shape they already had around the calls this replaces:
+
+    1. :meth:`coord.portal_bridge.PortalBridgeClient.upload_bundle` — raises
+       :class:`coord.portal_bridge.PortalBridgeError` on a transport/4xx/5xx
+       failure.
+    2. :func:`coord.mock_author.build_design_round` — reshapes the bundle
+       key + tracking-issue text into the D1 metadata payload; does not
+       raise (a malformed ``## Work order`` degrades to an empty
+       decomposition, per that function's own docstring).
+    3. :func:`enqueue_design_round` — raises :class:`PortalSyncError` for a
+       payload it refuses to queue.
+
+    Returns ``(bundle_key, row)`` — the R2 object key the portal assigned
+    the bundle, and the outbox row now queued for it.
+    """
+    from coord.mock_author import build_design_round  # noqa: PLC0415
+
+    bundle_key = client.upload_bundle(submission_id, files)
+    design_round = build_design_round(
+        milestone_title=milestone_title,
+        tracking_issue_title=tracking_issue_title,
+        tracking_issue_body=tracking_issue_body,
+        bundle_key=bundle_key,
+        round_number=round_number,
+    )
+    row = enqueue_design_round(submission_id, design_round, now=now)
+    return bundle_key, row
+
+
 def enqueue_preview(
     submission_id: str, preview_url: str, *, now: float | None = None
 ) -> portal_store.OutboxRow:

{code_coordinator-0.5.210 → code_coordinator-0.5.213}/docs/ORACLE_LOOP.md

@@ -393,8 +393,16 @@ Phase 0 steps 1–2 and Phase 1 step 6 above are also reachable by right-clickin
   not a live session). The CLI's own claim-detection refuses a duplicate dispatch while one is
   already in flight. This *is* Phase 0 step 1.
 - **"View Gate A mock (PR)"** 👁 → opens that worker's PR in the browser so a human can read
-  `contract.md` + the rendered mock(s). Disabled until a PR exists. **Merging that PR does not
-  satisfy Gate A** (#2063) — it is only how you *see* what you are signing off on.
+  `contract.md` and review/merge the branch. Disabled until a PR exists. **This does not show the
+  rendered mock(s)** (#2501) — GitHub's "Files changed" view renders `.html` as a source diff,
+  never a live page; use "View Gate A mock (local)" below for that. **Merging that PR does not
+  satisfy Gate A** (#2063) — it is only how you review/merge what you are signing off on.
+- **"View Gate A mock (local)"** 👁 → the actual mock viewer (#2501). Fast-forward-pulls the local
+  checkout's default branch (never forcing, never touching a dirty or diverged tree — aborts with
+  a toast instead, same as everywhere else this repo touches git destructively) and then opens
+  `tests/acceptance/ms-NN/mocks/` from disk in the OS's default browser, where `.html` actually
+  renders. Disabled until that mocks directory exists locally. Opens `mocks/index.html` once #2512
+  ships it; falls back to opening the mocks directory itself until then.
 - **"Approve Gate A"** ✓ → `coord gate-a --approved <repo> <tracking_issue>` — records the verdict
   that actually satisfies Gate A. Sits directly beside the 👁 on purpose: reviewing and recording
   are one gesture.