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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.7.7
+Version: 0.7.9
 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.9}/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.9"
 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.9}/src/phase_loop_runtime/__init__.py

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

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.9}/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.9}/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.9}/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.9/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/src/phase_loop_runtime/skills_bundle/gemini-execute-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/claude-execute-phase}/scripts/validate_plan_doc.py

@@ -477,6 +477,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -613,6 +643,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
 

{phase_loop_runtime-0.7.7/src/phase_loop_runtime/skills_bundle/gemini-plan-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/claude-plan-phase}/scripts/validate_plan_doc.py

@@ -560,6 +560,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -1057,6 +1087,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
     findings.extend(_check_i_spec_closeout_plan(src))

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.9}/src/phase_loop_runtime/skills_bundle/codex-execute-phase/scripts/validate_plan_doc.py

@@ -477,6 +477,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -613,6 +643,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
 

{phase_loop_runtime-0.7.7/src/phase_loop_runtime/skills_bundle/opencode-plan-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/codex-plan-phase}/scripts/validate_plan_doc.py

@@ -560,6 +560,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -1057,6 +1087,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
     findings.extend(_check_i_spec_closeout_plan(src))

{phase_loop_runtime-0.7.7/src/phase_loop_runtime/skills_bundle/opencode-execute-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/gemini-execute-phase}/scripts/validate_plan_doc.py

@@ -477,6 +477,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -613,6 +643,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
 

{phase_loop_runtime-0.7.7/src/phase_loop_runtime/skills_bundle/codex-plan-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/gemini-plan-phase}/scripts/validate_plan_doc.py

@@ -560,6 +560,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -1057,6 +1087,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
     findings.extend(_check_i_spec_closeout_plan(src))

{phase_loop_runtime-0.7.7/src/phase_loop_runtime/skills_bundle/claude-execute-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/opencode-execute-phase}/scripts/validate_plan_doc.py

@@ -477,6 +477,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -613,6 +643,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
 

{phase_loop_runtime-0.7.7/src/phase_loop_runtime/skills_bundle/claude-plan-phase → phase_loop_runtime-0.7.9/src/phase_loop_runtime/skills_bundle/opencode-plan-phase}/scripts/validate_plan_doc.py

@@ -560,6 +560,36 @@ def _check_f_interfaces_trace(
     return out
 
 
+def _check_o_producer_dependency(plan_path: Path) -> Findings:
+    """(O) A lane consuming an interface PROVIDED by another in-plan lane must depend on
+    that lane directly. Rather than REIMPLEMENT the parse + interface identity (which
+    reintroduces the very validator-vs-runtime divergence this closes — different lane
+    parsers and a normalized vs exact-string interface identity), DELEGATE to the runtime
+    lane IR (`phase_loop_runtime.plan_ir`) — the single source of truth the scheduler
+    fails closed on with `missing_producer_dependency`. Parity is then true by
+    construction. If the runtime is not importable at plan time, skip: the execute-time
+    lane IR still enforces the contract (no regression, and no divergent pre-warn).
+    agent-harness#182."""
+    try:
+        from phase_loop_runtime.plan_ir import parse_phase_plan_ir
+    except Exception:
+        return []
+    try:
+        ir = parse_phase_plan_ir(Path(plan_path))
+    except Exception:
+        # Parse/format errors are other checks' domain (A/B/C); (O) only speaks to the
+        # producer-dependency edge and stays silent when the plan cannot be parsed.
+        return []
+    out: Findings = []
+    for diag in getattr(ir, "diagnostics", ()):  # LaneIRDiagnostic
+        if getattr(diag, "kind", "") == "missing_producer_dependency":
+            out.append(
+                f"(O) {diag.message} — add the producer to the consumer's `Depends on` "
+                f"(the lane IR fails closed with missing_producer_dependency at execute time)"
+            )
+    return out
+
+
 def _check_g_grep_paired_with_tests(src: str) -> Findings:
     """Every acceptance criterion that uses `rg`/`grep` as its sole assertion
     must cite a test file in the same bullet. A bare grep is defeatable by
@@ -1057,6 +1087,7 @@ def main(argv: List[str]) -> int:
     findings.extend(_check_d_owned_files_disjoint(lane_sections_parsed, repo_root))
     findings.extend(_check_e_test_before_impl(lane_sections_parsed))
     findings.extend(_check_f_interfaces_trace(lane_sections_parsed, lane_sections_raw))
+    findings.extend(_check_o_producer_dependency(path))
     findings.extend(_check_g_grep_paired_with_tests(src))
     findings.extend(_check_h_eager_reexport(src))
     findings.extend(_check_i_spec_closeout_plan(src))

{phase_loop_runtime-0.7.7 → phase_loop_runtime-0.7.9}/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.9
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author: ViperJuice
 License-Expression: Apache-2.0