phase-loop-runtime 0.7.7__tar.gz → 0.7.8__tar.gz

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.7.7
+Version: 0.7.8
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author: ViperJuice
 License-Expression: Apache-2.0

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "phase-loop-runtime"  # PyPI dist name; NOT "agent-harness" (an unrelated third-party PyPI project)
-version = "0.7.7"
+version = "0.7.8"
 description = "Harness-neutral phase-loop orchestration runtime and CLI"
 readme = "README.md"
 requires-python = ">=3.10"

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.8}/src/phase_loop_runtime/__init__.py

@@ -18,4 +18,4 @@ __all__ = [
     "state_ops",
 ]
 
-__version__ = "0.7.7"
+__version__ = "0.7.8"

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.8}/src/phase_loop_runtime/cli.py

@@ -2934,11 +2934,42 @@ def _run_train_command(*, parser: argparse.ArgumentParser, args: argparse.Namesp
 
     as_json = bool(getattr(args, "json", False))
 
+    # Build a broker-authoritative coordinator runtime so publish actually opens PRs.
+    # Without a broker_client, publish_from_worktree fail-closes `broker_required` and
+    # the train opens ZERO PRs.  The routing broker binds per BrokerRequest.repo (the
+    # node's resolved workspace) AND keeps a PER-REPO admission/evidence store, so one
+    # node's ambiguous outcome fail-closes only that repo.  The broker root is namespaced
+    # by the roadmap's RESOLVED PATH hash (not the bare filename stem): two distinct
+    # roadmap files — even same-stemmed, even under one explicit `--ledger-dir` — get
+    # distinct broker roots, so an ambiguous outcome in one train can never fail-close a
+    # different train.  Keying on the stable path (not the content digest) keeps a
+    # resumed train on its own epoch across roadmap edits.  It lives under the ledger dir,
+    # which the roadmap author keeps outside any repo's .phase-loop/ (INV-4); it is NOT
+    # machine-enforced to be outside every node worktree, so keep train roadmaps + their
+    # ledger dir out of the checkouts.
+    import hashlib
+
+    from .convergence.broker import build_routing_broker_client
+
+    train_key = hashlib.sha256(str(train_path.resolve()).encode("utf-8")).hexdigest()[:16]
+    coordinator_root = ledger_dir / "broker" / train_key
+    coordinator_root.mkdir(parents=True, exist_ok=True)
+    roadmap_digest = hashlib.sha256(train_path.read_bytes()).hexdigest()
+    coordinator_runtime = train_runner.CoordinatorRuntime(
+        train_id=train_path.stem,
+        coordinator_root=coordinator_root,
+        roadmap_path=str(train_path),
+        roadmap_digest=roadmap_digest,
+        workspace_id=train_path.stem,
+        broker_client=build_routing_broker_client(broker_root=coordinator_root),
+    )
+
     result = train_runner.run_train(
         roadmap,
         ledger_path,
         run_mode=run_mode,
         resolve_workspace=_resolve_workspace,
+        coordinator_runtime=coordinator_runtime,
         _merge_phase_enabled=True,  # P4 gate: autonomous→drafts_open, governed→merge
     )
 

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.8}/src/phase_loop_runtime/convergence/broker/__init__.py

@@ -2,6 +2,6 @@
 from .admission import AdmissionRecord, BrokerAdmissionPolicy, LinearizableAdmissionStore
 from .credsep import BrokerEnvironmentBoundary, GitHubBrokerAdapter
 from .evidence import BrokerEvidenceStore, EvidenceRecord
-from .live import build_github_broker_client
+from .live import build_github_broker_client, build_routing_broker_client
 from .verbs import BrokerClient, BrokerExecutionResult, BrokerProviderAdapter, BrokerService, publish_committed_branch_idempotency_key
-__all__ = ["AdmissionRecord", "BrokerAdmissionPolicy", "LinearizableAdmissionStore", "BrokerEnvironmentBoundary", "GitHubBrokerAdapter", "BrokerEvidenceStore", "EvidenceRecord", "BrokerClient", "BrokerExecutionResult", "BrokerProviderAdapter", "BrokerService", "build_github_broker_client", "publish_committed_branch_idempotency_key"]
+__all__ = ["AdmissionRecord", "BrokerAdmissionPolicy", "LinearizableAdmissionStore", "BrokerEnvironmentBoundary", "GitHubBrokerAdapter", "BrokerEvidenceStore", "EvidenceRecord", "BrokerClient", "BrokerExecutionResult", "BrokerProviderAdapter", "BrokerService", "build_github_broker_client", "build_routing_broker_client", "publish_committed_branch_idempotency_key"]

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.8}/src/phase_loop_runtime/convergence/broker/credsep.py

@@ -98,7 +98,14 @@ class GitHubBrokerAdapter:
         # so remote.origin.pushurl / url.*.pushInsteadOf cannot redirect the mutation.
         pushed = self.run(["git", "-C", str(self.repo_path), "push", origin_url, ref], capture_output=True, text=True)
         if pushed.returncode: return self._ambiguous(request, "push-unconfirmed")
-        args = ["gh", "pr", "create", "--repo", origin_repo, "--draft"] if request.draft else ["gh", "pr", "create", "--repo", origin_repo, "--fill"]
+        # `gh pr create` REQUIRES --title (+ --body) when non-interactive; the bare
+        # `--draft`/`--fill` form aborts headless ("must provide --title and --body").
+        # Derive a deterministic title from the branch HEAD's commit subject and pass
+        # the request's pr_body verbatim (empty body is valid once --title is present).
+        # --head pins the branch explicitly so gh never infers a wrong head.
+        title = self._output("log", "-1", "--format=%s") or request.branch
+        args = ["gh", "pr", "create", "--repo", origin_repo, "--head", request.branch, "--title", title, "--body", request.pr_body or title]
+        if request.draft: args.append("--draft")
         created = self.run(args, cwd=self.repo_path, capture_output=True, text=True)
         if created.returncode: return self._ambiguous(request, "pr-unconfirmed")
         # Exact-published-head verification: READ the remote and confirm the branch

phase_loop_runtime-0.7.8/src/phase_loop_runtime/convergence/broker/live.py

@@ -0,0 +1,187 @@
+"""Opt-in construction of a live, credential-capable GitHub broker client.
+
+This is the *only* helper that assembles a broker able to perform a real GitHub
+mutation.  It is never auto-instantiated: legacy ``run_train`` callers that pass
+no ``coordinator_runtime`` (or a runtime with ``broker_client=None``) publish
+exactly as before.  A caller wanting broker-mediated publication builds a client
+here and attaches it to :class:`CoordinatorRuntime.broker_client`.
+
+The wired client enforces every already-merged safety property: linearizable
+admission, permanent fail-closed ``outcome_ambiguous_blocked`` evidence, canonical
+``(repo, branch, head_sha)`` idempotency, and the adapter's exact-published-head
+verification.  Only the ``publish_committed_branch``/``github`` verb is SUPPORTED
+(see ``provider_contracts``); the service refuses every other verb.
+"""
+from __future__ import annotations
+
+import hashlib
+import subprocess
+from pathlib import Path
+from typing import Callable
+
+from phase_loop_runtime.convergence.contracts import AdmissionRequest
+from phase_loop_runtime.convergence.provider_contracts import PROVIDER_COMPLETION_CLASSIFICATIONS
+
+from .admission import BrokerAdmissionPolicy, LinearizableAdmissionStore
+from .credsep import ALLOWED_ORIGIN_HOSTS, GitHubBrokerAdapter
+from .evidence import BrokerEvidenceStore
+from .verbs import BrokerClient, BrokerService
+
+
+def _default_admission_policy(_request: AdmissionRequest) -> bool:
+    """Admit any structurally-valid admission request.
+
+    ``AdmissionRequest.__post_init__`` already rejects a request missing any
+    fencing field, so a request that reaches the policy is well-formed.  Epoch
+    staleness and idempotency-key conflicts are enforced inside
+    ``LinearizableAdmissionStore.admit`` regardless of this policy.
+    """
+    return True
+
+
+def build_github_broker_client(
+    repo_path: Path,
+    *,
+    broker_root: Path,
+    admission_policy: BrokerAdmissionPolicy | None = None,
+    run: Callable[..., subprocess.CompletedProcess] = subprocess.run,
+) -> BrokerClient:
+    """Wire a live GitHub broker client.
+
+    Parameters
+    ----------
+    repo_path:
+        Worktree the :class:`GitHubBrokerAdapter` runs git/gh against.
+    broker_root:
+        Durable directory for the admission log + terminal-evidence log.  MUST
+        live OUTSIDE ``repo_path`` (e.g. ``CoordinatorRuntime.coordinator_root``)
+        so broker state never dirties the worktree being published — a dirty
+        worktree trips the publish staged-diff audit and the train clean-worktree
+        preflight.
+    admission_policy:
+        Optional admission gate; defaults to admitting any well-formed request.
+    run:
+        Injectable subprocess runner (tests pass a fake to mock the git/gh seam).
+
+    Returns
+    -------
+    BrokerClient
+        A :class:`BrokerService` bound to the global (verb-gated) contracts, so
+        only ``publish_committed_branch``/``github`` can execute.
+    """
+    admission_store = LinearizableAdmissionStore(
+        Path(broker_root),
+        admission_policy or _default_admission_policy,
+    )
+    evidence_store = BrokerEvidenceStore(Path(broker_root))
+    adapter = GitHubBrokerAdapter(Path(repo_path), run=run)
+    return BrokerService(
+        admission_store,
+        evidence_store,
+        adapter,
+        contracts=PROVIDER_COMPLETION_CLASSIFICATIONS,
+    )
+
+
+def _repo_store_slug(repo: str) -> str:
+    """Stable, filesystem-safe subdir name for a repo's per-repo broker store.
+
+    ``BrokerRequest.repo`` is an arbitrary absolute workspace path, so hash it rather
+    than embed the path.  A short hex prefix is collision-free in practice and keeps
+    the on-disk layout readable.
+    """
+    return hashlib.sha256(repo.encode("utf-8")).hexdigest()[:16]
+
+
+class _RoutingBrokerService:
+    """A :class:`BrokerClient` that routes each request to a PER-REPO broker service.
+
+    ``build_github_broker_client`` fixes ONE ``repo_path`` at construction, so a single
+    client can only faithfully serve one repo — a multi-repo ``run_train`` threading one
+    ``coordinator_runtime.broker_client`` across every node would run
+    ``git -C <wrong-repo>`` and trip the branch/head guard on node 2+.
+
+    Critically, each repo gets its OWN admission + evidence store under
+    ``broker_root/<repo-slug>`` — the stores are NOT shared.  ``epoch_blocked`` is a
+    GLOBAL scan over a store (``any(state is OUTCOME_AMBIGUOUS_BLOCKED)``) and an
+    ambiguous terminal is durable + permanent, and it fires on BENIGN transients
+    (push-unconfirmed / remote-read-failed / pr-unconfirmed / remote-head-mismatch /
+    pr-head-unconfirmed).  A shared store would therefore let one repo's transient
+    hiccup permanently fail-close every OTHER repo in the train (and, with an
+    un-namespaced ``broker_root``, other trains too).  Per-repo stores scope the
+    fail-closed epoch to exactly the repo whose mutation became ambiguous — the correct
+    blast radius: repo A's unknown state says nothing about repo B's independent remote.
+    The caller namespaces ``broker_root`` per train (see the ``run-train`` CLI), closing
+    the cross-train dimension.
+    """
+
+    def __init__(
+        self,
+        broker_root: Path,
+        *,
+        admission_policy: BrokerAdmissionPolicy,
+        run: Callable[..., subprocess.CompletedProcess],
+        allowed_hosts,
+        contracts=PROVIDER_COMPLETION_CLASSIFICATIONS,
+    ) -> None:
+        self._broker_root = Path(broker_root)
+        self._admission_policy = admission_policy
+        self._run = run
+        self._allowed_hosts = allowed_hosts
+        self._contracts = contracts
+        self._services: dict[str, BrokerService] = {}
+
+    def _service_for(self, repo: str) -> BrokerService:
+        service = self._services.get(repo)
+        if service is None:
+            root = self._broker_root / _repo_store_slug(repo)
+            service = BrokerService(
+                LinearizableAdmissionStore(root, self._admission_policy),
+                BrokerEvidenceStore(root),
+                GitHubBrokerAdapter(Path(repo), run=self._run, allowed_hosts=self._allowed_hosts),
+                contracts=self._contracts,
+            )
+            self._services[repo] = service
+        return service
+
+    def execute(self, request):
+        return self._service_for(request.repo).execute(request)
+
+
+def build_routing_broker_client(
+    *,
+    broker_root: Path,
+    admission_policy: BrokerAdmissionPolicy | None = None,
+    run: Callable[..., subprocess.CompletedProcess] = subprocess.run,
+    allowed_hosts=ALLOWED_ORIGIN_HOSTS,
+) -> BrokerClient:
+    """Wire a live GitHub broker client that serves a MULTI-repo train.
+
+    Like :func:`build_github_broker_client` but routes per ``BrokerRequest.repo``: the
+    git/gh adapter is bound to the request's repo, AND each repo gets its own admission
+    + evidence store under ``broker_root/<repo-slug>``.  Per-repo stores are load-bearing
+    for safety, not just routing — a shared store's GLOBAL ``epoch_blocked`` would let one
+    repo's ambiguous outcome (reachable via a benign transient) permanently fail-close
+    every other repo.  See :class:`_RoutingBrokerService`.
+
+    Parameters
+    ----------
+    broker_root:
+        Durable parent directory for the per-repo admission + evidence stores.  MUST
+        live OUTSIDE every node's worktree, and the caller SHOULD namespace it per train
+        (e.g. ``<ledger-dir>/broker/<train-stem>``) so unrelated trains never share an
+        epoch.
+    admission_policy:
+        Optional admission gate; defaults to admitting any well-formed request.
+    run:
+        Injectable subprocess runner (tests pass a fake to mock the git/gh seam).
+    allowed_hosts:
+        Origin-host allow-list applied to every per-request adapter (github.com-only
+        by default); a self-hosted/GHE fleet passes its own set.
+    """
+    return _RoutingBrokerService(
+        Path(broker_root),
+        admission_policy=admission_policy or _default_admission_policy,
+        run=run,
+        allowed_hosts=allowed_hosts,
+    )

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.8}/src/phase_loop_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.7.7
+Version: 0.7.8
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author: ViperJuice
 License-Expression: Apache-2.0

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.8}/src/phase_loop_runtime.egg-info/SOURCES.txt

@@ -742,6 +742,7 @@ tests/test_skills_bundle_drift.py
 tests/test_skills_canon_parity.py
 tests/test_skills_src_claude_literal_lint.py
 tests/test_spec_conformance_gate.py
+tests/test_specpkgmin_wheel.py
 tests/test_status_read_only_62.py
 tests/test_sweep_fleet_worktrees_script.py
 tests/test_sync_skills_apply_failloud.py

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.8}/tests/test_convergence_broker_credsep.py

@@ -41,6 +41,7 @@ def _base_responses():
     return [
         (("branch", "--show-current"), _BRANCH, 0),
         (("rev-parse",), _HEAD, 0),
+        (("log",), "commit subject line", 0),
         (("get-url",), "https://github.com/owner/repo.git", 0),
         (("push",), "", 0),
         (("create",), "", 0),
@@ -105,6 +106,26 @@ def test_gh_calls_are_bound_to_origin_repo_slug(tmp_path):
         assert "--repo" in c and "github.com/owner/repo" in c, f"gh call not host-bound: {c!r}"
 
 
+# --- Live-PILOT regression: `gh pr create` MUST be a complete non-interactive argv.
+# The bare `--draft`/`--fill` form aborts headless ("must provide --title and --body"),
+# so a mocked-run unit test passes while the real broker cannot open ANY PR.  Assert the
+# create argv carries --title + --body (+ --draft for a draft request) and pins --head. ---
+def test_pr_create_is_noninteractive_with_title_body_head(tmp_path):
+    body = "## Cross-repo release train\n\nbody text"
+    admission = AdmissionRequest("attempt", 1, "fence", "digest", "predicate", "scope", "key")
+    request = BrokerRequest(BrokerVerb.PUBLISH_COMMITTED_BRANCH, admission, "repo", _BRANCH, _HEAD, ("a.py",), draft=True, pr_body=body)
+    run = _FakeRun(_base_responses() + [
+        (("ls-remote",), f"{_HEAD}\trefs/heads/{_BRANCH}", 0),
+        (("list",), json.dumps([{"url": "https://gh/pr/9", "headRefOid": _HEAD}]), 0),
+    ])
+    GitHubBrokerAdapter(tmp_path, run=run).execute(request)
+    create = next(c for c in run.calls if c[:3] == ["gh", "pr", "create"])
+    assert "--title" in create and create[create.index("--title") + 1], f"create lacks non-empty --title: {create!r}"
+    assert "--body" in create and create[create.index("--body") + 1] == body, f"create lacks pr_body --body: {create!r}"
+    assert "--head" in create and _BRANCH in create, f"create lacks explicit --head: {create!r}"
+    assert "--draft" in create, f"draft request must carry --draft: {create!r}"
+
+
 def test_unresolvable_origin_fails_closed(tmp_path):
     run = _FakeRun([
         (("branch", "--show-current"), _BRANCH, 0),

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.8}/tests/test_convergence_live_enable.py

@@ -15,7 +15,7 @@ from subprocess import CompletedProcess
 
 import pytest
 
-from phase_loop_runtime.convergence.broker import build_github_broker_client
+from phase_loop_runtime.convergence.broker import build_github_broker_client, build_routing_broker_client
 from phase_loop_runtime.convergence.broker.admission import LinearizableAdmissionStore
 from phase_loop_runtime.convergence.broker.credsep import GitHubBrokerAdapter
 from phase_loop_runtime.convergence.broker.evidence import BrokerEvidenceStore
@@ -54,6 +54,8 @@ def _fake_git_gh(*, remote_sha: str = _HEAD, pr_head: str = _HEAD):
                 return CompletedProcess(cmd, 0, stdout=_BRANCH + "\n", stderr="")
             if sub[0] == "rev-parse":
                 return CompletedProcess(cmd, 0, stdout=_HEAD + "\n", stderr="")
+            if sub[0] == "log":
+                return CompletedProcess(cmd, 0, stdout="commit subject line\n", stderr="")
             if sub[0] == "push":
                 return CompletedProcess(cmd, 0, stdout="", stderr="")
             if sub[0] == "ls-remote":
@@ -166,3 +168,137 @@ def test_live_broker_builder_constructs_working_client(tmp_path):
     # Broker state is durable under broker_root, never inside the published worktree.
     assert (broker_root / "evidence.jsonl").exists()
     assert not (repo_path / "evidence.jsonl").exists()
+
+
+# (f) Routing broker: ONE client serves a MULTI-repo train ---------------------
+def _routing_fake(repos, seen_paths):
+    """git/gh fake that responds PER repo path, recording which path git ran under."""
+
+    def fake_run(cmd, **kwargs):
+        if cmd[0] == "git":
+            path = cmd[2]  # after: git -C <path>
+            seen_paths.append(path)
+            meta = repos[path]
+            sub = cmd[3:]
+            if sub[:2] == ["branch", "--show-current"]:
+                return CompletedProcess(cmd, 0, stdout=meta["branch"] + "\n", stderr="")
+            if sub[0] == "rev-parse":
+                return CompletedProcess(cmd, 0, stdout=meta["head"] + "\n", stderr="")
+            if sub[0] == "log":
+                return CompletedProcess(cmd, 0, stdout=f"{meta['branch']} subject\n", stderr="")
+            if sub[0] == "push":
+                return CompletedProcess(cmd, 0, stdout="", stderr="")
+            if sub[0] == "ls-remote":
+                return CompletedProcess(cmd, 0, stdout=f'{meta["head"]}\trefs/heads/{meta["branch"]}\n', stderr="")
+            if sub[:2] == ["remote", "get-url"]:
+                return CompletedProcess(cmd, 0, stdout="https://github.com/owner/repo.git\n", stderr="")
+        if cmd[0] == "gh":
+            meta = repos[str(kwargs.get("cwd"))]
+            if cmd[1:3] == ["pr", "create"]:
+                return CompletedProcess(cmd, 0, stdout="", stderr="")
+            if cmd[1:3] == ["pr", "list"]:
+                return CompletedProcess(cmd, 0, stdout=json.dumps([{"headRefOid": meta["head"], "url": meta["url"]}]), stderr="")
+        raise AssertionError(f"unexpected command: {cmd}")
+
+    return fake_run
+
+
+def _routing_request(repo_path, meta, key):
+    admission = AdmissionRequest("attempt", 1, "fence", "digest", "head == committed", "scope", key)
+    return BrokerRequest(BrokerVerb.PUBLISH_COMMITTED_BRANCH, admission, repo_path, meta["branch"], meta["head"], ("plan.md",))
+
+
+def test_routing_broker_binds_each_request_to_its_own_repo(tmp_path):
+    repos = {
+        "/ws/alpha": {"branch": "feat/alpha", "head": "a" * 40, "url": "https://gh/pr/alpha"},
+        "/ws/beta": {"branch": "feat/beta", "head": "b" * 40, "url": "https://gh/pr/beta"},
+    }
+    seen_paths: list = []
+    broker = build_routing_broker_client(broker_root=tmp_path / "coord", run=_routing_fake(repos, seen_paths))
+
+    for path, meta in repos.items():
+        result = broker.execute(_routing_request(path, meta, key=f"k-{path}"))
+        assert result.accepted, f"{path} not accepted"
+        assert result.publish_result.pr_url == meta["url"], f"{path} routed to the wrong repo's PR"
+        assert result.publish_result.head_sha == meta["head"]
+
+    # Each node's git ran under ITS OWN worktree path — the whole point of routing.
+    assert "/ws/alpha" in seen_paths and "/ws/beta" in seen_paths
+
+
+def test_routing_broker_dedups_within_a_repo_not_across(tmp_path):
+    # Each repo has its OWN store, and within a repo the de-dup key
+    # sha256(repo\0branch\0head) makes a replay under a fresh admission key return the
+    # prior result; a different repo is a distinct store + triple (a real second effect).
+    repos = {
+        "/ws/alpha": {"branch": "feat/alpha", "head": "a" * 40, "url": "https://gh/pr/alpha"},
+        "/ws/beta": {"branch": "feat/beta", "head": "b" * 40, "url": "https://gh/pr/beta"},
+    }
+    creates = {"n": 0}
+
+    def counting(cmd, **kwargs):
+        if cmd[0] == "gh" and cmd[1:3] == ["pr", "create"]:
+            creates["n"] += 1
+        return _routing_fake(repos, [])(cmd, **kwargs)
+
+    broker = build_routing_broker_client(broker_root=tmp_path / "coord", run=counting)
+    first = broker.execute(_routing_request("/ws/alpha", repos["/ws/alpha"], key="k1"))
+    replay = broker.execute(_routing_request("/ws/alpha", repos["/ws/alpha"], key="k2-different"))
+    other = broker.execute(_routing_request("/ws/beta", repos["/ws/beta"], key="k3"))
+
+    assert creates["n"] == 2, "alpha's replay must de-dup (1 real effect); beta is a distinct triple"
+    assert replay.publish_result == first.publish_result
+    assert other.publish_result.pr_url == repos["/ws/beta"]["url"]
+
+
+def test_one_repo_ambiguous_outcome_does_not_poison_other_repos(tmp_path):
+    """A benign transient making repo alpha's publish ambiguous must NOT fail-close beta.
+
+    ``epoch_blocked`` is a global scan over a store, an ambiguous terminal is durable +
+    permanent, and it fires on benign transients (here: alpha's ls-remote read fails).
+    With a SHARED store this would set the global epoch and beta would raise
+    ``PermissionError('epoch permanently blocked')``.  Per-repo stores scope the
+    fail-closed epoch to ONLY alpha (agent-harness#208 CR).
+    """
+    repos = {
+        "/ws/alpha": {"branch": "feat/alpha", "head": "a" * 40, "url": "https://gh/pr/alpha"},
+        "/ws/beta": {"branch": "feat/beta", "head": "b" * 40, "url": "https://gh/pr/beta"},
+    }
+
+    def fake_run(cmd, **kwargs):
+        if cmd[0] == "git":
+            path = cmd[2]
+            meta = repos[path]
+            sub = cmd[3:]
+            if sub[:2] == ["branch", "--show-current"]:
+                return CompletedProcess(cmd, 0, stdout=meta["branch"] + "\n", stderr="")
+            if sub[0] == "rev-parse":
+                return CompletedProcess(cmd, 0, stdout=meta["head"] + "\n", stderr="")
+            if sub[0] == "log":
+                return CompletedProcess(cmd, 0, stdout="subject\n", stderr="")
+            if sub[0] == "push":
+                return CompletedProcess(cmd, 0, stdout="", stderr="")
+            if sub[0] == "ls-remote":
+                if path == "/ws/alpha":  # benign transient: remote read fails -> ambiguous
+                    return CompletedProcess(cmd, 1, stdout="", stderr="network hiccup")
+                return CompletedProcess(cmd, 0, stdout=f'{meta["head"]}\trefs/heads/{meta["branch"]}\n', stderr="")
+            if sub[:2] == ["remote", "get-url"]:
+                return CompletedProcess(cmd, 0, stdout="https://github.com/owner/repo.git\n", stderr="")
+        if cmd[0] == "gh":
+            meta = repos[str(kwargs.get("cwd"))]
+            if cmd[1:3] == ["pr", "create"]:
+                return CompletedProcess(cmd, 0, stdout="", stderr="")
+            if cmd[1:3] == ["pr", "list"]:
+                return CompletedProcess(cmd, 0, stdout=json.dumps([{"headRefOid": meta["head"], "url": meta["url"]}]), stderr="")
+        raise AssertionError(f"unexpected command: {cmd}")
+
+    broker = build_routing_broker_client(broker_root=tmp_path / "coord", run=fake_run)
+
+    alpha = broker.execute(_routing_request("/ws/alpha", repos["/ws/alpha"], key="ka"))
+    assert not alpha.accepted
+    assert alpha.evidence.terminal_state == "outcome_ambiguous_blocked"
+
+    # beta must still publish — alpha's ambiguous epoch is scoped to alpha's store.
+    beta = broker.execute(_routing_request("/ws/beta", repos["/ws/beta"], key="kb"))
+    assert beta.accepted, "beta was fail-closed by alpha's ambiguous outcome (shared-epoch poison)"
+    assert beta.publish_result.pr_url == repos["/ws/beta"]["url"]

phase_loop_runtime-0.7.8/tests/test_specpkgmin_wheel.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+# Bound every child process so a hung wheel build / pip dependency resolution /
+# node interchange call fails as TimeoutExpired instead of hanging the suite.
+# Generous ceiling: the wheel build + pip install is the slow leg; node calls
+# are sub-second.
+_SUBPROCESS_TIMEOUT = 300
+
+
+def _required_root(name: str) -> Path:
+    value = os.environ.get(name)
+    if not value:
+        pytest.skip(f"{name} is required for the SPECPKGMIN cross-repo seam")
+    root = Path(value).resolve()
+    if not root.is_dir():
+        pytest.fail(f"{name} is not a directory: {root}")
+    return root
+
+
+def test_installed_wheel_dogfoods_frozen_seams_and_gp_interchange(tmp_path: Path):
+    spec_root = _required_root("SPEC_ROOT")
+    gp_root = _required_root("GP_ROOT")
+    harness_root = _required_root("HARNESS_ROOT")
+    assert harness_root == Path(__file__).resolve().parents[2]
+
+    package_root = spec_root / "packages" / "consiliency-spec-ingest"
+    dist = tmp_path / "dist"
+    venv = tmp_path / "venv"
+    build_source = tmp_path / "package-source"
+    shutil.copytree(package_root, build_source, ignore=shutil.ignore_patterns("build", "*.egg-info"))
+    subprocess.run(
+        [sys.executable, "-m", "build", str(build_source), "--wheel", "--outdir", str(dist)],
+        check=True,
+        timeout=_SUBPROCESS_TIMEOUT,
+        cwd=spec_root,
+    )
+    wheel = next(dist.glob("*.whl"))
+    subprocess.run([sys.executable, "-m", "venv", str(venv)], check=True, timeout=_SUBPROCESS_TIMEOUT)
+    python = venv / "bin" / "python"
+    subprocess.run([python, "-m", "pip", "install", "--disable-pip-version-check", str(wheel)], check=True, timeout=_SUBPROCESS_TIMEOUT)
+
+    certificate_path = tmp_path / "certificate.json"
+    probe = """
+import json
+import sys
+import consiliency_spec_ingest as ingest
+
+result = ingest.evaluate({\"nodes\": []}, {\"nodes\": [], \"revision\": \"specpkgmin-empty\"}, {\"entries\": []}, config={})
+try:
+    ingest.ingest_repo(\".\", graph_id=\"specpkgmin\")
+except ingest.CapabilityUnavailable as error:
+    unavailable = {\"capability\": error.capability, \"required_extra\": error.required_extra, \"available\": error.available}
+else:
+    raise AssertionError(\"ingest_repo must remain unavailable in the base wheel\")
+print(json.dumps({\"certificate\": result[\"certificate\"], \"unavailable\": unavailable, \"loaded\": sorted(sys.modules)}))
+"""
+    observed = json.loads(subprocess.run([python, "-c", probe], check=True,
+        timeout=_SUBPROCESS_TIMEOUT, text=True, capture_output=True).stdout)
+    assert observed["certificate"]["overall_result_state"] == "not_applicable"
+    assert observed["unavailable"] == {"capability": "ingest_repo", "required_extra": "ingest", "available": False}
+    assert not any(token in name for token in ("spec_brownfield", "treesitter", "canon_core", "realized") for name in observed["loaded"])
+    certificate_path.write_text(json.dumps(observed["certificate"]), encoding="utf-8")
+
+    fixtures = gp_root / "packages" / "pipeline-runtime" / "test" / "fixtures" / "specpkgmin"
+    helper = fixtures / "specpkgmin-interchange.mjs"
+    command = ["node", str(helper), str(certificate_path), str(fixtures / "canonical-spec-registry.json"), str(fixtures / "catalog-schema.v1.json")]
+    interchange = json.loads(subprocess.run(command, cwd=gp_root, check=True,
+        timeout=_SUBPROCESS_TIMEOUT, text=True, capture_output=True).stdout)
+    assert interchange["result"]["ok"] is True
+    assert interchange["result"]["verdict"]["overall_result_state"] == "not_applicable"
+    assert interchange["result"]["ratifiable"] is False
+    assert interchange["registry_bytes_unchanged"] is True
+    assert interchange["catalog_bytes_unchanged"] is True
+
+    malformed_path = tmp_path / "malformed-vacuity.json"
+    malformed = dict(observed["certificate"])
+    malformed["vacuity"] = "not-an-object"
+    malformed_path.write_text(json.dumps(malformed), encoding="utf-8")
+    malformed_result = json.loads(
+        subprocess.run(
+            ["node", str(helper), str(malformed_path), str(fixtures / "canonical-spec-registry.json"), str(fixtures / "catalog-schema.v1.json")],
+            cwd=gp_root,
+            check=True,
+        timeout=_SUBPROCESS_TIMEOUT,
+            text=True,
+            capture_output=True,
+        ).stdout
+    )
+    assert malformed_result["result"]["ok"] is False
+    assert malformed_result["result"]["blocker"]["blocker_class"] == "malformed_spec_certificate"