rsi-loop 0.1.0__py3-none-any.whl

rsi_loop/__init__.py

@@ -0,0 +1,10 @@
+"""RSI Loop — Universal self-improvement loop for AI agents."""
+
+from rsi_loop.analyzer import Analyzer
+from rsi_loop.fixer import Fixer
+from rsi_loop.loop import RSILoop
+from rsi_loop.observer import Observer
+from rsi_loop.types import Config, Fix, Outcome, Pattern
+
+__version__ = "0.1.0"
+__all__ = ["RSILoop", "Observer", "Analyzer", "Fixer", "Config", "Outcome", "Pattern", "Fix"]

rsi_loop/analyzer.py

@@ -0,0 +1,203 @@
+"""Analyzer — Detect improvement patterns from recorded outcomes."""
+
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from pathlib import Path
+
+from rsi_loop.observer import Observer
+from rsi_loop.types import HIGH_SEVERITY_ISSUES, Config, Outcome, Pattern
+
+
+# Category classification by issue
+_ISSUE_CATEGORIES: dict[str, str] = {
+    "skill_gap": "skill_gap", "missing_tool": "skill_gap", "wrong_output": "skill_gap",
+    "rate_limit": "model_routing", "model_fallback": "model_routing",
+    "wrong_model_tier": "model_routing", "slow_response": "model_routing",
+    "context_loss": "memory_continuity", "memory_miss": "memory_continuity",
+    "compaction_lost_context": "memory_continuity",
+    "repeated_mistake": "behavior_pattern", "over_confirmation": "behavior_pattern",
+    "bad_routing": "behavior_pattern",
+    "tool_error": "tool_reliability", "timeout": "tool_reliability",
+    "empty_response": "tool_reliability",
+}
+
+# Suggested actions by category
+_CATEGORY_ACTIONS: dict[str, str] = {
+    "skill_gap": "Create or improve relevant skill/tool",
+    "model_routing": "Update model routing configuration",
+    "memory_continuity": "Improve memory and context protocols",
+    "behavior_pattern": "Update agent behavior rules",
+    "tool_reliability": "Add retry logic or fallback tools",
+}
+
+# Cross-source correlation pairs
+_CORRELATED_ISSUES: dict[frozenset[str], str] = {
+    frozenset({"session_reset", "context_loss"}): "context_management",
+    frozenset({"cost_overrun", "wrong_model_tier"}): "model_routing",
+    frozenset({"empty_response", "tool_error"}): "tool_reliability",
+    frozenset({"hydration_fail", "context_loss"}): "session_recovery",
+}
+
+
+class Analyzer:
+    """Detects improvement patterns from recorded outcomes."""
+
+    def __init__(self, config: Config | None = None, observer: Observer | None = None) -> None:
+        self.config = config or Config()
+        self.observer = observer or Observer(self.config)
+        self._data_dir = Path(self.config.data_dir)
+        self._patterns_file = self._data_dir / "patterns.json"
+
+    def analyze(self, days: int | None = None) -> list[Pattern]:
+        """Scan outcomes and detect patterns. Returns ranked list by impact."""
+        window = days or self.config.analysis_window_days
+        outcomes = self.observer.load_outcomes(days=window)
+        if not outcomes:
+            return []
+
+        patterns: list[Pattern] = []
+        total = len(outcomes)
+
+        # ── Group by (task_type, issue) ────────────────────────────────────────
+        groups: dict[tuple[str, str], list[Outcome]] = defaultdict(list)
+        for o in outcomes:
+            issues = o.issues or ["none"]
+            for issue in issues:
+                groups[(o.task_type, issue)].append(o)
+
+        for (task, issue), group in groups.items():
+            n = len(group)
+            min_threshold = 1 if issue in HIGH_SEVERITY_ISSUES else 2
+            if n < min_threshold:
+                continue
+
+            failures = [o for o in group if not o.success]
+            failure_rate = len(failures) / n
+            avg_quality = sum(o.quality for o in group) / n
+            quality_deficit = 5.0 - avg_quality
+            impact = (n / total) * quality_deficit
+
+            category = _ISSUE_CATEGORIES.get(issue, "other")
+            action = _CATEGORY_ACTIONS.get(category, "Investigate and address")
+            sources = sorted(set(o.source for o in group))
+            errors = [o.error_message for o in group if o.error_message][:3]
+            timestamps = sorted(o.timestamp for o in group)
+
+            patterns.append(Pattern(
+                id=f"{task[:8]}-{issue[:8]}-{n}",
+                category=category,
+                task_type=task,
+                issue=issue,
+                frequency=n,
+                impact_score=impact,
+                failure_rate=failure_rate,
+                description=f"In '{task}' tasks, '{issue}' occurs {n}x "
+                            f"with {failure_rate:.0%} failure rate",
+                sample_errors=errors,
+                suggested_action=action,
+                sources=sources,
+                first_seen=timestamps[0] if timestamps else "",
+                last_seen=timestamps[-1] if timestamps else "",
+            ))
+
+        # ── Error message clustering ──────────────────────────────────────────
+        error_groups: dict[str, list[Outcome]] = defaultdict(list)
+        for o in outcomes:
+            if o.error_message:
+                norm = Observer.normalize_error(o.error_message)
+                error_groups[norm].append(o)
+
+        for norm_err, err_outcomes in error_groups.items():
+            if len(err_outcomes) < 2:
+                continue
+            n = len(err_outcomes)
+            failures = [o for o in err_outcomes if not o.success]
+            avg_quality = sum(o.quality for o in err_outcomes) / n
+            quality_deficit = 5.0 - avg_quality
+            impact = (n / total) * quality_deficit
+            sources = sorted(set(o.source for o in err_outcomes))
+
+            patterns.append(Pattern(
+                id=f"err-{hash(norm_err) % 99999:05d}-{n}",
+                category="error_cluster",
+                task_type="mixed",
+                issue="error_cluster",
+                frequency=n,
+                impact_score=impact,
+                failure_rate=len(failures) / n,
+                description=f"Error cluster ({n}x): {norm_err[:60]}",
+                sample_errors=[o.error_message for o in err_outcomes[:3]],
+                suggested_action="Investigate common error pattern",
+                sources=sources,
+            ))
+
+        # ── Recurrence detection ──────────────────────────────────────────────
+        prev_patterns = self._load_previous_patterns()
+        for p in patterns:
+            key = (p.task_type, p.issue)
+            if key in prev_patterns:
+                p.recurring = True
+                prev_freq = prev_patterns[key].get("frequency", 0)
+                p.trend = "increasing" if p.frequency > prev_freq else "stable"
+
+        # Sort by impact
+        patterns.sort(key=lambda p: -p.impact_score)
+        patterns = patterns[:20]
+
+        # Save for next cycle's recurrence detection
+        self._save_patterns(patterns)
+        return patterns
+
+    def health_score(self, days: int | None = None) -> float:
+        """Compute overall health score: 0.0 (broken) to 1.0 (healthy)."""
+        outcomes = self.observer.load_outcomes(days=days or self.config.analysis_window_days)
+        if not outcomes:
+            return 1.0  # No data = assume healthy
+
+        total_success = sum(1 for o in outcomes if o.success)
+        avg_quality = sum(o.quality for o in outcomes) / len(outcomes)
+        return round((total_success / len(outcomes)) * (avg_quality / 5.0), 3)
+
+    def cross_source_correlations(self, days: int | None = None) -> list[dict]:
+        """Detect correlated issues appearing across different sources."""
+        outcomes = self.observer.load_outcomes(days=days or self.config.analysis_window_days)
+        issue_sources: dict[str, set[str]] = defaultdict(set)
+        for o in outcomes:
+            for issue in o.issues:
+                issue_sources[issue].add(o.source)
+
+        active = set(issue_sources.keys())
+        correlations = []
+        for pair, name in _CORRELATED_ISSUES.items():
+            if pair.issubset(active):
+                all_sources: set[str] = set()
+                for iss in pair:
+                    all_sources.update(issue_sources[iss])
+                if len(all_sources) > 1:
+                    correlations.append({
+                        "issues": sorted(pair),
+                        "correlation": name,
+                        "sources": sorted(all_sources),
+                    })
+        return correlations
+
+    def _load_previous_patterns(self) -> dict[tuple[str, str], dict]:
+        if not self._patterns_file.exists():
+            return {}
+        try:
+            with open(self._patterns_file) as f:
+                data = json.load(f)
+            return {
+                (p.get("task_type", ""), p.get("issue", "")): p
+                for p in data.get("patterns", [])
+            }
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    def _save_patterns(self, patterns: list[Pattern]) -> None:
+        self._data_dir.mkdir(parents=True, exist_ok=True)
+        data = {"patterns": [p.to_dict() for p in patterns]}
+        with open(self._patterns_file, "w") as f:
+            json.dump(data, f, indent=2)

rsi_loop/fixer.py

@@ -0,0 +1,139 @@
+"""Fixer — Generate and apply fixes for detected patterns."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from rsi_loop.types import Config, Fix, Pattern
+
+# Issue → fix template mapping
+_FIX_TEMPLATES: dict[str, dict[str, str]] = {
+    "rate_limit": {
+        "type": "retry_logic",
+        "description": "Add/increase retry backoff for rate-limited endpoints",
+    },
+    "model_fallback": {
+        "type": "routing_config",
+        "description": "Update model fallback chain configuration",
+    },
+    "wrong_model_tier": {
+        "type": "routing_config",
+        "description": "Adjust tier classification thresholds",
+    },
+    "cost_overrun": {
+        "type": "routing_config",
+        "description": "Lower cost ceiling or adjust model routing",
+    },
+    "slow_response": {
+        "type": "threshold_tuning",
+        "description": "Increase timeout thresholds or add circuit breaker",
+    },
+    "timeout": {
+        "type": "threshold_tuning",
+        "description": "Increase timeout thresholds or add circuit breaker",
+    },
+    "empty_response": {
+        "type": "retry_logic",
+        "description": "Add empty-response detection and retry",
+    },
+    "session_reset": {
+        "type": "investigation",
+        "description": "Investigate context management protocols",
+    },
+}
+
+
+class Fixer:
+    """Generates fix proposals for detected patterns.
+
+    Safe categories are auto-applicable; everything else produces a proposal
+    saved to disk for human review.
+    """
+
+    def __init__(self, config: Config | None = None) -> None:
+        self.config = config or Config()
+        self._data_dir = Path(self.config.data_dir)
+        self._proposals_dir = self._data_dir / "proposals"
+
+    def propose(self, pattern: Pattern) -> Fix:
+        """Generate a fix proposal for a detected pattern."""
+        template = _FIX_TEMPLATES.get(pattern.issue, {})
+        fix_type = template.get("type", "investigation")
+        description = template.get(
+            "description",
+            f"Address '{pattern.issue}' in '{pattern.task_type}' tasks",
+        )
+
+        is_safe = fix_type in self.config.safe_categories
+
+        changes: list[dict[str, str]] = []
+        if fix_type == "routing_config":
+            changes.append({
+                "target": "model routing config",
+                "action": "Review and adjust routing thresholds",
+                "detail": f"Pattern '{pattern.issue}' suggests routing misconfiguration",
+            })
+        elif fix_type == "retry_logic":
+            changes.append({
+                "target": "relevant integration code",
+                "action": f"Add retry with backoff for '{pattern.issue}' errors",
+                "detail": f"Detected {pattern.frequency}x occurrences",
+            })
+        elif fix_type == "threshold_tuning":
+            changes.append({
+                "target": "relevant config",
+                "action": f"Adjust thresholds to reduce '{pattern.issue}'",
+                "detail": f"Current failure rate: {pattern.failure_rate:.0%}",
+            })
+
+        return Fix(
+            pattern_id=pattern.id,
+            type="auto" if is_safe else "manual",
+            status="proposed" if is_safe else "draft",
+            target=changes[0]["target"] if changes else "",
+            changes=changes,
+            safe_category=fix_type if is_safe else "",
+            description=description,
+        )
+
+    def apply_if_safe(self, fix: Fix) -> bool:
+        """Auto-apply if the fix is in a safe category. Returns True if applied.
+
+        Note: Even "safe" fixes only get their status updated and saved as a
+        proposal. Actual code/config changes require agent-specific implementation.
+        """
+        if fix.safe_category and fix.safe_category in self.config.safe_categories:
+            fix.status = "applied"
+            self._save_proposal(fix)
+            return True
+
+        fix.status = "draft"
+        self._save_proposal(fix)
+        return False
+
+    def propose_and_apply(self, pattern: Pattern) -> Fix:
+        """Convenience: propose a fix and auto-apply if safe."""
+        fix = self.propose(pattern)
+        self.apply_if_safe(fix)
+        return fix
+
+    def load_proposals(self) -> list[Fix]:
+        """Load all saved fix proposals."""
+        if not self._proposals_dir.exists():
+            return []
+        proposals: list[Fix] = []
+        for path in sorted(self._proposals_dir.glob("*.json")):
+            try:
+                with open(path) as f:
+                    proposals.append(Fix.from_dict(json.load(f)))
+            except (json.JSONDecodeError, OSError):
+                continue
+        return proposals
+
+    def _save_proposal(self, fix: Fix) -> Path:
+        self._proposals_dir.mkdir(parents=True, exist_ok=True)
+        path = self._proposals_dir / f"{fix.id}.json"
+        with open(path, "w") as f:
+            json.dump(fix.to_dict(), f, indent=2)
+        return path

rsi_loop/integrations/__init__.py

@@ -0,0 +1 @@
+"""RSI Loop integrations for various agent frameworks."""

rsi_loop/integrations/claude_code.py

@@ -0,0 +1,105 @@
+"""Claude Code / OpenClaw adapter for RSI Loop."""
+
+from __future__ import annotations
+
+from rsi_loop.loop import RSILoop
+from rsi_loop.types import Config, Outcome
+
+
+class ClaudeCodeAdapter:
+    """Wraps RSI Loop for Claude Code and OpenClaw agents.
+
+    Provides high-level methods matching common agent lifecycle events:
+    task completion, session resets, model fallbacks, etc.
+
+    Usage::
+
+        adapter = ClaudeCodeAdapter(data_dir="./rsi_data")
+        adapter.on_task_complete("code_review", success=True, model="sonnet-4.6")
+        adapter.on_model_fallback("opus-4", "sonnet-4.6", "rate_limit")
+        adapter.on_session_reset()
+    """
+
+    def __init__(self, data_dir: str = "./rsi_data", **config_kwargs) -> None:
+        self.loop = RSILoop(Config(data_dir=data_dir, **config_kwargs))
+
+    def on_task_complete(
+        self,
+        task: str,
+        success: bool = True,
+        error: str | None = None,
+        model: str | None = None,
+        duration_ms: int | None = None,
+        quality: int = 3,
+        notes: str = "",
+    ) -> Outcome:
+        """Record a completed task outcome."""
+        return self.loop.observer.record_simple(
+            task=task,
+            success=success,
+            error=error,
+            model=model,
+            duration_ms=duration_ms,
+            quality=quality,
+            source="openclaw",
+            notes=notes,
+        )
+
+    def on_session_reset(self, notes: str = "") -> Outcome:
+        """Record a session reset event."""
+        return self.loop.observer.record_simple(
+            task="session_management",
+            success=False,
+            error="Session reset — context lost",
+            source="openclaw",
+            quality=1,
+            notes=notes,
+        )
+
+    def on_model_fallback(
+        self,
+        from_model: str,
+        to_model: str,
+        reason: str = "unavailable",
+    ) -> Outcome:
+        """Record a model fallback event."""
+        return self.loop.observer.record_simple(
+            task="model_routing",
+            success=True,
+            error=f"Model fallback: {from_model} → {to_model} ({reason})",
+            model=to_model,
+            source="openclaw",
+            quality=2,
+            notes=f"Fell back from {from_model} to {to_model}: {reason}",
+        )
+
+    def on_cron_failure(self, job_name: str, error: str) -> Outcome:
+        """Record a cron job failure."""
+        return self.loop.observer.record_simple(
+            task="cron_management",
+            success=False,
+            error=error,
+            source="openclaw",
+            quality=1,
+            notes=f"Cron job '{job_name}' failed",
+        )
+
+    def on_subagent_failure(self, label: str, error: str, model: str = "") -> Outcome:
+        """Record a sub-agent failure."""
+        return self.loop.observer.record_simple(
+            task="subagent_management",
+            success=False,
+            error=error,
+            model=model,
+            source="openclaw",
+            quality=1,
+            notes=f"Sub-agent '{label}' failed",
+        )
+
+    def run_cycle(self):
+        """Run an improvement cycle."""
+        return self.loop.run_cycle()
+
+    def health_score(self) -> float:
+        """Get current health score."""
+        return self.loop.health_score()

rsi_loop/integrations/generic.py

@@ -0,0 +1,67 @@
+"""Generic file-based adapter — works with any agent."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from rsi_loop.loop import RSILoop
+from rsi_loop.types import Config, Outcome
+
+
+class GenericAdapter:
+    """File-based adapter. Drop JSON files into a watch directory and RSI picks them up.
+
+    Any agent can write a JSON file like::
+
+        {"task": "search", "success": false, "error": "timeout after 30s"}
+
+    Then call ``adapter.poll()`` to ingest new files.
+
+    Usage::
+
+        adapter = GenericAdapter(watch_dir="./rsi_inbox")
+        # Agent drops JSON files into ./rsi_inbox/
+        outcomes = adapter.poll()
+    """
+
+    def __init__(
+        self,
+        watch_dir: str = "./rsi_inbox",
+        data_dir: str = "./rsi_data",
+        **config_kwargs,
+    ) -> None:
+        self._watch_dir = Path(watch_dir)
+        self.loop = RSILoop(Config(data_dir=data_dir, **config_kwargs))
+        self._processed_dir = self._watch_dir / ".processed"
+
+    def poll(self) -> list[Outcome]:
+        """Scan watch_dir for new JSON files, ingest them, move to .processed/."""
+        if not self._watch_dir.exists():
+            return []
+
+        self._processed_dir.mkdir(parents=True, exist_ok=True)
+        outcomes: list[Outcome] = []
+
+        for path in sorted(self._watch_dir.glob("*.json")):
+            if path.name.startswith("."):
+                continue
+            try:
+                with open(path) as f:
+                    data = json.load(f)
+                outcome = Outcome.from_dict(data)
+                self.loop.observer.record(outcome)
+                outcomes.append(outcome)
+                path.rename(self._processed_dir / path.name)
+            except (json.JSONDecodeError, OSError):
+                continue
+
+        return outcomes
+
+    def run_cycle(self):
+        """Poll + analyze + fix."""
+        self.poll()
+        return self.loop.run_cycle()
+
+    def health_score(self) -> float:
+        return self.loop.health_score()

rsi_loop/integrations/webhook.py

@@ -0,0 +1,62 @@
+"""HTTP webhook adapter — POST outcomes to RSI Loop."""
+
+from __future__ import annotations
+
+from rsi_loop.loop import RSILoop
+from rsi_loop.types import Config, Outcome
+
+
+class WebhookAdapter:
+    """HTTP endpoint adapter for RSI Loop.
+
+    Creates a Flask app with endpoints::
+
+        POST /observe   — Record an outcome (JSON body)
+        GET  /health    — Get current health score
+        GET  /patterns  — Get detected patterns
+
+    Usage::
+
+        from rsi_loop.integrations.webhook import WebhookAdapter
+        app = WebhookAdapter(data_dir="./rsi_data").create_app()
+        app.run(port=8900)
+
+    Requires ``flask`` (install with ``uv add rsi-loop[webhook]``).
+    """
+
+    def __init__(self, data_dir: str = "./rsi_data", **config_kwargs) -> None:
+        self.loop = RSILoop(Config(data_dir=data_dir, **config_kwargs))
+
+    def create_app(self):
+        """Create and return a Flask app with RSI Loop endpoints."""
+        try:
+            from flask import Flask, jsonify, request
+        except ImportError:
+            raise ImportError(
+                "Flask is required for the webhook adapter. "
+                "Install with: uv add rsi-loop[webhook]"
+            )
+
+        app = Flask("rsi_loop_webhook")
+
+        @app.post("/observe")
+        def observe():
+            data = request.get_json(force=True)
+            outcome = Outcome.from_dict(data)
+            recorded = self.loop.observer.record(outcome)
+            return jsonify({"id": recorded.id, "issues": recorded.issues}), 201
+
+        @app.get("/health")
+        def health():
+            score = self.loop.health_score()
+            return jsonify({"health_score": score})
+
+        @app.get("/patterns")
+        def patterns():
+            pats = self.loop.run_cycle()
+            return jsonify({
+                "health_score": self.loop.health_score(),
+                "patterns": [p.to_dict() for p in pats],
+            })
+
+        return app

rsi_loop/loop.py

@@ -0,0 +1,71 @@
+"""RSILoop — The main recursive self-improvement loop."""
+
+from __future__ import annotations
+
+import threading
+import time
+
+from rsi_loop.analyzer import Analyzer
+from rsi_loop.fixer import Fixer
+from rsi_loop.observer import Observer
+from rsi_loop.types import Config, Fix, Pattern
+
+
+class RSILoop:
+    """Universal self-improvement loop: observe → analyze → fix → verify.
+
+    Usage::
+
+        loop = RSILoop()
+        loop.observer.record_simple("code_gen", success=True, model="sonnet-4.6")
+        patterns = loop.run_cycle()
+        print(loop.health_score())
+    """
+
+    def __init__(self, config: Config | None = None) -> None:
+        self.config = config or Config()
+        self.observer = Observer(self.config)
+        self.analyzer = Analyzer(self.config, observer=self.observer)
+        self.fixer = Fixer(self.config)
+        self._background_thread: threading.Thread | None = None
+        self._stop_event = threading.Event()
+
+    def run_cycle(self) -> list[Pattern]:
+        """Run one observe → analyze → fix cycle. Returns detected patterns."""
+        patterns = self.analyzer.analyze()
+        for pattern in patterns:
+            self.fixer.propose_and_apply(pattern)
+        return patterns
+
+    def health_score(self) -> float:
+        """Current health score: 0.0 (broken) to 1.0 (healthy)."""
+        return self.analyzer.health_score()
+
+    def patterns(self) -> list[Pattern]:
+        """Run analysis and return current patterns."""
+        return self.analyzer.analyze()
+
+    def fixes(self) -> list[Fix]:
+        """Return all saved fix proposals."""
+        return self.fixer.load_proposals()
+
+    def start_background(self, interval_seconds: int = 3600) -> None:
+        """Start the improvement loop in a background thread."""
+        if self._background_thread and self._background_thread.is_alive():
+            return
+        self._stop_event.clear()
+
+        def _loop() -> None:
+            while not self._stop_event.is_set():
+                self.run_cycle()
+                self._stop_event.wait(timeout=interval_seconds)
+
+        self._background_thread = threading.Thread(target=_loop, daemon=True)
+        self._background_thread.start()
+
+    def stop_background(self) -> None:
+        """Stop the background loop."""
+        self._stop_event.set()
+        if self._background_thread:
+            self._background_thread.join(timeout=5)
+            self._background_thread = None

rsi_loop/observer.py

@@ -0,0 +1,122 @@
+"""Observer — Record task outcomes and auto-classify issues."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from rsi_loop.types import ERROR_CLASSIFIERS, Config, Outcome
+
+
+class Observer:
+    """Records agent task outcomes to a JSONL store.
+
+    Framework-agnostic: works with any agent that can call ``record()``
+    or ``record_simple()`` after each task.
+    """
+
+    def __init__(self, config: Config | None = None) -> None:
+        self.config = config or Config()
+        self._data_dir = Path(self.config.data_dir)
+        self._outcomes_file = self._data_dir / "outcomes.jsonl"
+
+    def record(self, outcome: Outcome) -> Outcome:
+        """Record a full Outcome object. Auto-classifies issues from error_message."""
+        if outcome.error_message and not outcome.issues:
+            outcome.issues = self._classify_error(outcome.error_message)
+        outcome.quality = max(1, min(5, outcome.quality))
+
+        self._data_dir.mkdir(parents=True, exist_ok=True)
+        with open(self._outcomes_file, "a") as f:
+            f.write(json.dumps(outcome.to_dict()) + "\n")
+        return outcome
+
+    def record_simple(
+        self,
+        task: str,
+        success: bool = True,
+        error: str | None = None,
+        model: str | None = None,
+        duration_ms: int | None = None,
+        quality: int = 3,
+        source: str = "generic",
+        tags: list[str] | None = None,
+        notes: str = "",
+    ) -> Outcome:
+        """Convenience method — record an outcome with minimal arguments."""
+        issues: list[str] = []
+        if error:
+            issues = self._classify_error(error)
+        if not success and not issues:
+            issues = ["other"]
+
+        outcome = Outcome(
+            source=source,
+            task_type=task,
+            success=success,
+            quality=quality if success else min(quality, 2),
+            issues=issues,
+            error_message=error or "",
+            model=model or "",
+            duration_ms=duration_ms or 0,
+            notes=notes,
+            tags=tags or [],
+        )
+        return self.record(outcome)
+
+    def load_outcomes(self, days: int | None = None) -> list[Outcome]:
+        """Load outcomes from the JSONL store, optionally filtered by recency."""
+        if not self._outcomes_file.exists():
+            return []
+
+        import time
+        from datetime import datetime
+
+        cutoff = time.time() - ((days or self.config.analysis_window_days) * 86400)
+        outcomes: list[Outcome] = []
+
+        with open(self._outcomes_file) as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    data = json.loads(line)
+                    ts_str = data.get("ts", data.get("timestamp", ""))
+                    if ts_str:
+                        ts = datetime.fromisoformat(ts_str).timestamp()
+                        if ts < cutoff:
+                            continue
+                    outcomes.append(Outcome.from_dict(data))
+                except (json.JSONDecodeError, ValueError):
+                    continue
+        return outcomes
+
+    def recurrences(self, threshold: int | None = None) -> dict[str, int]:
+        """Return issues that recur >= threshold times in the analysis window."""
+        thresh = threshold or self.config.recurrence_threshold
+        outcomes = self.load_outcomes()
+        counts: dict[str, int] = {}
+        for o in outcomes:
+            for issue in o.issues:
+                counts[issue] = counts.get(issue, 0) + 1
+        return {issue: count for issue, count in counts.items() if count >= thresh}
+
+    @staticmethod
+    def _classify_error(error: str) -> list[str]:
+        """Auto-classify an error message into issue types."""
+        lower = error.lower()
+        issues: list[str] = []
+        for keywords, issue_type in ERROR_CLASSIFIERS:
+            if any(kw in lower for kw in keywords):
+                issues.append(issue_type)
+        return issues or ["other"]
+
+    @staticmethod
+    def normalize_error(error: str) -> str:
+        """Normalize an error message for clustering (strip IDs, numbers)."""
+        normalized = error.lower().strip()
+        normalized = re.sub(r"[0-9a-f]{8,}", "<ID>", normalized)
+        normalized = re.sub(r"\d+", "<N>", normalized)
+        return normalized[:120]

rsi_loop/types.py

@@ -0,0 +1,200 @@
+"""Core data types for RSI Loop."""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+
+def _utcnow() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _short_id() -> str:
+    return str(uuid.uuid4())[:8]
+
+
+# ── Issue taxonomy ─────────────────────────────────────────────────────────────
+
+ISSUE_TYPES: set[str] = {
+    # Model / routing
+    "rate_limit", "model_fallback", "wrong_model_tier", "cost_overrun",
+    "bad_routing", "slow_response",
+    # Tool / execution
+    "tool_error", "empty_response", "missing_tool", "incomplete_task",
+    # Output quality
+    "wrong_output",
+    # Memory / context
+    "context_loss", "memory_miss", "compaction_lost_context", "session_reset",
+    "hydration_fail",
+    # Self-governance
+    "over_confirmation", "repeated_mistake", "skill_gap", "wal_miss",
+    # Timeout
+    "timeout",
+    # Catch-all
+    "other",
+}
+
+HIGH_SEVERITY_ISSUES: set[str] = {
+    "tool_error", "wrong_output", "empty_response",
+    "session_reset", "cost_overrun", "wal_miss",
+}
+
+# ── Error keyword → issue mapping for auto-classification ─────────────────────
+
+ERROR_CLASSIFIERS: list[tuple[list[str], str]] = [
+    (["rate limit", "429", "too many requests", "quota exceeded"], "rate_limit"),
+    (["timeout", "timed out", "deadline exceeded"], "timeout"),
+    (["empty response", "empty reply", "no output", "null response"], "empty_response"),
+    (["context length", "token limit", "context window", "too long"], "context_loss"),
+    (["session reset", "session expired", "compaction"], "session_reset"),
+    (["model unavailable", "model not found", "fallback"], "model_fallback"),
+    (["permission denied", "unauthorized", "forbidden", "403"], "tool_error"),
+    (["not found", "404", "missing"], "missing_tool"),
+    (["connection refused", "connection reset", "network error"], "tool_error"),
+]
+
+
+@dataclass
+class Outcome:
+    """A single task outcome recorded by an agent."""
+
+    id: str = field(default_factory=_short_id)
+    timestamp: str = field(default_factory=_utcnow)
+    source: str = "generic"
+    task_type: str = "unknown"
+    success: bool = True
+    quality: int = 3  # 1-5
+    issues: list[str] = field(default_factory=list)
+    error_message: str = ""
+    model: str = ""
+    duration_ms: int = 0
+    notes: str = ""
+    tags: list[str] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "ts": self.timestamp,
+            "source": self.source,
+            "task_type": self.task_type,
+            "success": self.success,
+            "quality": max(1, min(5, self.quality)),
+            "issues": self.issues,
+            "error_message": self.error_message,
+            "model": self.model,
+            "duration_ms": self.duration_ms,
+            "notes": self.notes,
+            "tags": self.tags,
+            "metadata": self.metadata,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Outcome:
+        return cls(
+            id=data.get("id", _short_id()),
+            timestamp=data.get("ts", data.get("timestamp", _utcnow())),
+            source=data.get("source", "generic"),
+            task_type=data.get("task_type", data.get("task", "unknown")),
+            success=data.get("success", True),
+            quality=data.get("quality", 3),
+            issues=data.get("issues", []),
+            error_message=data.get("error_message", data.get("error_msg", data.get("error", ""))),
+            model=data.get("model", ""),
+            duration_ms=data.get("duration_ms", 0),
+            notes=data.get("notes", ""),
+            tags=data.get("tags", []),
+            metadata=data.get("metadata", {}),
+        )
+
+
+@dataclass
+class Pattern:
+    """A detected improvement pattern from analyzed outcomes."""
+
+    id: str = field(default_factory=_short_id)
+    category: str = "other"
+    task_type: str = "unknown"
+    issue: str = "other"
+    frequency: int = 0
+    impact_score: float = 0.0
+    failure_rate: float = 0.0
+    description: str = ""
+    sample_errors: list[str] = field(default_factory=list)
+    suggested_action: str = ""
+    sources: list[str] = field(default_factory=list)
+    first_seen: str = field(default_factory=_utcnow)
+    last_seen: str = field(default_factory=_utcnow)
+    recurring: bool = False
+    trend: str = "new"  # new, stable, increasing, decreasing
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "category": self.category,
+            "task_type": self.task_type,
+            "issue": self.issue,
+            "frequency": self.frequency,
+            "impact_score": round(self.impact_score, 4),
+            "failure_rate": round(self.failure_rate, 3),
+            "description": self.description,
+            "sample_errors": self.sample_errors,
+            "suggested_action": self.suggested_action,
+            "sources": self.sources,
+            "first_seen": self.first_seen,
+            "last_seen": self.last_seen,
+            "recurring": self.recurring,
+            "trend": self.trend,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Pattern:
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+
+@dataclass
+class Fix:
+    """A fix proposal or applied fix for a detected pattern."""
+
+    id: str = field(default_factory=_short_id)
+    pattern_id: str = ""
+    type: str = "manual"  # auto or manual
+    status: str = "draft"  # draft, proposed, applied, rejected
+    target: str = ""  # what to fix (file, config, etc.)
+    changes: list[dict[str, str]] = field(default_factory=list)
+    safe_category: str = ""
+    description: str = ""
+    created_at: str = field(default_factory=_utcnow)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "pattern_id": self.pattern_id,
+            "type": self.type,
+            "status": self.status,
+            "target": self.target,
+            "changes": self.changes,
+            "safe_category": self.safe_category,
+            "description": self.description,
+            "created_at": self.created_at,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Fix:
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+
+@dataclass
+class Config:
+    """Configuration for RSI Loop."""
+
+    data_dir: str = "./rsi_data"
+    analysis_window_days: int = 7
+    recurrence_threshold: int = 3
+    auto_fix_enabled: bool = True
+    safe_categories: list[str] = field(
+        default_factory=lambda: ["routing_config", "threshold_tuning", "retry_logic"]
+    )

rsi_loop-0.1.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: rsi-loop
+Version: 0.1.0
+Summary: Universal self-improvement loop for AI agents. Observe → Analyze → Fix → Verify.
+Project-URL: Homepage, https://github.com/clawinfra/rsi-loop
+Project-URL: Repository, https://github.com/clawinfra/rsi-loop
+Project-URL: Issues, https://github.com/clawinfra/rsi-loop/issues
+Author-email: ClawInfra <alex.chen31337@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: agents,ai,feedback-loop,rsi,self-improvement
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: webhook
+Requires-Dist: flask>=3.0; extra == 'webhook'
+Description-Content-Type: text/markdown
+
+# 🔄 RSI Loop
+
+[![CI](https://github.com/clawinfra/rsi-loop/actions/workflows/ci.yml/badge.svg)](https://github.com/clawinfra/rsi-loop/actions/workflows/ci.yml)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
+
+**Every AI agent makes mistakes. RSI Loop makes them learn.**
+
+---
+
+## The Problem
+
+AI agents repeat the same failures. They hit rate limits, return empty responses, lose context, pick the wrong model — and do it all again next session. There's no feedback loop. No memory of what went wrong. No automatic improvement.
+
+RSI Loop is the missing primitive: a universal **recursive self-improvement** loop that works with *any* agent framework.
+
+## How It Works
+
+```
+    ┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐
+    │ OBSERVE  │────▶│ ANALYZE  │────▶│   FIX    │────▶│  VERIFY  │
+    │          │     │          │     │          │     │          │
+    │ Record   │     │ Detect   │     │ Generate │     │ Check    │
+    │ outcomes │     │ patterns │     │ & apply  │     │ health   │
+    └──────────┘     └──────────┘     └──────────┘     └────┬─────┘
+         ▲                                                   │
+         └───────────────────────────────────────────────────┘
+```
+
+1. **Observe** — Record task outcomes: success/failure, quality, errors, model used, duration
+2. **Analyze** — Detect patterns: recurring failures, error clusters, cross-source correlations
+3. **Fix** — Auto-fix safe categories (routing, retries, thresholds); propose fixes for the rest
+4. **Verify** — Track health score over time; confirm fixes reduced failure rates
+
+## Quick Start
+
+```bash
+uv add rsi-loop
+```
+
+> **Not using uv?** `uv add rsi-loop` works too.
+
+```python
+from rsi_loop import RSILoop
+
+loop = RSILoop()
+loop.observer.record_simple("code_generation", success=True, model="sonnet-4.6")
+loop.observer.record_simple("api_call", success=False, error="429 Too Many Requests")
+loop.observer.record_simple("api_call", success=False, error="429 Too Many Requests")
+loop.observer.record_simple("api_call", success=False, error="429 Too Many Requests")
+
+# Run improvement cycle
+patterns = loop.run_cycle()
+print(f"Health: {loop.health_score():.0%}")
+print(f"Patterns found: {len(patterns)}")
+```
+
+## Framework Integrations
+
+### Claude Code / OpenClaw
+
+```python
+from rsi_loop.integrations.claude_code import ClaudeCodeAdapter
+
+adapter = ClaudeCodeAdapter(data_dir="./rsi_data")
+adapter.on_task_complete("code_review", success=True, model="claude-sonnet-4")
+adapter.on_model_fallback("claude-opus-4", "claude-sonnet-4", "rate_limit")
+adapter.on_session_reset()
+```
+
+### Generic (File-Based)
+
+Drop JSON files into a watch directory — works with any agent:
+
+```python
+from rsi_loop.integrations.generic import GenericAdapter
+
+adapter = GenericAdapter(watch_dir="./rsi_inbox")
+# Your agent writes: {"task": "search", "success": false, "error": "timeout"}
+# RSI picks it up automatically
+outcomes = adapter.poll()
+```
+
+### Webhook
+
+```python
+from rsi_loop.integrations.webhook import WebhookAdapter
+
+app = WebhookAdapter(data_dir="./rsi_data").create_app()
+# POST /observe {"task": "code_gen", "success": true, "quality": 4}
+# GET /health
+# GET /patterns
+```
+
+## Features
+
+- **Auto-classification** — Categorizes errors automatically: rate_limit, empty_response, timeout, context_loss, etc.
+- **Recurrence detection** — Flags issues that repeat 3+ times within the analysis window
+- **Health scoring** — 0.0 (broken) to 1.0 (healthy), recency-weighted
+- **Cross-source correlation** — Detects related issues across different agent sources
+- **Error clustering** — Groups similar error messages even with different IDs/numbers
+- **Safe auto-fix** — Automatically applies fixes for safe categories (routing, retries, thresholds)
+- **Fix proposals** — Generates detailed proposals for unsafe categories, saved for human review
+- **Background loop** — Run continuous improvement cycles in a background thread
+- **Framework-agnostic** — Works with Claude Code, Cursor, Codex, or any custom agent
+- **Zero dependencies** — Core package has no external dependencies (integrations optional)
+
+## Documentation
+
+- [Architecture](docs/architecture.md) — How RSI Loop works internally
+- [Source Taxonomy](docs/sources.md) — Source classification and cross-source correlation
+- [Auto-Fix](docs/auto_fix.md) — How auto-fix works, safe categories, and fix templates
+
+## Examples
+
+- [Claude Code Setup](examples/claude_code_setup.md)
+- [Cursor Setup](examples/cursor_setup.md)
+- [Generic Agent Setup](examples/generic_agent_setup.md)
+- [Quick Start Script](examples/quick_start.py)
+
+---
+
+Built by [ClawInfra](https://github.com/clawinfra) — infrastructure for autonomous agents.

rsi_loop-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+rsi_loop/__init__.py,sha256=xoBKdpYqzgnKvXXD7tjERIyJcOv1-TJlK2oYBbrt_6g,386
+rsi_loop/analyzer.py,sha256=MnRLOs6X1Rs3ra7YOm_kD1GJbdbupqDBZ2_-InGNLDc,8835
+rsi_loop/fixer.py,sha256=eEp5IZrZ9zNhCifAiQyTYvp2_Sr9ntGR1BBElvxRQsw,4969
+rsi_loop/loop.py,sha256=Xc43AIX1tbme8FQyYIsl_pmcuSPrGj__EJCITwkuJFg,2439
+rsi_loop/observer.py,sha256=Lh_I5cO1yUFN7YTvw-j2jh8wnyn9xdfwgUgczb3btZU,4412
+rsi_loop/types.py,sha256=2I2ZNda2Jtf4KVa_x4LIPKt9w3UGS4GGLTG8trH6Azw,6963
+rsi_loop/integrations/__init__.py,sha256=JSPouQ24Eh5HTM87q8qXvqy49YHHN1hT5B-oIzZNPGA,58
+rsi_loop/integrations/claude_code.py,sha256=IMfD84MalrWX3trIz9YP4yB9kggSlhZbc9GiaN69A6Q,3298
+rsi_loop/integrations/generic.py,sha256=DKTFd3bFuX9Z7prbZ_Pt9Ff-2TE6ghhI8Xzg68ZUXv4,2000
+rsi_loop/integrations/webhook.py,sha256=Gd-BQIdwBYOC3nEHDpOF1y_SgIjQx78KyX1GdFL-jI4,1948
+rsi_loop-0.1.0.dist-info/METADATA,sha256=I9ceHSvsRE2L_f6kTpz1yNuaEhqyI0CWIeWjCUgkhJc,6443
+rsi_loop-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+rsi_loop-0.1.0.dist-info/licenses/LICENSE,sha256=LlChPFyYuWPCh9cEjOBZNi8ALYoJtQSp7SEWzlpfi50,10707
+rsi_loop-0.1.0.dist-info/RECORD,,

rsi_loop-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

rsi_loop-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,189 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 ClawInfra
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.