apsimo 1.3.0__py3-none-any.whl

apsimo/skills/registry.py

@@ -0,0 +1,191 @@
+"""Skill registry for loading and managing initiative executor skills.
+
+Skills are discovered dynamically and can be hot-reloaded.
+"""
+
+import importlib
+import inspect
+import logging
+import os
+from typing import Any, Dict, List, Optional, Type
+
+from .base import InitiativeExecutorSkill
+
+logger = logging.getLogger(__name__)
+
+
+class _SkillView:
+    """Read-only adapter exposing a registered executor skill in the shape the
+    host/API layer expects (name/description/skill_id/status).
+
+    Built-in executor skills are runtime executors, not persisted skill
+    manifests awaiting approval, so they are always 'active' and never appear
+    under a DRAFT filter.
+    """
+
+    def __init__(self, skill: "InitiativeExecutorSkill"):
+        name = (
+            getattr(skill, "skill_name", None)
+            or getattr(skill, "skill_id", None)
+            or skill.__class__.__name__
+        )
+        self.skill_id = name
+        self.name = name
+        doc = (getattr(skill, "__doc__", "") or "").strip()
+        self.description = doc.split("\n", 1)[0].strip() if doc else name
+        self.status = "active"
+        self.created_at = None
+        self.tags: List[str] = []
+        self.trigger_patterns: List[str] = []
+        self.version = getattr(skill, "skill_version", None)
+
+
+
+class SkillRegistry:
+    """Registry of initiative executor skills.
+
+    Loads built-in skills automatically. Additional skills can be
+    registered manually or discovered from directories.
+    """
+
+    def __init__(self, graph_client=None, event_bus=None, telemetry=None):
+        self._skills: Dict[str, InitiativeExecutorSkill] = {}
+        self._graph = graph_client
+        self._events = event_bus
+        self._telemetry = telemetry
+
+        # Auto-load built-in skills
+        self._load_builtin_skills()
+
+    def _load_builtin_skills(self) -> None:
+        """Load all built-in executor skills."""
+        builtin_skills = [
+            "apsimo.skills.executors.subsystem_health",
+            "apsimo.skills.executors.data_quality",
+            "apsimo.skills.executors.operational_hygiene",
+            "apsimo.skills.executors.capability_gap",
+            "apsimo.skills.executors.knowledge_acquisition",
+            "apsimo.skills.executors.behavioral_correction",
+        ]
+
+        for module_path in builtin_skills:
+            try:
+                module = importlib.import_module(module_path)
+                # Find skill classes in the module
+                for name, obj in inspect.getmembers(module, inspect.isclass):
+                    if (
+                        issubclass(obj, InitiativeExecutorSkill)
+                        and obj is not InitiativeExecutorSkill
+                        and not getattr(obj, "__abstractmethods__", None)
+                    ):
+                        skill = obj(
+                            graph_client=self._graph,
+                            event_bus=self._events,
+                            telemetry=self._telemetry,
+                        )
+                        self.register(skill)
+                        logger.info("Loaded built-in skill: %s", skill.skill_name)
+            except ImportError as e:
+                logger.warning("Failed to load built-in skill module %s: %s", module_path, e)
+            except Exception as e:
+                logger.error("Error loading built-in skill %s: %s", module_path, e)
+
+    def register(self, skill: InitiativeExecutorSkill) -> None:
+        """Register a skill instance."""
+        self._skills[skill.skill_name] = skill
+        logger.debug("Registered skill: %s", skill.skill_name)
+
+    def unregister(self, skill_name: str) -> None:
+        """Unregister a skill by name."""
+        if skill_name in self._skills:
+            del self._skills[skill_name]
+            logger.debug("Unregistered skill: %s", skill_name)
+
+    def get(self, skill_name: str) -> Optional[InitiativeExecutorSkill]:
+        """Get a skill by name."""
+        return self._skills.get(skill_name)
+
+    def list_skills(self) -> List[str]:
+        """List all registered skill names."""
+        return list(self._skills.keys())
+
+    async def list_all(self, status=None) -> List["_SkillView"]:
+        """List all registered skills as lightweight views.
+
+        Mirrors the persisted-skill API shape so host context-assembly and the
+        /skills endpoints can enumerate the runtime executor registry. A status
+        filter (e.g. SkillStatus.DRAFT) returns only matching skills; built-in
+        executors are always 'active', so a DRAFT filter yields an empty list.
+        """
+        views = [_SkillView(s) for s in self._skills.values()]
+        if status is not None:
+            wanted = getattr(status, "value", status)
+            views = [v for v in views if v.status == wanted]
+        return views
+
+    async def find_skill_for_category(
+        self, category: Dict[str, Any], context: Dict[str, Any]
+    ) -> Optional[InitiativeExecutorSkill]:
+        """Find the first skill that can execute a given category.
+
+        Args:
+            category: InitiativeCategory node data
+            context: Execution context
+
+        Returns:
+            The matching skill, or None if no skill can handle it
+        """
+        executor_skill_name = category.get("executor_skill")
+
+        for skill in self._skills.values():
+            # Fast path: exact skill name match
+            if executor_skill_name and skill.skill_name == executor_skill_name:
+                if await skill.can_execute(category, context):
+                    return skill
+                continue
+
+            # Slow path: ask each skill
+            try:
+                if await skill.can_execute(category, context):
+                    return skill
+            except Exception as e:
+                logger.warning(
+                    "Skill %s.can_execute() failed: %s", skill.skill_name, e
+                )
+
+        return None
+
+    async def execute(
+        self,
+        skill_name: str,
+        initiative_context: Any,  # InitiativeExecutionContext
+    ) -> Any:  # ExecutionResult
+        """Execute an initiative using a specific skill.
+
+        Args:
+            skill_name: Name of the skill to use
+            initiative_context: The initiative execution context
+
+        Returns:
+            ExecutionResult
+        """
+        skill = self._skills.get(skill_name)
+        if not skill:
+            logger.error("Skill not found: %s", skill_name)
+            return None  # type: ignore[return-value]
+
+        try:
+            return await skill.execute(initiative_context)
+        except Exception as e:
+            logger.error("Skill %s execution failed: %s", skill_name, e)
+            return None  # type: ignore[return-value]
+
+    def health_check(self) -> Dict[str, Any]:
+        """Return health status of all registered skills."""
+        return {
+            "skills": {
+                name: skill.health_check()
+                for name, skill in self._skills.items()
+            },
+            "count": len(self._skills),
+        }

apsimo/skills/runtime.py

@@ -0,0 +1,58 @@
+"""Colony skill runtime handle.
+
+Provides synthesized skills with a ``colony`` object that exposes
+tool invocation via the sidecar HTTP API.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+class _ToolProxy:
+    """Namespace that lets skills call ``colony.tools.invoke(name, args)``."""
+
+    def __init__(self, base_url: str, headers: dict[str, str]) -> None:
+        self._base_url = base_url
+        self._headers = headers
+
+    async def invoke(self, name: str, args: dict[str, Any] | None = None) -> Any:
+        """Invoke a Colony MCP tool by name through the sidecar API.
+
+        Routes to the internal tool-dispatch endpoint so the skill
+        runs with the same auth context as the sidecar itself.
+        """
+        try:
+            async with httpx.AsyncClient(timeout=30) as client:
+                resp = await client.post(
+                    f"{self._base_url}/v1/host/tools/invoke",
+                    headers=self._headers,
+                    json={"tool": name, "args": args or {}},
+                )
+                resp.raise_for_status()
+                return resp.json()
+        except Exception as exc:
+            logger.error("colony.tools.invoke(%s) failed: %s", name, exc)
+            raise
+
+
+class ColonyRuntime:
+    """Thin runtime handle injected into synthesized skills that declare
+    a ``colony`` parameter in their ``run()`` signature.
+
+    Usage inside a skill::
+
+        async def run(colony, query: str) -> str:
+            result = await colony.tools.invoke("colony_lookup_facts", {"query": query})
+            return str(result)
+    """
+
+    def __init__(self, base_url: str = "http://127.0.0.1:7777") -> None:
+        self._base_url = base_url.rstrip("/")
+        self._headers: dict[str, str] = {}
+        self.tools = _ToolProxy(self._base_url, self._headers)

apsimo/skills/sandbox_runner.py

@@ -0,0 +1,229 @@
+"""Standalone skill-execution runner.
+
+Invoked as ``python -m apsimo.skills.sandbox_runner``. Reads a
+single JSON object from stdin describing the skill source, inputs, and
+resource limits; executes the skill's ``run`` function inside a process
+that has been hardened with ``resource.setrlimit``; emits a single JSON
+object on stdout with the result.
+
+Parent-side contract (``skills.executor.SkillExecutor``):
+    in  (stdin) : {"source": str, "inputs": dict, "limits":
+                   {"mem_mb": int, "cpu_secs": int, "fsize_mb": int}}
+    out (stdout): {"status": "success"|"failed",
+                   "output"?: Any, "error"?: str,
+                   "peak_memory_kb": int}
+
+All errors inside this runner are captured and reported on stdout — the
+runner never prints a stack trace to stderr as part of its contract, and
+exits 0 on normal completion so the parent can distinguish runner
+failures from kernel kills.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import sys
+from typing import Any, Dict, Optional
+
+
+def _fallback_repr(value: Any) -> Any:
+    """Best-effort conversion to something JSON can encode."""
+    try:
+        json.dumps(value)
+        return value
+    except Exception:
+        return repr(value)
+
+
+def _apply_limits(mem_mb: int, cpu_secs: int, fsize_mb: int) -> None:
+    """Apply process-level resource caps. Best-effort per platform."""
+    import resource
+
+    # Memory. Linux has RLIMIT_AS (total virtual memory); Darwin does not
+    # enforce RLIMIT_AS reliably — fall back to RLIMIT_DATA on that
+    # platform so heap allocations still hit a wall.
+    mem_bytes = mem_mb * 1024 * 1024
+    mem_set = False
+    if sys.platform.startswith("linux"):
+        try:
+            resource.setrlimit(resource.RLIMIT_AS, (mem_bytes, mem_bytes))
+            mem_set = True
+        except (ValueError, OSError):
+            pass
+    if not mem_set:
+        try:
+            resource.setrlimit(resource.RLIMIT_DATA, (mem_bytes, mem_bytes))
+        except (ValueError, OSError, AttributeError):
+            pass
+
+    # Wall-clock timeout is enforced by the parent via asyncio.wait_for;
+    # RLIMIT_CPU is a belt-and-braces backstop in case the parent's kill
+    # signal is delayed or ignored. A generous cushion avoids racing the
+    # parent — the parent should always win under normal operation, and
+    # this rlimit only fires if the parent's kill is itself blocked.
+    try:
+        resource.setrlimit(
+            resource.RLIMIT_CPU, (cpu_secs + 10, cpu_secs + 15),
+        )
+    except (ValueError, OSError):
+        pass
+
+    # Writable output size — stops `print(huge_thing)` from filling disks.
+    fsize_bytes = fsize_mb * 1024 * 1024
+    try:
+        resource.setrlimit(resource.RLIMIT_FSIZE, (fsize_bytes, fsize_bytes))
+    except (ValueError, OSError):
+        pass
+
+    # No fork / exec. Blocks `os.fork()`, `os.system()`, subprocess.Popen,
+    # multiprocessing — cuts off the broadest class of escape.
+    try:
+        resource.setrlimit(resource.RLIMIT_NPROC, (1, 1))
+    except (ValueError, OSError, AttributeError):
+        pass
+
+    # Cap file descriptors so a skill can't exhaust the process table.
+    try:
+        resource.setrlimit(resource.RLIMIT_NOFILE, (64, 64))
+    except (ValueError, OSError):
+        pass
+
+
+def _peak_memory_kb() -> int:
+    """Return peak resident-set size in KB for the current process."""
+    try:
+        import resource
+        ru = resource.getrusage(resource.RUSAGE_SELF)
+        # Linux reports ru_maxrss in KB; macOS in bytes. Normalize to KB.
+        val = int(ru.ru_maxrss)
+        if sys.platform == "darwin" and val > 10 * 1024 * 1024:
+            val = val // 1024
+        return val
+    except Exception:
+        return 0
+
+
+async def _invoke(source: str, inputs: Dict[str, Any], allowed_imports: List[str] | None = None) -> Any:
+    """Compile + exec the skill in a minimal namespace and call run()."""
+    # Minimal builtins. The scanner already rejects the loudest offenders
+    # at upload time; stripping them again at runtime is belt-and-braces
+    # in case a skill reached the runner through a non-standard path.
+    #
+    # ``__import__`` and ``__build_class__`` must stay reachable — Python's
+    # ``import`` statement and ``class`` statement compile down to calls to
+    # them, so without them even well-behaved skills can't run.
+    import builtins as _bi
+    import importlib as _importlib
+
+    _banned = {
+        "eval", "exec", "compile", "open", "breakpoint", "input",
+    }
+    _safe_dunders = {"__build_class__", "__name__", "__doc__"}
+
+    safe_builtins: Dict[str, Any] = {}
+    for name in dir(_bi):
+        if name in _banned:
+            continue
+        if name.startswith("_") and name not in _safe_dunders:
+            continue
+        safe_builtins[name] = getattr(_bi, name)
+
+    # Replace bare __import__ with a whitelist-enforcing wrapper.
+    # Pre-load declared modules so "from X import Y" works without
+    # hitting __import__ for declared modules.
+    declared_modules: set[str] = set(allowed_imports or [])
+    _original_import = _bi.__import__
+    preloaded: Dict[str, Any] = {}
+    for mod_name in declared_modules:
+        try:
+            preloaded[mod_name] = _importlib.import_module(mod_name)
+        except ImportError:
+            pass  # will fail at use-time if the skill actually needs it
+
+    def _restricted_import(name: str, *args: Any, **kwargs: Any) -> Any:
+        if name in preloaded:
+            return preloaded[name]
+        if name in declared_modules:
+            return _original_import(name, *args, **kwargs)
+        raise ImportError(f"Import of '{name}' not allowed (not in skill manifest)")
+
+    safe_builtins["__import__"] = _restricted_import
+
+    namespace: Dict[str, Any] = {"__builtins__": safe_builtins, "__name__": "__skill__"}
+    # Inject pre-loaded modules into namespace so top-level imports resolve
+    namespace.update(preloaded)
+    code = compile(source, "<skill>", "exec")
+    exec(code, namespace)  # noqa: S102
+
+    run_fn = namespace.get("run")
+    if run_fn is None:
+        raise AttributeError("skill has no 'run' function")
+
+    result = run_fn(**inputs)
+    if asyncio.iscoroutine(result):
+        result = await result
+    return result
+
+
+def _emit(payload: Dict[str, Any]) -> None:
+    sys.stdout.write(json.dumps(payload))
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+
+
+def main() -> int:
+    try:
+        raw = sys.stdin.read()
+        request = json.loads(raw)
+    except Exception as exc:
+        _emit({
+            "status": "failed",
+            "error": f"runner: invalid stdin payload: {type(exc).__name__}",
+            "peak_memory_kb": 0,
+        })
+        return 0
+
+    source: str = request.get("source", "")
+    inputs: Dict[str, Any] = request.get("inputs") or {}
+    allowed_imports: List[str] = request.get("allowed_imports") or []
+    limits: Dict[str, Any] = request.get("limits") or {}
+
+    mem_mb = int(limits.get("mem_mb") or 256)
+    cpu_secs = int(limits.get("cpu_secs") or 60)
+    fsize_mb = int(limits.get("fsize_mb") or 8)
+
+    _apply_limits(mem_mb=mem_mb, cpu_secs=cpu_secs, fsize_mb=fsize_mb)
+
+    # Close any inherited fds above the standard three. Best-effort —
+    # a skill shouldn't have access to parent sockets or pipes.
+    try:
+        os.closerange(3, 64)
+    except Exception:
+        pass
+
+    try:
+        output = asyncio.run(_invoke(source, inputs, allowed_imports))
+        _emit({
+            "status": "success",
+            "output": _fallback_repr(output),
+            "peak_memory_kb": _peak_memory_kb(),
+        })
+    except MemoryError:
+        _emit({
+            "status": "failed",
+            "error": "memory_limit_exceeded",
+            "peak_memory_kb": _peak_memory_kb(),
+        })
+    except Exception as exc:
+        _emit({
+            "status": "failed",
+            "error": f"{type(exc).__name__}: {exc}",
+            "peak_memory_kb": _peak_memory_kb(),
+        })
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

apsimo/skills/scheduler.py

@@ -0,0 +1,129 @@
+"""Colony Skills — skill scheduler with LRU-Cold eviction."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import List
+
+from apsimo.skills.budget import ContextBudget
+from apsimo.skills.index import SkillIndex
+from apsimo.skills.loader import LoadedSkill, SkillLoader
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SkillsConfig:
+    """Configuration for skill scheduling."""
+
+    context_budget_tokens: int = 8192
+    retention_policy: str = "lru"       # lru | ttl | manual
+    hot_skill_threshold: int = 5        # use_count above which a skill is "hot"
+    cold_ttl_secs: int = 1800           # 30 min TTL for cold skills when policy=ttl
+
+
+class SkillScheduler:
+    """Evaluates trigger patterns, manages skill load/evict lifecycle,
+    and enforces the context budget.
+    """
+
+    def __init__(
+        self,
+        index: SkillIndex,
+        loader: SkillLoader,
+        budget: ContextBudget,
+        config: SkillsConfig,
+    ) -> None:
+        self._index = index
+        self._loader = loader
+        self._budget = budget
+        self._config = config
+
+    async def evaluate(self, event_text: str) -> List[LoadedSkill]:
+        """Called once per autonomy loop tick.
+
+        1. Match event_text against SkillIndex (no imports).
+        2. For each match, if not loaded and budget permits: load.
+        3. If budget full: evict least-recently-used cold skill first.
+        4. Return list of all currently loaded skills relevant to event.
+        """
+        candidates = self._index.match(event_text)
+
+        for entry in candidates:
+            if entry.skill_id in self._loader.loaded_ids():
+                continue  # Already loaded; load_for_event will update last_used_at
+
+            needed = entry.context_tokens_estimate
+            current_used = self._loader.token_footprint()
+
+            if not self._budget.has_capacity(needed, current_used):
+                freed = await self.maybe_evict_for(needed)
+                if not freed:
+                    logger.debug(
+                        "SkillScheduler: cannot load %s — budget exhausted", entry.skill_id
+                    )
+                    continue
+
+        loaded = await self._loader.load_for_event(event_text, self._budget)
+        return loaded
+
+    async def evict_cold(self) -> int:
+        """Evict all cold skills (use_count < hot_threshold AND
+        last_used_at older than cold_ttl).
+
+        Returns number of skills evicted.
+        """
+        if self._config.retention_policy == "manual":
+            return 0
+
+        cold_deadline = datetime.now(timezone.utc) - timedelta(
+            seconds=self._config.cold_ttl_secs
+        )
+        evicted = 0
+        for ls in self._lru_cold():
+            if ls.last_used_at < cold_deadline:
+                await self._loader.unload(ls.entry.skill_id)
+                evicted += 1
+                logger.debug(
+                    "SkillScheduler: evicted cold skill %s (last_used=%s)",
+                    ls.entry.skill_id,
+                    ls.last_used_at.isoformat(),
+                )
+
+        if evicted:
+            logger.info("SkillScheduler: evicted %d cold skill(s)", evicted)
+        return evicted
+
+    async def maybe_evict_for(self, needed_tokens: int) -> bool:
+        """Free at least needed_tokens by evicting cold skills in LRU order.
+
+        Returns True if sufficient space was freed.
+        """
+        if self._config.retention_policy == "manual":
+            return False
+
+        candidates = self._lru_cold()
+        freed = 0
+        for ls in candidates:
+            if freed >= needed_tokens:
+                break
+            freed += ls.entry.context_tokens_estimate
+            await self._loader.unload(ls.entry.skill_id)
+            logger.debug(
+                "SkillScheduler: LRU-evicted skill %s to make room (freed %d tokens)",
+                ls.entry.skill_id,
+                ls.entry.context_tokens_estimate,
+            )
+
+        return freed >= needed_tokens
+
+    def _is_hot(self, skill: LoadedSkill) -> bool:
+        return skill.use_count >= self._config.hot_skill_threshold
+
+    def _lru_cold(self) -> List[LoadedSkill]:
+        """Cold skills sorted oldest last_used_at first."""
+        cold = [ls for ls in self._loader.all_loaded() if not self._is_hot(ls)]
+        cold.sort(key=lambda ls: ls.last_used_at)
+        return cold

apsimo/skills/schema.py

@@ -0,0 +1,79 @@
+"""Colony Skills — SQLite schema for the skill registry."""
+
+SKILLS_SCHEMA = """
+CREATE TABLE IF NOT EXISTS skills (
+    skill_id          TEXT PRIMARY KEY,
+    name              TEXT NOT NULL,
+    version           TEXT NOT NULL,
+    description       TEXT NOT NULL DEFAULT '',
+    author_colony_id  TEXT NOT NULL,
+    status            TEXT NOT NULL DEFAULT 'draft',
+    tags              TEXT NOT NULL DEFAULT '',
+    dependencies      TEXT NOT NULL DEFAULT '',
+    entry_point       TEXT NOT NULL DEFAULT 'skill:run',
+    checksum_sha256   TEXT NOT NULL DEFAULT '',
+    origin_task_id    TEXT,
+    parent_skill_id   TEXT,
+    trust_score       REAL NOT NULL DEFAULT 0.0,
+    execution_count   INTEGER NOT NULL DEFAULT 0,
+    last_executed_at  TEXT,
+    skill_dir         TEXT,
+    trigger_patterns  TEXT NOT NULL DEFAULT '[]',
+    context_tokens_estimate INTEGER NOT NULL DEFAULT 2048,
+    lazy_loader       TEXT,
+    created_at        TEXT NOT NULL,
+    updated_at        TEXT NOT NULL,
+    FOREIGN KEY (parent_skill_id) REFERENCES skills(skill_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_skills_status    ON skills(status);
+CREATE INDEX IF NOT EXISTS idx_skills_tags      ON skills(tags);
+CREATE INDEX IF NOT EXISTS idx_skills_trust     ON skills(trust_score DESC);
+CREATE INDEX IF NOT EXISTS idx_skills_author    ON skills(author_colony_id);
+
+CREATE TABLE IF NOT EXISTS skill_versions (
+    id                INTEGER PRIMARY KEY AUTOINCREMENT,
+    skill_id          TEXT NOT NULL,
+    version           TEXT NOT NULL,
+    checksum_sha256   TEXT NOT NULL,
+    skill_dir         TEXT NOT NULL,
+    promoted_at       TEXT NOT NULL,
+    promoted_by       TEXT NOT NULL,
+    FOREIGN KEY (skill_id) REFERENCES skills(skill_id)
+);
+
+CREATE TABLE IF NOT EXISTS skill_attestations (
+    id                INTEGER PRIMARY KEY AUTOINCREMENT,
+    skill_id          TEXT NOT NULL,
+    attesting_colony  TEXT NOT NULL,
+    risk_level        TEXT NOT NULL,
+    days_clean        INTEGER NOT NULL DEFAULT 0,
+    total_executions  INTEGER NOT NULL DEFAULT 0,
+    violations        INTEGER NOT NULL DEFAULT 0,
+    signature         TEXT NOT NULL,
+    attested_at       TEXT NOT NULL,
+    FOREIGN KEY (skill_id) REFERENCES skills(skill_id)
+);
+
+CREATE TABLE IF NOT EXISTS skill_quarantine_log (
+    id                INTEGER PRIMARY KEY AUTOINCREMENT,
+    skill_id          TEXT NOT NULL,
+    reason            TEXT NOT NULL,
+    resolved_by       TEXT,
+    resolved_at       TEXT,
+    created_at        TEXT NOT NULL,
+    FOREIGN KEY (skill_id) REFERENCES skills(skill_id)
+);
+
+CREATE TABLE IF NOT EXISTS skill_execution_log (
+    id                INTEGER PRIMARY KEY AUTOINCREMENT,
+    skill_id          TEXT NOT NULL,
+    execution_id      TEXT NOT NULL UNIQUE,
+    status            TEXT NOT NULL,
+    duration_ms       INTEGER,
+    peak_memory_mb    REAL,
+    violations        TEXT,
+    executed_at       TEXT NOT NULL,
+    FOREIGN KEY (skill_id) REFERENCES skills(skill_id)
+);
+"""