Evolver Cursor plugin v0.1.0: self-evolving agent memory

Native Cursor plugin (not a VSCode extension) wrapping the evolver
self-evolution engine's session hooks:
- sessionStart: inject recent successful evolution memory (workspace-scoped)
- afterFileEdit: detect improvement signals in edits
- stop: record the session outcome to local memory / EvoMap Hub

Plus a capability-evolver skill, an /evolve command, and a recall-and-record
rule. Hooks degrade gracefully without the @evomap/evolver package installed
(local memory fallback) and unlock the full review-and-solidify pipeline when
it is present. No MCP layer bundled — the gep_* tools ship separately via
@evomap/gep-mcp-server.

Hook scripts are derived from @evomap/evolver (GPL-3.0-or-later) and include
the Cursor compatibility fixes from evolver PRs #554 (project-dir resolution)
and #555 (workspace-scoped recall + bounded parse).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: autogame-17

.cursor-plugin/marketplace.json

@@ -0,0 +1,26 @@
+{
+  "name": "evolver",
+  "owner": {
+    "name": "EvoMap"
+  },
+  "plugins": [
+    {
+      "name": "evolver",
+      "source": "./",
+      "description": "Persistent, auditable evolution memory for the agent — recalls what worked, detects improvement signals, records outcomes. Powered by the Genome Evolution Protocol (GEP).",
+      "author": {
+        "name": "EvoMap"
+      },
+      "homepage": "https://evomap.ai",
+      "repository": "https://github.com/EvoMap/evolver-cursor-plugin",
+      "license": "GPL-3.0-or-later",
+      "keywords": [
+        "evolution",
+        "self-improvement",
+        "agent-memory",
+        "gep",
+        "mcp"
+      ]
+    }
+  ]
+}

.cursor-plugin/plugin.json

@@ -0,0 +1,33 @@
+{
+  "name": "evolver",
+  "displayName": "Evolver — Self-Evolving Agent Memory",
+  "description": "Gives the agent a persistent, auditable evolution memory. Recalls what worked on past tasks at session start, detects improvement signals while you edit, and records outcomes when a task ends — powered by the Genome Evolution Protocol (GEP). The hooks degrade gracefully without a local install; add the `@evomap/evolver` npm package to unlock the full review-and-solidify pipeline and EvoMap Hub sync.",
+  "version": "0.1.0",
+  "author": {
+    "name": "EvoMap",
+    "email": "team@evomap.ai"
+  },
+  "publisher": "EvoMap",
+  "homepage": "https://evomap.ai",
+  "repository": "https://github.com/EvoMap/evolver-cursor-plugin",
+  "license": "GPL-3.0-or-later",
+  "logo": "assets/logo.svg",
+  "keywords": [
+    "evolution",
+    "self-improvement",
+    "agent-memory",
+    "gep",
+    "meta-learning",
+    "evomap"
+  ],
+  "category": "developer-tools",
+  "tags": [
+    "memory",
+    "automation",
+    "self-improvement"
+  ],
+  "skills": "./skills/",
+  "commands": "./commands/",
+  "rules": "./rules/",
+  "hooks": "./hooks/hooks.json"
+}

.gitignore

@@ -0,0 +1,5 @@
+node_modules/
+*.log
+.env
+.env.*
+.DS_Store

LICENSE

@@ -0,0 +1,115 @@
+# Evolver — Self-Evolving Agent Memory (Cursor Plugin)
+
+Give the Cursor agent a **persistent, auditable evolution memory**. Instead of
+re-solving the same problem every session, the agent recalls what worked
+before, notices improvement signals as it edits, and records how each task
+turned out — so the next session starts smarter.
+
+Powered by the [Genome Evolution Protocol (GEP)](https://evomap.ai) and the
+[`@evomap/evolver`](https://github.com/EvoMap/evolver) engine.
+
+> **Status:** v0.1.0 — hooks + skill + rule. Works standalone (local memory).
+> The MCP tool surface is provided separately by
+> [`@evomap/gep-mcp-server`](https://github.com/EvoMap/gep-mcp-server) and is
+> intentionally **not** bundled here (see *Architecture* below).
+
+## What it does
+
+Three hooks run automatically — you don't invoke them:
+
+| Hook | Event | Effect |
+|---|---|---|
+| `evolver-session-start.js` | `sessionStart` | Injects a summary of recent **successful** outcomes (score ≥ 0.5, < 7 days, max 3) as context. |
+| `evolver-signal-detect.js` | `afterFileEdit` | Detects improvement signals (`log_error`, `perf_bottleneck`, `capability_gap`, …) in edits. |
+| `evolver-session-end.js` | `stop` | Classifies the task's git diff and appends the outcome to the evolution memory graph. |
+
+It also ships:
+
+- A **`capability-evolver` skill** describing the recall → work → record loop.
+- An **`/evolve` command** for a deliberate evolution checkpoint.
+- A **rule** that reminds the agent to use evolution memory on substantive work.
+
+## Install
+
+### From the Cursor Marketplace
+
+Search for **Evolver** in the Cursor plugin marketplace and install.
+
+### Local development
+
+```bash
+git clone https://github.com/EvoMap/evolver-cursor-plugin
+ln -s "$(pwd)/evolver-cursor-plugin" ~/.cursor/plugins/local/evolver
+```
+
+Reload Cursor. The hooks activate on the next session.
+
+## Requirements
+
+- **Node.js** (the hooks are Node scripts; Cursor invokes them via `node`).
+- Nothing else for local memory.
+
+## Modes
+
+### Local mode (default, zero config)
+
+Out of the box the hooks write outcomes to
+`~/.evolver/memory/evolution/memory_graph.jsonl` (or, inside an evolver-managed
+project, that project's `memory/evolution/`). Recall and record work
+immediately. **No account, no key, no network.**
+
+### Full engine
+
+```bash
+npm install -g @evomap/evolver
+```
+
+Once `@evomap/evolver` is on `PATH`, the same hooks automatically find it and
+run the **full pipeline** — automated log analysis and the review-and-solidify
+cycle that proposes and applies code improvements — instead of the local-only
+fallback. Set `EVOLVER_ROOT` to point at a specific install if you have more
+than one.
+
+### EvoMap Hub (community strategies)
+
+To sync outcomes and search strategies published by other agents, register an
+EvoMap node and set the Hub credentials in your environment:
+
+```bash
+export EVOMAP_HUB_URL="https://evomap.ai"
+export EVOMAP_API_KEY="…"     # from your EvoMap node
+export EVOMAP_NODE_ID="…"
+```
+
+The `stop` hook will then record outcomes to the Hub (with a local fallback if
+the Hub is unreachable). See the [evolver docs](https://evomap.ai) for node
+registration.
+
+## Architecture (why no bundled MCP server)
+
+EvoMap deliberately splits two products:
+
+- **`@evomap/evolver`** — the GPL-licensed, source-available evolution engine
+  (daemon + CLI). Its hook scripts are what this plugin bundles.
+- **`@evomap/gep-mcp-server`** — an Apache-licensed, standalone **protocol
+  layer** that exposes GEP capabilities as MCP tools to any MCP client.
+
+This plugin bundles the **evolver hooks** because they are exactly the
+session-lifecycle glue Cursor needs, and they degrade gracefully when the
+engine isn't installed. If you also want the `gep_*` MCP tools inside Cursor,
+add `@evomap/gep-mcp-server` to your Cursor MCP config directly — it is not
+re-bundled here to avoid duplicating that separately-maintained product.
+
+## Environment variables
+
+| Variable | Default | Purpose |
+|---|---|---|
+| `EVOLVER_ROOT` | (auto-detected) | Path to the `@evomap/evolver` install. |
+| `MEMORY_GRAPH_PATH` | (auto) | Override the memory graph file location. |
+| `EVOMAP_HUB_URL` / `EVOMAP_API_KEY` / `EVOMAP_NODE_ID` | (unset) | Enable Hub recording. |
+| `EVOLVER_HOOK_VERBOSE` | `0` | Set `1` to surface the session-end receipt inline (suppressed on Cursor by default). |
+
+## License
+
+GPL-3.0-or-later. The bundled hook scripts are derived from
+[`@evomap/evolver`](https://github.com/EvoMap/evolver). See `LICENSE`.

README.md

@@ -0,0 +1,31 @@
+---
+description: Run an evolution cycle — recall relevant past outcomes, reflect on the current task, and record what was learned.
+---
+
+# /evolve
+
+Trigger a deliberate evolution step for the current task.
+
+1. **Recall.** Look at the evolution memory the session-start hook injected (or
+   read the tail of the memory graph at
+   `~/.evolver/memory/evolution/memory_graph.jsonl`, or the project's
+   `memory/evolution/memory_graph.jsonl` if present). Summarize any recent
+   outcome — success or failure — that is relevant to what we're working on.
+
+2. **Reflect.** Given the current diff / task state, state in one or two lines:
+   what worked, what didn't, and what the durable lesson is.
+
+3. **Record.** The `stop` hook records outcomes automatically at task end. If
+   the user wants to record *now*, and the full engine is installed
+   (`@evomap/evolver` on `PATH`), run:
+
+   ```bash
+   evolver run
+   ```
+
+   to execute a full evolution cycle. If it is not installed, tell the user the
+   outcome will still be captured automatically by the stop hook, and that
+   `npm install -g @evomap/evolver` unlocks the full review-and-solidify cycle.
+
+Keep this lightweight — `/evolve` is for an explicit checkpoint, not a ceremony
+on every turn.

assets/logo.svg

@@ -0,0 +1,35 @@
+// _memoryFiltering.js
+// Shared memory filtering logic for evolver hooks (platform-independent).
+//
+// Responsibility: Filter evolution memory outcomes to reduce noise in Claude/Codex context.
+// - Removes failed outcomes (no learning value)
+// - Filters low-confidence outcomes (score < 0.5)
+// - Enforces time bounds (< 7 days old)
+// - Limits result size (max 3 outcomes)
+
+const DEFAULT_MIN_SCORE = 0.5;
+const DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+const DEFAULT_MAX_OUTCOMES = 3;
+
+function filterRelevantOutcomes(entries, opts = {}) {
+  const minScore = opts.minScore !== undefined ? opts.minScore : DEFAULT_MIN_SCORE;
+  const maxAgeMs = opts.maxAgeMs !== undefined ? opts.maxAgeMs : DEFAULT_MAX_AGE_MS;
+  const maxOutcomes = opts.maxOutcomes !== undefined ? opts.maxOutcomes : DEFAULT_MAX_OUTCOMES;
+
+  const now = Date.now();
+
+  return entries
+    .filter(e => {
+      // Only keep 'success' outcomes (failed ones don't provide learning value)
+      if (e.outcome?.status !== 'success') return false;
+      // Only keep high-confidence outcomes
+      if ((e.outcome?.score ?? 0) < minScore) return false;
+      // Only keep recent outcomes
+      const ts = e.timestamp ? new Date(e.timestamp).getTime() : 0;
+      if (now - ts > maxAgeMs) return false;
+      return true;
+    })
+    .slice(-maxOutcomes);
+}
+
+module.exports = { filterRelevantOutcomes, DEFAULT_MIN_SCORE, DEFAULT_MAX_AGE_MS, DEFAULT_MAX_OUTCOMES };