dsh-open-dream-rsi 0.2.0 → 0.2.3

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/cli.py

@@ -18,6 +18,9 @@ from open_dream_rsi.memory import DreamMemory
 
 
 def _build_client(provider: str, model: str | None):
+    if provider == "cursor-agent":
+        from open_dream_rsi.cursor_agent import CursorAgentClient
+        return CursorAgentClient(model=model)
     from open_dream_rsi.llm import LLMConfig, OpenAICompatibleClient
 
     cfg = LLMConfig.from_preset(provider)  # honours OPENAI_BASE_URL / ODR_LLM_MODEL
@@ -181,6 +184,38 @@ def cmd_sessions(args: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_task(args: argparse.Namespace) -> int:
+    """Queue tasks without MCP: append_task writes the same tasks.json the
+    loop/dream cycle consumes, so hooks or a terminal can feed the loop on
+    hosts where MCP servers are unavailable (e.g. blocked by policy)."""
+    from open_dream_rsi.loop import append_task
+
+    tasks_file = (Path(args.tasks) if args.tasks
+                  else Path(args.memory) / "tasks.json")
+    if args.task_cmd == "add":
+        task = {"task_id": args.id, "category": args.category,
+                "prompt": args.prompt, "tests": [],
+                "max_attempts": args.attempts}
+        if args.criteria:
+            task["criteria"] = args.criteria
+        try:
+            result = append_task(tasks_file, task)
+        except ValueError as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            return 2
+        print(json.dumps(result, ensure_ascii=False))
+        return 0
+    tasks = (json.loads(tasks_file.read_text(encoding="utf-8"))
+             if tasks_file.exists() else [])
+    for t in tasks:
+        marker = ("criteria: " + t["criteria"][:60] if t.get("criteria")
+                  else f"{len(t.get('tests') or [])} test(s)")
+        print(f"{t.get('task_id')}: [{t.get('category')}] "
+              f"attempts={t.get('max_attempts', 4)} {marker}")
+    print(f"({len(tasks)} task(s) in {tasks_file})")
+    return 0
+
+
 def cmd_dream(args: argparse.Namespace) -> int:
     """Automated cycle: evidence -> candidates -> promotion gate -> skills.
 
@@ -189,12 +224,20 @@ def cmd_dream(args: argparse.Namespace) -> int:
     cost), so any trigger — a Hermes hook, the MCP tool, or this CLI —
     can fire as often as it likes without overrunning the budget."""
     from open_dream_rsi.dream import dream_once
+    from open_dream_rsi.sessions import default_cursor_user_dir
 
     client = None
     if not args.offline:
         client = _build_client(args.provider, args.model)
+    if args.source == "cursor":
+        # the Cursor store is a User DIR (state.vscdb inside), not a db file
+        sessions_db = args.sessions or args.cursor_user_dir \
+            or str(default_cursor_user_dir())
+    else:
+        sessions_db = args.sessions
     report = dream_once(
-        args.memory, sessions_db=args.sessions, skills_out=args.skills_out,
+        args.memory, sessions_db=sessions_db, session_source=args.source,
+        skills_out=args.skills_out,
         client=client, budget=args.budget, max_tokens=args.max_tokens,
         category=args.category)
     print(json.dumps(report, indent=2, ensure_ascii=False))
@@ -298,7 +341,7 @@ def main(argv: list[str] | None = None) -> int:
     loop = sub.add_parser("loop", help="run the self-improvement cycle")
     loop.add_argument("--tasks", required=True, help="JSON file: list of Task dicts")
     loop.add_argument("--provider", default="openai",
-                      choices=["openai", "cursor", "local", "goose"],
+                      choices=["openai", "cursor-agent", "cursor", "local", "goose"],
                       help="LLM endpoint; 'goose' borrows goose's own "
                            "provider/model/key from ~/.config/goose")
     loop.add_argument("--model", default=None)
@@ -329,12 +372,18 @@ def main(argv: list[str] | None = None) -> int:
              "maintenance, skills publish; safe to fire from any trigger "
              "(cadence is decided internally, not by the caller)")
     dr.add_argument("--sessions", default=None,
-                    help="host state.db to import evidence from "
-                         "(e.g. ~/.hermes/state.db)")
+                    help="host session store to import evidence from "
+                         "(hermes: state.db path; cursor: the User dir)")
+    dr.add_argument("--source", default="hermes", choices=["hermes", "cursor"],
+                    help="kind of the --sessions store (default hermes; "
+                         "cursor reads state.vscdb directly, no MCP needed)")
+    dr.add_argument("--cursor-user-dir", default=None,
+                    help="Cursor User dir for --source cursor (default: the "
+                         "platform location, e.g. %%APPDATA%%\\Cursor\\User)")
     dr.add_argument("--skills-out", default=None,
                     help="render ACTIVE lessons here as SKILL.md files")
     dr.add_argument("--provider", default="openai",
-                    choices=["openai", "cursor", "local", "goose"])
+                    choices=["openai", "cursor-agent", "cursor", "local", "goose"])
     dr.add_argument("--model", default=None)
     dr.add_argument("--category", default=None,
                     help="force one KB category (default: per-episode cwd)")
@@ -345,6 +394,26 @@ def main(argv: list[str] | None = None) -> int:
                     help="no LLM: lifecycle maintenance only")
     dr.set_defaults(func=cmd_dream)
 
+    task = sub.add_parser(
+        "task", help="queue tasks without MCP (the file the loop consumes)")
+    task_sub = task.add_subparsers(dest="task_cmd", required=True)
+    ta = task_sub.add_parser("add", help="append one task to the queue file")
+    ta.add_argument("--id", required=True, help="unique task id")
+    ta.add_argument("--category", required=True,
+                    help="KB category (usually the project name)")
+    ta.add_argument("--prompt", required=True,
+                    help="the task prompt the agent will solve")
+    ta.add_argument("--criteria", default="",
+                    help="success criterion for test-less tasks")
+    ta.add_argument("--attempts", type=int, default=4)
+    ta.add_argument("--tasks", default=None,
+                    help="queue file (default: <memory>/tasks.json)")
+    tl = task_sub.add_parser("list", help="show queued tasks")
+    tl.add_argument("--tasks", default=None,
+                    help="queue file (default: <memory>/tasks.json)")
+    ta.set_defaults(func=cmd_task)
+    tl.set_defaults(func=cmd_task)
+
     status = sub.add_parser("status", help="show learned policies, recipes, recent events")
     status.set_defaults(func=cmd_status)
 
@@ -390,7 +459,7 @@ def main(argv: list[str] | None = None) -> int:
     dis.add_argument("--category", default=None,
                      help="KB category (default: cwd name of each episode)")
     dis.add_argument("--provider", default="openai",
-                     choices=["openai", "cursor", "local", "goose"])
+                     choices=["openai", "cursor-agent", "cursor", "local", "goose"])
     dis.add_argument("--model", default=None)
     dis.add_argument("--limit", type=int, default=None)
     dis.add_argument("--dry-run", action="store_true",

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/cursor_agent.py

@@ -0,0 +1,92 @@
+"""Dreamer brain via the Cursor Agent CLI (headless, no HTTP endpoint).
+
+Cursor ships no public OpenAI-compatible chat API, so the zero-proxy route
+to "the dreamer thinks with Cursor" is the ``cursor-agent`` CLI: it runs a
+headless agent turn authenticated by the user's Cursor login — no proxy, no
+API key, no endpoint to configure. Output text mode returns the final
+answer only, which is exactly what the curator contract needs.
+
+Failure semantics (the dream ingest contract, 0.2.4+): every failure here
+raises RuntimeError, which ``distill`` reports as ``llm error`` and
+``ingest_sessions`` treats as a transport error — the session is DEFERRED
+(stays unseen), so a machine without the CLI simply pauses learning instead
+of burning evidence.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from typing import Any, Dict, List, Optional
+
+#: Hard ceiling for one headless agent turn. The curator's distill prompt is
+#: small; a hang here must not stall the dream cycle.
+DEFAULT_TIMEOUT = 240.0
+
+_IS_WIN = sys.platform.startswith("win")
+
+
+class CursorAgentClient:
+    """OpenAI-compatible-shaped client backed by ``cursor-agent -p``.
+
+    Accepts the same ``chat(messages, model=..., temperature=..., max_tokens=...)``
+    call shape as ``OpenAICompatibleClient`` so it drops in anywhere a client
+    is expected (loop, curator, judge). ``temperature``/``max_tokens`` have no
+    CLI equivalent and are ignored on purpose — the agent applies its own
+    defaults. ``model``: only passed through when set; unset means "whatever
+    the user's Cursor is configured for" (the no-pinning default).
+    """
+
+    def __init__(self, model: Optional[str] = None,
+                 executable: str = "cursor-agent",
+                 timeout: Optional[float] = None) -> None:
+        self.model = model or os.environ.get("ODR_LLM_MODEL") or None
+        self.executable = executable
+        self.timeout = float(
+            timeout or os.environ.get("ODR_CURSOR_AGENT_TIMEOUT") or DEFAULT_TIMEOUT)
+
+    def chat(self, messages: List[Dict[str, str]], model: Optional[str] = None,
+             temperature: float = 0.7, max_tokens: int = 1024) -> str:
+        """One headless agent turn over the flattened conversation."""
+        effective = model or self.model
+        exe = shutil.which(self.executable)
+        if exe is None:
+            raise RuntimeError(
+                "cursor-agent CLI not found on PATH — install the Cursor CLI "
+                "(cursor.com/docs/cli) or pick another --provider")
+        argv = [exe, "-p", "--force", "--output-format", "text"]
+        if effective:
+            argv += ["--model", effective]
+        argv.append(_flatten(messages))
+        if _IS_WIN and exe.lower().endswith((".cmd", ".bat")):
+            # Windows npm shims are .cmd batch files: CreateProcess cannot
+            # exec them directly, so ride cmd.exe /c (Python >= 3.12 quotes
+            # batch-file arguments safely — the Store 3.13 runtime qualifies).
+            argv = ["cmd.exe", "/c"] + argv
+        try:
+            proc = subprocess.run(
+                argv, capture_output=True, timeout=self.timeout,
+                text=True, encoding="utf-8", errors="replace")
+        except subprocess.TimeoutExpired as exc:
+            raise RuntimeError(
+                f"cursor-agent timed out after {self.timeout:g}s") from exc
+        if proc.returncode != 0:
+            raise RuntimeError(
+                f"cursor-agent rc={proc.returncode}: "
+                f"{(proc.stderr or proc.stdout or '')[:300]}")
+        text = (proc.stdout or "").strip()
+        if not text:
+            raise RuntimeError("cursor-agent returned no output")
+        return text
+
+
+def _flatten(messages: List[Dict[str, str]]) -> str:
+    """system+user messages -> one prompt string (role-labelled)."""
+    parts = []
+    for m in messages:
+        role = str(m.get("role", "user"))
+        content = str(m.get("content", ""))
+        parts.append(f"[{role}]\n{content}" if role != "user" else content)
+    return "\n\n".join(parts)

package/open_dream_rsi/dashboard.py

@@ -2,7 +2,7 @@
 
     python -m open_dream_rsi dashboard                  # mock LLM, zero setup
     python -m open_dream_rsi dashboard --provider openai --tasks tasks.json
-    python -m open_dream_rsi dashboard --provider cursor --model cursor-grok-4.5-high
+    python -m open_dream_rsi dashboard --provider cursor --model grok-4.7
 
 Opens a dark, dependency-free dashboard (stdlib http.server only) showing:
 KPIs (cycles / API calls / solved / dream iterations), a live event feed,

package/open_dream_rsi/dream.py

@@ -145,14 +145,20 @@ def _append_probe_tasks(memory_root: Path, probes: List[Dict[str, Any]]) -> int:
 
 
 def ingest_sessions(memory, sessions_db: "str | Path", *,
+                    source: str = "hermes",
                     limit: int = 25, client=None,
                     category: Optional[str] = None) -> Dict[str, Any]:
     """Distil NEW (unseen) host sessions into staging lessons AND queue
     their source tasks as replay probes (the gate's counterparties).
 
-    Returns {'new': n_sessions, 'added': n_lessons, 'probes': n_tasks}.
-    Sessions already processed are skipped — transcripts stay in state.db,
-    so skipping a cycle loses nothing.
+    ``source="hermes"`` reads a Hermes ``state.db``; ``source="cursor"``
+    reads the Cursor ``User`` dir (``state.vscdb``) directly — no MCP
+    server involved, so this also works where MCP is blocked by policy.
+
+    Returns {'new': n_sessions, 'added': n_lessons, 'probes': n_tasks,
+             'deferred': n_deferred (endpoint failed; session left unseen)}.
+    Sessions already processed are skipped — transcripts stay in the
+    source store, so skipping a cycle loses nothing.
     """
     from open_dream_rsi.core.curator import (curate_lessons,
                                              evidence_snippets,
@@ -163,7 +169,15 @@ def ingest_sessions(memory, sessions_db: "str | Path", *,
     state = _load_state(root)
     seen = set(state.get("seen_sessions", []))
 
-    eps = read_hermes_sessions(sessions_db, limit=limit + len(seen))
+    if source not in ("hermes", "cursor"):
+        raise ValueError(f"unknown session source {source!r} "
+                         "(expected 'hermes' or 'cursor')")
+    if source == "cursor":
+        from open_dream_rsi.sessions import read_cursor_sessions
+        eps = read_cursor_sessions(user_dir=sessions_db,
+                                   limit=limit + len(seen))
+    else:
+        eps = read_hermes_sessions(sessions_db, limit=limit + len(seen))
     new = [e for e in eps if e.session_id not in seen][:limit]
     if not new:
         return {"new": 0, "added": 0}
@@ -175,6 +189,7 @@ def ingest_sessions(memory, sessions_db: "str | Path", *,
         # zero new so the caller stays in the cheap maintenance tier.
         return {"new": 0, "added": 0, "deferred": len(new)}
     added_total = 0
+    deferred = 0
     probes: List[Dict[str, Any]] = []
     for ep in new:
         seen.add(ep.session_id)
@@ -182,11 +197,23 @@ def ingest_sessions(memory, sessions_db: "str | Path", *,
         if not failures:
             continue
         cat = category or (Path(ep.cwd).name if ep.cwd else ep.source)
+        distilled, err = curator.distill(cat, ep.title or cat, failures,
+                                         memory.get_lessons(cat))
+        if err and err.startswith("llm error"):
+            # Transport failure (connect/HTTP/response shape): this session
+            # was never actually evaluated, so do NOT consume it — leave it
+            # unseen for the next cycle with a live endpoint. Consuming here
+            # would silently burn the evidence (a dead endpoint eats the
+            # backlog one session per fire, and the tier stays full).
+            seen.discard(ep.session_id)
+            deferred += 1
+            memory.log_event("lesson_deferred", source=ep.source,
+                             session_id=ep.session_id,
+                             reason=err[:300])
+            continue
         probe = _probe_task(ep, cat)
         if probe is not None:
             probes.append(probe)
-        distilled, err = curator.distill(cat, ep.title or cat, failures,
-                                         memory.get_lessons(cat))
         if err or not distilled:
             memory.log_event("lesson_rejected", source=ep.source,
                              session_id=ep.session_id,
@@ -204,13 +231,15 @@ def ingest_sessions(memory, sessions_db: "str | Path", *,
     n_probes = _append_probe_tasks(root, probes)
     if n_probes:
         memory.log_event("probe_tasks_queued", count=n_probes)
-    return {"new": len(new), "added": added_total, "probes": n_probes}
+    return {"new": len(new), "added": added_total, "probes": n_probes,
+            "deferred": deferred}
 
 
 # -- the seam ------------------------------------------------------------------
 
 def dream_once(memory_root: "str | Path", *,
                sessions_db: "str | Path | None" = None,
+               session_source: str = "hermes",
                skills_out: "str | Path | None" = None,
                client=None, tasks: Optional[List[Any]] = None,
                budget: int = 20, max_tokens: int = 4096,
@@ -231,7 +260,8 @@ def dream_once(memory_root: "str | Path", *,
         # 1. evidence (cheap unless new sessions carry failures)
         if sessions_db:
             report["ingest"] = ingest_sessions(
-                memory, sessions_db, client=client, category=category)
+                memory, sessions_db, source=session_source,
+                client=client, category=category)
 
         # 2. decide the tier
         state = _load_state(root)

package/open_dream_rsi/llm.py

@@ -4,7 +4,8 @@ Open Dream-RSI does not require a specific provider — any endpoint that
 implements the OpenAI protocol (``POST {base_url}/chat/completions``) works:
 
 * OpenAI                            -> https://api.openai.com/v1
-* Cursor Models API                 -> https://api2.cursor.sh
+* Cursor (via a local proxy over    -> http://127.0.0.1:3000/v1
+  the Cursor login, e.g. cursor-openai-api)
 * local vLLM / Ollama / LM Studio   -> http://127.0.0.1:8000/v1 etc.
 
 The client uses only the standard library (urllib), so the core package
@@ -63,10 +64,16 @@ ENDPOINT_PRESETS: Dict[str, Dict[str, str]] = {
         "api_key_env": "OPENAI_API_KEY",
         "default_model": "gpt-4o-mini",
     },
+    # Cursor ships no public OpenAI-compatible chat endpoint: a `crsr_` API
+    # key exposes the Cloud Agents API, and api2.cursor.sh is the IDE's
+    # internal (gRPC) backend — direct calls here can never work. The preset
+    # therefore targets a LOCAL OpenAI-compatible proxy over the Cursor login
+    # (e.g. `npx cursor-openai-api serve` on :3000) — see
+    # docs/integrations.md -> Cursor.
     "cursor": {
-        "base_url": "https://api2.cursor.sh",
+        "base_url": "http://127.0.0.1:3000/v1",
         "api_key_env": "CURSOR_API_KEY",
-        "default_model": "cursor-grok-4.5-high",
+        "default_model": "cursor-model",
     },
     "local": {
         "base_url": "http://127.0.0.1:8000/v1",
@@ -145,8 +152,8 @@ class LLMConfig:
         )
         if cfg.api_key is None and api_key_env:
             cfg.api_key = os.environ.get(api_key_env)
-        if cfg.api_key is None and preset == "local":
-            cfg.api_key = "local"  # vLLM/Ollama accept any bearer token
+        if cfg.api_key is None and preset in ("local", "cursor"):
+            cfg.api_key = "local"  # local servers and the Cursor login proxy accept any bearer token
         return cfg
 
     @classmethod

package/open_dream_rsi/loop.py

@@ -25,6 +25,7 @@ import json
 import random
 import time
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
 from open_dream_rsi.core.agent import ChatClient
@@ -113,6 +114,45 @@ class Task:
     criteria: str = ""
 
 
+def append_task(tasks_file: "str | Path", task: Dict[str, Any]) -> Dict[str, Any]:
+    """Append one task dict to a tasks.json queue file (atomic, idempotent).
+
+    The single write path shared by the MCP tool, the CLI and any other
+    no-MCP queue feeder (hooks, scripts): validates the required fields,
+    normalises the test-less shape, refuses duplicate task_ids, and writes
+    through a temp file so a concurrent reader never sees a torn queue.
+    """
+    task = dict(task)
+    task.setdefault("max_attempts", 4)
+    if not task.get("tests"):
+        task["tests"] = []
+    for field_name in ("task_id", "category", "prompt"):
+        if not task.get(field_name):
+            raise ValueError(f"'{field_name}' is required")
+    if not task.get("tests") and not task.get("criteria"):
+        raise ValueError("either 'tests' (non-empty list of {call, expected}) "
+                         "or 'criteria' (success description for the "
+                         "completion judge) is required")
+    if task.get("tests") and (not isinstance(task["tests"], list)
+                              or not task["tests"]):
+        raise ValueError("'tests' must be a non-empty list of {call, expected}")
+    path = Path(tasks_file)
+    existing: List[Dict[str, Any]] = []
+    if path.exists():
+        existing = json.loads(path.read_text(encoding="utf-8"))
+    if any(t.get("task_id") == task["task_id"] for t in existing):
+        return {"added": False,
+                "reason": f"task_id '{task['task_id']}' already queued"}
+    existing.append(task)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(existing, indent=2, ensure_ascii=False),
+                   encoding="utf-8")
+    tmp.replace(path)
+    return {"added": True, "task_id": task["task_id"],
+            "tasks_total": len(existing), "tasks_file": str(path)}
+
+
 #: Minimum new replay steps required before re-asking the LLM for a policy
 #: (one full cycle's worth of evidence — keeps generation cost bounded).
 POLICY_REGROW_STEPS = 4

package/open_dream_rsi/mcp.py

@@ -102,6 +102,8 @@ def tool_odr_lessons(args: Dict[str, Any]) -> Dict[str, Any]:
 
 def tool_odr_add_task(args: Dict[str, Any]) -> Dict[str, Any]:
     """Append a task to the task file so the next loop cycle picks it up."""
+    from open_dream_rsi.loop import append_task
+
     task = {
         "task_id": args.get("task_id"),
         "category": args.get("category"),
@@ -114,47 +116,31 @@ def tool_odr_add_task(args: Dict[str, Any]) -> Dict[str, Any]:
     for field_name in ("task_id", "category", "prompt"):
         if not task[field_name]:
             raise ValueError(f"'{field_name}' is required")
-    if not task.get("tests") and not task.get("criteria"):
-        raise ValueError("either 'tests' (non-empty list of {call, expected}) "
-                         "or 'criteria' (success description for the "
-                         "completion judge) is required")
-    if task.get("tests") and (not isinstance(task["tests"], list)
-                              or not task["tests"]):
-        raise ValueError("'tests' must be a non-empty list of {call, expected}")
-    # Normalise the test-less shape: the key exists with None whenever the
-    # caller passed no tests, so setdefault() would not fire and tasks.json
-    # would carry "tests": null.
-    if not task.get("tests"):
-        task["tests"] = []
-
-    path = _tasks_path(args)
-    existing: List[Dict[str, Any]] = []
-    if path.exists():
-        existing = json.loads(path.read_text(encoding="utf-8"))
-    if any(t.get("task_id") == task["task_id"] for t in existing):
-        return {"added": False, "reason": f"task_id '{task['task_id']}' already queued"}
-    existing.append(task)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(json.dumps(existing, indent=2, ensure_ascii=False), encoding="utf-8")
-    tmp.replace(path)
-    return {"added": True, "task_id": task["task_id"], "tasks_total": len(existing),
-            "tasks_file": str(path)}
+    return append_task(_tasks_path(args), task)
 
 
 def _default_provider() -> str:
     """Zero-configuration provider chain for harness-spawned servers.
 
-    Precedence: ODR_LLM_PRESET > OPENAI_* env (proxy/direct) > goose's own
-    model (desktop/CLI config on this machine) > local vLLM/Ollama default.
-    A goose/Claude/Codex/Hermes-spawned MCP server often gets a scrubbed
-    environment — the goose resolver reads config files instead of env, so
-    the dreamer still borrows the host's brain without any setup.
+    Precedence: ODR_LLM_PRESET > OPENAI_* env (proxy/direct) > the Cursor
+    Agent CLI (headless brain over the user's Cursor login — no proxy, no
+    key) > goose's own model (desktop/CLI config on this machine) > local
+    vLLM/Ollama default.  A goose/Claude/Codex/Hermes-spawned MCP server
+    often gets a scrubbed environment — the goose resolver reads config
+    files instead of env, so the dreamer still borrows the host's brain
+    without any setup.
     """
     if os.environ.get("ODR_LLM_PRESET"):
         return os.environ["ODR_LLM_PRESET"]
     if os.environ.get("OPENAI_BASE_URL") or os.environ.get("OPENAI_API_KEY"):
         return "openai"
+    try:
+        import shutil
+
+        if shutil.which("cursor-agent"):
+            return "cursor-agent"
+    except Exception:
+        pass
     try:
         from open_dream_rsi.utils.goose import goose_available
 

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.3",
   "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",