dsh-open-dream-rsi 0.2.3 → 0.3.1

package/open_dream_rsi/cli.py

@@ -147,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,

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

@@ -164,6 +164,11 @@ def ingest_sessions(memory, sessions_db: "str | Path", *,
                                              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)
@@ -191,13 +196,28 @@ def ingest_sessions(memory, sessions_db: "str | Path", *,
     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, failures,
+        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

package/package.json

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