memstack-skill-loader 3.5.0__py3-none-any.whl

memstack_skill_loader/server.py

@@ -0,0 +1,883 @@
+"""MCP server entry point — exposes skill search tools via stdio transport."""
+
+import asyncio
+import json
+import os
+import sys
+import tempfile
+import time
+import zipfile
+from pathlib import Path
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+from .config import load_config
+from .license import (
+    MAX_KEY_LEN,
+    clear_cache,
+    get_license_key,
+    is_pro_exclusive,
+    save_license_key,
+    validate_license,
+)
+from .compression import clear_cache as clear_compression_cache, get_or_compress
+from .stats import get_compression_stats, get_dashboard_data, log_compression, log_skill_fire
+from .tfidf_search import get_skill_by_name, list_all_skills, reset_cache, search_skills
+
+app = Server("memstack-skill-loader")
+_config = None
+_ignored_skills: frozenset[str] = frozenset()
+USAGE_FILE = Path.home() / ".memstack" / "skill-usage.json"
+
+PRO_BUNDLE_URL = "https://admin.cwaffiliateinvestments.com/api/skills/pro-bundle"
+PRO_SKILLS_HOME = Path.home() / ".memstack" / "pro-skills"
+_MAX_BUNDLE_SIZE = 10 * 1024 * 1024  # 10 MB
+
+
+async def _download_pro_skills(license_key: str, force: bool = False) -> str:
+    """Download and extract Pro skills bundle to ~/.memstack/pro-skills/."""
+    sentinel = PRO_SKILLS_HOME / ".complete"
+    if sentinel.exists() and not force:
+        return f"Pro skills already present at {PRO_SKILLS_HOME}"
+
+    import httpx
+
+    print("[memstack] Downloading Pro skills...", file=sys.stderr)
+    async with httpx.AsyncClient(timeout=60) as client:
+        resp = await client.get(
+            PRO_BUNDLE_URL,
+            headers={"Authorization": f"Bearer {license_key}"},
+        )
+        resp.raise_for_status()
+
+    content = resp.content
+    if len(content) > _MAX_BUNDLE_SIZE:
+        raise ValueError(f"Bundle too large ({len(content)} bytes, limit {_MAX_BUNDLE_SIZE})")
+
+    tmp_path = None
+    tmp_dir = None
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp:
+            tmp.write(content)
+            tmp_path = tmp.name
+
+        with zipfile.ZipFile(tmp_path) as zf:
+            # Zip-slip protection
+            for member in zf.namelist():
+                member_path = Path(member)
+                if member_path.is_absolute() or ".." in member_path.parts:
+                    raise ValueError(f"Unsafe zip member: {member}")
+
+            tmp_dir = tempfile.mkdtemp(
+                prefix="pro-skills-tmp-",
+                dir=PRO_SKILLS_HOME.parent,
+            )
+            zf.extractall(tmp_dir)
+
+        # Atomic swap
+        if PRO_SKILLS_HOME.exists():
+            import shutil
+            shutil.rmtree(PRO_SKILLS_HOME)
+        os.rename(tmp_dir, str(PRO_SKILLS_HOME))
+        tmp_dir = None  # rename succeeded, don't clean up
+
+        # Count installed skills
+        skill_count = sum(1 for _ in PRO_SKILLS_HOME.rglob("SKILL.md"))
+
+        # Write sentinel
+        (PRO_SKILLS_HOME / ".complete").write_text("ok", encoding="utf-8")
+
+        msg = f"{skill_count} Pro skills installed to {PRO_SKILLS_HOME}"
+        print(f"[memstack] {msg}", file=sys.stderr)
+        return msg
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        if tmp_dir and os.path.exists(tmp_dir):
+            import shutil
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+
+
+def _load_memstack_ignore() -> frozenset[str]:
+    """Load .memstack-ignore from the current working directory."""
+    ignore_path = Path.cwd() / ".memstack-ignore"
+    if not ignore_path.exists():
+        return frozenset()
+    try:
+        lines = ignore_path.read_text(encoding="utf-8").splitlines()
+        ignored = frozenset(
+            line.strip().lower()
+            for line in lines
+            if line.strip() and not line.strip().startswith("#")
+        )
+        if ignored:
+            print(
+                f'MemStack™: [{len(ignored)}] skills filtered by .memstack-ignore',
+                file=sys.stderr,
+            )
+        return ignored
+    except OSError as exc:
+        print(f"[memstack] failed to read .memstack-ignore: {exc}", file=sys.stderr)
+        return frozenset()
+
+
+def _is_ignored(skill_name: str) -> bool:
+    """Check if a skill name matches the ignore list."""
+    return skill_name.lower() in _ignored_skills
+
+
+# Category derivation — mirrors dashboard._CATEGORY_MAP for stats consistency
+_CATEGORY_MAP = {
+    # Internal
+    "__list__": "Core",
+    # Automation
+    "cron-scheduler": "Automation", "n8n-workflow-builder": "Automation",
+    "api-integration": "Automation", "webhook-designer": "Automation",
+    "content-pipeline": "Automation", "hosted-mcp-catalog": "Automation",
+    # Business
+    "quill": "Business", "scan": "Business", "governor": "Business",
+    "client-onboarding": "Business", "contract-template": "Business", "financial-model": "Business",
+    "freelancer-toolkit": "Business", "invoice-generator": "Business", "scope-of-work": "Business",
+    "sop-builder": "Business", "proposal-writer": "Business",
+    # Content
+    "humanize": "Content", "blog-post": "Content", "email-sequence": "Content",
+    "landing-page-copy": "Content", "newsletter": "Content", "product-description": "Content",
+    "tiktok-script": "Content", "twitter-thread": "Content", "youtube-script": "Content",
+    "kdp-format": "Content",
+    # Deployment
+    "railway-deploy": "Deployment", "docker-setup": "Deployment", "netlify-deploy": "Deployment",
+    "domain-ssl": "Deployment", "hetzner-setup": "Deployment", "ci-cd-pipeline": "Deployment",
+    "marketplace-submit": "Deployment",
+    # Development
+    "forge": "Development", "shard": "Development",
+    "state": "Development", "work": "Development", "verify": "Development",
+    "project": "Development", "familiar": "Development", "api-designer": "Development",
+    "code-reviewer": "Development", "database-architect": "Development", "migration-planner": "Development",
+    "performance-audit": "Development", "refactor-planner": "Development", "test-writer": "Development",
+    "changelog-generator": "Development", "mentor": "Development", "webapp-testing": "Development",
+    # Core
+    "compress": "Core", "diary": "Core", "echo": "Core", "grimoire": "Core",
+    "sight": "Core", "token-optimization": "Core",
+    # Marketing
+    "facebook-ad": "Marketing", "google-ad": "Marketing",
+    "launch-plan": "Marketing", "competitor-analysis": "Marketing", "pricing-strategy": "Marketing",
+    "lead-magnet": "Marketing", "webinar-script": "Marketing", "sales-funnel": "Marketing",
+    # SEO & GEO
+    "site-audit": "SEO & GEO", "keyword-research": "SEO & GEO",
+    "meta-tag-optimizer": "SEO & GEO", "schema-markup": "SEO & GEO",
+    "ai-search-visibility": "SEO & GEO", "local-seo": "SEO & GEO",
+    # Product
+    "prd-writer": "Product", "feature-spec": "Product",
+    "user-story-generator": "Product", "mvp-scoper": "Product", "roadmap-builder": "Product",
+    "feedback-analyzer": "Product",
+    # Security
+    "advanced-security": "Security", "env-manager-pro": "Security",
+    "api-audit": "Security", "csp-headers": "Security", "dependency-audit": "Security",
+    "owasp-top10": "Security", "owasp-top-10": "Security",
+    "rls-checker": "Security", "rls-guardian": "Security",
+    "secrets-scanner": "Security",
+    # Pro skills (for backfill matching)
+    "api-docs": "Core", "branching": "Core", "consolidate": "Core", "context-db": "Core",
+    "multi-agent": "Development", "codebase-index": "Development", "doc-index": "Development",
+    "diagram-generator": "Development", "browser-use": "Development", "session-restore": "Core",
+    "drift-detection": "Security", "mcp-builder": "Development", "claude-api-helper": "Development",
+    "test-generator": "Development", "log-analyzer": "Development",
+    "performance-profiler": "Development", "dependency-auditor": "Security",
+    "git-worktrees": "Development", "error-handler": "Development", "web-scraper": "Automation",
+    "hooks-integration": "Development",
+}
+
+
+def _derive_category(slug: str) -> str:
+    """Derive a display category from a skill slug or its parent directory."""
+    if slug in _CATEGORY_MAP:
+        return _CATEGORY_MAP[slug]
+    # Fallback: try to match the first path segment of the skill's source path
+    return "Other"
+
+
+def _record_skill_usage(skill_name: str) -> None:
+    """Increment the usage counter for a skill."""
+    try:
+        USAGE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        data: dict[str, int] = {}
+        if USAGE_FILE.exists():
+            data = json.loads(USAGE_FILE.read_text(encoding="utf-8"))
+        data[skill_name] = data.get(skill_name, 0) + 1
+        USAGE_FILE.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    except (OSError, json.JSONDecodeError) as exc:
+        print(f"[memstack] failed to record skill usage: {exc}", file=sys.stderr)
+
+_BLOCKED_MSG = (
+    "MemStack\u2122 grace period expired.\n\n"
+    "Run `activate_license` with your **email** to unlock 85 free skills.\n\n"
+    "Example: `activate_license(key=\"free\", email=\"you@example.com\")`\n\n"
+    "Already have a Pro key? Run `activate_license(key=\"your-key\", email=\"you@example.com\")`."
+)
+def _pro_skill_notice(skill_name: str) -> str:
+    return f"{skill_name} is a Pro skill. Details at memstack.pro"
+_GRACE_EXPIRED_MSG = (
+    "\U0001f512 MemStack\u2122 grace period expired. "
+    "Run `activate_license` with your email to unlock 85 free skills."
+)
+_TAMPERED_MSG = (
+    "\U0001f512 MemStack\u2122 Pro: License file integrity check failed. "
+    "Get your key at https://memstack.pro"
+)
+
+
+def _grace_banner(status) -> str:
+    """Return a warning banner if the user is on a grace period, else empty."""
+    if status.grace_period and status.grace_days_remaining > 0:
+        return (
+            f"> \u26a0\ufe0f **MemStack\u2122 free trial:** "
+            f"**{status.grace_days_remaining} days** remaining. "
+            f"Run `activate_license` with your email to keep access permanently.\n\n"
+        )
+    return ""
+
+
+def _get_config():
+    global _config
+    if _config is None:
+        _config = load_config().with_pro_skills()
+    return _config
+
+
+def _check_index() -> bool:
+    """Return True if TF-IDF index exists on disk."""
+    config = _get_config()
+    pkl_path = config.resolved_vector_db_path / "tfidf_index.pkl"
+    return pkl_path.exists()
+
+
+@app.list_tools()
+async def list_tools() -> list[Tool]:
+    return [
+        Tool(
+            name="find_skill",
+            description=(
+                "Search MemStack\u2122 skills by describing what you need. Returns the most "
+                "relevant skill(s) with full instructions. Call this BEFORE starting any "
+                "task to check if a skill exists for it.\n"
+                "Workflow: 1) find_skill (preview) to identify the right skill, "
+                "2) get_skill to load full content for the one you need."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": (
+                            "Natural language description of what you need "
+                            "(e.g., 'deploy to Railway', 'set up Supabase RLS')"
+                        ),
+                    },
+                    "top_k": {
+                        "type": "integer",
+                        "description": "Number of results to return (1-10, default 3)",
+                        "minimum": 1,
+                        "maximum": 10,
+                        "default": 3,
+                    },
+                    "full": {
+                        "type": "boolean",
+                        "description": (
+                            "Return full skill content (default false). "
+                            "When false, returns name + short description + score only. "
+                            "Use get_skill to fetch full content for a specific skill."
+                        ),
+                        "default": False,
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        Tool(
+            name="list_skills",
+            description=(
+                "List all available MemStack\u2122 skills with names and descriptions. "
+                "Use this to browse the full skill catalog."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "compact": {
+                        "type": "boolean",
+                        "description": (
+                            "Return skill names only, grouped by category (default false). "
+                            "When false, includes descriptions."
+                        ),
+                        "default": False,
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="get_skill",
+            description=(
+                "Get the full content of a specific skill by exact name. "
+                "Use after find_skill to load a specific skill."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string",
+                        "description": "Skill name (case-insensitive, fuzzy match supported)",
+                    },
+                    "full": {
+                        "type": "boolean",
+                        "description": "Return uncompressed skill content. Default false (compressed).",
+                        "default": False,
+                    },
+                },
+                "required": ["name"],
+            },
+        ),
+        Tool(
+            name="reindex_skills",
+            description="Rebuild the skill vector index. Run after adding or modifying skills.",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+        Tool(
+            name="skill_stats",
+            description=(
+                "View MemStack\u2122 skill usage statistics. Shows most used skills, "
+                "least used skills, and total activations."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+        Tool(
+            name="manage_skills",
+            description=(
+                "Enable, disable, or list disabled skills for this project. "
+                "Disabled skills are hidden from find_skill, list_skills, and get_skill."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "action": {
+                        "type": "string",
+                        "description": "Action to perform: disable, enable, or list_disabled",
+                        "enum": ["disable", "enable", "list_disabled"],
+                    },
+                    "skill": {
+                        "type": "string",
+                        "description": "Skill name to enable or disable (not required for list_disabled)",
+                    },
+                },
+                "required": ["action"],
+            },
+        ),
+        Tool(
+            name="activate_license",
+            description=(
+                "Activate a MemStack license key to unlock skills. "
+                "Requires your email. Use key=\"free\" for a free license. "
+                "Get a Pro key at memstack.pro"
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "key": {
+                        "type": "string",
+                        "description": "Your MemStack license key (use \"free\" for free tier)",
+                    },
+                    "email": {
+                        "type": "string",
+                        "description": "Your email (required for activation)",
+                    },
+                },
+                "required": ["key", "email"],
+            },
+        ),
+        Tool(
+            name="dashboard_stats",
+            description=(
+                "View MemStack\u2122 usage dashboard data \u2014 skill fires, trends, "
+                "category breakdown, and context savings estimates."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+    ]
+
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+    try:
+        return await _handle_tool(name, arguments)
+    except Exception as e:
+        print(f"Error in tool {name}: {e}", file=sys.stderr)
+        return [TextContent(type="text", text=f"Error executing {name}: {e}")]
+
+
+async def _handle_tool(name: str, arguments: dict) -> list[TextContent]:
+    config = _get_config()
+
+    if name == "find_skill":
+        t0 = time.perf_counter()
+        print(f"[find_skill] start query={arguments.get('query', '')!r}", file=sys.stderr)
+        if not _check_index():
+            return [TextContent(
+                type="text",
+                text="No TF-IDF index found. Call reindex_skills first to build the index.",
+            )]
+
+        license_status = await validate_license()
+
+        # No valid license and no grace period
+        if not license_status.valid:
+            if license_status.grace_tampered:
+                return [TextContent(type="text", text=_TAMPERED_MSG)]
+            if license_status.grace_expired:
+                return [TextContent(type="text", text=_GRACE_EXPIRED_MSG)]
+            return [TextContent(type="text", text=_BLOCKED_MSG)]
+
+        query = arguments["query"]
+        top_k = arguments.get("top_k", config.default_top_k)
+        results = await asyncio.to_thread(search_skills, query, config, top_k)
+        # Filter ignored skills
+        results = [r for r in results if not _is_ignored(r["name"])]
+        t1 = time.perf_counter()
+        print(f"[find_skill] search done in {t1 - t0:.3f}s", file=sys.stderr)
+
+        if not results:
+            return [TextContent(type="text", text="No matching skills found.")]
+
+        # Track usage
+        project_name = os.path.basename(os.getcwd())
+        for r in results:
+            _record_skill_usage(r["name"])
+            try:
+                log_skill_fire(r["name"], category=_derive_category(r.get("slug", "")), project=project_name, tool="find_skill")
+            except Exception:
+                pass
+
+        full_mode = arguments.get("full", False)
+        banner = _grace_banner(license_status)
+        parts = []
+        for i, r in enumerate(results, 1):
+            if full_mode:
+                if license_status.tier == "pro" or not is_pro_exclusive(r["slug"]):
+                    tier = license_status.tier or "free"
+                    content, t_before, t_after = get_or_compress(r, tier=tier)
+                    try:
+                        log_compression(r["name"], t_before, t_after, tier)
+                    except Exception:
+                        pass
+                    parts.append(
+                        f"## {i}. {r['name']} (score: {r['score']})\n"
+                        f"**Source:** {r['source_label']}\n\n"
+                        f"{content}"
+                    )
+                else:
+                    parts.append(
+                        f"## {i}. {r['name']} (score: {r['score']})\n"
+                        f"**Source:** {r['source_label']}\n\n"
+                        + _pro_skill_notice(r["name"])
+                    )
+            else:
+                # Preview mode: name + short description + score only
+                desc = r.get("description", "")
+                desc_short = desc[:120] + "..." if len(desc) > 120 else desc
+                lock = ""
+                if license_status.tier != "pro" and is_pro_exclusive(r["slug"]):
+                    lock = " \U0001f512 Pro"
+                parts.append(
+                    f"{i}. **{r['name']}** (score: {r['score']}){lock}\n"
+                    f"   {desc_short}"
+                )
+        t2 = time.perf_counter()
+        print(f"[find_skill] response ready in {t2 - t0:.3f}s", file=sys.stderr)
+        separator = "\n\n---\n\n" if full_mode else "\n"
+        hint = "" if full_mode else "\n\n_Use `get_skill` with the skill name to load full content._"
+        return [TextContent(type="text", text=banner + separator.join(parts) + hint)]
+
+    elif name == "list_skills":
+        license_status = await validate_license()
+
+        if not license_status.valid:
+            if license_status.grace_tampered:
+                return [TextContent(type="text", text=_TAMPERED_MSG)]
+            if license_status.grace_expired:
+                return [TextContent(type="text", text=_GRACE_EXPIRED_MSG)]
+            return [TextContent(type="text", text=_BLOCKED_MSG)]
+
+        skills = await asyncio.to_thread(list_all_skills, config)
+        # Filter ignored skills
+        skills = [s for s in skills if not _is_ignored(s["name"])]
+        if not skills:
+            return [TextContent(
+                type="text",
+                text="No skills indexed yet. Call reindex_skills to build the index.",
+            )]
+
+        try:
+            log_skill_fire("__list__", tool="list_skills", project=os.path.basename(os.getcwd()))
+        except Exception:
+            pass
+
+        compact = arguments.get("compact", False)
+        banner = _grace_banner(license_status)
+
+        if compact:
+            # Group by source_label, names only
+            groups: dict[str, list[str]] = {}
+            for s in skills:
+                label = s["source_label"]
+                lock = ""
+                if license_status.tier != "pro" and is_pro_exclusive(s["slug"]):
+                    lock = " \U0001f512"
+                groups.setdefault(label, []).append(f"{s['name']}{lock}")
+            lines = [f"# MemStack\u2122 Skills ({len(skills)})\n"]
+            for label, names in groups.items():
+                lines.append(f"**{label}** ({len(names)}):")
+                lines.append(", ".join(names))
+                lines.append("")
+            lines.append("_Use `get_skill` with a name to load full content._")
+            return [TextContent(type="text", text=banner + "\n".join(lines))]
+
+        lines = [f"# MemStack\u2122 Skill Catalog ({len(skills)} skills)\n"]
+        for i, s in enumerate(skills, 1):
+            desc = s["description"][:120] + "..." if len(s["description"]) > 120 else s["description"]
+            if license_status.tier != "pro" and is_pro_exclusive(s["slug"]):
+                lock = " \U0001f512 Pro"
+            else:
+                lock = ""
+            lines.append(f"{i}. **{s['name']}** [{s['source_label']}]{lock}\n   {desc}")
+        return [TextContent(type="text", text=banner + "\n".join(lines))]
+
+    elif name == "get_skill":
+        if not _check_index():
+            return [TextContent(
+                type="text",
+                text="No TF-IDF index found. Call reindex_skills first to build the index.",
+            )]
+
+        license_status = await validate_license()
+
+        # Check license before reading from disk
+        if not license_status.valid:
+            if license_status.grace_tampered:
+                return [TextContent(type="text", text=_TAMPERED_MSG)]
+            if license_status.grace_expired:
+                return [TextContent(type="text", text=_GRACE_EXPIRED_MSG)]
+            return [TextContent(type="text", text=_BLOCKED_MSG)]
+
+        skill = await asyncio.to_thread(get_skill_by_name, arguments["name"], config)
+        if skill is None or _is_ignored(skill["name"]):
+            return [TextContent(
+                type="text",
+                text=f"Skill '{arguments['name']}' not found. Use list_skills to see available skills.",
+            )]
+
+        # Track usage
+        _record_skill_usage(skill["name"])
+        try:
+            log_skill_fire(skill["name"], category=_derive_category(skill.get("slug", "")), project=os.path.basename(os.getcwd()), tool="get_skill")
+        except Exception:
+            pass
+
+        banner = _grace_banner(license_status)
+        full_mode = arguments.get("full", False)
+        if license_status.tier == "pro" or not is_pro_exclusive(skill["slug"]):
+            if full_mode:
+                content = skill["content"]
+            else:
+                tier = license_status.tier or "free"
+                content, tokens_before, tokens_after = get_or_compress(skill, tier=tier)
+                try:
+                    log_compression(skill["name"], tokens_before, tokens_after, tier)
+                except Exception:
+                    pass
+            return [TextContent(
+                type="text",
+                text=banner + f"# {skill['name']}\n**Source:** {skill['source_label']}\n\n{content}",
+            )]
+        # Free tier + Pro-exclusive skill
+        return [TextContent(
+            type="text",
+            text=(
+                f"# {skill['name']}\n**Source:** {skill['source_label']}\n\n"
+                + _pro_skill_notice(skill["name"])
+            ),
+        )]
+
+    elif name == "activate_license":
+        key = arguments.get("key", "").strip()
+        email = arguments.get("email", "").strip() or None
+        if not email:
+            return [TextContent(
+                type="text",
+                text=(
+                    "\u274c Email is required to activate MemStack\u2122.\n\n"
+                    "Run: `activate_license(key=\"your-key\", email=\"you@example.com\")`\n\n"
+                    "Don't have a key? Use `key=\"free\"` to get a free license."
+                ),
+            )]
+        if not key or len(key) > MAX_KEY_LEN:
+            return [TextContent(
+                type="text",
+                text="\u274c No valid license key provided. Get one at https://memstack.pro",
+            )]
+
+        # Clear any stale cache for this key so the fresh API call runs.
+        clear_cache(key)
+
+        status = await validate_license(license_key=key, email=email)
+        if status.valid:
+            save_license_key(key)
+            if status.tier == "pro":
+                try:
+                    dl_msg = await _download_pro_skills(key)
+                    print(f"[memstack] {dl_msg}", file=sys.stderr)
+                except Exception as exc:
+                    print(
+                        f"[memstack] Pro skills download failed: {exc}. "
+                        "Please try again or contact support@memstack.pro",
+                        file=sys.stderr,
+                    )
+                from .indexer import build_index
+                await asyncio.to_thread(build_index, config)
+                reset_cache()
+                clear_compression_cache()
+                skills = await asyncio.to_thread(list_all_skills, config)
+                total = len(skills) if skills else 0
+                msg = (
+                    f"\u2705 License activated! Tier: **Pro**. "
+                    f"All {total} skills unlocked."
+                )
+            else:
+                skills = await asyncio.to_thread(list_all_skills, config)
+                total = len(skills) if skills else 0
+                free_count = sum(
+                    1 for s in (skills or []) if not is_pro_exclusive(s.get("slug", s["name"]))
+                )
+                msg = (
+                    f"\u2705 License activated! Tier: **Free**. "
+                    f"{free_count} skills unlocked. "
+                    f"Upgrade to Pro at https://memstack.pro to unlock all {total}."
+                )
+            return [TextContent(type="text", text=msg)]
+        return [TextContent(
+            type="text",
+            text="\u274c Invalid license key. Get one at https://memstack.pro",
+        )]
+
+    elif name == "skill_stats":
+        try:
+            if USAGE_FILE.exists():
+                data: dict[str, int] = json.loads(
+                    USAGE_FILE.read_text(encoding="utf-8")
+                )
+            else:
+                data = {}
+        except (OSError, json.JSONDecodeError):
+            data = {}
+
+        if not data:
+            return [TextContent(
+                type="text",
+                text="No skill usage data yet. Use find_skill or get_skill to start tracking.",
+            )]
+
+        total = sum(data.values())
+        sorted_skills = sorted(data.items(), key=lambda x: x[1], reverse=True)
+        most_used = sorted_skills[:10]
+        least_used = sorted_skills[-5:] if len(sorted_skills) > 5 else sorted_skills
+
+        lines = [f"# MemStack\u2122 Skill Usage Stats\n"]
+        lines.append(f"**Total activations:** {total}")
+        lines.append(f"**Unique skills used:** {len(data)}\n")
+        lines.append("## Most Used")
+        for name_, count in most_used:
+            lines.append(f"- **{name_}**: {count} activations")
+        lines.append("\n## Least Used")
+        for name_, count in reversed(least_used):
+            lines.append(f"- **{name_}**: {count} activations")
+
+        return [TextContent(type="text", text="\n".join(lines))]
+
+    elif name == "dashboard_stats":
+        data = get_dashboard_data()
+        try:
+            data["compression"] = get_compression_stats()
+        except Exception:
+            pass
+        return [TextContent(type="text", text=json.dumps(data, indent=2))]
+
+    elif name == "manage_skills":
+        global _ignored_skills
+        action = arguments.get("action", "")
+        skill_name = arguments.get("skill", "").strip()
+        ignore_path = Path.cwd() / ".memstack-ignore"
+
+        if action == "list_disabled":
+            if not _ignored_skills:
+                return [TextContent(
+                    type="text",
+                    text="No skills are currently disabled for this project.",
+                )]
+            lines_ = ["# Disabled Skills\n"]
+            for s in sorted(_ignored_skills):
+                lines_.append(f"- {s}")
+            lines_.append(f"\n**{len(_ignored_skills)}** skills filtered by .memstack-ignore")
+            return [TextContent(type="text", text="\n".join(lines_))]
+
+        if not skill_name:
+            return [TextContent(
+                type="text",
+                text="Skill name is required for enable/disable actions.",
+            )]
+
+        if action == "disable":
+            # Read existing file content (preserve comments)
+            existing_lines: list[str] = []
+            if ignore_path.exists():
+                existing_lines = ignore_path.read_text(encoding="utf-8").splitlines()
+
+            # Check if already disabled
+            active_entries = {
+                line.strip().lower()
+                for line in existing_lines
+                if line.strip() and not line.strip().startswith("#")
+            }
+            if skill_name.lower() in active_entries:
+                return [TextContent(
+                    type="text",
+                    text=f"'{skill_name}' is already disabled.",
+                )]
+
+            # Append the skill
+            existing_lines.append(skill_name.lower())
+            ignore_path.write_text(
+                "\n".join(existing_lines) + "\n", encoding="utf-8"
+            )
+
+            # Refresh in-memory ignore list
+            _ignored_skills = _load_memstack_ignore()
+            return [TextContent(
+                type="text",
+                text=f"Disabled {skill_name}. {len(_ignored_skills)} skills now filtered.",
+            )]
+
+        if action == "enable":
+            if not ignore_path.exists():
+                return [TextContent(
+                    type="text",
+                    text=f"'{skill_name}' is not disabled (no .memstack-ignore file).",
+                )]
+
+            existing_lines = ignore_path.read_text(encoding="utf-8").splitlines()
+            # Remove matching entries, preserve comments and other entries
+            new_lines = [
+                line for line in existing_lines
+                if line.strip().startswith("#") or line.strip().lower() != skill_name.lower()
+            ]
+
+            # Check if anything was actually removed
+            if len(new_lines) == len(existing_lines):
+                return [TextContent(
+                    type="text",
+                    text=f"'{skill_name}' is not currently disabled.",
+                )]
+
+            # Check if only comments/blanks remain
+            active_entries = [
+                line for line in new_lines
+                if line.strip() and not line.strip().startswith("#")
+            ]
+            if not active_entries:
+                # No active entries left — delete the file
+                ignore_path.unlink()
+                _ignored_skills = frozenset()
+                return [TextContent(
+                    type="text",
+                    text=f"Enabled {skill_name}. No skills filtered (removed .memstack-ignore).",
+                )]
+
+            ignore_path.write_text(
+                "\n".join(new_lines) + "\n", encoding="utf-8"
+            )
+
+            # Refresh in-memory ignore list
+            _ignored_skills = _load_memstack_ignore()
+            return [TextContent(
+                type="text",
+                text=f"Enabled {skill_name}. {len(_ignored_skills)} skills now filtered.",
+            )]
+
+        return [TextContent(
+            type="text",
+            text=f"Unknown action: {action}. Use disable, enable, or list_disabled.",
+        )]
+
+    elif name == "reindex_skills":
+        from .indexer import build_index
+        count = await asyncio.to_thread(build_index, config)
+        reset_cache()
+        clear_compression_cache()
+        if count == 0:
+            return [TextContent(
+                type="text",
+                text="Warning: No skills found to index. Check config.json skill_sources paths.",
+            )]
+        return [TextContent(
+            type="text",
+            text=f"Reindexed {count} skills successfully.",
+        )]
+
+    return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+
+async def run():
+    global _ignored_skills
+    config = _get_config()
+
+    # Load .memstack-ignore from project directory
+    _ignored_skills = _load_memstack_ignore()
+
+    # Print grace period status on startup if no license key is set
+    if not get_license_key():
+        from .license import _get_grace_period_status
+        active, remaining, _tampered = _get_grace_period_status()
+        if active:
+            print(
+                f"[memstack] No license key. Grace period: {remaining} days remaining. "
+                f"Get your free key at memstack.pro",
+                file=sys.stderr,
+            )
+        else:
+            print(
+                "[memstack] No license key. Grace period expired. "
+                "Get your free key at memstack.pro",
+                file=sys.stderr,
+            )
+
+    # Check for updates (cached, non-blocking)
+    from .version_check import check_for_updates
+    check_for_updates()
+
+    # Backfill NULL categories in stats.db from category map
+    from .stats import backfill_categories
+    backfill_categories(_CATEGORY_MAP)
+
+    # Pre-load TF-IDF index before stdio_server starts its stdin reader thread.
+    # On Windows, a blocking readline() in the stdin thread causes GIL contention
+    # that slows down CPU-intensive operations (like sklearn import) by ~20x.
+    from .tfidf_search import _get_index
+    _get_index(config)
+    async with stdio_server() as (read_stream, write_stream):
+        await app.run(read_stream, write_stream, app.create_initialization_options())