phase-loop-runtime 0.7.22__tar.gz → 0.7.24__tar.gz

{phase_loop_runtime-0.7.22/src/phase_loop_runtime.egg-info → phase_loop_runtime-0.7.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.7.22
+Version: 0.7.24
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author-email: ViperJuice <viperjuice@users.noreply.github.com>
 License-Expression: Apache-2.0
@@ -16,7 +16,8 @@ Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: detect-secrets==1.5.0
-Requires-Dist: baml-py<0.223,>=0.222
+Requires-Dist: baml-bridge==0.20.1
+Requires-Dist: protobuf<8,>=6.31.1
 Requires-Dist: pydantic<3,>=2
 Requires-Dist: PyYAML<7,>=6
 Requires-Dist: consiliency-contract<0.7,>=0.6.5
@@ -49,7 +50,7 @@ To install just this runtime package directly:
 
 ```sh
 pip install phase-loop-runtime              # latest compatible release
-pip install phase-loop-runtime==0.7.22      # …or pin an exact version
+pip install phase-loop-runtime==0.7.24      # …or pin an exact version
 ```
 
 To pin a specific tag from source instead, substitute a tag from

{phase_loop_runtime-0.7.22 → phase_loop_runtime-0.7.24}/README.md

@@ -19,7 +19,7 @@ To install just this runtime package directly:
 
 ```sh
 pip install phase-loop-runtime              # latest compatible release
-pip install phase-loop-runtime==0.7.22      # …or pin an exact version
+pip install phase-loop-runtime==0.7.24      # …or pin an exact version
 ```
 
 To pin a specific tag from source instead, substitute a tag from

{phase_loop_runtime-0.7.22 → phase_loop_runtime-0.7.24}/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.22"
+version = "0.7.24"
 description = "Harness-neutral phase-loop orchestration runtime and CLI"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -20,7 +20,8 @@ classifiers = [
 ]
 dependencies = [
     "detect-secrets==1.5.0",
-    "baml-py>=0.222,<0.223",
+    "baml-bridge==0.20.1",
+    "protobuf>=6.31.1,<8",
     "pydantic>=2,<3",
     "PyYAML>=6,<7",
     # PIN (spec-integration v0.3.0): floor at 0.6.3 -- ships the `gate_posture_registry`
@@ -155,6 +156,7 @@ phase_loop_runtime = [
 markers = [
     "dotfiles_integration: test requires a dotfiles fleet tree (skipped standalone)",
     "quarantine(reason): known flake tracked by an OPEN issue; deselected on pull-request CI only (agent-harness#1029)",
+    "host_seat_credentials: live jailed-seat test that reads the host's Claude login and seat-jail state (agent-harness#1132)",
 ]
 
 [tool.setuptools.data-files]

{phase_loop_runtime-0.7.22 → phase_loop_runtime-0.7.24}/src/phase_loop_runtime/__init__.py

@@ -18,4 +18,4 @@ __all__ = [
     "state_ops",
 ]
 
-__version__ = "0.7.22"
+__version__ = "0.7.24"

phase_loop_runtime-0.7.24/src/phase_loop_runtime/_baml_worker.py

@@ -0,0 +1,202 @@
+"""BAML v1 worker process for ``phase_loop_runtime.baml_modular`` (agent-harness#1135).
+
+This file runs as a standalone script (``python -I -S _baml_worker.py ...``).
+It imports only the standard library and, after ``init``, ``baml_bridge``; it
+never imports ``phase_loop_runtime``.  Importing this module has no side
+effects: everything below runs under ``if __name__ == "__main__":``.
+
+argv: ``<owner pid> <comma-separated env allowlist keys> [--no-pdeathsig]``.
+
+Protocol: one JSON object per line, UTF-8 with ``ensure_ascii=True``.  Requests
+arrive on fd 0; responses leave on a dup of fd 1 taken before fd 1 is pointed
+at stderr, so nothing the native runtime prints can corrupt the protocol.
+Every request carries an ``id`` that the response echoes.  A response has
+exactly the keys ``{id, fingerprint, <one of ok|error|request|fault>}``.
+
+Op table (fixed): ``init``, ``parse_closeout``, ``closeout_request``,
+``evidence_request``, plus ``env`` when ``init`` carried ``test_mode``.  An op
+before ``init`` or a second ``init`` is answered with a ``fault``.  Any
+exception raised by an op (``BaseException``, including ``BamlPanic``) is
+returned as a ``fault``; the client then discards and kills the worker.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+
+_OP_FUNCTIONS = {
+    "parse_closeout": ("user.phase_loop_parse_closeout", ("raw",), ("ok", "error")),
+    "closeout_request": (
+        "user.phase_loop_closeout_request",
+        ("phase_alias", "plan_produces", "plan_owned_files", "closeout_commit_sha"),
+        ("request",),
+    ),
+    "evidence_request": (
+        "user.phase_loop_evidence_request",
+        ("tier2_signal_summary", "sample_artifact_content", "expected_artifact_characteristics"),
+        ("request",),
+    ),
+}
+# The client caps a request frame at 4 MiB + 1 KiB; anything larger here is a
+# client bug or a hostile writer, and is refused rather than buffered forever.
+_MAX_REQUEST_LINE = 4 * 1024 * 1024 + 1024 + 4096
+_WATCHDOG_INTERVAL_S = 0.5
+_PR_SET_PDEATHSIG = 1
+
+
+def fingerprint(files: dict[str, str]) -> str:
+    canonical = json.dumps(files, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
+    return hashlib.sha256(canonical.encode("ascii")).hexdigest()
+
+
+def _set_pdeathsig(owner_pid: int) -> None:
+    import ctypes
+    import signal
+
+    # ctypes.CDLL(None) resolves prctl on glibc and musl alike; find_library("c")
+    # and "libc.so.6" do not work on musl.
+    libc = ctypes.CDLL(None, use_errno=True)
+    if libc.prctl(_PR_SET_PDEATHSIG, int(signal.SIGKILL), 0, 0, 0) != 0:
+        os._exit(70)
+    # The owner may have died between our fork and the prctl.
+    if os.getppid() != owner_pid:
+        os._exit(0)
+
+
+def _start_watchdog(owner_pid: int) -> None:
+    import threading
+    import time
+
+    def watch() -> None:
+        while True:
+            if os.getppid() != owner_pid:
+                os._exit(0)
+            time.sleep(_WATCHDOG_INTERVAL_S)
+
+    threading.Thread(target=watch, name="baml-worker-watchdog", daemon=True).start()
+
+
+class _Worker:
+    def __init__(self, out_fd: int, no_pdeathsig: bool) -> None:
+        self.out_fd = out_fd
+        self.no_pdeathsig = no_pdeathsig
+        self.fp: str | None = None
+        self.fns: dict[str, object] | None = None
+        self.test_mode = False
+
+    def send(self, obj: dict) -> None:
+        data = (json.dumps(obj, separators=(",", ":"), ensure_ascii=True) + "\n").encode("ascii")
+        view = memoryview(data)
+        while view:
+            written = os.write(self.out_fd, view)
+            view = view[written:]
+
+    def handle(self, line: bytes) -> None:
+        req_id = None
+        try:
+            req = json.loads(line.decode("ascii"))
+            if not isinstance(req, dict):
+                raise ValueError("request is not a JSON object")
+            req_id = req.get("id")
+            op = req.get("op")
+            if op == "init":
+                result = self.init(req)
+                self.send({"id": req_id, "fingerprint": self.fp, "ok": result})
+                return
+            if self.fns is None:
+                raise RuntimeError(f"op before init: {op!r}")
+            if op == "env" and self.test_mode:
+                self.send({"id": req_id, "fingerprint": self.fp, "ok": {"env": sorted(os.environ), "cwd": os.getcwd(), "pid": os.getpid()}})
+                return
+            if op not in _OP_FUNCTIONS:
+                raise RuntimeError(f"unknown op: {op!r}")
+            _name, params, keys = _OP_FUNCTIONS[op]
+            args = req.get("args")
+            if not isinstance(args, dict) or set(args) != set(params):
+                raise RuntimeError(f"bad args for {op}")
+            out = self.fns[op](**args)
+            if not isinstance(out, dict) or len(out) != 1:
+                raise RuntimeError(f"bridge {op} returned an unexpected shape")
+            ((key, value),) = out.items()
+            if key not in keys or not isinstance(value, str):
+                raise RuntimeError(f"bridge {op} returned key {key!r}")
+            self.send({"id": req_id, "fingerprint": self.fp, key: value})
+        except BaseException as exc:  # noqa: BLE001 - every op failure is a typed fault
+            message = f"{type(exc).__module__}.{type(exc).__qualname__}: {str(exc)[:500]}"
+            self.send({"id": req_id, "fingerprint": self.fp, "fault": message})
+
+    def init(self, req: dict) -> dict:
+        if self.fns is not None:
+            raise RuntimeError("second init")
+        self.test_mode = req.get("test_mode") is True
+        if self.no_pdeathsig and not self.test_mode:
+            raise RuntimeError("--no-pdeathsig requires test_mode")
+        for entry in req.get("sys_path") or []:
+            if isinstance(entry, str) and os.path.isabs(entry) and entry not in sys.path:
+                sys.path.append(entry)
+        files = req.get("files")
+        if not isinstance(files, dict) or not all(isinstance(k, str) and isinstance(v, str) for k, v in files.items()):
+            raise RuntimeError("init files must be a map of strings")
+        import baml_bridge
+
+        baml_bridge.BamlRuntime.initialize_runtime("baml_src", files)
+        fns = {op: baml_bridge.define_function(name, "sync", list(params)) for op, (name, params, _keys) in _OP_FUNCTIONS.items()}
+        self.fp = fingerprint(files)
+        self.fns = fns
+        return {"version": baml_bridge.get_version(), "pid": os.getpid()}
+
+    def serve(self) -> None:
+        buf = b""
+        while True:
+            chunk = os.read(0, 1 << 16)
+            if not chunk:
+                return  # stdin EOF: the graceful shutdown path
+            buf += chunk
+            while True:
+                newline = buf.find(b"\n")
+                if newline < 0:
+                    break
+                line, buf = buf[:newline], buf[newline + 1 :]
+                self.handle(line)
+            if len(buf) > _MAX_REQUEST_LINE:
+                self.send({"id": None, "fingerprint": self.fp, "fault": "request line over cap"})
+                return
+
+
+def main(argv: list[str]) -> int:
+    owner_pid = int(argv[1])
+    allowlist = {key for key in argv[2].split(",") if key} if len(argv) > 2 else set()
+    no_pdeathsig = "--no-pdeathsig" in argv[3:]
+
+    out_fd = os.dup(1)
+    os.dup2(2, 1)
+    sys.stdout = sys.stderr
+
+    # Normalize the environment before baml_bridge is ever imported: this drops
+    # interpreter-injected keys (C-locale coercion's LC_CTYPE,
+    # __PYVENV_LAUNCHER__) that the parent's allowlist never passed.
+    for key in list(os.environ):
+        if key not in allowlist:
+            del os.environ[key]
+    # The v1 runtime keeps a profile store of call data under the working
+    # directory (``.baml/profiles-v1``) unless profiling is off.  Forced, not
+    # defaulted: no call data is ever written to disk, whatever was passed in.
+    os.environ["BAML_PROFILE"] = "0"
+    os.environ.pop("BAML_PROFILE_DIR", None)
+
+    if os.name == "posix":
+        if sys.platform.startswith("linux") and not no_pdeathsig:
+            _set_pdeathsig(owner_pid)
+        elif os.getppid() != owner_pid:
+            os._exit(0)
+        _start_watchdog(owner_pid)
+    # Windows: the parent's Job Object (KILL_ON_JOB_CLOSE) enforces owner death.
+
+    _Worker(out_fd, no_pdeathsig).serve()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

{phase_loop_runtime-0.7.22 → phase_loop_runtime-0.7.24}/src/phase_loop_runtime/adoption_bundle.py

@@ -16,6 +16,7 @@ C4_DOCUMENT = Path("docs/c4/phase-loop-runtime-c4-document.md")
 TASK_CATALOG = Path("docs/tasks/dotfiles-task-catalog.md")
 RUNTIME_PROJECTION_SURFACE = "phase-loop status --runtime-projection --json"
 BAML_SCHEMA_ROOT = Path("vendor/phase-loop-runtime/src/phase_loop_runtime/baml_src")
+BAML_BRIDGE_SOURCE = "phase_loop_bridge.baml"
 ADOPTION_BUNDLE_PATH = Path("docs/adoption/dotfiles-adoption-bundle.json")
 
 
@@ -143,6 +144,8 @@ def _source_roots(repo: Path) -> list[dict[str, str]]:
 def _schema_refs(repo: Path) -> list[dict[str, str]]:
     refs: list[dict[str, str]] = []
     for path in sorted((repo / BAML_SCHEMA_ROOT).glob("*.baml")):
+        if path.name == BAML_BRIDGE_SOURCE:
+            continue  # host glue with no classes, not a schema (agent-harness#1135 #26)
         source_path = _repo_relative(repo, path)
         refs.append(
             {