dsh-open-dream-rsi 0.3.8 → 0.3.9

package/open_dream_rsi/__init__.py

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

package/open_dream_rsi/bench.py

@@ -57,7 +57,7 @@ def _make_client(provider: str, model: Optional[str]) -> Any:
 def _default_tasks() -> List[Task]:
     from open_dream_rsi.dashboard import DEMOS
 
-    return [Task(max_attempts=3, **t) for t in DEMOS]
+    return [Task(**{**t, "max_attempts": 3}) for t in DEMOS]
 
 
 def run_arm(

package/open_dream_rsi/bench_policy.py

@@ -72,7 +72,6 @@ class TrapSuite:
     promising: str
     fix: str
     low: str
-    low: str
 
 
 TRAP_SUITES: List[TrapSuite] = [

package/open_dream_rsi/cli.py

@@ -109,6 +109,7 @@ def cmd_sessions(args: argparse.Namespace) -> int:
     from open_dream_rsi.sessions import (
         episode_failures,
         load_episodes,
+        read_claude_code_sessions,
         read_cursor_sessions,
         read_hermes_sessions,
         write_episodes,
@@ -120,6 +121,9 @@ def cmd_sessions(args: argparse.Namespace) -> int:
                                        source=args.filter,
                                        limit=args.limit,
                                        redact=not args.no_redact)
+        elif args.source == "claude":
+            eps = read_claude_code_sessions(args.db, limit=args.limit,
+                                            redact=not args.no_redact)
         else:
             # --db accepts either the Cursor User dir or a state.vscdb copy
             db_arg = args.db
@@ -243,7 +247,8 @@ 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
+    from open_dream_rsi.sessions import (default_claude_projects_dir,
+                                         default_cursor_user_dir)
 
     client = None
     if not args.offline:
@@ -252,6 +257,9 @@ def cmd_dream(args: argparse.Namespace) -> int:
         # 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())
+    elif args.source == "claude":
+        # Claude Code transcripts live in a projects DIR of JSONL files
+        sessions_db = args.sessions or str(default_claude_projects_dir())
     else:
         sessions_db = args.sessions
     report = dream_once(
@@ -264,10 +272,12 @@ def cmd_dream(args: argparse.Namespace) -> int:
 
 
 def cmd_lessons(args: argparse.Namespace) -> int:
-    """Git-backed lesson stores: publish active lessons, import others'
+    """Git-backed stores: publish lessons/worlds/policies, import others'
     knowledge as staging (see README 'Sharing lessons')."""
     from open_dream_rsi.share import (LessonShareError, export_lessons,
-                                      import_lessons, store_status)
+                                      export_policies, export_worlds,
+                                      import_lessons, import_policies,
+                                      import_worlds, store_status)
 
     memory = DreamMemory(args.memory)
     try:
@@ -284,6 +294,31 @@ def cmd_lessons(args: argparse.Namespace) -> int:
                 print(f"[odr] {cat}: +{n} staging lesson(s) — activate via "
                       f"the paired-replay gate (odr loop)")
             return 0
+        elif args.lessons_cmd == "worlds-export":
+            st = export_worlds(memory, args.store, task_ids=args.task,
+                               message=args.message, push=not args.no_push)
+        elif args.lessons_cmd == "worlds-import":
+            counts = import_worlds(args.store, memory, task_ids=args.task)
+            if not counts:
+                print("[odr] nothing imported (empty/filtered store)")
+                return 0
+            for tid, n in sorted(counts.items()):
+                print(f"[odr] {tid}: imported world ({n} nodes) -> "
+                      f"trees/imported/{tid}.json (evidence, never a live task)")
+            return 0
+        elif args.lessons_cmd == "policies-export":
+            st = export_policies(memory, args.store, categories=args.category,
+                                 message=args.message, push=not args.no_push)
+        elif args.lessons_cmd == "policies-import":
+            counts = import_policies(args.store, memory,
+                                     categories=args.category)
+            if not counts:
+                print("[odr] nothing imported (empty/filtered store)")
+                return 0
+            for cat, n in sorted(counts.items()):
+                print(f"[odr] {cat}: +{n} policy program(s) registered as "
+                      f"CANDIDATE->VALIDATED in the ALM (adoption stays local)")
+            return 0
         else:  # status
             st = store_status(args.store)
     except LessonShareError as exc:
@@ -294,13 +329,59 @@ def cmd_lessons(args: argparse.Namespace) -> int:
     else:
         print(f"[odr] store: {st.location} "
               f"({'git' if st.git else 'plain dir'}, ok={st.ok})")
+        label = {"export": "lesson(s)", "worlds-export": "node(s)",
+                 "policies-export": "program(s)"}.get(args.lessons_cmd, "entry")
         for cat, n in sorted(st.categories.items()):
-            print(f"  {cat}: {n} lesson(s)")
+            if ":" in cat:  # status mixes sections; derive the label per key
+                label = {"world": "node(s)", "policy": "program(s)"}[
+                    cat.split(":", 1)[0]]
+                print(f"  {cat}: {n} {label}")
+            else:
+                print(f"  {cat}: {n} {label}")
         for e in st.errors:
             print(f"  ! {e}")
     return 0 if st.ok else 1
 
 
+def cmd_holdout(args: argparse.Namespace) -> int:
+    """Single-use holdout reservations: a preregistered eval task is consumed
+    once; a later phase cannot silently reuse it (see README 'Holdout hygiene')."""
+    from open_dream_rsi.holdout import HoldoutRegistry, split_reserved
+
+    reg = HoldoutRegistry(args.memory)
+    if args.holdout_cmd == "claim":
+        refused = [t for t in args.ids if not reg.claim(t, args.purpose,
+                                                        phase=args.phase)]
+        ok = [t for t in args.ids if t not in refused]
+        print(f"[odr] reserved {len(ok)} task id(s) for '{args.purpose}'"
+              + (f" (phase {args.phase})" if args.phase else ""))
+        if refused:
+            print(f"[odr] REFUSED (already held for another purpose): "
+                  f"{', '.join(refused)}", file=sys.stderr)
+            return 1
+        return 0
+    if args.holdout_cmd == "release":
+        released = [t for t in args.ids if reg.release(t)]
+        print(f"[odr] released {len(released)} reservation(s): "
+              f"{', '.join(released) or '(none)'}")
+        return 0
+    if args.holdout_cmd == "show":
+        entries = reg.entries()
+        if not entries:
+            print("[odr] no reservations")
+        for tid, meta in sorted(entries.items()):
+            print(f"  {tid}  purpose={meta.get('purpose')}"
+                  + (f" phase={meta['phase']}" if meta.get("phase") else ""))
+        return 0
+    # split: report which tasks of a queue file are holdout-reserved
+    tasks = json.loads(Path(args.tasks).read_text(encoding="utf-8"))
+    allowed, held = split_reserved(tasks, reg)
+    print(f"[odr] {len(allowed)} allowed, {len(held)} holdout-reserved")
+    for t in held:
+        print(f"  held: {t.get('task_id') if isinstance(t, dict) else t}")
+    return 0
+
+
 def cmd_skills(args: argparse.Namespace) -> int:
     """Render the curated lesson KB into Hermes-style skills (issue #3
     boundary: only lessons that EARNED activation become a prompt)."""
@@ -399,9 +480,11 @@ def main(argv: list[str] | None = None) -> int:
     dr.add_argument("--sessions", default=None,
                     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"],
+    dr.add_argument("--source", default="hermes",
+                    choices=["hermes", "cursor", "claude"],
                     help="kind of the --sessions store (default hermes; "
-                         "cursor reads state.vscdb directly, no MCP needed)")
+                         "cursor reads state.vscdb directly, no MCP needed; "
+                         "claude reads ~/.claude/projects JSONL)")
     dr.add_argument("--cursor-user-dir", default=None,
                     help="Cursor User dir for --source cursor (default: the "
                          "platform location, e.g. %%APPDATA%%\\Cursor\\User)")
@@ -459,16 +542,19 @@ def main(argv: list[str] | None = None) -> int:
 
     sess = sub.add_parser(
         "sessions",
-        help="import host transcripts (Hermes state.db / Cursor state.vscdb) "
+        help="import host transcripts (Hermes state.db / Cursor "
+             "state.vscdb / Claude Code projects JSONL) "
              "as curator evidence — export to JSONL, then distill into "
              "staging lessons (promotion gate still decides activation)")
     sess_sub = sess.add_subparsers(dest="sessions_cmd", required=True)
 
     exp = sess_sub.add_parser("export", help="read a host store, write episodes.jsonl")
-    exp.add_argument("--source", required=True, choices=["hermes", "cursor"])
+    exp.add_argument("--source", required=True,
+                     choices=["hermes", "cursor", "claude"])
     exp.add_argument("--db", default=None,
-                     help="path to state.db (hermes) or Cursor User dir "
-                          "(default: platform Cursor location)")
+                     help="path to state.db (hermes), the Cursor User dir, "
+                          "or the Claude Code projects dir (default: the "
+                          "platform location)")
     exp.add_argument("--filter", default=None,
                      help="hermes only: session source filter (e.g. cli, desktop)")
     exp.add_argument("--limit", type=int, default=None)
@@ -532,11 +618,74 @@ def main(argv: list[str] | None = None) -> int:
     limp.add_argument("--category", action="append", default=None)
     limp.set_defaults(func=cmd_lessons)
 
+    wexp = ls_sub.add_parser("worlds-export",
+                             help="add archived discovery trees to a store")
+    wexp.add_argument("--store", required=True,
+                      help="local dir or git URL")
+    wexp.add_argument("--task", action="append", default=None,
+                      help="limit to these task ids (repeatable)")
+    wexp.add_argument("--message", default=None, help="git commit message")
+    wexp.add_argument("--no-push", action="store_true",
+                      help="commit locally but do not push")
+    wexp.set_defaults(func=cmd_lessons)
+
+    wimp = ls_sub.add_parser("worlds-import",
+                             help="import a store's worlds as evidence "
+                                  "(trees/imported/, never live tasks)")
+    wimp.add_argument("--store", required=True, help="local dir or git URL")
+    wimp.add_argument("--task", action="append", default=None,
+                      help="limit to these task ids (repeatable)")
+    wimp.set_defaults(func=cmd_lessons)
+
+    pexp = ls_sub.add_parser("policies-export",
+                             help="add promoted exploration-policy programs "
+                                  "(structural gate applies on export)")
+    pexp.add_argument("--store", required=True, help="local dir or git URL")
+    pexp.add_argument("--category", action="append", default=None,
+                      help="limit to these categories (repeatable)")
+    pexp.add_argument("--message", default=None, help="git commit message")
+    pexp.add_argument("--no-push", action="store_true",
+                      help="commit locally but do not push")
+    pexp.set_defaults(func=cmd_lessons)
+
+    pimp = ls_sub.add_parser("policies-import",
+                             help="register a store's policy programs as "
+                                  "ALM CANDIDATE->VALIDATED (never incumbents)")
+    pimp.add_argument("--store", required=True, help="local dir or git URL")
+    pimp.add_argument("--category", action="append", default=None)
+    pimp.set_defaults(func=cmd_lessons)
+
     lst = ls_sub.add_parser("status", help="verify manifest + checksums")
     lst.add_argument("--store", required=True)
     lst.add_argument("--json", action="store_true")
     lst.set_defaults(func=cmd_lessons)
 
+    hld = sub.add_parser(
+        "holdout",
+        help="single-use holdout reservations — a preregistered eval task "
+             "is consumed once; later phases cannot silently reuse it")
+    hld_sub = hld.add_subparsers(dest="holdout_cmd", required=True)
+
+    hc = hld_sub.add_parser("claim", help="reserve task ids for a purpose")
+    hc.add_argument("--ids", nargs="+", required=True, help="task id(s)")
+    hc.add_argument("--purpose", required=True,
+                    help="e.g. travelplanner_eval, spolki_holdout")
+    hc.add_argument("--phase", default=None,
+                    help="optional phase label recorded with the reservation")
+    hc.set_defaults(func=cmd_holdout)
+
+    hr = hld_sub.add_parser("release", help="forget a reservation (correction path)")
+    hr.add_argument("--ids", nargs="+", required=True)
+    hr.set_defaults(func=cmd_holdout)
+
+    hs = hld_sub.add_parser("show", help="list all reservations")
+    hs.set_defaults(func=cmd_holdout)
+
+    hsplit = hld_sub.add_parser(
+        "split", help="partition a task queue into allowed vs held-back")
+    hsplit.add_argument("--tasks", required=True, help="tasks JSON file")
+    hsplit.set_defaults(func=cmd_holdout)
+
     dash = sub.add_parser("dashboard", help="serve the live web dashboard")
     dash.add_argument("--host", default="0.0.0.0",
                       help="bind address (default 0.0.0.0 — reachable on the LAN)")

package/open_dream_rsi/core/curator.py

@@ -88,7 +88,8 @@ LESSON_CONTRACT = (
     "Reply with ONLY one fenced ```json``` block containing an array of "
     "objects, each exactly: {{\"trigger\": \"...\", \"text\": \"...\"}}. "
     "'trigger' is 1-4 lowercase keywords tying the lesson to this failure "
-    "family; 'text' is one actionable insight in at most 3000 characters, "
+    "family — separate the keywords with SINGLE SPACES, never commas or "
+    "semicolons; 'text' is one actionable insight in at most 3000 characters, "
     "grounded ONLY in the evidence shown. Be SPECIFIC, not terse: name the "
     "observable signal (the exact error shape, tool, or state that "
     "recurs), the mechanism that made the attempt fail, and the bounded "
@@ -144,18 +145,28 @@ def validate_lesson_items(items: Any, max_lessons: int) -> List[Dict[str, str]]:
         raise LessonValidationError("payload is not a JSON array")
     out: List[Dict[str, str]] = []
     seen = set()
+    reasons: List[str] = []
     for it in items:
         if not isinstance(it, dict):
-            raise LessonValidationError("lesson entry is not an object")
+            reasons.append("entry is not an object")
+            continue
         trig = str(it.get("trigger", "")).strip()
         text = str(it.get("text", "")).strip()
         words = normalize(trig).split()
         if not (MIN_TRIGGER_WORDS <= len(words) <= MAX_TRIGGER_WORDS):
-            raise LessonValidationError(
-                f"trigger must be {MIN_TRIGGER_WORDS}-{MAX_TRIGGER_WORDS} words, got {trig!r}")
+            # Tolerate comma/semicolon-separated keyword lists (LLMs produce
+            # "traceback, timeout" despite the contract): fold to the
+            # fragments when the joined form fits the word budget.
+            folded = " ".join(w for w in re.split(r"[,;/]+", trig) if w.strip())
+            if MIN_TRIGGER_WORDS <= len(folded.split()) <= MAX_TRIGGER_WORDS:
+                trig = folded
+                words = folded.split()
+            else:
+                reasons.append(f"trigger width {trig!r}")
+                continue
         if not (20 <= len(text) <= MAX_LESSON_CHARS):
-            raise LessonValidationError(
-                f"lesson text must be 20-{MAX_LESSON_CHARS} chars, got {len(text)}")
+            reasons.append(f"text len {len(text)}")
+            continue
         key = lesson_key({"trigger": trig, "text": text})
         if key in seen:
             continue
@@ -163,6 +174,11 @@ def validate_lesson_items(items: Any, max_lessons: int) -> List[Dict[str, str]]:
         out.append({"trigger": trig, "text": text})
         if len(out) >= max_lessons:
             break
+    if not out:
+        # All-or-nothing (the old behaviour) destroyed mixed payloads: one
+        # malformed trigger discarded every good lesson with it. Raise only
+        # when nothing is salvageable; the message feeds the repair loop.
+        raise LessonValidationError("; ".join(reasons[:3]) or "empty payload")
     return out
 
 
@@ -359,7 +375,9 @@ def lesson_gate_verdict(results: Dict[str, List[Tuple[bool, bool]]]) -> GateVerd
       unbounded exploration instruction must never activate on a greedy
       solver no matter what a small sample says.
     """
-    promoted, rejected, detail = [], [], {}
+    promoted: List[str] = []
+    rejected: List[str] = []
+    detail: Dict[str, Any] = {}
     for key, pairs in results.items():
         gains = sum(1 for w, wo in pairs if w and not wo)
         regs = sum(1 for w, wo in pairs if wo and not w)

package/open_dream_rsi/core/policygen.py

@@ -61,7 +61,8 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from open_dream_rsi.core.tree import DiscoveryTree
-from open_dream_rsi.sandbox import run_isolated
+from open_dream_rsi.sandbox import (SandboxCache, cached_run_isolated,
+                                    content_key, run_isolated)
 
 #: Weight of branch diversity in the rollout score (the paper's beta_2:
 #: replay objectives reward visiting *different* branches, not just high-
@@ -289,8 +290,11 @@ class PolicySandbox:
     gated by :func:`validate_policy_source` before we ever spawn a process.
     """
 
-    def __init__(self, timeout: float = 5.0):
+    def __init__(self, timeout: float = 5.0,
+                 cache: Optional[SandboxCache] = None):
         self.timeout = timeout
+        #: Optional content-addressed result cache (opt-in; None = uncached).
+        self.cache = cache
 
     def choose(self, source: str, frontier: List[Dict[str, Any]], step: int) -> PolicyRun:
         try:
@@ -305,10 +309,14 @@ class PolicySandbox:
         fr_path.write_text(json.dumps(frontier), encoding="utf-8")
         harness_path.write_text(_POLICY_HARNESS, encoding="utf-8")
         try:
-            proc = run_isolated(
+            proc = cached_run_isolated(
+                run_isolated,
                 [sys.executable, "-I", str(harness_path), str(src_path), str(fr_path), str(step)],
+                key=content_key({"harness": _POLICY_HARNESS, "policy": source,
+                                 "frontier": frontier}, timeout=self.timeout),
                 timeout=self.timeout,
                 cwd=d,
+                cache=self.cache,
             )
         except subprocess.TimeoutExpired:
             return PolicyRun(None, "policy execution timed out")
@@ -346,10 +354,14 @@ class PolicySandbox:
         world_path.write_text(json.dumps(world), encoding="utf-8")
         harness_path.write_text(_ROLLOUT_HARNESS, encoding="utf-8")
         try:
-            proc = run_isolated(
+            proc = cached_run_isolated(
+                run_isolated,
                 [sys.executable, "-I", str(harness_path), str(src_path), str(world_path)],
+                key=content_key({"harness": _ROLLOUT_HARNESS, "policy": source,
+                                 "world": world}, timeout=self.timeout),
                 timeout=self.timeout,
                 cwd=d,
+                cache=self.cache,
             )
         except subprocess.TimeoutExpired:
             return None, [], 0, "policy rollout timed out"
@@ -410,7 +422,7 @@ def frontier_entry(node: Any, outcomes: Dict[str, float]) -> Dict[str, Any]:
     ``outcome`` per step with the as-of-now value over revealed descendants
     only (prefix rule).
     """
-    errors = []
+    errors: List[Any] = []
     result = node.result
     if isinstance(result, dict):
         errors = result.get("errors") or []
@@ -635,6 +647,25 @@ Previous candidate rejection reason: {feedback}
 Return an improved complete policy as one python code block."""
 
 
+REVISE_USER_TEMPLATE = """Category: {category}
+
+Your current policy program (the incumbent — keep its successful strategy,
+fix only what the replay feedback indicts):
+```python
+{incumbent}
+```
+
+Replay metrics of the current policy: {metrics}
+
+Discovery history summary ({nodes} nodes, best score {best_score}):
+{summary}
+
+Why the last challenger was rejected: {feedback}
+
+Return a REVISED complete policy as one python code block (full program,
+not a patch)."""
+
+
 @dataclass
 class GenerationResult:
     source: Optional[str]
@@ -664,6 +695,7 @@ class PolicyGenerator:
         incumbent_score: float,
         tree: DiscoveryTree,
         api_calls: Optional[List[int]] = None,
+        revise: bool = False,
     ) -> GenerationResult:
         steps = sum(1 for n in tree.nodes.values() if n.parent_id)
         if steps < 2:
@@ -671,8 +703,13 @@ class PolicyGenerator:
         summary = self._tree_summary(tree)
         feedback = ""
         source: Optional[str] = None
+        user_template = REVISE_USER_TEMPLATE if revise else GEN_USER_TEMPLATE
+        system_prompt = (
+            POLICY_CONTRACT + " You are REVISING the incumbent policy: keep "
+            "its successful strategy, change only what the feedback indicts."
+            if revise else POLICY_CONTRACT)
         for attempt in range(1 + self.max_repair):
-            user = GEN_USER_TEMPLATE.format(
+            user = user_template.format(
                 category=category,
                 incumbent=incumbent_source or "(none — first policy)",
                 metrics=f"{incumbent_score:.4f}",
@@ -686,7 +723,7 @@ class PolicyGenerator:
                 if self.max_tokens:
                     kwargs["max_tokens"] = self.max_tokens
                 reply = self.client.chat(
-                    [{"role": "system", "content": POLICY_CONTRACT},
+                    [{"role": "system", "content": system_prompt},
                      {"role": "user", "content": user}],
                     **kwargs,
                 )
@@ -720,6 +757,50 @@ class PolicyGenerator:
             return GenerationResult(source, score, "")
         return GenerationResult(None, float("-inf"), feedback or "generation failed")
 
+    @staticmethod
+    def _replay_brief(tree: DiscoveryTree, horizon: Optional[int] = None,
+                      max_steps: int = 24) -> str:
+        """Greedy replay trace: the counterfactual the incumbent must beat.
+
+        Mirrors :func:`_simulate_step_rewards` (greedy pick = best visible
+        score) and reports, per step, what the greedy policy would harvest —
+        the model sees WHERE the greedy replay stalls (repeated exhausted
+        picks, zero-reward steps) and revises against that evidence instead
+        of rewriting blind.
+        """
+        if not tree.nodes:
+            return "(empty)"
+        world = rollout_world_payload(tree, horizon)
+
+        def pick(visible, step):
+            return max(visible, key=lambda e: e["score"])["node_id"] if visible else None
+
+        rewards, picks, _invalid, _err = _simulate_step_rewards(world, pick)
+        lines = []
+        for i, (pick_id, reward) in enumerate(list(zip(picks, rewards))[:max_steps]):
+            repeat = " REPEAT" if picks[:i].count(pick_id) else ""
+            lines.append(f"step {i}: expand {pick_id} -> reward {reward:.3f}{repeat}")
+        exhausted = [p for p in picks if picks.count(p) > 1]
+        if exhausted:
+            lines.append(f"greedy re-picks: {sorted(set(exhausted))[:4]} "
+                         "(exhausted branches — the incumbent camps here)")
+        return "\n".join(lines) or "(no steps)"
+
+    def generate_with_brief(self, category, incumbent_source, incumbent_score,
+                            tree, api_calls=None):
+        """Revise mode with the greedy replay brief as structured feedback.
+
+        A candidate promoted here faced strictly stronger evidence than a
+        blind rewrite: same promotion gate, same strict win requirement —
+        only the prompt carries the incumbent's measured replay trace.
+        """
+        brief = self._replay_brief(tree)
+        result = self.generate(category, incumbent_source, incumbent_score,
+                               tree, api_calls=api_calls, revise=True)
+        if result.source is None and brief:
+            result.error = f"{result.error} | greedy replay: {brief[:200]}".strip(" |")
+        return result
+
     @staticmethod
     def _tree_summary(tree: DiscoveryTree, max_nodes: int = 12) -> str:
         lines = []

package/open_dream_rsi/dashboard.py

@@ -51,7 +51,7 @@ SOLUTIONS = {
     ),
 }
 
-DEMOS = [
+DEMOS: List[Dict[str, Any]] = [
     dict(task_id="add1", category="add",
          prompt="Implement add(a, b) returning the sum of two numbers.",
          tests=[{"call": "add(2, 3)", "expected": 5}, {"call": "add(-1, 1)", "expected": 0}]),
@@ -224,7 +224,7 @@ def run_dashboard(host: str = "0.0.0.0", port: int = 8765, provider: str = "mock
         raw = json.loads(open(tasks_file, encoding="utf-8").read())
         demo_tasks = [Task(**t) for t in raw]
     else:
-        demo_tasks = [Task(max_attempts=3, **t) for t in DEMOS]
+        demo_tasks = [Task(**{**t, "max_attempts": 3}) for t in DEMOS]
 
     if provider == "mock":
         client: Any = MockLLM()

package/open_dream_rsi/dream.py

@@ -194,6 +194,8 @@ def ingest_sessions(memory, sessions_db: "str | Path", *,
     ``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.
+    ``source="claude"`` reads Claude Code JSONL transcripts under
+    ``~/.claude/projects`` (or the given projects dir).
 
     Returns {'new': n_sessions, 'added': n_lessons, 'probes': n_tasks,
              'deferred': n_deferred (endpoint failed; session left unseen)}.
@@ -214,13 +216,17 @@ def ingest_sessions(memory, sessions_db: "str | Path", *,
     state = _load_state(root)
     seen = set(state.get("seen_sessions", []))
 
-    if source not in ("hermes", "cursor"):
+    if source not in ("hermes", "cursor", "claude"):
         raise ValueError(f"unknown session source {source!r} "
-                         "(expected 'hermes' or 'cursor')")
+                         "(expected 'hermes', 'cursor' or 'claude')")
     if source == "cursor":
         from open_dream_rsi.sessions import read_cursor_sessions
         eps = read_cursor_sessions(user_dir=sessions_db,
                                    limit=limit + len(seen))
+    elif source == "claude":
+        from open_dream_rsi.sessions import read_claude_code_sessions
+        eps = read_claude_code_sessions(projects_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]