dsh-open-dream-rsi 0.2.0 → 0.2.1

package/README.md

@@ -40,8 +40,8 @@ directory holding your `tasks.json`:
 
 ```bash
 # from the npm registry, a tarball, a checkout, or straight from GitHub — pick one:
-dsh plugin --profile <name> add dsh-open-dream-rsi            # or pin: dsh-open-dream-rsi@0.2.0
-dsh plugin --profile <name> add /path/to/dsh-open-dream-rsi-0.2.0.tgz
+dsh plugin --profile <name> add dsh-open-dream-rsi            # or pin: dsh-open-dream-rsi@0.2.1
+dsh plugin --profile <name> add /path/to/dsh-open-dream-rsi-0.2.1.tgz
 dsh plugin --profile <name> add /path/to/open-dream-rsi/plugins/deepseek_harness
 dsh plugin --profile <name> add github:patrykorwat/open-dream-rsi#path:plugins/deepseek_harness
 

package/open_dream_rsi/__init__.py

@@ -46,7 +46,7 @@ from open_dream_rsi.bench_policy import (
     run_policy_benchmark,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 __all__ = [
     "DiscoveryTree",

package/open_dream_rsi/core/policygen.py

@@ -302,6 +302,10 @@ class PolicySandbox:
             )
         except subprocess.TimeoutExpired:
             return PolicyRun(None, "policy execution timed out")
+        except subprocess.SubprocessError as exc:
+            # A failed spawn (e.g. "Exception occurred in preexec_fn" under a
+            # low hard rlimit) must not kill the whole cycle.
+            return PolicyRun(None, f"sandbox spawn failed: {exc}")
         finally:
             for p in (src_path, fr_path, harness_path):
                 p.unlink(missing_ok=True)
@@ -339,6 +343,10 @@ class PolicySandbox:
             )
         except subprocess.TimeoutExpired:
             return None, [], 0, "policy rollout timed out"
+        except subprocess.SubprocessError as exc:
+            # See choose(): a failed spawn is an errored rollout, not a
+            # crashed cycle.
+            return None, [], 0, f"sandbox spawn failed: {exc}"
         finally:
             for p in (src_path, world_path, harness_path):
                 p.unlink(missing_ok=True)

package/open_dream_rsi/sandbox.py

@@ -57,21 +57,51 @@ def _memory_mb() -> int:
 
 
 def _make_preexec(timeout: float):
-    """preexec_fn: RLIMIT_AS / RLIMIT_CPU / RLIMIT_NPROC for the child."""
+    """preexec_fn: RLIMIT_AS / RLIMIT_CPU / RLIMIT_NPROC for the child.
+
+    Best-effort by design: in restrictive environments (a hard rlimit below
+    the request — common for daemons and desktop sandboxes) ``setrlimit``
+    would raise and kill the spawn with ``Exception occurred in
+    preexec_fn``, so each limit is clamped to the hard ceiling and applied
+    only when it can be.
+    """
     import resource
 
     mem_bytes = _memory_mb() * 1024 * 1024
     cpu_soft = max(2, int(timeout) + 1)
 
+    def _apply(limit: int, soft: int, hard_extra: Optional[int]) -> bool:
+        """Set one rlimit, clamped to the environment's hard ceiling."""
+        try:
+            _, hard = resource.getrlimit(limit)
+        except (ValueError, OSError):
+            hard = resource.RLIM_INFINITY
+        if hard == 0:
+            # The environment forbids this resource entirely; applying
+            # soft=0 would insta-kill the child, so skip it.
+            return False
+        if hard != resource.RLIM_INFINITY:
+            soft = min(soft, hard)
+        if hard_extra is not None:
+            hard = (soft + hard_extra) if hard == resource.RLIM_INFINITY \
+                else min(hard, soft + hard_extra)
+        try:
+            resource.setrlimit(limit, (soft, hard))
+        except (ValueError, OSError):
+            return False
+        return True
+
     def _limits() -> None:  # runs in the forked child only
-        resource.setrlimit(resource.RLIMIT_AS, (mem_bytes, mem_bytes))
-        resource.setrlimit(resource.RLIMIT_CPU, (cpu_soft, cpu_soft + 1))
+        # Each limit is best-effort: degrade to fewer enforced limits
+        # rather than kill the spawn.
+        _apply(resource.RLIMIT_AS, mem_bytes, None)
+        _apply(resource.RLIMIT_CPU, cpu_soft, 1)
+        # RLIMIT_NPROC counts THREADS of this uid (shared with the parent),
+        # so the floor must sit ABOVE the uid's current task count or every
+        # fork fails with EAGAIN. Count threads via /proc, fall back to the
+        # static floor where /proc is absent.
+        existing = 0
         try:
-            # RLIMIT_NPROC counts THREADS of this uid (shared with the
-            # parent), so the floor must sit ABOVE the uid's current task
-            # count or every fork fails with EAGAIN. Count threads via
-            # /proc, fall back to the static floor where /proc is absent.
-            existing = 0
             for entry in os.listdir("/proc"):
                 if not entry.isdigit():
                     continue
@@ -87,10 +117,7 @@ def _make_preexec(timeout: float):
         except OSError:
             existing = 0
         cap = max(MAX_PROCS, existing + 64)
-        try:
-            resource.setrlimit(resource.RLIMIT_NPROC, (cap, cap))
-        except (ValueError, OSError):
-            pass  # platform without NPROC limits
+        _apply(resource.RLIMIT_NPROC, cap, None)
 
     return _limits
 

package/open_dream_rsi/tools.py

@@ -101,6 +101,12 @@ class CodeVerifier:
         except subprocess.TimeoutExpired:
             return {"ok": False, "error": "execution timed out",
                     "defined": [], "stdout": ""}
+        except subprocess.SubprocessError as exc:
+            # Restrictive environments can fail the spawn itself (e.g.
+            # "Exception occurred in preexec_fn" under a low hard rlimit):
+            # report sandbox evidence instead of killing the whole cycle.
+            return {"ok": False, "error": f"sandbox spawn failed: {exc}",
+                    "defined": [], "stdout": ""}
         finally:
             Path(path).unlink(missing_ok=True)
         line = proc.stdout.strip().splitlines()[-1] if proc.stdout.strip() else ""
@@ -129,6 +135,10 @@ class CodeVerifier:
             )
         except subprocess.TimeoutExpired:
             return ToolResult(False, 0.0, "execution timed out")
+        except subprocess.SubprocessError as exc:
+            # See smoke_run: a failed spawn is sandbox evidence, not a
+            # crashed cycle.
+            return ToolResult(False, 0.0, f"sandbox spawn failed: {exc}")
         finally:
             Path(path).unlink(missing_ok=True)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-open-dream-rsi",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Let your coding agent dream: strategies must survive counterfactual replay before they earn trust. An offline self-improvement loop over an evolving world model — no fine-tuning, the LLM stays frozen. Speaks MCP. Ships its Python server inside the package — the only requirement is a system python3 (3.10+) on PATH — and the plugin's bridge serves the dreamer's LLM calls from the model your harness is already configured with (no API keys, no env, no extra endpoints).",
   "type": "module",
   "license": "MIT",