docs: structured marketplace descriptions with USER LEVEL, PROJECT LEVEL, and BEST SUITED FOR

.cursor-plugin/marketplace.json

@@ -11,37 +11,42 @@
     {
       "name": "teaching",
       "source": "teaching",
-      "description": "Skill mapping, practice plans, and learning retrospectives."
+      "description": "USER LEVEL: You get a structured path with checkpoints and retros—less thrashing, clearer progress signals on what to drill next. PROJECT LEVEL: Onboarding and mentorship scale because skill goals and practice cadence are explicit instead of tribal knowledge. Builds skill maps, practice plans, and learning retrospectives with milestones so improvement is deliberate instead of random prompt attempts. BEST SUITED FOR: • Developers leveling up on a new language, stack, or framework • Mentors needing repeatable lesson and practice scaffolding • Teams capturing how they teach internal tools and APIs"
     },
     {
       "name": "continual-learning",
       "source": "continual-learning",
-      "description": "Incremental transcript-driven memory updates for AGENTS.md using high-signal bullet points only."
+      "description": "USER LEVEL: You stop repeating the same stylistic rules, name choices, and workflow quirks every Monday—the assistant remembers what actually stuck. PROJECT LEVEL: Shared agent guidance reflects how the team works today, not a stale template from the repo’s first commit. Mines transcripts for durable preferences and facts, then appends concise bullets to AGENTS.md so future sessions start aligned. BEST SUITED FOR: • Long-lived monorepos with evolving conventions • Teams heavy on Cursor and shared AGENTS.md guidance • Projects where small decisions deserve persistent agent memory"
     },
     {
       "name": "cursor-team-kit",
       "source": "cursor-team-kit",
-      "description": "Internal team workflows used by Cursor developers for CI, code review, and shipping."
+      "description": "USER LEVEL: You inherit battle-tested habits from Cursor engineers when CI breaks, reviews stall, or diffs need tightening before merge. PROJECT LEVEL: Teams converge on repeatable PR and CI hygiene instead of inventing bespoke runbooks per repo. Cursor’s internal shipping playbook as skills—CI triage and fixes, PR flow, conflicts, smoke and compiler checks, cleanup passes, and summaries. BEST SUITED FOR: • Repositories with active GitHub Actions or similar CI • Maintainers juggling multiple PRs and flaky checks • Groups adopting structured review and ship discipline"
     },
     {
       "name": "create-plugin",
       "source": "create-plugin",
-      "description": "Scaffold and validate new Cursor plugins."
+      "description": "USER LEVEL: You create a valid plugin skeleton without memorizing manifest edge cases or marketplace wiring. PROJECT LEVEL: Internal extensions and partner plugins stay consistent, cutting review churn from broken metadata. Scaffolds marketplace-ready Cursor plugins—folder layout, manifest, optional skills and MCP—and runs quality checks before publish. BEST SUITED FOR: • Teams packaging MCP servers with skills and rules • Authors preparing Cursor marketplace submissions • Platform groups standardizing plugin templates"
     },
     {
       "name": "ralph-loop",
       "source": "ralph-loop",
-      "description": "Iterative self-referential AI loops using the Ralph Wiggum technique."
+      "description": "USER LEVEL: You offload grindy fix-test cycles while keeping guardrails (hooks) that prevent infinite thrash. PROJECT LEVEL: Deterministic refactors or test stabilizations finish without micromanaging every intermediate step. Runs an agent loop on a focused task—repeat the same prompt with hook-driven stop conditions until the work converges. BEST SUITED FOR: • Large mechanical refactors with clear completion checks • Flaky test stabilization and iterative repro cycles • Tasks where partial progress compounds across attempts"
     },
     {
       "name": "agent-compatibility",
       "source": "agent-compatibility",
-      "description": "CLI-backed repo compatibility scans plus Cursor agents that audit startup, validation, and docs against reality."
+      "description": "USER LEVEL: You avoid losing an afternoon to outdated README steps agents obediently follow into failure. PROJECT LEVEL: Onboarding and automation keep pace when toolchains rotate—docs and CI claims get verified, not assumed. CLI-backed audits that compare install scripts, CI, and docs with what actually runs so agents and humans share a truthful quick start. BEST SUITED FOR: • Complex local setups with many prerequisites • Fast-moving repos where docs drift from reality • Organizations onboarding coding agents broadly"
     },
     {
       "name": "cli-for-agent",
       "source": "cli-for-agent",
-      "description": "Patterns for designing CLIs that coding agents can run reliably: flags, help with examples, pipelines, errors, idempotency, dry-run."
+      "description": "USER LEVEL: You design or review CLI UX that agents can drive without surprise prompts or missing non-interactive paths. PROJECT LEVEL: Internal tools and release CLIs become reliable citizens in CI and agent workflows instead of brittle shells. Patterns for CLIs built for automation—flags, layered help with examples, stdin, actionable errors, idempotency, dry-run. BEST SUITED FOR: • Products exposing developer CLIs • Platform teams wrapping tooling for autonomous runners • Repos where scripts are part of the contract with agents"
+    },
+    {
+      "name": "appwrite",
+      "source": "appwrite",
+      "description": "USER LEVEL: You describe outcomes in plain language (collections, users, functions) and the assistant uses your project’s API key against the real endpoint—less tab switching and fewer stale examples. PROJECT LEVEL: Schemas, permissions, and Functions stay aligned with production because the agent operates on the same Appwrite project your app uses, with reviews still gated by your key scopes. Connects Cursor to your live Appwrite project through the official Appwrite API MCP server and skills so agents read and change real backend resources—not guesses from docs alone. BEST SUITED FOR: • Web and mobile apps built on Appwrite Auth, Databases, and Storage • Teams managing collections, indexes, and Cloud Functions in Appwrite • Self-hosted or Appwrite Cloud projects needing agent-driven operations"
     }
   ]
 }

README.md

@@ -4,15 +4,30 @@ Official Cursor plugins for popular developer tools, frameworks, and SaaS produc
 
 ## Plugins
 
-| `name` | Plugin | Author | Category | `description` (from marketplace) |
-|:-------|:-------|:-------|:---------|:-------------------------------------|
-| `continual-learning` | [Continual Learning](continual-learning/) | Cursor | Developer Tools | Incremental transcript-driven memory updates for AGENTS.md using high-signal bullet points only. |
-| `cursor-team-kit` | [Cursor Team Kit](cursor-team-kit/) | Cursor | Developer Tools | Internal team workflows used by Cursor developers for CI, code review, and shipping. |
-| `create-plugin` | [Create Plugin](create-plugin/) | Cursor | Developer Tools | Scaffold and validate new Cursor plugins. |
-| `agent-compatibility` | [Agent Compatibility](agent-compatibility/) | Cursor | Developer Tools | CLI-backed repo compatibility scans plus Cursor agents that audit startup, validation, and docs against reality. |
-| `cli-for-agent` | [CLI for Agents](cli-for-agent/) | Cursor | Developer Tools | Patterns for designing CLIs that coding agents can run reliably: flags, help with examples, pipelines, errors, idempotency, dry-run. |
-
-Author values match each plugin’s `plugin.json` `author.name` (Cursor lists `plugins@cursor.com` in the manifest).
+| `name` | Plugin | Author | Category | Notes |
+|:-------|:-------|:-------|:---------|:------|
+| `appwrite` | [Appwrite](appwrite/) | Appwrite | Developer Tools | Appwrite API MCP (`uvx mcp-server-appwrite`) + skills; configure `.mcp.json` / Cursor MCP env. |
+| `continual-learning` | [Continual Learning](continual-learning/) | Cursor | Developer Tools | Transcript-driven updates to AGENTS.md. |
+| `cursor-team-kit` | [Cursor Team Kit](cursor-team-kit/) | Cursor | Developer Tools | CI, PR, and shipping skills. |
+| `create-plugin` | [Create Plugin](create-plugin/) | Cursor | Developer Tools | Plugin scaffolding and checks. |
+| `ralph-loop` | [Ralph Loop](ralph-loop/) | Cursor | Developer Tools | Iterative agent loops with hooks. |
+| `teaching` | [Teaching](teaching/) | Cursor | Utilities | Skill maps, practice plans, retrospectives. |
+| `agent-compatibility` | [Agent Compatibility](agent-compatibility/) | Cursor | Developer Tools | Audits docs/CI vs runnable reality. |
+| `cli-for-agent` | [CLI for Agents](cli-for-agent/) | Cursor | Developer Tools | CLI design patterns for automation. |
+
+Marketplace copy is **composed** from structured `marketplaceDetail` in each `.cursor-plugin/plugin.json` (`USER LEVEL`, `PROJECT LEVEL`, overview line, `BEST SUITED FOR` bullets) so the Cursor detail view (`marketplace-editor__description`) stays a single paragraph **without duplicated “integrate with your projects” phrasing**—edit the YAML-like fields, then run `npm run compose`.
+
+### After Cursor refreshes plugin cache
+
+Cursor may overwrite `~/.cursor/plugins/cache/cursor-public/**` when it re-downloads packages. To re-apply manifests from this repo:
+
+```bash
+npm run after-cursor-update
+```
+
+That runs `compose` then `sync-cache`. Optionally install a git hook: `powershell -ExecutionPolicy Bypass -File scripts/install-git-post-merge-hook.ps1` (runs the same after `git pull`).
+
+Author values match each plugin’s `plugin.json` `author.name` where listed (Cursor lists `plugins@cursor.com` in Cursor-authored manifests).
 
 ## Repository structure
 

agent-compatibility/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "agent-compatibility",
   "displayName": "Agent Compatibility",
   "version": "1.0.0",
-  "description": "CLI-backed repo compatibility scans plus Cursor agents that audit startup, validation, and docs against reality.",
+  "description": "USER LEVEL: You avoid losing an afternoon to outdated README steps agents obediently follow into failure. PROJECT LEVEL: Onboarding and automation keep pace when toolchains rotate—docs and CI claims get verified, not assumed. CLI-backed audits that compare install scripts, CI, and docs with what actually runs so agents and humans share a truthful quick start. BEST SUITED FOR: • Complex local setups with many prerequisites • Fast-moving repos where docs drift from reality • Organizations onboarding coding agents broadly",
   "author": {
     "name": "Cursor",
     "email": "plugins@cursor.com"
@@ -28,5 +28,15 @@
     "workflow"
   ],
   "skills": "./skills/",
-  "agents": "./agents/"
+  "agents": "./agents/",
+  "marketplaceDetail": {
+    "summary": "CLI-backed audits that compare install scripts, CI, and docs with what actually runs so agents and humans share a truthful quick start.",
+    "userLevel": "You avoid losing an afternoon to outdated README steps agents obediently follow into failure.",
+    "projectLevel": "Onboarding and automation keep pace when toolchains rotate—docs and CI claims get verified, not assumed.",
+    "bestSuitedFor": [
+      "Complex local setups with many prerequisites",
+      "Fast-moving repos where docs drift from reality",
+      "Organizations onboarding coding agents broadly"
+    ]
+  }
 }

agent-compatibility/README.md

@@ -1,5 +1,22 @@
 # Agent Compatibility
 
+<!-- cursor-plugin-enhancements:begin -->
+
+## Who this is for
+
+### For you (user level)
+You trust the README again: the assistant checks whether install, test, and lint commands in docs match what the repo really does.
+
+### For your projects (project level)
+Open-source and inner-source projects reduce onboarding friction and agent failure modes when “quick start” drift silently breaks.
+
+### Best suited for
+- Polyglot or fast-moving repos where docs fall behind scripts
+- Projects onboarding agents as first-class “users” of the repo
+- Maintainers preparing for external contributors or marketplace plugins
+
+<!-- cursor-plugin-enhancements:end -->
+
 Cursor plugin for checking how well a repo holds up under agent workflows. It pairs the published `agent-compatibility` CLI with focused reviews for startup, validation, and docs reliability.
 
 By default, the full pass returns one overall score and one short list of the highest-leverage fixes. If the user wants the full breakdown, the agents can expose the component scores and the reasoning behind them.

appwrite/.cursor-plugin/plugin.json

@@ -0,0 +1,41 @@
+{
+  "name": "appwrite",
+  "displayName": "Appwrite",
+  "version": "1.0.0",
+  "description": "USER LEVEL: You describe outcomes in plain language (collections, users, functions) and the assistant uses your project’s API key against the real endpoint—less tab switching and fewer stale examples. PROJECT LEVEL: Schemas, permissions, and Functions stay aligned with production because the agent operates on the same Appwrite project your app uses, with reviews still gated by your key scopes. Connects Cursor to your live Appwrite project through the official Appwrite API MCP server and skills so agents read and change real backend resources—not guesses from docs alone. BEST SUITED FOR: • Web and mobile apps built on Appwrite Auth, Databases, and Storage • Teams managing collections, indexes, and Cloud Functions in Appwrite • Self-hosted or Appwrite Cloud projects needing agent-driven operations",
+  "author": {
+    "name": "Appwrite",
+    "email": "team@appwrite.io"
+  },
+  "homepage": "https://appwrite.io",
+  "repository": "https://github.com/appwrite/appwrite",
+  "license": "MIT",
+  "keywords": [
+    "appwrite",
+    "baas",
+    "backend",
+    "mcp",
+    "database",
+    "auth",
+    "functions"
+  ],
+  "category": "developer-tools",
+  "tags": [
+    "backend",
+    "cloud",
+    "api",
+    "mcp"
+  ],
+  "skills": "./skills/",
+  "mcpServers": ".mcp.json",
+  "marketplaceDetail": {
+    "summary": "Connects Cursor to your live Appwrite project through the official Appwrite API MCP server and skills so agents read and change real backend resources—not guesses from docs alone.",
+    "userLevel": "You describe outcomes in plain language (collections, users, functions) and the assistant uses your project’s API key against the real endpoint—less tab switching and fewer stale examples.",
+    "projectLevel": "Schemas, permissions, and Functions stay aligned with production because the agent operates on the same Appwrite project your app uses, with reviews still gated by your key scopes.",
+    "bestSuitedFor": [
+      "Web and mobile apps built on Appwrite Auth, Databases, and Storage",
+      "Teams managing collections, indexes, and Cloud Functions in Appwrite",
+      "Self-hosted or Appwrite Cloud projects needing agent-driven operations"
+    ]
+  }
+}

appwrite/.mcp.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "appwrite": {
+      "command": "uvx",
+      "args": ["mcp-server-appwrite"],
+      "env": {
+        "APPWRITE_PROJECT_ID": "YOUR_PROJECT_ID",
+        "APPWRITE_API_KEY": "YOUR_API_KEY",
+        "APPWRITE_ENDPOINT": "https://cloud.appwrite.io/v1"
+      }
+    }
+  }
+}

appwrite/README.md

@@ -0,0 +1,14 @@
+# Appwrite plugin
+
+Official-style integration pattern: **skills** teach when and how to use Appwrite safely; **MCP** (`mcp-server-appwrite` via `uvx`) performs live API operations.
+
+## MCP setup
+
+1. Install [uv](https://docs.astral.sh/uv/getting-started/installation/) so `uvx` is available.
+2. Create an Appwrite API key with the scopes you are willing to expose to the assistant.
+3. In `.mcp.json`, replace placeholders—or override env vars in **Cursor Settings → MCP** for this server.
+4. For self-hosted Appwrite, set `APPWRITE_ENDPOINT` to your instance API URL (see Appwrite docs for the `/v1` base).
+
+## Tool surface
+
+Additional APIs (users, storage, functions, …) are opt-in flags on `mcp-server-appwrite` to control context size.

appwrite/skills/appwrite/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: appwrite
+description: Use when the user works with Appwrite (Auth, Databases, Functions, Storage, teams) and needs accurate API operations or setup guidance inside Cursor.
+---
+
+# Appwrite
+
+- Ensure `.mcp.json` uses real `APPWRITE_PROJECT_ID`, `APPWRITE_API_KEY`, and the correct `APPWRITE_ENDPOINT` (self-hosted installs use their own URL).
+- Prefer enabling only the Appwrite MCP tool groups you need (`uvx mcp-server-appwrite --help`) to preserve model context.
+- Follow least-privilege API keys; never commit secrets—configure them in Cursor MCP settings or environment.

cli-for-agent/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "cli-for-agent",
   "displayName": "CLI for Agents",
   "version": "1.0.0",
-  "description": "Patterns for designing CLIs that coding agents can run reliably: non-interactive flags, layered help with examples, pipelines, actionable errors, idempotency, and dry-run.",
+  "description": "USER LEVEL: You design or review CLI UX that agents can drive without surprise prompts or missing non-interactive paths. PROJECT LEVEL: Internal tools and release CLIs become reliable citizens in CI and agent workflows instead of brittle shells. Patterns for CLIs built for automation—flags, layered help with examples, stdin, actionable errors, idempotency, dry-run. BEST SUITED FOR: • Products exposing developer CLIs • Platform teams wrapping tooling for autonomous runners • Repos where scripts are part of the contract with agents",
   "author": {
     "name": "Cursor",
     "email": "plugins@cursor.com"
@@ -26,5 +26,15 @@
     "automation",
     "developer-tools"
   ],
-  "skills": "./skills/"
+  "skills": "./skills/",
+  "marketplaceDetail": {
+    "summary": "Patterns for CLIs built for automation—flags, layered help with examples, stdin, actionable errors, idempotency, dry-run.",
+    "userLevel": "You design or review CLI UX that agents can drive without surprise prompts or missing non-interactive paths.",
+    "projectLevel": "Internal tools and release CLIs become reliable citizens in CI and agent workflows instead of brittle shells.",
+    "bestSuitedFor": [
+      "Products exposing developer CLIs",
+      "Platform teams wrapping tooling for autonomous runners",
+      "Repos where scripts are part of the contract with agents"
+    ]
+  }
 }

cli-for-agent/README.md

@@ -1,5 +1,22 @@
 # CLI for Agents
 
+<!-- cursor-plugin-enhancements:begin -->
+
+## Who this is for
+
+### For you (user level)
+You learn how to spot CLIs that will frustrate agents (hidden prompts, ambiguous errors) and how to fix them before they waste a long autonomous run.
+
+### For your projects (project level)
+Tooling and platform teams ship command-line interfaces that are safe for scripts and coding agents—fewer “it works interactively but not in CI” surprises.
+
+### Best suited for
+- Developer tools, CLIs, and internal scripts consumed by automation
+- Repos adding agent-run make/npx/pnpm targets
+- Reviewing third-party CLIs before wiring them into agent playbooks
+
+<!-- cursor-plugin-enhancements:end -->
+
 Cursor plugin with a single skill that encodes patterns for **CLIs meant to be driven by coding agents**: non-interactive flags first, layered `--help` with examples, stdin and pipelines, fast actionable errors, idempotency, `--dry-run`, and predictable command structure.
 
 ## What it includes