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

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

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

{phase_loop_runtime-0.7.6 → phase_loop_runtime-0.7.7}/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.6"
+version = "0.7.7"
 description = "Harness-neutral phase-loop orchestration runtime and CLI"
 readme = "README.md"
 requires-python = ">=3.10"

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

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

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

@@ -653,6 +653,19 @@ def build_parser() -> argparse.ArgumentParser:
             "Default: current directory."
         ),
     )
+    run_train_sub.add_argument(
+        "--workspace",
+        dest="workspace_overrides",
+        action="append",
+        default=None,
+        metavar="repo=PATH",
+        help=(
+            "Per-node workspace override: map a node's repo to an arbitrary "
+            "absolute checkout path (e.g. a different volume). Repeatable: "
+            "--workspace my-service=/mnt/vol/my-service. Takes precedence over "
+            "a node's **Workspace:** attribute and the --workspace-root default."
+        ),
+    )
     run_train_sub.add_argument(
         "--ledger-dir",
         default=None,
@@ -2886,9 +2899,29 @@ def _run_train_command(*, parser: argparse.ArgumentParser, args: argparse.Namesp
     # run_mode mirrors how 'run' handles --governed (cli.py:796)
     run_mode = "governed" if bool(getattr(args, "governed", False)) else "autonomous"
 
-    # Workspace resolution: <workspace-root>/<node.repo>
+    # Workspace resolution precedence (highest first):
+    #   1. --workspace <repo>=<path> CLI override (arbitrary absolute paths)
+    #   2. the node's **Workspace:** attribute (from the train roadmap)
+    #   3. <workspace-root>/<node.repo>  (the default)
     workspace_root = Path(getattr(args, "workspace_root", None) or ".")
+    workspace_overrides: dict = {}
+    for spec in getattr(args, "workspace_overrides", None) or []:
+        if "=" not in spec:
+            parser.error(f"--workspace expects 'repo=PATH', got {spec!r}")
+        repo_key, _, path_val = spec.partition("=")
+        repo_key = repo_key.strip()
+        path_val = path_val.strip()
+        if not repo_key or not path_val:
+            parser.error(f"--workspace expects a non-empty 'repo=PATH', got {spec!r}")
+        workspace_overrides[repo_key] = Path(path_val)
+
     def _resolve_workspace(node) -> Path:
+        override = workspace_overrides.get(node.repo)
+        if override is not None:
+            return override
+        node_ws = getattr(node, "workspace", None)
+        if node_ws:
+            return Path(node_ws)
         return workspace_root / node.repo
 
     # Ledger path — must not be inside any repo's .phase-loop/

{phase_loop_runtime-0.7.6 → phase_loop_runtime-0.7.7}/src/phase_loop_runtime/train_roadmap.py

@@ -45,12 +45,27 @@ from .cross_repo_channel import ChannelDescriptor, parse_channel_line
 # ---------------------------------------------------------------------------
 # Data model — IF-0-P2-1
 
+#: Supported node modes.  ``execute`` (default) runs the per-repo run_loop to
+#: build the node's phase, then publishes what it produced.  ``prebuilt`` lands
+#: an already-committed, independently-verified branch WITHOUT re-executing the
+#: phase (no executor dispatch) — see ``train_runner`` for the prebuilt path.
+SUPPORTED_NODE_MODES = frozenset({"execute", "prebuilt"})
+
+
 @dataclass(frozen=True)
 class TrainNode:
-    """Identity of one node in the release train: a ``(repo, roadmap)`` pair."""
+    """Identity of one node in the release train: a ``(repo, roadmap)`` pair.
+
+    ``mode`` selects how the coordinator lands the node (``execute`` = run the
+    phase then publish; ``prebuilt`` = publish an already-committed branch with
+    no executor dispatch).  ``workspace`` optionally overrides where the node's
+    checkout lives on disk (an absolute path), for nodes on arbitrary volumes.
+    """
 
     repo: str
     roadmap: str
+    mode: str = "execute"
+    workspace: Optional[str] = None
 
     @property
     def node_id(self) -> str:
@@ -116,7 +131,7 @@ class TrainRoadmap:
 _TITLE_RE = re.compile(r"^#\s+Release Train:\s*(.+?)\s*$", re.MULTILINE)
 _NODE_HEADING_RE = re.compile(r"^###\s+Node:\s*(.+?)\s*$", re.MULTILINE)
 _FIELD_RE = re.compile(
-    r"^\*\*(?P<label>Depends on|Channel):\*\*\s*(?P<value>.+)$",
+    r"^\*\*(?P<label>Depends on|Channel|Mode|Workspace):\*\*\s*(?P<value>.+)$",
     re.MULTILINE | re.IGNORECASE,
 )
 
@@ -180,13 +195,41 @@ def parse_train_roadmap(text: str) -> TrainRoadmap:
     raw_edges: List[Tuple[TrainNode, str, str]] = []  # (downstream, dep_id, channel_raw)
 
     for raw_id, body in node_bodies:
-        node = _parse_node_id(raw_id)
-        nodes.append(node)
+        base = _parse_node_id(raw_id)
 
         fields: Dict[str, str] = {}
         for m in _FIELD_RE.finditer(body):
             fields[m.group("label").lower()] = m.group("value").strip()
 
+        # Mode: default 'execute'; a bare (none) value also means the default.
+        # Reject any unknown mode with a coded, node-named parse error.  (T-A..
+        # T-F are taken by validate_train; (T-G) is the next free code and keeps
+        # the same coded-diagnostic style for the mode-grammar violation.)
+        mode_raw = fields.get("mode", "execute").strip().lower()
+        if mode_raw in _NONE_VALUES:
+            mode_raw = "execute"
+        if mode_raw not in SUPPORTED_NODE_MODES:
+            raise ValueError(
+                f"(T-G) node '{base.node_id}' declares unknown mode {mode_raw!r}; "
+                f"supported modes are 'execute' (default) and 'prebuilt'"
+            )
+
+        # Workspace: optional per-node absolute-path override for the checkout.
+        workspace_raw = fields.get("workspace")
+        workspace = (
+            workspace_raw.strip()
+            if workspace_raw and workspace_raw.strip().lower() not in _NONE_VALUES
+            else None
+        )
+
+        node = TrainNode(
+            repo=base.repo,
+            roadmap=base.roadmap,
+            mode=mode_raw,
+            workspace=workspace,
+        )
+        nodes.append(node)
+
         dep_raw = fields.get("depends on", "(none)")
         channel_raw = fields.get("channel", "(none)")
 

{phase_loop_runtime-0.7.6 → phase_loop_runtime-0.7.7}/src/phase_loop_runtime/train_runner.py

@@ -72,6 +72,11 @@ from .train_roadmap import TrainEdge, TrainNode, TrainRoadmap
 ResolveWorkspace = Callable[[TrainNode], Path]
 ResolveOwnedPaths = Callable[[TrainNode], Sequence[str]]
 
+#: Default base branch a prebuilt node's committed work is measured against.
+#: Matches ``_check_base_branch_exists``'s default so the ahead-check and the
+#: existence-check agree on which ``origin/<base>`` to use.
+_DEFAULT_BASE = "main"
+
 
 @dataclass(frozen=True)
 class CoordinatorRuntime:
@@ -195,6 +200,71 @@ def _check_base_branch_exists(
     return None
 
 
+def _check_branch_ahead_of_base(
+    workspace: Path, node_id: str, base: str = _DEFAULT_BASE
+) -> Optional[str]:
+    """Return an error string if the branch is NOT strictly ahead of origin/<base>.
+
+    A prebuilt node must carry committed work — a clean-but-not-ahead workspace
+    has nothing to publish, which is a preflight error.  Uses the two-dot
+    ``origin/<base>..HEAD`` count (commits on HEAD not on base).
+    """
+    completed = subprocess.run(
+        ["git", "-C", str(workspace), "rev-list", "--count", f"origin/{base}..HEAD"],
+        capture_output=True,
+        text=True,
+        timeout=15,
+    )
+    if completed.returncode != 0:
+        return (
+            f"[{node_id}] could not compute commits ahead of 'origin/{base}': "
+            f"{completed.stderr.strip() or 'rev-list failed'}"
+        )
+    try:
+        ahead = int(completed.stdout.strip() or "0")
+    except ValueError:
+        ahead = 0
+    if ahead <= 0:
+        return (
+            f"[{node_id}] prebuilt node workspace '{workspace}' is clean but not "
+            f"ahead of 'origin/{base}' — nothing to publish (a prebuilt node must "
+            f"carry committed work)"
+        )
+    return None
+
+
+def _prebuilt_owned_paths(
+    workspace: Path, base: str = _DEFAULT_BASE
+) -> List[str]:
+    """Return the paths a prebuilt branch changed vs origin/<base> (committed diff).
+
+    Uses the three-dot ``origin/<base>...HEAD`` diff (changes on HEAD since the
+    merge-base) so the published PR's owned-paths reflect exactly the committed
+    work.  Stubbable seam: inject ``_prebuilt_owned_paths_fn`` into
+    :func:`run_train`.
+    """
+    completed = subprocess.run(
+        ["git", "-C", str(workspace), "diff", "--name-only", f"origin/{base}...HEAD"],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    if completed.returncode != 0:
+        # Fail CLOSED: a diff error must not yield an empty owned-paths scope that the
+        # broker admission would approve while the push still publishes the real branch
+        # (approved-nothing / published-something scope mismatch).  Raising blocks the node.
+        raise RuntimeError(
+            f"could not compute prebuilt owned paths vs 'origin/{base}': "
+            f"{completed.stderr.strip() or 'git diff failed'}"
+        )
+    owned = [p.strip() for p in completed.stdout.splitlines() if p.strip()]
+    if not owned:
+        # A prebuilt node that is ahead-of-base yet has no net file changes has nothing
+        # to publish — fail closed rather than admit an empty scope.
+        raise RuntimeError(f"prebuilt branch has no committed changes vs 'origin/{base}' to publish")
+    return owned
+
+
 def _default_preflight(
     nodes: List[TrainNode],
     resolve_workspace: ResolveWorkspace,
@@ -206,6 +276,11 @@ def _default_preflight(
     2. Per-repo: workspace clean (no uncommitted changes).
     3. Per-repo: remote ``origin`` is reachable.
     4. Per-repo: base branch ``origin/main`` exists.
+    5. Prebuilt nodes only: the branch is strictly AHEAD of ``origin/main``
+       (it carries the committed work).  A clean-but-not-ahead prebuilt node
+       is a preflight error — nothing to publish.
+
+    Execute-node checks (2–4) are unchanged; prebuilt adds check 5.
 
     A non-empty return means the entry gate is closed; zero PRs must be opened.
     """
@@ -218,11 +293,15 @@ def _default_preflight(
 
     for node in nodes:
         workspace = resolve_workspace(node)
-        for check_fn in (
+        checks = [
             _check_repo_clean,
             _check_remote_reachable,
             _check_base_branch_exists,
-        ):
+        ]
+        # Prebuilt nodes must additionally be strictly ahead of the base.
+        if getattr(node, "mode", "execute") == "prebuilt":
+            checks.append(_check_branch_ahead_of_base)
+        for check_fn in checks:
             err = check_fn(workspace, node.node_id)
             if err:
                 errors.append(err)
@@ -666,6 +745,9 @@ def run_train(
     _pr_is_open: Optional[Callable] = None,
     _live_pr_head_sha_fn: Optional[Callable] = None,
     _preflight_fn: Optional[Callable] = None,
+    # Prebuilt-node seam: derives a prebuilt branch's owned paths from its
+    # committed diff vs base.  Defaults to the live git implementation.
+    _prebuilt_owned_paths_fn: Optional[Callable] = None,
     # Broker admission builder (runtime, node, workspace, owned_paths) → AdmissionRequest.
     # Only invoked when a broker-authoritative coordinator_runtime is supplied.
     _admission_fn: Optional[Callable] = None,
@@ -753,6 +835,11 @@ def run_train(
         _live_pr_head_sha_fn if _live_pr_head_sha_fn is not None else _live_pr_head_sha
     )
     preflight_fn = _preflight_fn if _preflight_fn is not None else _default_preflight
+    prebuilt_owned_paths_fn = (
+        _prebuilt_owned_paths_fn
+        if _prebuilt_owned_paths_fn is not None
+        else _prebuilt_owned_paths
+    )
     admission_fn = _admission_fn if _admission_fn is not None else _default_build_admission
 
     # Track whether caller supplied an explicit owned-paths resolver so we know
@@ -775,6 +862,26 @@ def run_train(
     # --- Step 1: Topo-sort (raises ValueError on cycle) --------------------
     topo_order = roadmap.topo_order()
 
+    # Prebuilt nodes stop at drafts_open; P4 governed merge for prebuilt nodes
+    # is out of scope (the re-verify path expects per-repo phase-loop state a
+    # prebuilt node need not carry).  Fail loud BEFORE any PR opens rather than
+    # emit a misleading reverify failure mid-merge.  Follow-up: a prebuilt-aware
+    # P4 re-verify (verify the committed branch against the merged upstream pin).
+    if _merge_phase_enabled and run_mode == "governed":
+        prebuilt_ids = [
+            n.node_id for n in topo_order
+            if getattr(n, "mode", "execute") == "prebuilt"
+        ]
+        if prebuilt_ids:
+            return {
+                "status": "preflight_failed",
+                "errors": [
+                    "prebuilt node(s) are not supported under --governed (P4 merge): "
+                    f"{', '.join(prebuilt_ids)}; run without --governed to open draft "
+                    "PRs and stop at drafts_open, then merge the prebuilt PRs manually"
+                ],
+            }
+
     # --- Step 2: Train-level preflight — ALL repos, BEFORE any PR ----------
     # This is the structural guarantee that preflight failure → zero PRs:
     # we return immediately here, before the per-node loop is entered.
@@ -930,138 +1037,171 @@ def run_train(
         append_record(ledger_path, LedgerRecord(node_id=nid, status="running"))
 
         try:
-            # (i) Inject upstream draft refs (IF-0-P2-2) BEFORE run_loop.
-            #     Collect injected paths to union into owned_paths after run_loop.
-            #
-            # The guard below is a defensive invariant.  It should be unreachable
-            # in a well-formed train: validate_train_loud (T-B) ensures every
-            # upstream is a declared node, and topo-sort guarantees we processed
-            # it before this node.  If the upstream failed/was blocked, run_train
-            # returns immediately and never reaches this downstream.  Kept here to
-            # make the "no silent skip" contract explicit and catch future refactors.
-            injected_channel_paths: List[str] = []
-            for edge in upstream_edges:
-                if edge.channel.kind == "order-only":
-                    # #47: an order-only edge enforces merge ORDER (via the topo
-                    # sort + sequential per-node execution) but carries no physical
-                    # channel — the downstream does not consume the upstream, so
-                    # there is nothing to inject. Skip; do not resolve a ref.
-                    continue
-                upstream_result = completed_nodes.get(edge.upstream.node_id)
-                if upstream_result is None:
-                    # Defensive: topo-order + T-B validation make this
-                    # unreachable; kept as an explicit fail-loud guard.
-                    raise RuntimeError(
-                        f"upstream ref for '{edge.upstream.node_id}' is not resolved "
-                        f"(not in completed_nodes) — cannot inject into "
-                        f"'{nid}'; the upstream must be built and published first"
-                    )
-                ref = upstream_result.get("head_sha")
-                if not ref:
-                    # Block: do NOT fall back to injecting a moving branch name.
-                    # A missing SHA means neither the live query nor the ledger
-                    # have a pinnable ref — injecting a branch name would build
-                    # the downstream against a moving target.
-                    raise RuntimeError(
-                        f"no resolvable SHA for upstream '{edge.upstream.node_id}' "
-                        f"(live head SHA query returned None and ledger head_sha is "
-                        f"None); cannot inject a moving branch name for channel "
-                        f"{edge.channel.kind!r} — resolve the upstream SHA and re-run"
+            if getattr(node, "mode", "execute") == "prebuilt":
+                # Prebuilt node: land already-committed, independently-verified
+                # work.  NO upstream injection (it would dirty the clean tree and
+                # force a re-commit), NO run_loop (no executor dispatch), NO
+                # snapshot guard.  owned_paths come from the committed diff vs
+                # base (or an explicit resolver); publish pushes the existing
+                # branch WITHOUT a new commit (prebuilt=True).
+                if _explicit_owned_paths:
+                    owned_paths = list(resolve_owned_paths(node))  # type: ignore[arg-type]
+                else:
+                    owned_paths = list(prebuilt_owned_paths_fn(workspace, _DEFAULT_BASE))
+                pr_body = _build_pr_body(node, topo_order, completed_nodes, upstream_edges)
+                publish_kwargs: Dict[str, object] = {
+                    "draft": True,  # P3 invariant: draft-only, never merge
+                    "pr_body": pr_body,
+                    "prebuilt": True,
+                }
+                # Route the prebuilt publish through the broker EXACTLY as the
+                # execute path does: a broker-authoritative coordinator_runtime
+                # supplies the client + a per-node admission.  Without a
+                # broker_client the publish primitive fails closed
+                # (broker_required) — a prebuilt node never does a direct push.
+                if coordinator_runtime is not None:
+                    publish_kwargs["broker_client"] = coordinator_runtime.broker_client
+                    publish_kwargs["admission"] = admission_fn(
+                        coordinator_runtime, node, workspace, owned_paths
                     )
-                injected = set_upstream_ref_fn(workspace, edge.channel, ref)
-                if injected:
-                    injected_channel_paths.extend(injected)
-
-            # (ii) Invoke the unchanged per-repo run_loop.
-            #      The real run_loop returns (StateSnapshot, list[LaunchResult]).
-            result_tuple = run_loop_fn(
-                workspace, workspace / node.roadmap, run_mode=run_mode
-            )
-
-            # SHOULD-FIX 3: Guard against partial multi-phase nodes.
-            #
-            # run_loop defaults to max_phases=1, so a node with a >1-phase
-            # roadmap stops after the first phase.  If any phase is still
-            # "planned" the node is incomplete — publishing it ships a partial
-            # draft PR.  Block loudly instead.
-            #
-            # Use getattr so we're forward-compatible with test fixtures that
-            # return lightweight SimpleNamespace objects lacking a phases field.
-            _node_snapshot = result_tuple[0] if isinstance(result_tuple, tuple) else None
-            _node_phases = getattr(_node_snapshot, "phases", None)
-            if _node_phases is not None:
-                # A node may publish a draft PR only when EVERY phase reached a
-                # clean green terminal — "complete" or "awaiting_phase_closeout"
-                # (the post-run_loop success state under manual closeout).  ANY
-                # other state (planned/blocked/failed_verification/executing/
-                # human_required/unknown) means the node is incomplete or broken.
-                # Blocking only "planned" (the prior narrow guard) let a
-                # *failed*-phase node publish a draft that could later trivial-pass
-                # P4 re-verify on a no-verification plan — a combined false-green.
-                # Block loudly on any non-green phase instead.
-                _GREEN_PHASE_STATES = {"complete", "awaiting_phase_closeout"}
-                _not_green = sorted(
-                    ph for ph, st in _node_phases.items() if st not in _GREEN_PHASE_STATES
+                publish_result = publish_fn(
+                    workspace,
+                    owned_paths,
+                    **publish_kwargs,
                 )
-                if _not_green:
-                    raise RuntimeError(
-                        f"node '{nid}' has phases not in a green state after run_loop "
-                        f"({', '.join(_not_green)}); refusing to publish a partial or "
-                        f"failed draft PR — every phase must reach complete/"
-                        f"awaiting_phase_closeout before publishing"
-                    )
-
-            # (iii) Determine owned paths (Finding #1).
-            #       If the caller supplied an explicit resolver, honour it.
-            #       Otherwise use the snapshot's produced/owned paths so the
-            #       published PR contains the actual implementation, not just
-            #       the roadmap file.
-            if _explicit_owned_paths:
-                owned_paths = list(resolve_owned_paths(node))  # type: ignore[arg-type]
             else:
-                snapshot = result_tuple[0] if isinstance(result_tuple, tuple) else None
-                if snapshot is not None:
-                    produced = (
-                        getattr(snapshot, "phase_owned_dirty_paths", None)
-                        or getattr(snapshot, "dirty_paths", None)
-                        or ()
+                # (i) Inject upstream draft refs (IF-0-P2-2) BEFORE run_loop.
+                #     Collect injected paths to union into owned_paths after run_loop.
+                #
+                # The guard below is a defensive invariant.  It should be unreachable
+                # in a well-formed train: validate_train_loud (T-B) ensures every
+                # upstream is a declared node, and topo-sort guarantees we processed
+                # it before this node.  If the upstream failed/was blocked, run_train
+                # returns immediately and never reaches this downstream.  Kept here to
+                # make the "no silent skip" contract explicit and catch future refactors.
+                injected_channel_paths: List[str] = []
+                for edge in upstream_edges:
+                    if edge.channel.kind == "order-only":
+                        # #47: an order-only edge enforces merge ORDER (via the topo
+                        # sort + sequential per-node execution) but carries no physical
+                        # channel — the downstream does not consume the upstream, so
+                        # there is nothing to inject. Skip; do not resolve a ref.
+                        continue
+                    upstream_result = completed_nodes.get(edge.upstream.node_id)
+                    if upstream_result is None:
+                        # Defensive: topo-order + T-B validation make this
+                        # unreachable; kept as an explicit fail-loud guard.
+                        raise RuntimeError(
+                            f"upstream ref for '{edge.upstream.node_id}' is not resolved "
+                            f"(not in completed_nodes) — cannot inject into "
+                            f"'{nid}'; the upstream must be built and published first"
+                        )
+                    ref = upstream_result.get("head_sha")
+                    if not ref:
+                        # Block: do NOT fall back to injecting a moving branch name.
+                        # A missing SHA means neither the live query nor the ledger
+                        # have a pinnable ref — injecting a branch name would build
+                        # the downstream against a moving target.
+                        raise RuntimeError(
+                            f"no resolvable SHA for upstream '{edge.upstream.node_id}' "
+                            f"(live head SHA query returned None and ledger head_sha is "
+                            f"None); cannot inject a moving branch name for channel "
+                            f"{edge.channel.kind!r} — resolve the upstream SHA and re-run"
+                        )
+                    injected = set_upstream_ref_fn(workspace, edge.channel, ref)
+                    if injected:
+                        injected_channel_paths.extend(injected)
+
+                # (ii) Invoke the unchanged per-repo run_loop.
+                #      The real run_loop returns (StateSnapshot, list[LaunchResult]).
+                result_tuple = run_loop_fn(
+                    workspace, workspace / node.roadmap, run_mode=run_mode
+                )
+
+                # SHOULD-FIX 3: Guard against partial multi-phase nodes.
+                #
+                # run_loop defaults to max_phases=1, so a node with a >1-phase
+                # roadmap stops after the first phase.  If any phase is still
+                # "planned" the node is incomplete — publishing it ships a partial
+                # draft PR.  Block loudly instead.
+                #
+                # Use getattr so we're forward-compatible with test fixtures that
+                # return lightweight SimpleNamespace objects lacking a phases field.
+                _node_snapshot = result_tuple[0] if isinstance(result_tuple, tuple) else None
+                _node_phases = getattr(_node_snapshot, "phases", None)
+                if _node_phases is not None:
+                    # A node may publish a draft PR only when EVERY phase reached a
+                    # clean green terminal — "complete" or "awaiting_phase_closeout"
+                    # (the post-run_loop success state under manual closeout).  ANY
+                    # other state (planned/blocked/failed_verification/executing/
+                    # human_required/unknown) means the node is incomplete or broken.
+                    # Blocking only "planned" (the prior narrow guard) let a
+                    # *failed*-phase node publish a draft that could later trivial-pass
+                    # P4 re-verify on a no-verification plan — a combined false-green.
+                    # Block loudly on any non-green phase instead.
+                    _GREEN_PHASE_STATES = {"complete", "awaiting_phase_closeout"}
+                    _not_green = sorted(
+                        ph for ph, st in _node_phases.items() if st not in _GREEN_PHASE_STATES
                     )
-                    owned_paths = list(produced)
+                    if _not_green:
+                        raise RuntimeError(
+                            f"node '{nid}' has phases not in a green state after run_loop "
+                            f"({', '.join(_not_green)}); refusing to publish a partial or "
+                            f"failed draft PR — every phase must reach complete/"
+                            f"awaiting_phase_closeout before publishing"
+                        )
+
+                # (iii) Determine owned paths (Finding #1).
+                #       If the caller supplied an explicit resolver, honour it.
+                #       Otherwise use the snapshot's produced/owned paths so the
+                #       published PR contains the actual implementation, not just
+                #       the roadmap file.
+                if _explicit_owned_paths:
+                    owned_paths = list(resolve_owned_paths(node))  # type: ignore[arg-type]
                 else:
-                    owned_paths = []
-
-            # Union the coordinator-injected channel paths into owned_paths so
-            # the pin/submodule change always ships in the PR even if run_loop's
-            # snapshot doesn't include the injected file (Finding #6 / union fix).
-            # de-duplicate while preserving order (snapshot paths first).
-            if injected_channel_paths:
-                seen = set(owned_paths)
-                for p in injected_channel_paths:
-                    if p not in seen:
-                        owned_paths.append(p)
-                        seen.add(p)
-
-            # (iv) Publish as draft PR via the P1 runtime primitive.
-            #      draft=True is structural — P3 never merges.
-            pr_body = _build_pr_body(node, topo_order, completed_nodes, upstream_edges)
-            publish_kwargs: Dict[str, object] = {
-                "draft": True,  # P3 invariant: draft-only, never merge
-                "pr_body": pr_body,
-            }
-            # Route the publish through the broker's admission+verb path when a
-            # broker-authoritative runtime is supplied.  Past the line-699 guard,
-            # coordinator_runtime is not None ⟹ broker_client is not None.  Legacy
-            # callers (no runtime) publish exactly as before — no broker kwargs.
-            if coordinator_runtime is not None:
-                publish_kwargs["broker_client"] = coordinator_runtime.broker_client
-                publish_kwargs["admission"] = admission_fn(
-                    coordinator_runtime, node, workspace, owned_paths
+                    snapshot = result_tuple[0] if isinstance(result_tuple, tuple) else None
+                    if snapshot is not None:
+                        produced = (
+                            getattr(snapshot, "phase_owned_dirty_paths", None)
+                            or getattr(snapshot, "dirty_paths", None)
+                            or ()
+                        )
+                        owned_paths = list(produced)
+                    else:
+                        owned_paths = []
+
+                # Union the coordinator-injected channel paths into owned_paths so
+                # the pin/submodule change always ships in the PR even if run_loop's
+                # snapshot doesn't include the injected file (Finding #6 / union fix).
+                # de-duplicate while preserving order (snapshot paths first).
+                if injected_channel_paths:
+                    seen = set(owned_paths)
+                    for p in injected_channel_paths:
+                        if p not in seen:
+                            owned_paths.append(p)
+                            seen.add(p)
+
+                # (iv) Publish as draft PR via the P1 runtime primitive.
+                #      draft=True is structural — P3 never merges.
+                pr_body = _build_pr_body(node, topo_order, completed_nodes, upstream_edges)
+                publish_kwargs: Dict[str, object] = {
+                    "draft": True,  # P3 invariant: draft-only, never merge
+                    "pr_body": pr_body,
+                }
+                # Route the publish through the broker's admission+verb path when a
+                # broker-authoritative runtime is supplied.  Past the line-699 guard,
+                # coordinator_runtime is not None ⟹ broker_client is not None.  Legacy
+                # callers (no runtime) publish exactly as before — no broker kwargs.
+                if coordinator_runtime is not None:
+                    publish_kwargs["broker_client"] = coordinator_runtime.broker_client
+                    publish_kwargs["admission"] = admission_fn(
+                        coordinator_runtime, node, workspace, owned_paths
+                    )
+                publish_result = publish_fn(
+                    workspace,
+                    owned_paths,
+                    **publish_kwargs,
                 )
-            publish_result = publish_fn(
-                workspace,
-                owned_paths,
-                **publish_kwargs,
-            )
 
         except Exception as exc:
             # Inject or run_loop or publish raised — mark blocked so the node

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

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

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

@@ -752,6 +752,7 @@ tests/test_train_e2e.py
 tests/test_train_invariants.py
 tests/test_train_merge.py
 tests/test_train_order_only_deps_47.py
+tests/test_train_prebuilt.py
 tests/test_train_roadmap.py
 tests/test_train_runner.py
 tests/test_unattended_release.py