activegraph 1.7.0__tar.gz → 1.7.1__tar.gz

{activegraph-1.7.0/activegraph.egg-info → activegraph-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: activegraph
-Version: 1.7.0
+Version: 1.7.1
 Summary: An event-sourced reactive graph runtime for long-running, auditable, agentic systems.
 Author: Active Graph contributors
 License-Expression: Apache-2.0

{activegraph-1.7.0 → activegraph-1.7.1}/activegraph/__init__.py

@@ -242,4 +242,4 @@ __all__ = [
     "tool",
 ]
 
-__version__ = "1.7.0"
+__version__ = "1.7.1"

{activegraph-1.7.0 → activegraph-1.7.1}/activegraph/sandbox/__init__.py

@@ -59,6 +59,7 @@ pack's static gates remain the pre-execution filter.
 from __future__ import annotations
 
 import json
+import logging
 import os
 import subprocess
 import sys
@@ -66,6 +67,8 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional
 
+_log = logging.getLogger("activegraph.sandbox")
+
 
 #: The closed outcome set. ``crashed`` is the implementation's one
 #: addition over the design draft: a child that dies without a
@@ -144,6 +147,12 @@ class TrialReport:
     favor of the store. Richer evidence (tracebacks, diffs) is read
     from the fork's log directly: ``Runtime.load(store, run_id=
     report.fork_run_id)`` then ``trace.failures()`` / ``diff()``.
+
+    ``warnings`` (v1.7.1) carries any resource net that DEGRADED on
+    this platform — most notably the memory cap (RLIMIT_AS) on macOS,
+    which the Darwin kernel refuses. A degraded net is announced, never
+    silently skipped: the same strings are also folded into ``detail``,
+    and the parent logs each one.
     """
 
     outcome: str
@@ -152,6 +161,7 @@ class TrialReport:
     behavior_failures: int
     detail: str
     exit_code: Optional[int]
+    warnings: tuple[str, ...] = ()
 
 
 class SandboxStartupError(RuntimeError):
@@ -277,22 +287,52 @@ def _run_child(
         return proc.returncode, stdout, stderr, True
 
 
+#: A representative memory cap the preflight probe applies when the
+#: caller left ``max_rss_bytes`` unset — generous enough not to cap a
+#: just-started child into a false ``MemoryError`` on Linux (a child
+#: after importing activegraph sits near ~40 MiB of address space),
+#: finite enough to actually exercise the ``setrlimit(RLIMIT_AS)`` call
+#: that Darwin rejects. The point of the probe is to trip the platform
+#: check, not to bound anything.
+_PREFLIGHT_PROBE_RSS = 1024 * 2**20
+
+
+def _limits_job_block(limits: TrialLimits, *, probe: bool) -> dict[str, object]:
+    """The ``limits`` sub-dict of a child job. ``probe=True`` fills an
+    unset ``max_rss_bytes`` with :data:`_PREFLIGHT_PROBE_RSS` so
+    preflight always exercises the RLIMIT_AS path."""
+    max_rss = limits.max_rss_bytes
+    if probe and max_rss is None:
+        max_rss = _PREFLIGHT_PROBE_RSS
+    return {
+        "max_rss_bytes": max_rss,
+        "max_events": limits.max_events,
+        "max_llm_calls": limits.max_llm_calls,
+        "cpu_seconds": int(limits.wall_clock_seconds) + 5,
+    }
+
+
 def _preflight_with(
     env: dict[str, str],
     *,
+    limits: TrialLimits = TrialLimits(),
     python_flags: tuple[str, ...] = (),
     timeout: float = 30.0,
-) -> None:
+) -> tuple[str, ...]:
     """The preflight check against a specific ``env`` (the testable
-    seam under :func:`preflight`). Raises :class:`SandboxStartupError`
-    if a child cannot start and report ``preflight: ok``.
+    seam under :func:`preflight`). Applies a representative limits block
+    so the resource-limit path is actually exercised. Returns any
+    degradation warnings (empty when every requested net applied);
+    raises :class:`SandboxStartupError` if a child cannot start and
+    report ``preflight: ok``.
     """
+    job = {"preflight": True, "limits": _limits_job_block(limits, probe=True)}
     exit_code, stdout, stderr, timed_out = _run_child(
-        {"preflight": True}, env=env, wall_clock=timeout, python_flags=python_flags
+        job, env=env, wall_clock=timeout, python_flags=python_flags
     )
     tail = _parse_report_tail(stdout)
     if not timed_out and exit_code == 0 and tail.get("preflight") == "ok":
-        return
+        return tuple(str(w) for w in (tail.get("warnings") or ()))
     cause = _stderr_tail(stderr) or (
         "child timed out" if timed_out else "no preflight tail on stdout"
     )
@@ -301,18 +341,33 @@ def _preflight_with(
     )
 
 
-def preflight(*, limits: TrialLimits = TrialLimits(), timeout: float = 30.0) -> None:
+def preflight(
+    *, limits: TrialLimits = TrialLimits(), timeout: float = 30.0
+) -> tuple[str, ...]:
     """Verify a trial child can START under the sandbox env on this box.
 
-    Spawns the child with a null job (no fork, no store, no candidate):
-    it imports ``activegraph``, echoes ``preflight: ok``, and exits 0.
-    Returns ``None`` on success; raises :class:`SandboxStartupError`
-    with the child's stderr tail otherwise. Consumers call this once at
-    boot so a broken sandbox env (e.g. a platform whose package
-    discovery the allow-list strips) fails LOUD here instead of showing
-    up as an opaque ``crashed`` on the first real trial.
+    Spawns the child with a null job that exercises the full startup
+    path a real trial hits — importing ``activegraph`` under the sandbox
+    env AND applying resource limits (v1.7.1: a go/no-go gate that
+    skipped limit application passed on macOS where every real trial
+    then crashed on RLIMIT_AS). No fork, no store, no candidate.
+
+    Returns a tuple of degradation warnings — empty when every net
+    applied cleanly, non-empty (and logged) when a net degraded on this
+    platform (e.g. the memory cap on macOS). Raises
+    :class:`SandboxStartupError` with the child's stderr tail if a child
+    cannot start at all. So on macOS this PASSES with a memory-net
+    warning rather than pass-then-crash; on a box that cannot import
+    activegraph it RAISES with the real cause. Consumers call it once at
+    boot to fail loud or learn what degraded before the first trial.
+
+    Pass the same ``limits`` a real trial will carry to probe that exact
+    configuration; the default probes with a representative memory cap.
     """
-    _preflight_with(_child_env(limits), timeout=timeout)
+    warnings = _preflight_with(_child_env(limits), limits=limits, timeout=timeout)
+    for w in warnings:
+        _log.warning("sandbox preflight: %s", w)
+    return warnings
 
 
 def run_forked_trial(
@@ -379,12 +434,7 @@ def run_forked_trial(
             for p in extra_packs
         ],
         "scenario": scenario,
-        "limits": {
-            "max_rss_bytes": limits.max_rss_bytes,
-            "max_events": limits.max_events,
-            "max_llm_calls": limits.max_llm_calls,
-            "cpu_seconds": int(limits.wall_clock_seconds) + 5,
-        },
+        "limits": _limits_job_block(limits, probe=False),
     }
     exit_code, stdout, stderr, timed_out = _run_child(
         job, env=_child_env(limits), wall_clock=limits.wall_clock_seconds
@@ -418,6 +468,17 @@ def run_forked_trial(
         if err_tail:
             detail = f"{detail}; child stderr:\n{err_tail}"
 
+    # Degraded resource nets (v1.7.1): announced, never silent. A memory
+    # cap the platform refused (RLIMIT_AS on macOS) is folded into detail
+    # and logged, so a trial that ran WITHOUT the memory net it asked for
+    # is loud rather than quietly unbounded.
+    warnings = tuple(str(w) for w in (tail.get("warnings") or ()))
+    if warnings:
+        joined = "; ".join(warnings)
+        detail = f"{detail} [degraded: {joined}]" if detail else f"[degraded: {joined}]"
+        for w in warnings:
+            _log.warning("sandbox trial %s: %s", fork_run_id, w)
+
     # The store is the record: re-read the fork run for the numbers.
     events_appended = 0
     behavior_failures = 0
@@ -437,4 +498,5 @@ def run_forked_trial(
         behavior_failures=behavior_failures,
         detail=detail,
         exit_code=exit_code,
+        warnings=warnings,
     )

{activegraph-1.7.0 → activegraph-1.7.1}/activegraph/sandbox/_child.py

@@ -22,6 +22,9 @@ from pathlib import Path
 from typing import Any, Callable, Optional
 
 
+_LIMIT_WARNINGS: list[str] = []
+
+
 def _report(
     outcome: str,
     *,
@@ -39,6 +42,11 @@ def _report(
                 "events_appended": events_appended,
                 "behavior_failures": behavior_failures,
                 "detail": detail[:500],
+                # Degraded-limit warnings (v1.7.1): a resource net that
+                # could not be applied on this platform is announced,
+                # never silently skipped. The parent folds these into
+                # TrialReport.warnings and TrialReport.detail.
+                "warnings": list(_LIMIT_WARNINGS),
             }
         ),
         flush=True,
@@ -46,19 +54,67 @@ def _report(
     raise SystemExit(exit_code)
 
 
-def _apply_rlimits(limits: dict[str, Any]) -> None:
-    """POSIX resource caps; on platforms without ``resource`` the
-    wall-clock and budget nets still hold (stated in the design)."""
+def _apply_rlimits(limits: dict[str, Any]) -> list[str]:
+    """Apply POSIX resource caps portably, returning a warning for any
+    cap that could not be set on this platform.
+
+    RLIMIT_AS (the memory net) is settable on Linux but rejected by the
+    Darwin kernel (``ValueError: current limit exceeds maximum limit``
+    — Darwin does not support address-space limiting). Rather than
+    crash (a trial child that can't start is useless) or silently skip
+    (a memory net that quietly does nothing is worse than one that
+    announces it is off), an unsettable cap DEGRADES: we record a loud
+    warning and let the wall-clock kill and event budget — which are
+    unaffected — remain the active nets. We never RAISE a hard limit
+    (that needs privilege and is what triggered the Darwin crash): the
+    target is clamped to the existing hard limit, so the call only ever
+    lowers, and the strong soft==hard cap is preserved where the kernel
+    allows it. Returns the list of degradation warnings (empty when all
+    requested caps applied).
+    """
+    warnings: list[str] = []
     try:
         import resource
     except ImportError:  # pragma: no cover — Windows
-        return
+        if limits.get("max_rss_bytes"):
+            warnings.append(_mem_off("no `resource` module on this platform"))
+        return warnings
+
+    def _cap(kind: str, name: str, requested: int) -> None:
+        limit = getattr(resource, name)
+        _, hard = resource.getrlimit(limit)
+        target = (
+            requested
+            if hard == resource.RLIM_INFINITY
+            else min(requested, hard)
+        )
+        try:
+            resource.setrlimit(limit, (target, target))
+        except (ValueError, OSError) as e:
+            warnings.append(
+                _mem_off(f"{sys.platform}: {type(e).__name__}: {e}")
+                if kind == "memory"
+                else (
+                    f"CPU cap (RLIMIT_CPU) could not be applied on "
+                    f"{sys.platform}: {type(e).__name__}: {e}"
+                )
+            )
+
     max_rss = limits.get("max_rss_bytes")
     if max_rss:
-        resource.setrlimit(resource.RLIMIT_AS, (max_rss, max_rss))
+        _cap("memory", "RLIMIT_AS", max_rss)
     cpu = limits.get("cpu_seconds")
     if cpu:
-        resource.setrlimit(resource.RLIMIT_CPU, (cpu, cpu))
+        _cap("cpu", "RLIMIT_CPU", cpu)
+    return warnings
+
+
+def _mem_off(reason: str) -> str:
+    return (
+        f"memory cap (RLIMIT_AS) could not be applied ({reason}); the "
+        f"memory net is OFF for this trial — the wall-clock kill and "
+        f"event budget still bound a runaway"
+    )
 
 
 def _materialize_pack(job: dict[str, Any]) -> Any:
@@ -138,18 +194,28 @@ def _resolve_scenario(
 def main() -> None:
     job = json.loads(sys.stdin.read())
 
-    # Preflight (v1.7): a null job that only proves the child could
-    # START — i.e. that importing activegraph under the sandbox env
-    # succeeded, which happens before this function even runs. Reaching
-    # here at all means the heavy import chain worked; echo the marker
-    # and exit clean. No fork, no store, no candidate touched.
+    # Apply resource limits BEFORE the preflight branch (v1.7.1): the
+    # limit-application path is exactly what varies by host (Darwin
+    # rejects RLIMIT_AS), so preflight must exercise it to be a real
+    # go/no-go gate — a null job that skipped it would pass on a box
+    # where every real trial then crashed. Degradation warnings are
+    # stashed for _report and echoed on the preflight tail.
+    _LIMIT_WARNINGS.extend(_apply_rlimits(job.get("limits", {})))
+
+    # Preflight (v1.7): a null job that proves the child could START —
+    # importing activegraph under the sandbox env succeeded (before this
+    # function ran) AND resource limits could be applied (just above).
+    # Echo the marker plus any degradation warnings and exit clean. No
+    # fork, no store, no candidate touched.
     if job.get("preflight"):
-        print(json.dumps({"preflight": "ok"}), flush=True)
+        print(
+            json.dumps({"preflight": "ok", "warnings": list(_LIMIT_WARNINGS)}),
+            flush=True,
+        )
         raise SystemExit(0)
 
     fork_run_id = str(job["fork_run_id"])
     initial = int(job.get("initial_events", 0))
-    _apply_rlimits(job.get("limits", {}))
 
     def counts(rt: Any) -> tuple[int, int]:
         return (

{activegraph-1.7.0 → activegraph-1.7.1/activegraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: activegraph
-Version: 1.7.0
+Version: 1.7.1
 Summary: An event-sourced reactive graph runtime for long-running, auditable, agentic systems.
 Author: Active Graph contributors
 License-Expression: Apache-2.0

{activegraph-1.7.0 → activegraph-1.7.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "activegraph"
-version = "1.7.0"
+version = "1.7.1"
 description = "An event-sourced reactive graph runtime for long-running, auditable, agentic systems."
 readme = "README.md"
 requires-python = ">=3.11"

{activegraph-1.7.0 → activegraph-1.7.1}/tests/test_sandbox_trial.py

@@ -540,9 +540,9 @@ def test_child_import_crash_surfaces_the_cause_in_detail(tmp_path, monkeypatch):
 
 
 def test_preflight_succeeds_on_a_working_env():
-    # Returns None (no raise) when a child can start under the sandbox
-    # env — the normal case on any box where the parent imports fine.
-    assert preflight(timeout=30.0) is None
+    # Returns () (no raise, no degradation) when a child can start AND
+    # apply limits under the sandbox env — the normal case on Linux.
+    assert preflight(timeout=30.0) == ()
 
 
 def test_preflight_fails_loud_with_the_cause_on_a_restricted_env():
@@ -570,7 +570,7 @@ def test_explicit_code_channel_rescues_a_restricted_child():
             python_flags=("-S",),
             timeout=30.0,
         )
-        is None
+        == ()
     )
 
 
@@ -598,3 +598,133 @@ def test_env_passthrough_still_forwards_named_vars(monkeypatch):
     env = sandbox._child_env(TrialLimits(env_passthrough=("MY_TRIAL_FLAG",)))
     assert env["MY_TRIAL_FLAG"] == "1"
     assert "PYTHONPATH" in env
+
+
+# ------------------- portable RLIMIT_AS (v1.7.1 macOS soak fix)
+
+resource = pytest.importorskip("resource")
+from activegraph.sandbox import _child  # noqa: E402
+
+
+def test_rlimit_as_applies_cleanly_on_linux():
+    # Linux shape: a settable RLIMIT_AS applies with no degradation.
+    warnings = _child._apply_rlimits(
+        {"max_rss_bytes": 1024 * 2**20, "cpu_seconds": 60}
+    )
+    assert warnings == []
+
+
+def test_rlimit_as_rejection_degrades_not_crashes(monkeypatch):
+    # macOS shape (simulated): Darwin rejects setrlimit(RLIMIT_AS) with
+    # exactly this ValueError. The child must NOT crash and must NOT
+    # silently skip — it degrades with a loud, announced warning. This
+    # is the regression guard for the macOS rotation-1 crash.
+    real = resource.setrlimit
+
+    def darwin(which, pair):
+        if which == resource.RLIMIT_AS:
+            raise ValueError("current limit exceeds maximum limit")
+        return real(which, pair)
+
+    monkeypatch.setattr(resource, "setrlimit", darwin)
+    warnings = _child._apply_rlimits(
+        {"max_rss_bytes": 256 * 2**20, "cpu_seconds": 60}
+    )
+    assert len(warnings) == 1
+    assert "memory net is OFF" in warnings[0]
+    assert "RLIMIT_AS" in warnings[0]
+    # The CPU cap (which Darwin DOES accept) still applied — only the
+    # unsupported net degraded.
+    assert "RLIMIT_CPU" not in warnings[0]
+
+
+def test_rlimit_never_raises_the_hard_limit(monkeypatch):
+    # The Darwin crash was setrlimit raising the hard limit; we clamp to
+    # the existing hard limit so the call only ever LOWERS. Prove the
+    # target passed to setrlimit never exceeds the current hard limit.
+    seen = {}
+    real_get = resource.getrlimit
+    monkeypatch.setattr(
+        resource, "getrlimit", lambda w: (0, 512 * 2**20)  # finite hard
+    )
+
+    def capture(which, pair):
+        seen[which] = pair
+
+    monkeypatch.setattr(resource, "setrlimit", capture)
+    _child._apply_rlimits({"max_rss_bytes": 4096 * 2**20})  # ask for MORE
+    soft, hard = seen[resource.RLIMIT_AS]
+    assert soft == hard == 512 * 2**20  # clamped to existing hard, not raised
+
+
+def test_preflight_exercises_the_limit_path():
+    # Fix 2: preflight must send a limits block so it reaches
+    # _apply_rlimits — a null job that skipped it passed on macOS where
+    # every real trial then crashed.
+    probe = sandbox._limits_job_block(TrialLimits(), probe=True)
+    assert probe["max_rss_bytes"] == sandbox._PREFLIGHT_PROBE_RSS
+    # A caller's explicit cap is probed as-is.
+    probe2 = sandbox._limits_job_block(
+        TrialLimits(max_rss_bytes=333 * 2**20), probe=True
+    )
+    assert probe2["max_rss_bytes"] == 333 * 2**20
+    # A real trial's block keeps the caller's None (no probe fill).
+    real = sandbox._limits_job_block(TrialLimits(), probe=False)
+    assert real["max_rss_bytes"] is None
+
+
+def test_trial_report_surfaces_degraded_warning(tmp_path, monkeypatch):
+    # End-to-end parent surfacing: a child that reports a degraded net
+    # must land it in TrialReport.warnings AND detail (loud), on an
+    # otherwise-completed trial.
+    path, parent_run, tip, n_parent = _parent_store(tmp_path)
+    root, bundle = _candidate_dir(tmp_path)
+
+    degraded = "memory cap (RLIMIT_AS) could not be applied (darwin: ...); the memory net is OFF for this trial"
+
+    def fake_run_child(job, *, env, wall_clock, python_flags=()):
+        tail = {
+            "outcome": "completed",
+            "fork_run_id": job["fork_run_id"],
+            "events_appended": 1,
+            "behavior_failures": 0,
+            "detail": "",
+            "warnings": [degraded],
+        }
+        import json as _json
+
+        return 0, _json.dumps(tail), "", False
+
+    monkeypatch.setattr(sandbox, "_run_child", fake_run_child)
+    report = run_forked_trial(
+        path,
+        parent_run_id=parent_run,
+        at_event=tip,
+        pack_source=PackSource(root_dir=str(root), expected_bundle_hash=bundle),
+        scenario="scenario.py",
+        limits=TrialLimits(max_rss_bytes=256 * 2**20),
+    )
+    assert report.outcome == "completed"
+    assert report.warnings == (degraded,)
+    assert "degraded" in report.detail
+    assert "memory net is OFF" in report.detail
+
+
+def test_real_trial_with_memory_cap_completes_on_linux(tmp_path):
+    # Integration: a real trial carrying a memory cap runs clean on
+    # Linux (the net applied, no degradation) — proving the portable
+    # path did not break the platform where RLIMIT_AS works.
+    path, parent_run, tip, n_parent = _parent_store(tmp_path)
+    root, bundle = _candidate_dir(tmp_path)
+
+    report = run_forked_trial(
+        path,
+        parent_run_id=parent_run,
+        at_event=tip,
+        pack_source=PackSource(root_dir=str(root), expected_bundle_hash=bundle),
+        scenario="scenario.py",
+        limits=TrialLimits(max_rss_bytes=1024 * 2**20, wall_clock_seconds=60),
+    )
+    assert report.outcome == "completed", report.detail
+    assert report.warnings == ()
+    _parent_untouched(path, parent_run, n_parent)