skillpool 4.3.0__py3-none-any.whl

skillpool/utils/logger.py

@@ -0,0 +1,273 @@
+"""SkillPoolLogger — structlog-style structured logging without external dependencies.
+
+Processor chain: add_timestamp -> add_trace_id -> add_skill_context -> format_json
+Context binding: bind_contextvars(skill_id=..., checkpoint=..., gate_result=...)
+Canonical log lines: single JSON line with all context
+Two renderers: JSONRenderer (prod) and ConsoleRenderer (dev, colored)
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "ConsoleRenderer",
+    "ContextVarsBinding",
+    "JSONRenderer",
+    "SkillPoolLogger",
+    "get_skillpool_logger",
+]
+
+import json
+import sys
+from contextvars import ContextVar
+from typing import Any
+
+from skillpool.utils.time_utils import utc_now
+
+
+# ── Context Variables ──
+
+_context_vars: dict[str, ContextVar[Any]] = {}
+
+
+def _get_context_var(key: str) -> ContextVar[Any]:
+    """Get or create a ContextVar for the given key."""
+    if key not in _context_vars:
+        _context_vars[key] = ContextVar(f"skillpool_log_{key}", default=None)
+    return _context_vars[key]
+
+
+class ContextVarsBinding:
+    """Thread-safe + asyncio-safe context variable binding.
+
+    Uses Python's contextvars module for automatic propagation across
+    asyncio tasks and thread pools.
+    """
+
+    @staticmethod
+    def bind(**kwargs: Any) -> None:
+        """Bind context variables. These will be included in all subsequent log entries."""
+        for key, value in kwargs.items():
+            var = _get_context_var(key)
+            var.set(value)
+
+    @staticmethod
+    def unbind(*keys: str) -> None:
+        """Unbind context variables by resetting them to None."""
+        for key in keys:
+            var = _get_context_var(key)
+            var.set(None)
+
+    @staticmethod
+    def get() -> dict[str, Any]:
+        """Get all currently bound context variables as a dict."""
+        result: dict[str, Any] = {}
+        for key, var in _context_vars.items():
+            value = var.get(None)
+            if value is not None:
+                result[key] = value
+        return result
+
+
+# ── Processors ──
+
+
+def add_timestamp(logger: str, method: str, event_dict: dict[str, Any]) -> dict[str, Any]:
+    """Add ISO 8601 UTC timestamp to the event dict."""
+    if "timestamp" not in event_dict:
+        event_dict["timestamp"] = utc_now().isoformat()
+    return event_dict
+
+
+def add_trace_id(logger: str, method: str, event_dict: dict[str, Any]) -> dict[str, Any]:
+    """Add trace_id from context vars if not already present."""
+    if "trace_id" not in event_dict:
+        ctx = ContextVarsBinding.get()
+        if "trace_id" in ctx:
+            event_dict["trace_id"] = ctx["trace_id"]
+    return event_dict
+
+
+def add_skill_context(logger: str, method: str, event_dict: dict[str, Any]) -> dict[str, Any]:
+    """Add skill_id, checkpoint, gate_result from context vars."""
+    ctx = ContextVarsBinding.get()
+    for key in ("skill_id", "checkpoint", "gate_result"):
+        if key not in event_dict and key in ctx:
+            event_dict[key] = ctx[key]
+    return event_dict
+
+
+def format_json(logger: str, method: str, event_dict: dict[str, Any]) -> dict[str, Any]:
+    """Ensure event_dict is JSON-serializable. No-op processor for consistency."""
+    return event_dict
+
+
+# ── Renderers ──
+
+
+class JSONRenderer:
+    """Render log events as single JSON lines (production)."""
+
+    def __call__(self, logger: str, method: str, event_dict: dict[str, Any]) -> str:
+        """Render event dict to a JSON string."""
+        return json.dumps(event_dict, sort_keys=True, ensure_ascii=False, default=str)
+
+
+class ConsoleRenderer:
+    """Render log events as colored console output (development).
+
+    Color codes:
+    - DEBUG:    grey
+    - INFO:     green
+    - WARNING:  yellow
+    - ERROR:    red
+    """
+
+    _COLORS: dict[str, str] = {
+        "debug": "\033[90m",  # grey
+        "info": "\033[32m",  # green
+        "warning": "\033[33m",  # yellow
+        "error": "\033[31m",  # red
+    }
+    _RESET = "\033[0m"
+
+    def __init__(self, stream: Any | None = None) -> None:
+        self._stream = stream or sys.stderr
+        self._is_tty = hasattr(self._stream, "isatty") and self._stream.isatty()
+
+    def __call__(self, logger: str, method: str, event_dict: dict[str, Any]) -> str:
+        """Render event dict to a colored console line."""
+        level = method.upper()
+        timestamp = event_dict.pop("timestamp", "")
+        message = event_dict.pop("event", "")
+
+        # Build context suffix from remaining fields
+        context_parts = []
+        for k, v in sorted(event_dict.items()):
+            context_parts.append(f"{k}={v}")
+        context_str = " ".join(context_parts)
+
+        if self._is_tty:
+            color = self._COLORS.get(method, "")
+            line = f"{color}{level:<8}{self._RESET} {timestamp} {message}"
+            if context_str:
+                line += f"  {context_str}"
+        else:
+            line = f"{level:<8} {timestamp} {message}"
+            if context_str:
+                line += f"  {context_str}"
+
+        # Restore popped keys so the dict is not mutated for other processors
+        if timestamp:
+            event_dict["timestamp"] = timestamp
+        event_dict["event"] = message
+
+        return line
+
+
+# ── Default processor chain ──
+
+DEFAULT_PROCESSORS = [
+    add_timestamp,
+    add_trace_id,
+    add_skill_context,
+    format_json,
+]
+
+DEFAULT_RENDERER = JSONRenderer()
+
+
+def get_skillpool_logger(name: str) -> SkillPoolLogger:
+    """Factory: return a SkillPoolLogger with the appropriate renderer.
+
+    In prod (SKILLPOOL_LOG_LEVEL=PROD or when not a TTY), uses JSONRenderer.
+    Otherwise uses ConsoleRenderer for readable dev output.
+    """
+    import os as _os
+
+    _log_level = _os.environ.get("SKILLPOOL_LOG_LEVEL", "INFO").upper()
+    renderer: Any = ConsoleRenderer() if sys.stderr.isatty() else JSONRenderer()
+    return SkillPoolLogger(name=name, renderer=renderer)
+
+
+# ── Logger ──
+
+
+class SkillPoolLogger:
+    """structlog-style structured logger.
+
+    Processor chain: add_timestamp -> add_trace_id -> add_skill_context -> format_json
+    Each log entry goes through the processor chain, then gets rendered.
+
+    Args:
+        name: Logger name (usually module path).
+        processors: List of processor callables. Each takes (logger, method, event_dict) -> event_dict.
+        renderer: Final renderer callable. Takes (logger, method, event_dict) -> str.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        processors: list | None = None,
+        renderer: Any | None = None,
+    ) -> None:
+        self._name = name
+        self._processors = processors or list(DEFAULT_PROCESSORS)
+        self._renderer = renderer or DEFAULT_RENDERER
+        self._bound: dict[str, Any] = {}
+
+    def bind(self, **kwargs: Any) -> SkillPoolLogger:
+        """Return a new logger with additional bound context.
+
+        The original logger is not modified.
+        """
+        new_logger = SkillPoolLogger(
+            name=self._name,
+            processors=self._processors,
+            renderer=self._renderer,
+        )
+        new_logger._bound = {**self._bound, **kwargs}
+        return new_logger
+
+    def _log(self, level: str, message: str, **kwargs: Any) -> None:
+        """Core logging method: build event dict, run processors, render, emit."""
+        event_dict: dict[str, Any] = {
+            "event": message,
+            "logger": self._name,
+            "level": level,
+        }
+
+        # Merge bound context
+        event_dict.update(self._bound)
+
+        # Merge call-site kwargs (override bound)
+        event_dict.update(kwargs)
+
+        # Run processor chain
+        for processor in self._processors:
+            event_dict = processor(self._name, level, event_dict)
+
+        # Render
+        output = self._renderer(self._name, level, event_dict)
+
+        # Emit to stderr
+        try:
+            sys.stderr.write(output + "\n")
+            sys.stderr.flush()
+        except (ValueError, OSError):
+            pass  # stderr closed or broken — don't crash
+
+    def debug(self, message: str, **kwargs: Any) -> None:
+        """Log at DEBUG level."""
+        self._log("debug", message, **kwargs)
+
+    def info(self, message: str, **kwargs: Any) -> None:
+        """Log at INFO level."""
+        self._log("info", message, **kwargs)
+
+    def warning(self, message: str, **kwargs: Any) -> None:
+        """Log at WARNING level."""
+        self._log("warning", message, **kwargs)
+
+    def error(self, message: str, **kwargs: Any) -> None:
+        """Log at ERROR level."""
+        self._log("error", message, **kwargs)

skillpool/utils/runtime_audit.py

@@ -0,0 +1,163 @@
+"""Runtime Audit Hook — Security monitoring via sys.addaudithook (PEP 578).
+
+Tracks security-sensitive operations: exec, compile, open, subprocess.Popen,
+socket.connect. Cannot be removed once registered (by design).
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "RuntimeAuditHook",
+]
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable
+
+
+from skillpool.config import get_data_dir
+
+_DEFAULT_LOG_DIR = get_data_dir() / "logs"
+_DEFAULT_LOG_FILE = _DEFAULT_LOG_DIR / "runtime_audit.jsonl"
+
+
+class RuntimeAuditHook:
+    """Monitor security-sensitive operations via sys.addaudithook.
+
+    Tracks: exec, compile, open, subprocess.Popen, socket.connect.
+    Cannot be removed once registered (by design — PEP 578 constraint).
+
+    Usage:
+        hook = RuntimeAuditHook()
+        hook.install()
+        # ... code runs, events are logged ...
+        events = hook.get_events()
+    """
+
+    MONITORED_EVENTS: frozenset[str] = frozenset(
+        {
+            "exec",
+            "compile",
+            "open",
+            "subprocess.Popen",
+            "socket.connect",
+        }
+    )
+
+    def __init__(
+        self,
+        callback: Callable[[str, tuple[Any, ...]], None] | None = None,
+        log_file: Path | None = None,
+    ) -> None:
+        """Initialize the audit hook.
+
+        Args:
+            callback: Optional custom callback receiving (event_name, args).
+                      If None, events are logged to the default JSONL file.
+            log_file: Override the default log file path.
+        """
+        self._callback = callback
+        self._log_file = log_file or _DEFAULT_LOG_FILE
+        self._installed = False
+        self._events: list[dict[str, Any]] = []
+        self._in_handler = False  # Reentrancy guard
+
+    def install(self, force: bool = False) -> None:
+        """Register the audit hook via sys.addaudithook.
+
+        Safe to call multiple times — subsequent calls are no-ops.
+        The hook cannot be removed once registered (PEP 578 design).
+
+        By default, only installs in production environments
+        (SKILLPOOL_ENV=prod). In dev/test, the I/O overhead of
+        monitoring every open/exec/subprocess event is prohibitive.
+        Use force=True to override this check.
+
+        Args:
+            force: Install regardless of environment (for tests).
+        """
+        if self._installed:
+            return
+
+        # Skip in non-production environments unless forced
+        env = os.environ.get("SKILLPOOL_ENV", "dev")
+        if env != "prod" and not force:
+            self._installed = True  # Mark as installed to prevent retries
+            return
+        if self._installed:
+            return
+
+        def _audit_handler(event_name: str, args: tuple[Any, ...]) -> None:
+            if event_name not in self.MONITORED_EVENTS:
+                return
+
+            # Reentrancy guard: prevent infinite recursion when
+            # _log_to_file triggers its own 'open' audit event
+            if self._in_handler:
+                return
+            self._in_handler = True
+
+            try:
+                entry = {
+                    "event": event_name,
+                    "args": _serialize_args(args),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                }
+
+                self._events.append(entry)
+
+                if self._callback:
+                    self._callback(event_name, args)
+                else:
+                    self._log_to_file(entry)
+            finally:
+                self._in_handler = False
+
+        sys.addaudithook(_audit_handler)
+        self._installed = True
+
+    def get_events(self) -> list[dict[str, Any]]:
+        """Retrieve all logged events since hook installation.
+
+        Returns:
+            List of event dicts with keys: event, args, timestamp.
+        """
+        return list(self._events)
+
+    def is_installed(self) -> bool:
+        """Check if the audit hook has been registered."""
+        return self._installed
+
+    def _log_to_file(self, entry: dict[str, Any]) -> None:
+        """Append an event entry to the JSONL log file."""
+        try:
+            self._log_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(self._log_file, "a", encoding="utf-8") as f:
+                f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+        except OSError:
+            # Silently fail — audit hook must not raise (PEP 578 constraint)
+            pass
+
+
+def _serialize_args(args: tuple[Any, ...]) -> list[Any]:
+    """Convert audit hook args to JSON-serializable form.
+
+    Args may contain arbitrary objects; we convert what we can and
+    stringify the rest.
+    """
+    result: list[Any] = []
+    for arg in args:
+        if isinstance(arg, (str, int, float, bool, type(None))):
+            result.append(arg)
+        elif isinstance(arg, bytes):
+            result.append(arg.decode("utf-8", errors="replace"))
+        elif isinstance(arg, (list, tuple, set, frozenset)):
+            result.append(_serialize_args(tuple(arg)))
+        elif isinstance(arg, dict):
+            result.append({str(k): str(v) for k, v in arg.items()})
+        else:
+            result.append(str(arg))
+    return result

skillpool/utils/time_utils.py

@@ -0,0 +1,13 @@
+"""Time utilities — timezone-aware UTC helpers."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+
+def utc_now() -> datetime:
+    """Return the current UTC datetime (timezone-aware).
+
+    Replaces datetime.utcnow() which is deprecated and returns naive datetimes.
+    """
+    return datetime.now(timezone.utc)

skillpool-4.3.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: skillpool
+Version: 4.3.0
+Summary: Skill Pool V4.3 — AI Agent Skill Governance & Delivery Platform
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: fastmcp>=0.2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: graph
+Requires-Dist: numpy>=1.24; extra == "graph"
+Requires-Dist: scipy>=1.10; extra == "graph"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: pytest-bdd>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"

skillpool-4.3.0.dist-info/RECORD

@@ -0,0 +1,90 @@
+skillpool/__init__.py,sha256=iqCqRbDt8qM961d-QyQePsf7lrGV5ge4LeGFEAoqW9I,2155
+skillpool/__main__.py,sha256=4NyWBZ_yt1y4GxeCVehQv4XF3_7LZAUiTwkH0ms-wMY,125
+skillpool/clawmem_client.py,sha256=7sQmBP6Jp6jb9dSNe-uQv97tBueqYnaurcixOgxZg1w,5973
+skillpool/cli.py,sha256=k2bzzgJPzGOsQBL5F0soQQis5E1earcatrwImBwXcUI,26937
+skillpool/config.py,sha256=_-wlKZjggznLD-i1KETzukeUmfeHsABp1t805wI2jLg,1109
+skillpool/csdf.py,sha256=xtq9r3imOFzl-tw3Oj74McX-ILjWq-pYIZIRZ6No4yU,4103
+skillpool/gate.py,sha256=cWadO5l-HYSk5dIO7VfvGfRIfjShBVjU-PSeS5unPKI,9190
+skillpool/lifecycle.py,sha256=6CskpHbouOozUrwpUCZH7mZUtasa-jy5nQR2upISYR4,4869
+skillpool/mcp_server.py,sha256=BfFEDzQtDGzUj59DtqtheTyI-tbndRi4NbV5FrJ1STs,73378
+skillpool/profile.py,sha256=5Qr0s65IBgshazu4UCnqYyhOI-9Qd1DR5AZz7l4AOJA,3466
+skillpool/quality.py,sha256=BHt5Uoq2VlVJF-zSLeFqqfwlmwy544qLpebwlnQi5Vs,8893
+skillpool/schemas.py,sha256=CL0fY5_uUrH_LF8izJs7IXq_0_gN14C7MJPuTytrbpo,3837
+skillpool/telemetry.py,sha256=8cNH7iBqP8cghkWj_-y2UFEsa44z1lSLpixaPxqP4g8,4104
+skillpool/adapters/__init__.py,sha256=xkyEmCrHeLa5pZjkMBnBxEmSTfVv75z7RBYrBu3stVU,318
+skillpool/adapters/base.py,sha256=-RaOTYdJelPlajkvf9AAhEuSZda0SnBbgldaQdVsN44,1518
+skillpool/adapters/claude_adapter.py,sha256=CQ0AMtPWrj-EfDvbEpuhpH0SFL87UhXpCsQpvhh1jkg,1528
+skillpool/adapters/codex_adapter.py,sha256=Zmaee0KAUCLTbRThBGKvi58s6DoZS-rhv0CaHpUPzpU,3903
+skillpool/adapters/hermes_adapter.py,sha256=4d7LUSzRKb-1XtJ6h6XlcslSi8cHvk8xfbZRKOw2L0c,1658
+skillpool/audit/__init__.py,sha256=VqifTn0OAmsaMxh1ovjL04I9AedpoEjOdXjcZpzRlhc,23726
+skillpool/bridge/__init__.py,sha256=XDAu38vD3tCXt44IlyBFKAPA2mnQ4NRhUY_cNHSCnro,462
+skillpool/bridge/freeze_detector.py,sha256=-_Dagt8vRyA1GBpZxVXBXTpjrmHo3LuvZWOt2XH9quw,4659
+skillpool/bridge/maintenance.py,sha256=KdX58HDbee4EAPhe2L5aRjlfml57W6AkQWDS8vYlaYk,4271
+skillpool/bridge/wal_manager.py,sha256=Zqa_s5y0-RsbvJuBStLTw-Hw1kufZwscLl73aumYIF4,4758
+skillpool/combiner/__init__.py,sha256=IC8fH_6KqbgrkIq0IhuT5qhinyMwBnBBtVqim-YNjuM,1025
+skillpool/combiner/lifecycle.py,sha256=2lJiRbs3ySsyJ__hdlMV9AjVZD7iWE_s6LcS8XL3My4,17167
+skillpool/combiner/models.py,sha256=0K_W5TM1xWo9JRY3LiMMysPYam4wzjf0Ydd_gSZN0Cs,3912
+skillpool/cost/__init__.py,sha256=3msWWd8zDJdC5nzmzSqRajzeisyQtMjtTYz7m2Lq8uU,4031
+skillpool/cost/audit_hash.py,sha256=1kznujWw-ejUz94xKv9ahOtP-X0SxIKuUby8YZJsgHI,1797
+skillpool/cost/budget_tracker.py,sha256=0GRHyxYlhgB2HVMXk3JhCtDGlE2SKeYnaKhLQHG4fgQ,2615
+skillpool/cost/dashboard.py,sha256=PXOcKbcdbbg-xGlMcGjYufera5OQ3UArG7vvt1NiC80,7124
+skillpool/cost/models.py,sha256=6NJU44FbWMn_i3DAD8b9vjHggQw3aggN5Kkd0YzPmlM,4491
+skillpool/cost/token_governor.py,sha256=TXdCDd3T-iJZcLl9UbFx9-QiD0-GgtEQMW9ZXRE_h3o,10588
+skillpool/cost/trace_ceiling.py,sha256=-SCYu5tnVjWf7niUJlug2gcHIc4zD1fvXFjAYPxXW6Y,1410
+skillpool/evolver/__init__.py,sha256=DAoM0QhHtV8CBmJ6lkGsAv2f6ToDRBXo9POw9I41XoE,35972
+skillpool/gain/__init__.py,sha256=4oIjzdwHPvhQ6-BA48T_rhLnPRB9VGH_GLTjm2GWC7Q,10464
+skillpool/gate_policy/__init__.py,sha256=xfOoI5zbNcPqXyuDgwcTzJFTuwEWnRvlZS1CVlUM8cw,708
+skillpool/gate_policy/incremental.py,sha256=s-DfM4KbTfEthaQfCxlbKJoki2p_brKGiSVr1xiDAho,4982
+skillpool/gate_policy/parser.py,sha256=ZvpYRfpb0kh0tDqaquTAw6YhoQT2cImsbQ1dFcoUexo,8346
+skillpool/gate_policy/state_machine.py,sha256=QCUlTVlgsfYSdy1HMwujzlBz-tzTBtRJ3DKnaSEMMyk,15592
+skillpool/graph/__init__.py,sha256=V3gQE11svLSlFIKP_po6hCDHt8r4_PQg25fvvtFvpKM,486
+skillpool/graph/ppr.py,sha256=-PKarRL0yU1t9s5YQTMp5X5sODOtkSCs9aNJtRUx9h0,7961
+skillpool/health/__init__.py,sha256=ZeOs9tJGhRXOAideatmOkFP2Fqz-Q19MJJ7VF6ZeF6E,2748
+skillpool/health/check.py,sha256=rtH2NK3_wPENYJ4_-R9fn2PxY2vL7xpyLPcq1SNhl8U,2693
+skillpool/health/degradation.py,sha256=8rJCbTyH2JkN5Ob9hTDdwEYGjmuIi833ePNfJrHd7kQ,3722
+skillpool/health/models.py,sha256=iZT4LcDlAHspRBsxz159myuQadUiilDUwmD2nZdeQbg,1410
+skillpool/hooks/__init__.py,sha256=d7xaAwAcSmipiT9MRlaKOygFvtUCuXmycPTkL45X0vg,145
+skillpool/hooks/security_scanner.py,sha256=sdhj3scNGolaUX7GAUInJBcayPgdFqbg7wH2VEUY_fk,11059
+skillpool/materializer/__init__.py,sha256=lK2iQcHj8S63Ue58ANRNInaCPIFMNsuS0mOSABE0AhM,3883
+skillpool/materializer/budget_cropper.py,sha256=2BPx-K_oh4O2UpKG28sePfllx7oWev5S499nNxZDGIw,6465
+skillpool/materializer/csdf_loader.py,sha256=Tt-RC1XQrT6ap6eg2J5ir_EXPQfylDxPvgSatiSJIUo,3636
+skillpool/materializer/lazy_loader.py,sha256=dtpHPuyeqdFe2MnQ_EaD6fHKfzB0Nmx3dPHCEMlwW0I,9922
+skillpool/materializer/lifecycle_filter.py,sha256=tVtnTRptoP58yF0elovtZLSqlrXYaC1QCUU8ajyf538,3569
+skillpool/materializer/mapper.py,sha256=8PZg1EXDAURmLSKtNLF6ePFFmS2VwpiRnv4DJFE9cg4,6021
+skillpool/materializer/models.py,sha256=AgflQMn-9KHzeEQ9UDvmDSoCD7B2Xn0oHXrglRKgfEw,1998
+skillpool/monitor/__init__.py,sha256=nsBkbNw1JUTijdyoPzKs3pWgL2rYNrhGaRvniHaSuUo,19319
+skillpool/monitor/bug_collector.py,sha256=bJzWWJOevr6-HHE_lgvnPLcpCH8iWGWFJxLTr1HQa-Y,13779
+skillpool/monitor/defect_classifier.py,sha256=yYSz5TBQaAkbSddfjUqJnLavbHDNWnXA3VWXa2pGHRk,8135
+skillpool/monitor/self_healing.py,sha256=mNrlRCEsI4YSWNQBixk_HKKlyGZFUgAb8cKdtQG0CUo,19195
+skillpool/monitor/telemetry_bridge.py,sha256=9vRxzoohO1i4oH6fi9VHUmCnN4zyCZ9g8m01f2aIuB4,6113
+skillpool/paradigm/__init__.py,sha256=zXZBydz9yDryR4YWawrKnRX4B-mBR-lKQjB1CvkQHg4,11301
+skillpool/paradigm/override.py,sha256=oOv788wwYhR_NZ5tmBIwtIjrIXFfNDlFkqnBHxv5l6c,9031
+skillpool/registry/__init__.py,sha256=h5TjYzWCkSRJgAMgeeVVfUeu14HxBxqvySZVU_1Z-NE,17443
+skillpool/registry/models.py,sha256=mTV6R1YxJ7tUKlLp3NWWYOdP_Bq2c-1ywjaoA_d85sg,2192
+skillpool/resolver/__init__.py,sha256=Qkq4CATCmDel40S_G4rJqDzsWDMASAiVtg_MMCcsbqE,11410
+skillpool/resolver/cache.py,sha256=uYIUBBTOwnzILQyKBvqiJFYfzfOn1Q7lY1V2juDAoSQ,3505
+skillpool/resolver/circuit_breaker.py,sha256=bt-V3WL6fV1LkwcMgU0uA3kL9mEK8hiPfzEHsyFhlWw,3324
+skillpool/resolver/conflict_detector.py,sha256=XUo7AdbvJUoNLZR1xjNBMhCqnbDotyWH880i7G8ZLRc,4212
+skillpool/resolver/health_filter.py,sha256=qJmhrpET0WRQMdNeCQHtC8hGgZXUEfE1tBC8E_5MhkQ,1042
+skillpool/resolver/models.py,sha256=1LzE4v6-vlW1EsF1eCymeY0cpI5EwEbLZlvVYBT8U7k,5451
+skillpool/resolver/rate_limiter.py,sha256=P_asznbAVQT7U7EC6Cl8sdGb7G0gEBF-M4e2It7diWI,1474
+skillpool/resolver/skill_graph.py,sha256=29xadJeFtAz46N2e7j6CskLlqxDObLp-uznpuHGD6Hk,6031
+skillpool/review/__init__.py,sha256=u9wR2u7AwCGr3W7kAqXh9t7UX0IoXre6pvqAK5Q_NjE,9254
+skillpool/review/async_queue.py,sha256=F9nqVSyHFMCikiHGDqar7EBv-gXY95Lwenza7_7-Gfs,3524
+skillpool/review/checkpoint_runner.py,sha256=3cD_V8rip7Dtqr6BNuNdabdeOsbNHopc_g0eXRSkB44,12061
+skillpool/review/models.py,sha256=HIL_1jXo58RnuDmYaSJ2_KBcmrMES4VTJcYn9M5mvMU,5147
+skillpool/review/suspect_marker.py,sha256=SRp3nbNJIJZYEe0RgFmZoBJr5wDB43TdS3R7t0DG1Mw,1254
+skillpool/review/veto_evaluator.py,sha256=Q6SEyWQuuvtwnlDrejGrNTQyhyYfG9JzDKu8nE4OLMo,3399
+skillpool/router/__init__.py,sha256=CnS53PQ81IAkBAGgBnEgtxs3r_MQt0j5_z9_d5jIoLY,19540
+skillpool/synergy/__init__.py,sha256=ggki1UfjGk4e0qT21Y97rRBFWUSZt1GL-oAthUb4_Qk,9695
+skillpool/synergy/detector.py,sha256=2PXH_ImR-RHU4jYbwlZ2MWwA_m2JkquxH3UtM1x2oKk,216
+skillpool/utils/__init__.py,sha256=28bgrDSBhCFHRpxlmq0qhj5GGkDKyriS4zeoMHhQ4x8,445
+skillpool/utils/changelog.py,sha256=tIMSnJwsHKPI2Wig970hSbJxJ-qGlianN3PVepz128Y,7326
+skillpool/utils/logger.py,sha256=uPlNPD0OQ9Ncthb4NDkKK5bZoLeMIP8FV0rTeVR1Rs4,8594
+skillpool/utils/runtime_audit.py,sha256=D4irlvJ5NBKzF0gEtuCSyW9tDbrrQqzUWodAqQuK2ws,5274
+skillpool/utils/time_utils.py,sha256=QUoDWFSQUEei-U6QfQOaASA5J-4obleWqickg008hdA,343
+skillpool-4.3.0.dist-info/METADATA,sha256=hzNizCDwF59B7WjxlpQos37BWgHqWCkNNDQfYSnDR6E,717
+skillpool-4.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+skillpool-4.3.0.dist-info/entry_points.txt,sha256=BHsoSynXvvIDkxBXgjdv-sO0_IpWT3m1D5BkFEzLl8o,91
+skillpool-4.3.0.dist-info/top_level.txt,sha256=ne3n_NFhpOKwQk8NODbsGyod7FIuqDczdDHv8S9xKzs,10
+skillpool-4.3.0.dist-info/RECORD,,

skillpool-4.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

skillpool-4.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+skillpool = skillpool.cli:main
+skillpool-mcp = skillpool.mcp_server:main

skillpool-4.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+skillpool