thumbgate 0.9.10

package/plugins/codex-profile/README.md

@@ -0,0 +1,37 @@
+# ThumbGate for Codex
+
+This directory is the repo-local Codex app plugin surface for ThumbGate.
+
+It packages the same ThumbGate runtime you already use elsewhere:
+
+- `plugins/codex-profile/.codex-plugin/plugin.json` for Codex plugin metadata
+- `plugins/codex-profile/.mcp.json` for the MCP server launcher
+- `adapters/codex/config.toml` for the version-pinned manual install path
+
+## What it does
+
+- adds ThumbGate's Pre-Action Gates to Codex workflows
+- captures thumbs-up/down feedback that survives session boundaries
+- reuses the same local-first MCP runtime as Claude, Cursor, Gemini, Amp, and OpenCode
+
+## Install paths
+
+### Codex app plugin
+
+Use the repo-local Codex plugin metadata and MCP config in this folder when Codex is loading plugin surfaces from the repository.
+
+### Manual install
+
+Copy the MCP profile from `adapters/codex/config.toml` into `~/.codex/config.toml`.
+
+That profile launches:
+
+```toml
+[mcp_servers.thumbgate]
+command = "npx"
+args = ["-y", "thumbgate@0.9.10", "serve"]
+```
+
+## Why this exists
+
+The Codex support story is no longer just "copy this config block." This folder is the shipped Codex plugin artifact for ThumbGate, so the repo can truthfully claim a Codex app plugin surface alongside the Claude Desktop bundle and Cursor plugin.

package/plugins/cursor-marketplace/.cursor-plugin/plugin.json

@@ -0,0 +1,23 @@
+{
+  "name": "thumbgate",
+  "displayName": "ThumbGate",
+  "description": "👍👎 Thumbs down a mistake — your AI agent won't repeat it. Thumbs up good work — it remembers the pattern.",
+  "version": "0.9.10",
+  "author": {
+    "name": "Igor Ganapolsky"
+  },
+  "homepage": "https://thumbgate-production.up.railway.app",
+  "repository": "https://github.com/IgorGanapolsky/ThumbGate",
+  "license": "MIT",
+  "keywords": [
+    "cursor",
+    "cursor-plugin",
+    "feedback",
+    "thumbs-up-down",
+    "thumbgate",
+    "ai-agent-memory",
+    "mistake-prevention",
+    "coding-agent"
+  ],
+  "logo": "assets/logo-400x400.png"
+}

package/plugins/cursor-marketplace/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+## 0.8.1 - 2026-03-26
+
+- Unified ThumbGate branding across all public surfaces (README, AGENTS.md, CLAUDE.md, GEMINI.md, landing page, package.json).
+- Landing page SEO: "human-in-the-loop enforcement", "vibe coding" positioning, FAQPage JSON-LD schema for Google rich results.
+- Added congruence CI check (`scripts/check-congruence.js`) — enforces version, branding, tech stack terms, and honest disclaimer across README and landing page on every PR.
+- Performance: deferred non-critical side-effects in `captureFeedback` (contextFs, RLAIF self-audit) via `setImmediate`.
+- Added `_captureMs` timing field to accepted feedback responses for observability.
+- Added `mcpize.yaml` to version sync targets.
+- Dead code removal: -1,551 lines (contract-audit.js, prove-rlaif.js, stale landing-page.html, 3 duplicate docs).
+- Fixed GitGuardian incident #29200799: scrubbed hardcoded Google API key from git history.
+- Social automation pipeline: post-everywhere CLI, reply monitor with AutoMod-safe Reddit posts.
+- TDS article draft: "Beyond Prompt Rules: How Pre-Action Gates Stop AI Coding Agents From Repeating Mistakes".
+
+## 0.8.0 - 2026-03-25
+
+- **Lesson DB:** SQLite + FTS5 full-text search replaces linear Jaccard token-overlap. Sub-millisecond ranked search indexed by signal, domain, tags, importance.
+- **Corrective actions:** On negative feedback, `capture_feedback` returns `correctiveActions[]` — top 3 remediation steps inferred from similar past failures.
+- **search_lessons MCP tool:** Exposes corrective actions, lifecycle state, linked rules, linked gates, and next harness fixes per lesson.
+- **search_thumbgate MCP tool:** Searches raw ThumbGate state across feedback logs, ContextFS memory, and prevention rules.
+- **Rejection ledger:** Tracks why vague feedback was rejected with revival conditions.
+- **Bayesian belief updates:** Each memory carries a posterior that updates on new evidence; high-entropy contradictions auto-prune.
+
+## 0.7.4 - 2026-03-20
+
+- Added `session_handoff` and `session_primer` MCP tools for seamless cross-session context continuity.
+- New `session` namespace in ContextFS stores primer.json with auto-captured git state (branch, last 5 commits, modified files, working tree status), last completed task, next step, and blockers.
+- `session_handoff` records provenance events for full audit trail of session transitions.
+- Closes Layer 2 (primer.md) of the 5-layer memory stack — no manual primer file needed.

package/plugins/cursor-marketplace/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Igor Ganapolsky
+
+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.

package/plugins/cursor-marketplace/README.md

@@ -0,0 +1,124 @@
+# ThumbGate — for Cursor
+
+`ThumbGate` is the human-facing plugin name in Cursor listings.
+`thumbgate` stays the plugin slug, npm package, and launcher target.
+
+The canonical short description is:
+
+> 👍👎 Thumbs down a mistake — your AI agent won't repeat it. Thumbs up good work — it remembers the pattern.
+
+How it works:
+
+- 👎 **Thumbs down** a mistake — it gets blocked from happening again
+- 👍 **Thumbs up** good work — the agent remembers the pattern
+- **History-aware lesson distillation** — vague thumbs signals can be grounded in the last ~10 messages and failed tool call
+- **Cross-session memory** — lessons persist between conversations
+- **Automatic enforcement** — repeated failures become prevention rules
+- **Zero config** — install and start giving feedback
+
+## What's included
+
+### Rules
+
+| File | Always on | Description |
+|------|-----------|-------------|
+| `rules/pre-action-gates.mdc` | Yes | Before risky tool calls (git push, rm -rf, npm publish, deploy), check prevention rules via the thumbgate MCP server. Blocks and explains if a rule matches. |
+| `rules/feedback-capture.mdc` | No | After any mistake or unexpected behavior, prompt to capture structured feedback with context and tags. |
+| `rules/session-continuity.mdc` | No | At session start, recall past context; at session end, hand off state for next session. |
+
+### Skills
+
+| Skill | Description |
+|-------|-------------|
+| `recall-context` | Recall relevant past failures, prevention rules, and context packs before starting a coding task. |
+| `capture-feedback` | Capture structured thumbs up/down feedback with context, tags, and optional rubric scores. |
+| `search-lessons` | Search promoted lessons for corrective actions, lifecycle state, linked rules, and linked gates. |
+| `prevention-rules` | Generate and review prevention rules auto-promoted from repeated failure patterns. |
+
+### Agent
+
+| Agent | Description |
+|-------|-------------|
+| `reliability-reviewer` | A reliability-focused reviewer that checks code changes against known failure patterns from the project's ThumbGate memory. |
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `/check-gates` | Run a Pre-Action Gate check against prevention rules before executing a risky action. |
+| `/show-lessons` | Display promoted lessons and their corrective actions. |
+| `/capture-feedback` | Quick feedback capture with structured signals. |
+
+### Hooks
+
+| Hook | Trigger | Description |
+|------|---------|-------------|
+| `beforeShellExecution` | `git push`, `rm -rf`, `npm publish`, `deploy` | Runs `scripts/gate-check.sh` to perform a pre-action health check via `thumbgate doctor`. |
+
+### MCP Server
+
+| Server | Command |
+|--------|---------|
+| `thumbgate` | `npx -y thumbgate@latest serve` |
+
+## Install
+
+### Cursor Marketplace
+
+Search for **ThumbGate** in the Cursor marketplace and install.
+
+### Team Marketplace
+
+Cursor Teams and Enterprise can import this repository through `Dashboard -> Settings -> Plugins -> Team Marketplaces`. If Cursor exposes `Enable Auto Refresh`, turn it on so repo-backed plugin updates refresh automatically.
+
+### Cursor Directory
+
+Treat Cursor Directory as a discoverability surface, not the runtime distribution channel. It helps people find the plugin, but npm releases do not rewrite directory copy on their own. The Cursor Directory does not auto-refresh from npm.
+
+If a manual submission form asks for `Name`, use `ThumbGate` instead of the slug.
+
+### Manual setup
+
+Use the existing project bootstrap:
+
+```bash
+npx thumbgate init
+```
+
+Or copy the plugin MCP config into `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "thumbgate": {
+      "command": "npx",
+      "args": ["-y", "thumbgate@latest", "serve"]
+    }
+  }
+}
+```
+
+## Update behavior
+
+- Runtime updates: the plugin asks npm for `thumbgate@latest`, so new npm releases can flow into the Cursor runtime without editing the plugin config.
+- Metadata updates: `npm publish` does not refresh the marketplace description, screenshots, README, or directory listing copy. Republish the plugin bundle when those assets change.
+- Guaranteed rollouts: if you need deterministic behavior for a specific release, pin a version manually in local config instead of relying on `@latest`.
+
+## Feedback
+
+Use the `/capture-feedback` command or the `capture_feedback` MCP tool to send structured feedback directly to the ThumbGate memory system. Feedback drives prevention rule generation — repeated failure patterns are auto-promoted into enforceable gates.
+
+When the user only gives a quick `thumbs_down`, `wrong`, or `correct`, the Cursor plugin should include the last ~10 messages and the failed tool call in `chatHistory` so ThumbGate can propose the lesson automatically. If the explanation comes later, reuse the earlier event with `relatedFeedbackId` instead of creating an isolated duplicate.
+
+## What makes this useful in Cursor
+
+ThumbGate gives Cursor agents a practical guardrail layer:
+
+- **Pre-Action Gates** block known-bad actions before tool use
+- **Prevention rules** auto-generated from repeated failures
+- **Context packs** keep relevant project history in scope
+- **Feedback capture** with structured up/down signals and history-aware lesson proposals
+- **Reliability reviewer** checks changes against known failure patterns
+
+Verification evidence for shipped behavior lives in `docs/VERIFICATION_EVIDENCE.md`.
+Release and promotion rules live in `docs/CURSOR_PLUGIN_OPERATIONS.md`.

package/plugins/cursor-marketplace/agents/reliability-reviewer.md

@@ -0,0 +1,31 @@
+---
+name: reliability-reviewer
+description: A reliability-focused reviewer agent that checks code changes against known failure patterns from the project's ThumbGate memory. Prioritizes preventing repeated mistakes.
+---
+
+# Reliability Reviewer
+
+You are a reliability-focused code reviewer. Your job is to check proposed code changes against the project's known failure patterns stored in ThumbGate memory.
+
+## Review process
+
+1. **Recall context** — Use the `recall` MCP tool to retrieve relevant prevention rules and past failures for the files being changed.
+2. **Search lessons** — Use the `search_lessons` MCP tool to find promoted lessons related to the components being modified.
+3. **Cross-reference changes** — Compare the proposed changes against known failure patterns. Flag any changes that match or resemble past failures.
+4. **Check gates** — Use the `prevention_rules` MCP tool to verify no active prevention rules are violated by the changes.
+5. **Report findings** — Summarize which past failures are relevant, what risks exist, and what corrective actions should be applied.
+
+## Review priorities
+
+1. **Repeated mistakes** — Changes that match previously captured failure patterns are highest priority.
+2. **Missing gate checks** — Risky operations without corresponding pre-action gate checks.
+3. **Untested paths** — Changes to code paths that previously caused failures without new test coverage.
+4. **Feedback gaps** — Changes in areas with no captured feedback history (unknown risk).
+
+## Output format
+
+For each finding, include:
+- The matched failure pattern or prevention rule
+- The specific code change that triggered the match
+- The recommended corrective action
+- Severity: critical (matches active prevention rule), warning (matches past failure), or info (no history)

package/plugins/cursor-marketplace/commands/capture-feedback.md

@@ -0,0 +1,33 @@
+---
+name: capture-feedback
+description: Quick feedback capture with structured signals.
+---
+
+# Capture Feedback
+
+Quickly capture structured feedback about the current task or action.
+
+## Usage
+
+Invoke this command to record a feedback signal with context and tags. If the user only gives a quick `thumbs_down`, `wrong`, or `correct`, the command should still call `capture_feedback` and pass recent context through `chatHistory`.
+
+## Steps
+
+1. Specify signal: `thumbs_up` or `thumbs_down`.
+2. If the user already gave a clear explanation, pass it as `context`.
+3. If the explanation is vague or omitted, gather the last ~10 messages plus the failed tool call into `chatHistory`.
+4. Add tags for categorization.
+5. If this is a later clarification for an existing feedback event, include `relatedFeedbackId`.
+6. Call the `capture_feedback` MCP tool and show the proposed lesson or corrective rule back to the user.
+
+## Example
+
+```
+/capture-feedback thumbs_down "Tests broke after migration" database,migration
+```
+
+```
+/capture-feedback thumbs_down
+```
+
+In the second example, the command should rely on history-aware distillation instead of refusing the signal outright.

package/plugins/cursor-marketplace/commands/check-gates.md

@@ -0,0 +1,25 @@
+---
+name: check-gates
+description: Run a Pre-Action Gate check against prevention rules before executing a risky action.
+---
+
+# Check Gates
+
+Run a pre-action gate check to verify if a planned action is safe to execute.
+
+## Usage
+
+Invoke this command before performing risky operations like deployments, force pushes, or destructive file operations.
+
+## Steps
+
+1. Describe the action you are about to take.
+2. The command queries the `prevention_rules` MCP tool to check for matching rules.
+3. If a match is found, the blocked action and corrective action are displayed.
+4. If no match is found, the action is cleared to proceed.
+
+## Example
+
+```
+/check-gates git push --force origin main
+```

package/plugins/cursor-marketplace/commands/show-lessons.md

@@ -0,0 +1,27 @@
+---
+name: show-lessons
+description: Display promoted lessons and their corrective actions.
+---
+
+# Show Lessons
+
+Display promoted lessons from the project's ThumbGate memory along with their corrective actions and linked prevention rules.
+
+## Usage
+
+Invoke this command to review what the system has learned from past failures.
+
+## Steps
+
+1. The command calls the `search_lessons` MCP tool to retrieve all active promoted lessons.
+2. Results are displayed with:
+   - Lesson description
+   - Corrective action
+   - Linked prevention rules (if any)
+   - Lifecycle state (active, archived, superseded)
+
+## Example
+
+```
+/show-lessons
+```

package/plugins/cursor-marketplace/hooks/hooks.json

@@ -0,0 +1,10 @@
+{
+  "hooks": {
+    "beforeShellExecution": [
+      {
+        "command": "./scripts/gate-check.sh",
+        "matcher": "git push|rm -rf|npm publish|deploy"
+      }
+    ]
+  }
+}

package/plugins/cursor-marketplace/mcp.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "thumbgate": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "thumbgate@latest",
+        "serve"
+      ]
+    }
+  }
+}

package/plugins/cursor-marketplace/rules/feedback-capture.mdc

@@ -0,0 +1,34 @@
+---
+description: After any mistake or unexpected behavior, prompt to capture structured feedback with context, history-aware lesson distillation, and tags.
+alwaysApply: false
+---
+
+# Feedback Capture
+
+After any mistake, unexpected behavior, or completed task, prompt to capture structured feedback.
+
+## When to trigger
+
+- A tool call produces an unexpected error
+- A test fails after code changes
+- The user corrects an approach mid-task
+- A task completes successfully (capture positive signal)
+
+## How to capture
+
+1. Call the `capture_feedback` MCP tool with:
+   - `signal`: "thumbs_up" or "thumbs_down"
+   - `context`: Brief description of what happened when the explanation is already explicit
+   - `tags`: Relevant tags (e.g., "test-failure", "wrong-approach", "deployment-error")
+   - `chatHistory`: the last ~10 messages plus the failed tool call when the signal is vague and the lesson should be inferred from recent conversation
+   - `relatedFeedbackId`: use for a later clarification that should refine an existing feedback event
+   - `rubric_scores`: Optional structured scores if a rubric applies
+
+2. Include enough context so the feedback is useful for future prevention rule generation.
+3. If the user only gives a bare thumbs signal or short correction, still capture it and let ThumbGate propose `whatWentWrong` / `whatToChange` from recent history.
+
+## Examples
+
+- Test failure after refactor: signal=thumbs_down, tags=["test-failure", "refactor"], context="Tests broke after extracting helper function — missed internal dependency"
+- Successful deployment: signal=thumbs_up, tags=["deployment", "success"], context="Clean deploy after running gate checks"
+- Vague correction after failed tool use: signal=thumbs_down, chatHistory=[last 10 messages + failed tool call], tags=["wrong-approach", "tool-failure"]

package/plugins/cursor-marketplace/rules/pre-action-gates.mdc

@@ -0,0 +1,30 @@
+---
+description: Before risky tool calls (git push, rm -rf, npm publish, deploy), check prevention rules via the thumbgate MCP server. If a rule matches, STOP and explain why.
+alwaysApply: true
+---
+
+# Pre-Action Gates
+
+Before executing any of these risky actions, query the `prevention_rules` MCP tool to check for matching prevention rules:
+
+- `git push` (especially force push)
+- `rm -rf` or recursive file deletion
+- `npm publish`
+- `deploy` commands (any deployment target)
+- Database migration commands
+- Secret or credential changes
+
+## Enforcement flow
+
+1. Extract the command or action about to be executed.
+2. Call `prevention_rules` with the action description to check for matching rules.
+3. If a rule matches:
+   - **STOP** the action immediately.
+   - Display the matched rule's description and corrective action.
+   - Ask the user to confirm before proceeding.
+4. If no rules match, proceed normally.
+
+## After a blocked action
+
+- Suggest the corrective action from the matched prevention rule.
+- Offer to capture feedback if the block was incorrect (false positive).

package/plugins/cursor-marketplace/rules/session-continuity.mdc

@@ -0,0 +1,28 @@
+---
+description: At session start, recall past context. At session end, hand off state for next session.
+alwaysApply: false
+---
+
+# Session Continuity
+
+Maintain context across coding sessions using the ThumbGate memory system.
+
+## Session start
+
+1. Call the `recall` MCP tool to retrieve:
+   - Recent prevention rules relevant to the current project
+   - Past failure patterns and corrective actions
+   - Active context packs from previous sessions
+2. Summarize recalled context before starting work.
+
+## Session end
+
+1. Capture any new feedback from the session using `capture_feedback`.
+2. Note any unfinished work or pending decisions as context for the next session.
+3. If new failure patterns emerged, flag them for potential prevention rule promotion.
+
+## Between sessions
+
+- Prevention rules persist automatically via the MCP server.
+- Lessons promoted during the session are available in future recalls.
+- Context packs expire based on configured retention policies.

package/plugins/cursor-marketplace/scripts/gate-check.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# Pre-action gate check — runs before risky shell commands.
+# Called by hooks/hooks.json beforeShellExecution hook.
+# Performs a quick health check via thumbgate doctor.
+
+set -euo pipefail
+
+npx -y thumbgate@latest doctor 2>/dev/null || {
+  echo "[gate-check] thumbgate doctor returned non-zero — review before proceeding." >&2
+  exit 1
+}

package/plugins/cursor-marketplace/skills/capture-feedback/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: capture-feedback
+description: Capture structured thumbs up/down feedback with context, history-aware lesson distillation, tags, and optional rubric scores after completing a task.
+---
+
+# Capture Feedback
+
+Record structured feedback after completing a task or encountering an issue.
+
+## When to use
+
+- After completing a coding task (positive or negative outcome)
+- When a tool call produces unexpected results
+- After a test failure or deployment issue
+- When the user explicitly wants to record feedback
+
+## How it works
+
+Use the `capture_feedback` MCP tool with:
+
+- **signal** — `"thumbs_up"` or `"thumbs_down"`
+- **context** — Description of what happened and why when the user already said it clearly
+- **tags** — Array of relevant tags for categorization (e.g., `["test-failure", "refactor"]`)
+- **chatHistory** — The last ~10 messages plus the failed tool call when the thumbs signal is vague and the lesson must be distilled from recent context
+- **relatedFeedbackId** — Use when the user adds clarifying detail later and it should refine the existing feedback event
+- **rubric_scores** — Optional object with structured quality scores
+
+## Example
+
+```
+Capture feedback: thumbs_down for the failed database migration.
+Context: Migration script dropped the wrong index, causing query timeouts.
+Tags: database, migration, production-incident
+```
+
+## Vague signal recovery
+
+If the user only says `thumbs_down`, `wrong`, `correct`, or `this failed`, do not stop there. Call `capture_feedback` with:
+
+- the signal
+- any minimal context the user already gave
+- `chatHistory` containing the recent conversation window
+- the failed tool call or command when available
+
+That lets ThumbGate propose `whatWentWrong`, `whatToChange`, and a candidate rule automatically.
+
+Feedback feeds into the prevention rule promotion pipeline. Repeated failures with the same pattern are automatically promoted into enforceable prevention rules.

package/plugins/cursor-marketplace/skills/prevention-rules/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: prevention-rules
+description: Generate and review prevention rules auto-promoted from repeated failure patterns.
+---
+
+# Prevention Rules
+
+Manage prevention rules that are auto-generated from repeated failure patterns.
+
+## When to use
+
+- Reviewing current active prevention rules for the project
+- Checking if a specific action is blocked by a prevention rule
+- Understanding why an action was blocked
+- Generating new prevention rules from observed patterns
+
+## How it works
+
+Use the `prevention_rules` MCP tool to:
+
+1. **List rules** — View all active prevention rules with their match patterns and corrective actions.
+2. **Check rules** — Test if a specific action matches any prevention rule before execution.
+3. **Review rule history** — See which feedback events led to a rule's promotion.
+
+## Example
+
+```
+Check prevention rules for "npm publish without running tests" to see if this action is blocked.
+```
+
+Prevention rules are auto-promoted when the same failure pattern appears multiple times in captured feedback. Each rule includes the original failure context and a corrective action.

package/plugins/cursor-marketplace/skills/recall-context/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: recall-context
+description: Recall relevant past failures, prevention rules, and context packs before starting a coding task.
+---
+
+# Recall Context
+
+Retrieve relevant historical context before beginning work on a coding task.
+
+## When to use
+
+- Starting a new coding task or feature
+- Before making changes to code that has failed before
+- Resuming work from a previous session
+
+## How it works
+
+Use the `recall` MCP tool to retrieve:
+
+1. **Prevention rules** — Rules auto-promoted from repeated failure patterns that apply to the current task.
+2. **Past failures** — Specific failure events with context, tags, and corrective actions.
+3. **Context packs** — Bundled project context from previous sessions.
+
+## Example
+
+```
+Use the recall MCP tool to check for known issues with the authentication module before refactoring.
+```
+
+The tool returns structured context that helps avoid repeating past mistakes and surfaces corrective actions from promoted lessons.

package/plugins/cursor-marketplace/skills/search-lessons/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: search-lessons
+description: Search promoted lessons for corrective actions, lifecycle state, linked rules, and linked gates.
+---
+
+# Search Lessons
+
+Search the promoted lessons database for corrective actions and guidance.
+
+## When to use
+
+- Looking for corrective actions for a specific failure pattern
+- Checking if a known lesson applies to the current task
+- Reviewing lifecycle state of lessons (active, archived, superseded)
+- Finding linked prevention rules and gates for a topic
+
+## How it works
+
+Use the `search_lessons` MCP tool with a query string. The tool searches across:
+
+1. **Lesson descriptions** — What happened and why
+2. **Corrective actions** — Specific steps to prevent recurrence
+3. **Linked rules** — Prevention rules generated from the lesson
+4. **Linked gates** — Pre-action gates that enforce the lesson
+5. **Lifecycle state** — Whether the lesson is active, archived, or superseded
+
+## Example
+
+```
+Search lessons for "force push" to find corrective actions and prevention rules related to force pushing.
+```
+
+Results include the full lesson context, any linked enforcement rules, and the current lifecycle state.