superlocalmemory 4.1.13 → 4.1.15

package/src/superlocalmemory/evolution/model_selection.py

@@ -1,175 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.7.9 — evolution model selection
-
-"""Per-step LLM model selection for the skill-evolution pipeline.
-
-v3.7.9: skill evolution defaults to the *lowest-cost* capable model for
-whatever backend is active, and lets users override each step
-(``evolution.mutation_model`` / ``verify_model`` / ``confirm_model``).
-
-Two invariants this module enforces:
-
-1. **Lowest cost by default.** Claude backend → Haiku; Ollama → a local
-   (free) model. No step silently defaults to a premium model.
-2. **Generator != verifier.** Blind verification must run on a *different*
-   model from the generator, otherwise the generator effectively grades
-   its own homework. When an independent verifier isn't available for
-   free (Claude backend, no local Ollama), we reuse the cheapest model
-   and set ``independent=False`` so the caller can log the reduced-safety
-   condition — we never escalate the verifier to a premium model just to
-   force independence (that would defeat the cost goal).
-
-This module is pure: it takes ``ollama_available`` as an argument instead
-of probing, so it is fully unit-testable without network access.
-
-Author: Varun Pratap Bhardwaj / Qualixar
-"""
-
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass
-
-logger = logging.getLogger(__name__)
-
-# Allow-listed model ids (must stay a subset of
-# ``llm_dispatch.ALLOWED_LLM_MODELS``).
-CHEAPEST_CLAUDE = "claude-haiku-4-5"
-QUALITY_CLAUDE = "claude-sonnet-4-6"
-CHEAPEST_OLLAMA = "ollama:llama3"
-ALT_OLLAMA = "ollama:qwen2.5"
-CHEAPEST_OPENAI = "openai:gpt-4o-mini"
-
-# Short-name → allow-listed model id. Single source of truth for aliasing;
-# ``skill_evolver`` re-exports these for backward compatibility.
-_MODEL_ALIASES: dict[str, str] = {
-    "haiku": CHEAPEST_CLAUDE,
-    "sonnet": QUALITY_CLAUDE,
-    "ollama": CHEAPEST_OLLAMA,
-    "ollama:llama3": CHEAPEST_OLLAMA,
-    "ollama:qwen2.5": ALT_OLLAMA,
-    "openai": CHEAPEST_OPENAI,
-    "openai:gpt-4o-mini": CHEAPEST_OPENAI,
-    CHEAPEST_CLAUDE: CHEAPEST_CLAUDE,
-    QUALITY_CLAUDE: QUALITY_CLAUDE,
-}
-
-# Models this subsystem is allowed to dispatch. Anything resolving outside
-# this set falls back to the cheapest safe default rather than dispatching
-# an unvetted (or forbidden) model.
-_ALLOWED: frozenset[str] = frozenset(_MODEL_ALIASES.values())
-
-
-def _resolve_model_alias(alias: str) -> str:
-    """Translate a short alias (``haiku``/``sonnet``) to an allow-listed id.
-
-    Unknown aliases fall back to the cheapest Claude model — the same
-    fail-safe the evolver has always used.
-    """
-    return _MODEL_ALIASES.get(alias, CHEAPEST_CLAUDE)
-
-
-@dataclass(frozen=True)
-class ResolvedModels:
-    """Concrete allow-listed model id for each pipeline step."""
-
-    mutation: str
-    verify: str
-    confirm: str
-    independent: bool  # True when verify != mutation (blind-verify is sound)
-
-
-def _cheapest_for_backend(backend: str) -> str:
-    """Lowest-cost allow-listed model for a detected backend.
-
-    The configured backend is authoritative: when the caller explicitly
-    names a provider, models are drawn from that provider only —
-    never silently downgraded to a different vendor's offering.
-    """
-    if backend == "ollama":
-        return CHEAPEST_OLLAMA
-    if backend == "openai":
-        return CHEAPEST_OPENAI
-    # claude CLI, anthropic API, and any non-Ollama/non-OpenAI backend
-    # route through the cheapest Claude model.
-    return CHEAPEST_CLAUDE
-
-
-def _resolve_field(value: str, default: str) -> str:
-    """Resolve a config field: empty → default; else alias→id, validated."""
-    if not value:
-        return default
-    resolved = _resolve_model_alias(value)
-    if resolved not in _ALLOWED:  # pragma: no cover — defensive
-        logger.warning(
-            "evolution: configured model %r is not allow-listed; "
-            "falling back to %s", value, default,
-        )
-        return default
-    return resolved
-
-
-def _independent_verifier(
-    mutation: str, *, ollama_available: bool,
-) -> str:
-    """Pick a cheap verifier that differs from the generator when possible.
-
-    - Ollama generator → the *other* local model (both free, distinct).
-    - OpenAI generator → same OpenAI model (single-provider constraint;
-      independence flag will be False — caller logs the condition).
-    - Claude generator + local Ollama up → free local verifier.
-    - Claude generator, no Ollama → the cheapest *different* Claude tier if
-      the generator was a premium model; otherwise reuse the cheapest model
-      (caller flags reduced independence — we don't pay for a premium
-      verifier just to force distinctness).
-    """
-    if mutation.startswith("ollama:"):
-        return ALT_OLLAMA if mutation != ALT_OLLAMA else CHEAPEST_OLLAMA
-    if mutation.startswith("openai:"):
-        # Honor the configured provider: stay within OpenAI models.
-        return CHEAPEST_OPENAI
-    if ollama_available:
-        return CHEAPEST_OLLAMA
-    if mutation != CHEAPEST_CLAUDE:
-        return CHEAPEST_CLAUDE
-    return CHEAPEST_CLAUDE
-
-
-def resolve_evolution_models(
-    config: object, backend: str, *, ollama_available: bool,
-) -> ResolvedModels:
-    """Resolve mutation/verify/confirm models for a backend.
-
-    ``config`` is an ``EvolutionConfig`` (duck-typed: reads
-    ``mutation_model`` / ``verify_model`` / ``confirm_model`` attributes,
-    each an alias, allow-listed id, or "" for auto).
-    """
-    cheapest = _cheapest_for_backend(backend)
-
-    mutation = _resolve_field(getattr(config, "mutation_model", ""), cheapest)
-    confirm = _resolve_field(getattr(config, "confirm_model", ""), cheapest)
-
-    verify_cfg = getattr(config, "verify_model", "")
-    if verify_cfg:
-        verify = _resolve_field(verify_cfg, cheapest)
-    else:
-        verify = _independent_verifier(
-            mutation, ollama_available=ollama_available,
-        )
-
-    independent = verify != mutation
-    if not independent:
-        logger.warning(
-            "evolution: blind-verify model == generator model (%s) — "
-            "blind-verification independence is reduced. Set "
-            "evolution.verify_model to a different model, or run Ollama "
-            "locally, for an independent verifier.",
-            mutation,
-        )
-    return ResolvedModels(
-        mutation=mutation,
-        verify=verify,
-        confirm=confirm,
-        independent=independent,
-    )

package/src/superlocalmemory/evolution/mutation_generator.py

@@ -1,226 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Mutation Generator — LLM-driven skill improvement.
-
-Reads the original SKILL.md + failure evidence + performance data,
-generates an improved version. Apply-retry cycle (3 attempts) for
-malformed output.
-
-Token-driven termination: <EVOLUTION_COMPLETE> or <EVOLUTION_FAILED>.
-Adopted from OpenSpace evolver.py patterns.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-"""
-
-from __future__ import annotations
-
-import logging
-import re
-from typing import Optional
-
-from superlocalmemory.evolution.types import (
-    EvolutionCandidate,
-    EvolutionType,
-)
-
-logger = logging.getLogger(__name__)
-
-MAX_APPLY_RETRIES = 3
-MAX_CONTENT_CHARS = 12_000  # Truncate skill content in prompt
-
-
-def build_mutation_prompt(
-    candidate: EvolutionCandidate,
-    original_content: str,
-) -> str:
-    """Build the LLM prompt for skill mutation."""
-    truncated = original_content[:MAX_CONTENT_CHARS]
-    evidence_text = "\n".join(f"- {e}" for e in candidate.evidence)
-
-    if candidate.evolution_type == EvolutionType.FIX:
-        return _fix_prompt(candidate.skill_name, truncated, evidence_text, candidate.effective_score)
-    elif candidate.evolution_type == EvolutionType.DERIVED:
-        return _derived_prompt(candidate.skill_name, truncated, evidence_text, candidate.effective_score)
-    else:
-        return _captured_prompt(candidate.skill_name, evidence_text)
-
-
-def parse_mutation_output(output: str) -> Optional[str]:
-    """Extract evolved SKILL.md content from LLM output.
-
-    Looks for content between markdown code fences or after
-    <EVOLUTION_COMPLETE> token. Returns None if <EVOLUTION_FAILED>
-    or no valid content found.
-    """
-    if "<EVOLUTION_FAILED>" in output:
-        return None
-
-    # Try extracting from code fence
-    fence_match = re.search(
-        r"```(?:markdown|md)?\s*\n(---\s*\n.*?)```",
-        output,
-        re.DOTALL,
-    )
-    if fence_match:
-        return fence_match.group(1).strip()
-
-    # Try extracting after EVOLUTION_COMPLETE token
-    complete_match = re.search(
-        r"<EVOLUTION_COMPLETE>\s*(---\s*\n.*)",
-        output,
-        re.DOTALL,
-    )
-    if complete_match:
-        return complete_match.group(1).strip()
-
-    # Try finding YAML frontmatter directly
-    frontmatter_match = re.search(
-        r"(---\s*\nname:.*?)(?:\n---|\Z)",
-        output,
-        re.DOTALL,
-    )
-    if frontmatter_match:
-        # Return everything from the frontmatter start
-        idx = output.index(frontmatter_match.group(0))
-        return output[idx:].strip()
-
-    return None
-
-
-# An evolved SKILL.md is auto-loaded into future sessions, so a mutation that
-# hallucinated (or was prompt-injected into producing) code-execution or
-# secret-exfiltration instructions must never be persisted. Structure checks
-# alone are insufficient — reject dangerous content outright.
-_SKILL_DENY_PATTERNS: tuple[str, ...] = (
-    # Reading the environment. "os.environ" was listed and "os.getenv" was not,
-    # which is the same act spelled the other way.
-    "os.environ", "os.getenv", "getenv(", "environ[",
-    # Running things.
-    "subprocess", "import subprocess", "import os", "__import__",
-    "exec(", "eval(", "compile(", "os.system", "os.popen", "os.spawn",
-    "popen(", "pty.spawn", "runpy",
-    # PowerShell and Windows shells, which were absent entirely.
-    "invoke-webrequest", "invoke-expression", "iex ", "start-process",
-    "new-object net.webclient", "powershell -", "cmd.exe /c",
-    # POSIX shells and fetchers. The trailing space is gone: "curl" at the end
-    # of a line, or followed by a newline, was not matched.
-    "curl", "wget", "rm -rf", "bash -c", "sh -c", "zsh -c", "nc -",
-    # Network from inside Python.
-    "requests.get", "requests.post", "urllib.request", "httpx.get",
-    "httpx.post", "socket.socket", "smtplib",
-    # Deserialisation and encoding used to smuggle payloads.
-    "pickle.loads", "marshal.loads", "base64.b64decode", "codecs.decode",
-    # Secrets.
-    "ANTHROPIC_API_KEY", "OPENAI_API_KEY", "AWS_SECRET", "AWS_ACCESS_KEY",
-    "/.ssh/", ".install_token", ".aws/credentials", ".netrc",
-    # Semantic exfiltration patterns — skills must not instruct unauthorized
-    # data transfer or bypass of user consent.
-    "without consent", "exfiltrat",
-)
-
-#: Whitespace between a name and its opening parenthesis. ``eval (payload)``
-#: runs exactly as ``eval(payload)`` does, and a substring list only saw the
-#: second. Collapsing it before matching closes the whole family rather than
-#: one member of it.
-_CALL_SPACING = re.compile(r"([A-Za-z_][A-Za-z0-9_.]*)\s+\(")
-
-
-def validate_skill_content(content: str) -> Optional[str]:
-    """Validate evolved skill content. Returns error message or None if valid."""
-    if not content or len(content) < 50:
-        return "Content too short (< 50 chars)"
-    if "---" not in content:
-        return "Missing YAML frontmatter (no --- found)"
-    if content.count("---") >= 2 and "name:" not in content.split("---")[1]:
-        return "Missing 'name:' in frontmatter"
-    # Normalise before matching, so a space, a newline or a non-breaking space
-    # between the name and the parenthesis does not walk past the list.
-    lowered = _CALL_SPACING.sub(r"\1(", content.lower().replace("\u00a0", " "))
-    for pat in _SKILL_DENY_PATTERNS:
-        if pat.lower() in lowered:
-            return (f"Rejected: evolved skill contains a disallowed pattern "
-                    f"({pat!r}) — skills must not execute code or access secrets")
-    return None
-
-
-def build_retry_prompt(original_prompt: str, error: str, attempt: int) -> str:
-    """Build retry prompt after failed mutation attempt."""
-    return (
-        f"{original_prompt}\n\n"
-        f"--- RETRY (attempt {attempt}/{MAX_APPLY_RETRIES}) ---\n"
-        f"Previous output was invalid: {error}\n"
-        f"Please generate a valid SKILL.md with proper YAML frontmatter "
-        f"(--- / name: / description: / ---) followed by markdown instructions.\n"
-        f"End with <EVOLUTION_COMPLETE> or <EVOLUTION_FAILED>."
-    )
-
-
-# ------------------------------------------------------------------
-# Prompt templates
-# ------------------------------------------------------------------
-
-def _fix_prompt(skill_name: str, content: str, evidence: str, score: float) -> str:
-    return f"""You are a skill evolution engine. A skill is underperforming and needs repair.
-
-SKILL NAME: {skill_name}
-EFFECTIVE SCORE: {score:.0%} (approximate)
-
-CURRENT SKILL CONTENT:
-{content}
-
-EVIDENCE OF PROBLEMS:
-{evidence}
-
-YOUR TASK:
-Generate an improved version of this SKILL.md that addresses the identified problems.
-Keep the same overall structure and purpose. Fix what's broken, don't rewrite from scratch.
-
-OUTPUT FORMAT:
-Return the complete improved SKILL.md content inside a markdown code fence.
-The file must start with YAML frontmatter (--- / name: / description: / ---).
-End your response with <EVOLUTION_COMPLETE> if you generated a valid improvement,
-or <EVOLUTION_FAILED> if you cannot improve this skill."""
-
-
-def _derived_prompt(skill_name: str, content: str, evidence: str, score: float) -> str:
-    return f"""You are a skill evolution engine. A skill works for some tasks but not others.
-Create a specialized variant for the failing task type.
-
-PARENT SKILL: {skill_name}
-EFFECTIVE SCORE: {score:.0%} (moderate — works sometimes, fails sometimes)
-
-PARENT SKILL CONTENT:
-{content}
-
-EVIDENCE:
-{evidence}
-
-YOUR TASK:
-Create a specialized DERIVED variant that handles the failing cases better.
-Give it a new name (e.g., "{skill_name}-specialized" or a descriptive name).
-Keep the parent's strengths. Add specific handling for the failure patterns.
-
-OUTPUT FORMAT:
-Return the complete new SKILL.md inside a markdown code fence.
-Must start with YAML frontmatter (--- / name: / description: / ---).
-End with <EVOLUTION_COMPLETE> or <EVOLUTION_FAILED>."""
-
-
-def _captured_prompt(skill_name: str, evidence: str) -> str:
-    return f"""You are a skill evolution engine. A repeated workflow pattern was detected
-that no existing skill covers. Create a new skill to codify this pattern.
-
-PATTERN NAME: {skill_name}
-EVIDENCE:
-{evidence}
-
-YOUR TASK:
-Create a new SKILL.md that codifies this workflow pattern into a reusable skill.
-Make it specific and actionable — not generic advice.
-
-OUTPUT FORMAT:
-Return the complete SKILL.md inside a markdown code fence.
-Must start with YAML frontmatter (--- / name: / description: / ---).
-End with <EVOLUTION_COMPLETE> or <EVOLUTION_FAILED>."""

package/src/superlocalmemory/evolution/skill_activator.py

@@ -1,270 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later — see LICENSE file
-# Part of SuperLocalMemory V4 | https://qualixar.com | https://varunpratap.com
-
-"""SkillActivator — atomic activation of quarantined evolved skills.
-
-Copies a VERIFIED_QUARANTINED skill artifact into the live skill directory
-(~/.claude/skills/{skill_name}/SKILL.md), retains the prior artifact as a
-.bak file, and provides a tested rollback path.
-
-Invariants:
-  1. The destination directory is a child of live_root — path traversal raises ValueError.
-  2. The backup is written BEFORE the live copy is overwritten.
-  3. Activation is atomic via a .tmp file → os.replace (POSIX atomic on same fs).
-  4. Rollback restores from the .bak file and leaves the live copy unchanged.
-  5. Only the quarantined artifact identified by quarantine_dir_name is copied;
-     no arbitrary file can be activated.
-
-CRIT-2 note: skill_name and quarantine_dir_name are ALWAYS different strings:
-  - skill_name: the original skill identifier (e.g. "brainstorming")
-  - quarantine_dir_name: the sanitized quarantine subdir (e.g. "brainstorming-vabc12")
-Both are required; neither defaults from the other.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-"""
-
-from __future__ import annotations
-
-import hashlib
-import logging
-import os
-import re
-import shutil
-from datetime import datetime, timezone
-from pathlib import Path
-
-from superlocalmemory.infra.data_root import canonical_data_root
-
-logger = logging.getLogger(__name__)
-
-LIVE_SKILLS_ROOT: Path = Path.home() / ".claude" / "skills"
-BACKUP_ROOT: Path = canonical_data_root() / "skill_backups"
-QUARANTINE_ROOT: Path = canonical_data_root() / "quarantine" / "skills"
-
-_SAFE_NAME_RE = re.compile(r"[^a-zA-Z0-9_-]")
-
-
-class SkillActivationError(Exception):
-    """Raised when activation fails after writing the backup.
-
-    The caller must invoke rollback() after receiving this error to restore
-    the previous live artifact.
-    """
-
-
-class SkillActivator:
-    """Activates a quarantined evolved skill into the live skill directory."""
-
-    def __init__(
-        self,
-        *,
-        live_root: Path | None = None,
-        backup_root: Path | None = None,
-        quarantine_root: Path | None = None,
-    ) -> None:
-        self._live_root = live_root or LIVE_SKILLS_ROOT
-        self._backup_root = backup_root or BACKUP_ROOT
-        self._quarantine_root = quarantine_root or QUARANTINE_ROOT
-
-    # ------------------------------------------------------------------
-    # Path helpers
-    # ------------------------------------------------------------------
-
-    def _safe_skill_dir(self, skill_name: str, base: Path) -> Path:
-        """Return base / sanitized_name, raising ValueError on traversal.
-
-        Two-layer check (fail-fast + belt-and-suspenders):
-          1. Reject the raw skill_name if it contains '..' or is absolute.
-          2. After sanitization, resolve the target path and verify it remains
-             inside base.  This catches any edge case the regex misses.
-        """
-        # Fail-fast: detect traversal in raw name before sanitization.
-        raw = Path(skill_name)
-        if raw.is_absolute() or ".." in raw.parts:
-            raise ValueError(
-                f"skill_name {skill_name!r} contains path traversal sequences"
-            )
-        safe = _SAFE_NAME_RE.sub("-", skill_name).lower()[:50] or "skill"
-        target = (base / safe).resolve()
-        base_resolved = base.resolve()
-        # Audit P2-5: is_relative_to is not prefix-fragile (a sibling like
-        # ".../skills-evil" cannot masquerade as being under ".../skills").
-        if not target.is_relative_to(base_resolved):
-            raise ValueError(
-                f"skill_name {skill_name!r} escapes sandbox: {target}"
-            )
-        return target
-
-    def _quarantine_path(self, quarantine_dir_name: str) -> Path:
-        """Return the SKILL.md path inside quarantine for a given dir name.
-
-        quarantine_dir_name is the sanitized directory name (CRIT-2), e.g.
-        'brainstorming-vabc12'.  It is NOT the skill_name.
-
-        Hardened (audit P0-1 / P1-4): reject absolute paths and '..' traversal,
-        then resolve() and require containment inside the quarantine root. The
-        resolve() step also defeats a symlinked quarantine dir that would
-        otherwise redirect the read outside the sandbox and inject arbitrary
-        content into a live skill.
-        """
-        raw = Path(quarantine_dir_name)
-        if raw.is_absolute() or ".." in raw.parts:
-            raise ValueError(
-                f"quarantine_dir_name {quarantine_dir_name!r} contains path traversal"
-            )
-        root = self._quarantine_root.resolve()
-        q_dir = (self._quarantine_root / quarantine_dir_name).resolve()
-        if not q_dir.is_relative_to(root):
-            raise ValueError(
-                f"quarantine_dir_name {quarantine_dir_name!r} escapes sandbox: {q_dir}"
-            )
-        q_path = (q_dir / "SKILL.md").resolve()
-        if not q_path.is_relative_to(root):
-            raise ValueError(
-                f"quarantine artifact escapes sandbox: {q_path}"
-            )
-        return q_path
-
-    def _live_path(self, skill_name: str) -> Path:
-        return self._safe_skill_dir(skill_name, self._live_root) / "SKILL.md"
-
-    def _backup_path(self, skill_name: str) -> Path:
-        return self._safe_skill_dir(skill_name, self._backup_root) / "SKILL.md.bak"
-
-    # ------------------------------------------------------------------
-    # Public API
-    # ------------------------------------------------------------------
-
-    def activate(
-        self,
-        skill_name: str,
-        quarantine_dir_name: str,
-        *,
-        actor_id: str = "",
-    ) -> dict:
-        """Atomically activate a quarantined skill.
-
-        Steps:
-          1. Resolve quarantine_path using quarantine_dir_name and verify it exists.
-          2. Read quarantine content and compute SHA-256.
-          3. Write backup of existing live SKILL.md (if any) to backup_root.
-          4. Write quarantine content to live path via .tmp → os.replace.
-          5. Return activation metadata.
-
-        Args:
-            skill_name: The original skill identifier (CRIT-2), e.g. "brainstorming".
-            quarantine_dir_name: The sanitized quarantine subdir, e.g. "brainstorming-vabc12".
-            actor_id: Who triggered activation (e.g. "auto" or a user id).
-
-        Raises:
-            FileNotFoundError: Quarantine artifact does not exist.
-            ValueError: Path traversal detected in skill_name.
-            SkillActivationError: Any OS error after the backup was already written.
-        """
-        q_path = self._quarantine_path(quarantine_dir_name)
-        live_path = self._live_path(skill_name)  # raises ValueError on traversal
-        backup_path = self._backup_path(skill_name)
-
-        if not q_path.exists():
-            raise FileNotFoundError(
-                f"Quarantine artifact not found: {q_path}"
-            )
-
-        content = q_path.read_bytes()
-        content_hash = hashlib.sha256(content).hexdigest()
-        ts = datetime.now(timezone.utc).isoformat()
-
-        # Step 3: backup existing live artifact BEFORE any overwrite
-        backup_path.parent.mkdir(parents=True, exist_ok=True)
-        backup_written = False
-        if live_path.exists():
-            shutil.copy2(live_path, backup_path)
-            backup_written = True
-            logger.info(
-                "skill_activator: backed up %s → %s",
-                live_path, backup_path,
-            )
-
-        # Step 4: atomic write via .tmp → rename (same directory = same fs)
-        live_path.parent.mkdir(parents=True, exist_ok=True)
-        tmp_path = live_path.with_suffix(".tmp")
-        try:
-            tmp_path.write_bytes(content)
-            os.replace(tmp_path, live_path)
-        except OSError as exc:
-            try:
-                tmp_path.unlink(missing_ok=True)
-            except OSError:
-                pass
-            raise SkillActivationError(
-                f"atomic write failed for {live_path}: {exc}"
-            ) from exc
-
-        logger.info(
-            "skill_activator: activated %s @ %s (sha256=%s, actor=%s)",
-            skill_name, live_path, content_hash[:12], actor_id,
-        )
-        return {
-            "skill_name": skill_name,
-            "live_path": str(live_path),
-            "backup_path": str(backup_path) if backup_written else None,
-            "content_hash": content_hash,
-            "activated_at": ts,
-            "actor_id": actor_id,
-        }
-
-    def rollback(self, skill_name: str) -> dict:
-        """Restore the live SKILL.md from the backup written by activate().
-
-        If no backup exists, removes the live file (the skill was new).
-        Never raises on missing backup — logs a warning instead.
-
-        Args:
-            skill_name: The original skill identifier, same value used in activate().
-        """
-        live_path = self._live_path(skill_name)
-        backup_path = self._backup_path(skill_name)
-        ts = datetime.now(timezone.utc).isoformat()
-
-        if backup_path.exists():
-            # Audit P2-4: restore atomically (tmp → os.replace) so a crash
-            # mid-rollback cannot leave a torn live SKILL.md.
-            live_path.parent.mkdir(parents=True, exist_ok=True)
-            tmp_path = live_path.with_suffix(".tmp")
-            tmp_path.write_bytes(backup_path.read_bytes())
-            os.replace(tmp_path, live_path)
-            logger.info(
-                "skill_activator: rolled back %s ← %s",
-                live_path, backup_path,
-            )
-            return {
-                "skill_name": skill_name,
-                "rolled_back": True,
-                "restored_from": str(backup_path),
-                "rolled_back_at": ts,
-            }
-        elif live_path.exists():
-            live_path.unlink()
-            logger.warning(
-                "skill_activator: no backup for %s; removed live file",
-                skill_name,
-            )
-            return {
-                "skill_name": skill_name,
-                "rolled_back": True,
-                "restored_from": None,
-                "note": "no backup; live file removed",
-                "rolled_back_at": ts,
-            }
-        else:
-            logger.warning(
-                "skill_activator: rollback called but no live file for %s",
-                skill_name,
-            )
-            return {
-                "skill_name": skill_name,
-                "rolled_back": False,
-                "note": "nothing to rollback",
-                "rolled_back_at": ts,
-            }