dsh-open-dream-rsi 0.2.1 → 0.3.1

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
@@ -144,31 +147,49 @@ def cmd_sessions(args: argparse.Namespace) -> int:
     memory = DreamMemory(args.memory)
     provider = getattr(args, "provider", "openai")
     if args.dry_run:
+        from open_dream_rsi.corrections import user_corrections
         for ep in eps[: args.limit or len(eps)]:
             fails = episode_failures(ep)
+            corrs = user_corrections(ep)
             print(f"[{ep.source}:{ep.session_id[:12]}] {ep.title[:60]} "
-                  f"— {len(fails)} failure-shaped record(s)")
-            for f in fails[:3]:
+                  f"— {len(fails)} failure-shaped, {len(corrs)} correction-shaped record(s)")
+            for f in (fails + corrs)[:3]:
                 print("   ", f["errors"][0][:100])
         return 0
     from open_dream_rsi.cli import _build_client
     client = _build_client(provider, args.model)
     curator = KnowledgeCurator(client)
+    from open_dream_rsi.corrections import (
+        dedupe_corrections,
+        distillable,
+        user_corrections,
+    )
     total_added = 0
-    for ep in eps:
-        failures = episode_failures(ep)
-        if not failures:
+    ep_evidence = [(ep, episode_failures(ep), user_corrections(ep))
+                   for ep in eps]
+    all_corr = distillable(
+        dedupe_corrections([c for _, _, cs in ep_evidence for c in cs]))
+    kept = {(c.get("session_id"), c.get("msg_index")) for c in all_corr}
+    for ep, failures, corr_raw in ep_evidence:
+        corrections = [c for c in corr_raw
+                       if (c.get("session_id"), c.get("msg_index")) in kept]
+        if corrections:
+            memory.log_event("user_correction_found", source=ep.source,
+                             session_id=ep.session_id, count=len(corrections),
+                             classes=[c.get("class", "") for c in corrections][:6])
+        evidence = failures + corrections
+        if not evidence:
             continue
         category = args.category or (
             Path(ep.cwd).name if ep.cwd else ep.source)
         distilled, err = curator.distill(category, ep.title or category,
-                                         failures, memory.get_lessons(category))
+                                         evidence, memory.get_lessons(category))
         if err or not distilled:
             memory.log_event("lesson_rejected", source=ep.source,
                              session_id=ep.session_id, reason=(err or "empty")[:300])
             continue
         result = curate_lessons(memory.get_lessons(category), distilled,
-                                evidence=evidence_snippets(failures))
+                                evidence=evidence_snippets(evidence))
         memory.replace_lessons(category, result.entries)
         memory.log_event("lessons_curated", source=ep.source,
                          session_id=ep.session_id, category=category,
@@ -181,6 +202,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 +242,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 +359,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 +390,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 +412,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 +477,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/curator.py

@@ -397,11 +397,16 @@ class KnowledgeCurator:
         known = "\n".join(f"  - [{l.get('trigger', '')}] {l.get('text', '')}"
                           for l in existing[-MAX_LESSONS_PER_CATEGORY:]) or "(empty KB)"
         feedback = ""
+        has_corr = any("user said:" in e for e in evidence)
         for attempt in range(1 + self.max_repair):
             user = (f"Category [{category}]: {task_prompt}\n\n"
                     f"Lessons already in the knowledge base (do not restate):\n{known}\n\n"
-                    f"Failed attempts this cycle:\n" + "\n".join(evidence) + "\n\n"
-                    f"Previous rejection reason: {feedback or '(none)'}\n\n"
+                    f"Failed attempts this cycle:\n" + "\n".join(evidence) +
+                    ("\n\nNote: some records are user corrections (action starts with "
+                     "'user_correction'): the user's wording is evidence worth testing, "
+                     "not verified truth; distil only the reusable, scoped rule."
+                     if has_corr else "") +
+                    f"\n\nPrevious rejection reason: {feedback or '(none)'}\n\n"
                     f"Return the JSON array of at most {self.max_lessons} lessons.")
             kwargs: Dict[str, Any] = {"temperature": 0.5}  # distillation, not creativity
             kwargs["max_tokens"] = self.max_tokens

package/open_dream_rsi/corrections.py

@@ -0,0 +1,213 @@
+"""User-correction extraction (issue #6): natural-language evidence.
+
+Host sessions contain corrections the user states in prose ("nie tak,
+użyj istniejącego klienta", "don't create another client") — invisible to
+:func:`open_dream_rsi.sessions.episode_failures`, which scans tool output
+for error markers. This module turns such turns into evidence records
+shaped like failure records (``action`` / ``score`` / ``errors``) so the
+existing curator and replay-gate flow consumes them without a second
+pipeline, while keeping the ``user_correction`` evidence kind and
+provenance recoverable (README § Verdicts must be replayable).
+
+Trust model is unchanged: a user correction is *evidence worth testing*,
+not verified truth. Nothing here can make a lesson ACTIVE — candidates
+enter staging like every other lesson and face the same paired-replay
+gate. Extraction is deterministic and deliberately conservative: only
+obvious, well-scoped candidates are kept; ambiguous negatives, ordinary
+follow-ups and task expansions stay unclassified.
+"""
+
+import re
+from typing import Any, Dict, List, Optional
+
+__all__ = ["classify_user_message", "user_corrections", "dedupe_corrections",
+           "prioritize_corrections", "distillable"]
+
+#: Turns that reject a result or approach ("Correction" / "Approach
+#: redirect" in issue #6). Kept tight on purpose — a broad "nie|not" net
+#: would swallow ordinary follow-ups (the measured v3 lesson: trust is
+#: earned per class, never by breadth).
+_CORRECTION_HINTS = re.compile(
+    r"\b(?:nie\s+tak|nie\s+o\s+to|nie\s+chodzi\s+o|chodzi\s+mi\s+o|"
+    r"źle|błędnie|błędne|błędn|złe\s+założen|przecież|zamiast|"
+    r"nadpis|nie\s+wolno|nie\s+rób|nie\s+używaj|nie\s+twórz|"
+    r"weź\s+pod\s+uwagę|uwzględnij|użyj\s+istniejąc|skorzystaj\s+z\s+istniejąc|"
+    r"jak\s+(?:napisałem|mówiłem|prosiłem)|już\s+(?:pisałem|mówiłem|prosiłem)|"
+    r"znowu\s+(?:to\s+samo|piszesz|robisz)|"
+    r"\bwrong\b|\bincorrectly?\b|that'?s\s+not|that\s+is\s+not|instead\s+of|"
+    r"don't\s+(?:do|create|use|touch|add|overwrite)|do\s+not\s+(?:do|create|use|touch|add|overwrite)|"
+    r"reuse\s+(?:the\s+)?(?:existing|shared)|as\s+i\s+(?:said|wrote|told|asked)|"
+    r"we\s+already\s+(?:tried|did|fixed)|\bbreaks\b|\bbroke\b|stop\s+(?:doing|touching|creating)"
+    r")", re.IGNORECASE)
+
+#: Stated conventions ("Preference" in issue #6). Legitimate scoped-rule
+#: evidence, but never framed as a failure lesson by the caller.
+_PREFERENCE_HINTS = re.compile(
+    r"\b(?:preferuję|wolę|zawsze\s+(?:używaj|pisz|rób|dziel)|"
+    r"nigdy\s+(?:nie\s+)?(?:używaj|pisz|rób)|trzymaj\s+się\s+konwencji|"
+    r"\bprefer\b|\bi\s+prefer\b|\bi\s+usually\b|always\s+(?:use|write|split)|"
+    r"never\s+(?:use|do|commit)|convention\s+is\b)", re.IGNORECASE)
+
+#: Task expansion / new requirement ("New requirement or clarification").
+#: Extracted for completeness (the classes must be distinguishable) but
+#: NOT distillation-ready by default: it is not evidence of a mistake.
+_REQUIREMENT_HINTS = re.compile(
+    r"\b(?:dodaj\s+jeszcze|dołóż|także\s+|poza\s+tym|oprócz\s+tego|"
+    r"a\s+co\s+z\s+|możesz\s+też|przy\s+okazji|"
+    r"what\s+about\b|also\s+add|in\s+addition|one\s+more\s+thing|"
+    r"while\s+you'?re\s+at\s+it)", re.IGNORECASE)
+
+#: Cheap ambiguity guards: short reactions, thanks, questions and bare
+#: acknowledgements are never promoted (issue §1: reject or leave
+#: unclassified rather than promote).
+_AMBIGUITY = re.compile(
+    r"^\s*(?:no|no,|nope|ok|okej|okay|super|spoko|git|dobrze|dziękuję|dzieki|thanks|"
+    r"thank\s+you|thx|why|czemu|dlaczego|ale\b)[.!?,\s]|(\?)")
+
+#: Assistant replies that suggest the session recovered after the
+#: correction ("subsequent outcome supports the correction").
+_OUTCOME_MARKERS = ("działa", "dziala", "zrobione", "gotowe", "naprawione",
+                    "passes", "passed", "fixed", "works now", "solved")
+
+_MIN_TEXT = 25
+_MAX_RECORDS = 6
+_MAX_TEXT = 220
+
+_STOPWORDS = {
+    "this", "that", "with", "have", "jest", "nie", "jak", "dla", "ale",
+    "się", "sie", "tym", "tego", "który", "ktore", "ktora", "jestem",
+    "made", "make", "want", "need", "please", "prosze", "proszę", "the",
+    "and", "you", "your", "have", "that", "this", "with", "dont", "don't",
+}
+
+
+def classify_user_message(text: str) -> Optional[str]:
+    """Classify one user turn: ``correction`` | ``approach_redirect`` |
+    ``preference`` | ``new_requirement`` | ``None`` (not a candidate).
+
+    ``correction`` wins over ``approach_redirect`` when both fire — a
+    rejection with a proposed alternative is recorded as the correction
+    it is; the redirect nuance lives in the text, not the label.
+    """
+    t = (text or "").strip()
+    if len(t) < _MIN_TEXT or _AMBIGUITY.search(t[:24] or t):
+        return None
+    corr = _CORRECTION_HINTS.search(t)
+    pref = _PREFERENCE_HINTS.search(t)
+    # Earliest explicit signal wins: "Preferuję małe commity zamiast jednego
+    # dużego" states a preference — the comparative "zamiast" is not a
+    # rejection — while "Nie twórz X, zamiast tego użyj Y" leads with the
+    # rejection. Ties resolve to correction (the class the gate and priority
+    # ranking are calibrated for).
+    if pref and (not corr or pref.start() < corr.start()):
+        return "preference"
+    if corr:
+        return "correction"
+    if _REQUIREMENT_HINTS.search(t):
+        return "new_requirement"
+    return None
+
+
+def user_corrections(ep: Any, max_items: int = _MAX_RECORDS) -> List[Dict[str, Any]]:
+    """Extract user-correction evidence records from one episode.
+
+    Each record pairs the correction with the assistant turn it targets
+    (nearest preceding assistant message, tool rows skipped) and carries
+    provenance (source host, session id, workspace, message index) plus
+    ``outcome_supported`` — whether the next assistant reply suggests the
+    session recovered after the correction. Message text arrives already
+    secret-redacted from the readers; nothing is added back.
+    """
+    records: List[Dict[str, Any]] = []
+    msgs = list(getattr(ep, "messages", []))
+    for i, m in enumerate(msgs):
+        if getattr(m, "role", "") != "user":
+            continue
+        cls = classify_user_message(m.text or "")
+        if cls is None:
+            continue
+        assistant_text = ""
+        for j in range(i - 1, -1, -1):
+            if msgs[j].role == "assistant":
+                assistant_text = msgs[j].text or ""
+                break
+        outcome = False
+        for j in range(i + 1, len(msgs)):
+            if msgs[j].role == "assistant":
+                low = (msgs[j].text or "").lower()
+                outcome = any(k in low for k in _OUTCOME_MARKERS)
+                break
+        records.append({
+            "action": f"user_correction:{getattr(ep, 'source', '')}:"
+                      f"{str(getattr(ep, 'session_id', ''))[:12]}#{i}",
+            "score": 0.0,
+            "errors": [
+                f"user said: {(m.text or '')[:_MAX_TEXT]}",
+                f"assistant had: {assistant_text[:_MAX_TEXT]}",
+                f"outcome: {'confirmed' if outcome else 'unverified'}",
+            ],
+            "kind": "user_correction",
+            "class": cls,
+            "source": getattr(ep, "source", ""),
+            "session_id": getattr(ep, "session_id", ""),
+            "cwd": getattr(ep, "cwd", ""),
+            "msg_index": i,
+            "outcome_supported": outcome,
+            "repeats": 1,
+            "occurrences": 1,
+        })
+    return records[-max_items:]
+
+
+def _content_words(text: str) -> frozenset:
+    words = re.findall(r"[a-ząćęłńóśźż]{4,}", (text or "").lower())
+    return frozenset(w for w in words if w not in _STOPWORDS)
+
+
+def dedupe_corrections(records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Collapse near-identical corrections before any paid curator call.
+
+    Two records merge when their content words overlap (Jaccard >= 0.6).
+    Repeats inside ONE episode do not strengthen the evidence: ``repeats``
+    counts distinct episodes behind the observation, ``occurrences`` the
+    raw message count (issue §3).
+    """
+    kept: List[Dict[str, Any]] = []
+    sigs: List[frozenset] = []
+    for rec in records:
+        sig = _content_words(" ".join(rec.get("errors", [])))
+        merged = False
+        for k, (old, old_sig) in enumerate(zip(kept, sigs)):
+            if old_sig and sig and (len(sig & old_sig) / len(sig | old_sig)) >= 0.6:
+                old["occurrences"] += 1
+                if old.get("session_id") != rec.get("session_id"):
+                    old["repeats"] += 1
+                if rec.get("outcome_supported") and not old.get("outcome_supported"):
+                    old["outcome_supported"] = True
+                    old["errors"] = list(old["errors"])[:2] + ["outcome: confirmed"]
+                merged = True
+                break
+        if not merged:
+            kept.append(rec)
+            sigs.append(sig)
+    return kept
+
+
+def prioritize_corrections(records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Highest-priority first (issue §3): confirmed outcome > repeated
+    across episodes > bare correction > preference. Stable sort."""
+    def rank(r: Dict[str, Any]) -> tuple:
+        return (
+            3 if r.get("outcome_supported") else 0,
+            2 if r.get("repeats", 1) >= 2 else 0,
+            1 if r.get("class") == "correction" else 0,
+        )
+    return sorted(records, key=rank, reverse=True)
+
+
+def distillable(records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Records eligible for the existing curator flow: corrections,
+    redirects and preferences — never new requirements or unclassified
+    turns (issue §1/§3: a task expansion is not evidence of a mistake)."""
+    return [r for r in records
+            if r.get("class") in ("correction", "approach_redirect", "preference")]

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,25 +145,44 @@ 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,
                                              KnowledgeCurator)
     from open_dream_rsi.sessions import episode_failures, read_hermes_sessions
+    from open_dream_rsi.corrections import (
+        dedupe_corrections,
+        distillable,
+        user_corrections,
+    )
 
     root = Path(memory.root)
     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,18 +194,46 @@ 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:
+    # Issue #6: user corrections are a second evidence class. Collect per
+    # episode, dedupe deterministically ACROSS the batch before any paid
+    # curator call, then distil failures + surviving corrections together
+    # — one pipeline, one gate, no second learning path.
+    ep_evidence = [(ep, episode_failures(ep), user_corrections(ep))
+                   for ep in new]
+    all_corr = distillable(
+        dedupe_corrections([c for _, _, cs in ep_evidence for c in cs]))
+    kept = {(c.get("session_id"), c.get("msg_index")) for c in all_corr}
+    for ep, failures, corr_raw in ep_evidence:
         seen.add(ep.session_id)
-        failures = episode_failures(ep)
-        if not failures:
+        corrections = [c for c in corr_raw
+                       if (c.get("session_id"), c.get("msg_index")) in kept]
+        if corrections:
+            memory.log_event("user_correction_found", source=ep.source,
+                             session_id=ep.session_id, count=len(corrections),
+                             classes=[c.get("class", "") for c in corrections][:6])
+        evidence = failures + corrections
+        if not evidence:
             continue
         cat = category or (Path(ep.cwd).name if ep.cwd else ep.source)
+        distilled, err = curator.distill(cat, ep.title or cat, evidence,
+                                         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 +251,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 +280,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-open-dream-rsi",
-  "version": "0.2.1",
+  "version": "0.3.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",