rlhf-feedback-loop 0.5.0 → 0.6.1

package/README.md

@@ -1,308 +1,77 @@
 # RLHF Feedback Loop
 
 [![CI](https://github.com/IgorGanapolsky/rlhf-feedback-loop/actions/workflows/ci.yml/badge.svg)](https://github.com/IgorGanapolsky/rlhf-feedback-loop/actions/workflows/ci.yml)
-[![Self-Healing](https://github.com/IgorGanapolsky/rlhf-feedback-loop/actions/workflows/self-healing-monitor.yml/badge.svg)](https://github.com/IgorGanapolsky/rlhf-feedback-loop/actions/workflows/self-healing-monitor.yml)
+[![npm](https://img.shields.io/npm/v/rlhf-feedback-loop)](https://www.npmjs.com/package/rlhf-feedback-loop)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
 [![MCP Ready](https://img.shields.io/badge/MCP-ready-black)](adapters/mcp/server-stdio.js)
 [![DPO Ready](https://img.shields.io/badge/DPO-ready-blue)](scripts/export-dpo-pairs.js)
 
-Production-grade RLHF operations for AI agents across ChatGPT, Claude, Gemini, Codex, and Amp.
-
-## Quick Install
-
-Install on any platform with a single command. Be capturing feedback in under 5 minutes.
-
-### Universal (any platform)
-
-```bash
-npx rlhf-feedback-loop init
-node .rlhf/capture-feedback.js --feedback=up --context="test"
-```
-
-### Claude Code
-
-```bash
-cp plugins/claude-skill/SKILL.md .claude/skills/rlhf-feedback.md
-```
-
-Full guide: [plugins/claude-skill/INSTALL.md](plugins/claude-skill/INSTALL.md)
-
-### Codex
-
-```bash
-cat adapters/codex/config.toml >> ~/.codex/config.toml
-```
-
-Full guide: [plugins/codex-profile/INSTALL.md](plugins/codex-profile/INSTALL.md)
-
-### Gemini
-
-```bash
-cp adapters/gemini/function-declarations.json .gemini/rlhf-tools.json
-```
-
-Full guide: [plugins/gemini-extension/INSTALL.md](plugins/gemini-extension/INSTALL.md)
-
-### Amp
-
-```bash
-cp plugins/amp-skill/SKILL.md .amp/skills/rlhf-feedback.md
-```
-
-Full guide: [plugins/amp-skill/INSTALL.md](plugins/amp-skill/INSTALL.md)
-
-### ChatGPT (GPT Actions)
-
-Import `adapters/chatgpt/openapi.yaml` in the GPT Builder Actions editor.
-
-Full guide: [adapters/chatgpt/INSTALL.md](adapters/chatgpt/INSTALL.md)
-
----
-
-## Value Proposition
-
-Most teams collect feedback but do not convert it into reliable behavior change.
-This project gives you a working loop:
-
-1. Capture thumbs up/down with context.
-2. Score outcomes with weighted rubrics and objective guardrails.
-3. Promote only schema-valid, rubric-eligible memories.
-4. Generate prevention rules from repeated mistakes and failed rubric dimensions.
-5. Export DPO-ready preference pairs with rubric deltas.
-6. Construct bounded context packs (constructor/loader/evaluator).
-7. Reuse the same core through API + MCP wrappers.
-8. Route intents through policy bundles with human checkpoints on high-risk actions.
-
-## Pricing
-
-| Plan | Price | What you get |
-|------|-------|-------------|
-| **Open Source** | $0 forever | Full source, self-hosted, MIT license, 314+ tests, 5-platform plugins |
-| **Cloud Pro** | $49/mo | Hosted HTTPS API on Railway, provisioned API key on payment, usage metering, email support |
-
-Get Cloud Pro: see the [landing page](docs/landing-page.html) or go straight to Stripe Checkout.
-
----
-
-## Quick Start
-
-```bash
-cp .env.example .env
-npm test
-npm run prove:adapters
-npm run prove:automation
-npm run start:api
-```
-
-Set `RLHF_API_KEY` before running the API (or explicitly set `RLHF_ALLOW_INSECURE=true` for isolated local testing only).
-
-Capture feedback:
-
-```bash
-node .claude/scripts/feedback/capture-feedback.js \
-  --feedback=down \
-  --context="Claimed done without test evidence" \
-  --what-went-wrong="No proof attached" \
-  --what-to-change="Always run tests and include output" \
-  --tags="verification,testing"
-```
-
-## Integration Adapters
-
-- ChatGPT Actions: `adapters/chatgpt/openapi.yaml`
-- Claude MCP: `adapters/claude/.mcp.json`
-- Codex MCP: `adapters/codex/config.toml`
-- Gemini tools: `adapters/gemini/function-declarations.json`
-- Amp skill: `adapters/amp/skills/rlhf-feedback/SKILL.md`
-
-## API Surface
-
-- `POST /v1/feedback/capture`
-- `GET /v1/feedback/stats`
-- `GET /v1/intents/catalog`
-- `POST /v1/intents/plan`
-- `GET /v1/feedback/summary`
-- `POST /v1/feedback/rules`
-- `POST /v1/dpo/export`
-- `POST /v1/context/construct`
-- `POST /v1/context/evaluate`
-- `GET /v1/context/provenance`
-
-Spec: `openapi/openapi.yaml`
-
-## Versioning
-
-- Package/runtime release version: `package.json`
-- API contract version: `openapi/openapi.yaml`
-- MCP server protocol version: `adapters/mcp/server-stdio.js` `serverInfo.version`
-
-## ContextFS
-
-The repo includes a file-system context substrate for multi-agent memory orchestration:
-- Constructor: relevance-ranked context pack assembly
-- Loader: strict `maxItems` + `maxChars` budgeting
-- Evaluator: outcome/provenance logging for improvement loops
-
-Docs: [docs/CONTEXTFS.md](docs/CONTEXTFS.md)
-
-## MCP Policy Profiles
-
-Use least-privilege MCP profiles based on runtime risk:
-
-- `default`: full local toolset
-- `readonly`: read-heavy operations
-- `locked`: summary-only constrained mode
-
-Config: [config/mcp-allowlists.json](config/mcp-allowlists.json)
-
-## Rubric Engine
-
-Rubric config: `config/rubrics/default-v1.json`
-
-- Weighted criteria scoring (`1-5`)
-- Multi-judge disagreement detection
-- Objective guardrail checks (`testsPassed`, `pathSafety`, `budgetCompliant`)
-- Promotion gate blocks positive memory writes on unsafe/high-disagreement signals
-
-## Intent Router
-
-Versioned orchestration bundles define intent-to-action plans and checkpoint policy:
-
-- Bundle configs: `config/policy-bundles/*.json`
-- CLI list: `npm run intents:list`
-- CLI plan: `npm run intents:plan`
-
-The router marks high-risk intents as `checkpoint_required` unless explicitly approved.
-Details: [docs/INTENT_ROUTER.md](docs/INTENT_ROUTER.md)
-
-## Autonomous GitOps
-
-The repo now ships with PR-gated autonomous operations:
-
-- `CI` (`.github/workflows/ci.yml`): required quality gate (`npm test`, adapter proof, automation proof)
-- `Agent PR Auto-Merge` (`.github/workflows/agent-automerge.yml`): auto-merges eligible agent branches (`claude/*`, `codex/*`, `auto/*`, `agent/*`) after required checks pass
-- `Dependabot Auto-Merge` (`.github/workflows/dependabot-automerge.yml`): auto-approves and merges safe dependency updates after required checks pass
-- `Self-Healing Monitor` (`.github/workflows/self-healing-monitor.yml`): scheduled health checks, auto-created alert issue on failure, remediation PR generation when fixable
-- `Self-Healing Auto-Fix` (`.github/workflows/self-healing-auto-fix.yml`): scheduled safe-fix attempts that open remediation PRs
-- `Merge Branch to Main` (`.github/workflows/merge-branch.yml`): manual fallback that still uses PR flow and branch protections
-
-Required repo settings:
-
-- `main` protected + required check(s)
-- auto-merge enabled
-- branch deletion on merge enabled
-
-Secrets:
-
-- Required: `GH_PAT` (or rely on `GITHUB_TOKEN` where permitted)
-- Optional: `SENTRY_AUTH_TOKEN`, `SENTRY_DSN`
-- Optional (LLM router): `LLM_GATEWAY_BASE_URL`, `LLM_GATEWAY_API_KEY`, `TETRATE_API_KEY`
-
-Sync helper:
-
-```bash
-bash scripts/sync-gh-secrets-from-env.sh IgorGanapolsky/rlhf-feedback-loop
-```
+**Make your AI agent learn from mistakes.** Capture thumbs up/down feedback, block repeated failures, and export DPO training data — across ChatGPT, Claude, Codex, Gemini, and Amp.
 
 ## Architecture
 
-### RLHF Feedback Loop
+![RLHF Architecture](docs/diagrams/rlhf-architecture-pb.png)
 
-```mermaid
-flowchart TD
-    A["👍/👎 User Feedback"] --> B["Capture Layer\n(context + tags)"]
-    B --> C{"Action Resolver"}
-    C -->|store-learning| D["Schema Validator"]
-    C -->|store-mistake| D
-    C -->|no-action| X["Discard"]
-    D -->|valid| E["Memory Store\n(learning / error)"]
-    D -->|invalid| X
-    E --> F["Analytics\n(trends + recurrence)"]
-    F --> G["Prevention Rules Engine"]
-    F --> H["DPO Export\n(prompt/chosen/rejected)"]
-    E --> I["Rubric Engine\n(weighted scoring + guardrails)"]
-    I -->|promotion gate| E
-```
+![Plugin Topology](docs/diagrams/plugin-topology-pb.png)
 
-### Plugin Topology
+## Get Started
 
-```mermaid
-flowchart LR
-    subgraph Adapters
-        GPT["ChatGPT\n(GPT Actions)"]
-        CL["Claude\n(MCP Server)"]
-        CX["Codex\n(MCP Config)"]
-        GEM["Gemini\n(Function Calling)"]
-        AMP["Amp\n(Skills Template)"]
-    end
+One command. Pick your platform:
 
-    subgraph Core["RLHF Feedback API"]
-        SV["Schema Validation"]
-        PR["Prevention Rules"]
-        DPO["DPO Export"]
-        BG["Budget Guard\n($10/mo cap)"]
-    end
-
-    GPT <--> Core
-    CL <--> Core
-    CX <--> Core
-    GEM <--> Core
-    AMP <--> Core
-```
+| Platform | Install |
+|----------|---------|
+| **Claude** | `claude mcp add rlhf -- npx -y rlhf-feedback-loop serve` |
+| **Codex** | `codex mcp add rlhf -- npx -y rlhf-feedback-loop serve` |
+| **Gemini** | `gemini mcp add rlhf -- npx -y rlhf-feedback-loop serve` |
+| **All at once** | `npx add-mcp rlhf-feedback-loop` |
 
-### PaperBanana (high-fidelity PNG)
+That's it. Your agent can now capture feedback, recall past learnings mid-conversation, and block repeated mistakes.
 
-Generate richer architecture visuals with a budget guard:
+## How It Works
 
-```bash
-npm run diagrams:paperbanana
-npm run budget:status
+```
+Thumbs up/down
+      |
+      v
+  Capture → JSONL log
+      |
+      v
+  Rubric engine (block false positives)
+      |
+  +---+---+
+  |       |
+ Good    Bad
+  |       |
+  v       v
+Learn   Prevention rule
+  |       |
+  v       v
+LanceDB   ShieldCortex
+vectors   context packs
+  |
+  v
+DPO export → fine-tune your model
 ```
 
-Docs: [docs/PAPERBANANA.md](docs/PAPERBANANA.md)
-Verification evidence: [docs/VERIFICATION_EVIDENCE.md](docs/VERIFICATION_EVIDENCE.md)
-Compatibility proof artifacts: [proof/compatibility/report.md](proof/compatibility/report.md), [proof/compatibility/report.json](proof/compatibility/report.json)
-Automation proof artifacts: [proof/automation/report.md](proof/automation/report.md), [proof/automation/report.json](proof/automation/report.json)
-
-## Budget Guardrail
-
-Default monthly cap is `$10` for paid external operations.
-The local budget ledger blocks additional spend if cap would be exceeded.
-
-## Semantic Cache (Cost + Latency)
-
-Context pack construction now supports semantic cache reuse for similar queries:
-
-- token-overlap (Jaccard) similarity gate
-- TTL-bound cache entries
-- full provenance (`context_pack_cache_hit`)
-
-Environment toggles:
-
-- `RLHF_SEMANTIC_CACHE_ENABLED=true|false` (default `true`)
-- `RLHF_SEMANTIC_CACHE_THRESHOLD=0.7`
-- `RLHF_SEMANTIC_CACHE_TTL_SECONDS=86400`
-
-This directly reduces repeated retrieval/LLM context assembly work and improves response latency under budget constraints.
-
-## Optional Tetrate Router
+All data stored locally as **JSONL** files — fully transparent, fully portable, no vendor lock-in. **LanceDB** indexes memories as vector embeddings for semantic search. **ShieldCortex** assembles context packs so your agent starts each task informed.
 
-Not required for core local RLHF logic.
-Recommended only when routing paid LLM calls (PaperBanana, external judges, hosted control-plane features):
+## Why This Exists
 
-- centralized provider routing
-- price/fallback control
-- unified usage observability
+| Problem | What this does |
+|---------|---------------|
+| Agent keeps making the same mistake | Prevention rules auto-generated from repeated failures |
+| Agent claims "done" without proof | Rubric engine blocks positive feedback without test evidence |
+| Feedback collected but never used | DPO pairs exported for actual model fine-tuning |
+| Different tools, different formats | One MCP server works across 5 platforms |
+| Agent starts every task blank | In-session recall injects past learnings into current conversation |
 
-## Commercialization
+## Deep Dive
 
-- OSS core for adoption
-- Hosted control plane for teams
-- Enterprise support and compliance features
+- [API Reference](openapi/openapi.yaml) — full OpenAPI spec
+- [Context Engine](docs/CONTEXTFS.md) — multi-agent memory orchestration
+- [Autonomous GitOps](docs/AUTONOMOUS_GITOPS.md) — self-healing CI/CD
+- [Contributing](CONTRIBUTING.md)
 
-See:
+## License
 
-- [docs/PACKAGING_AND_SALES_PLAN.md](docs/PACKAGING_AND_SALES_PLAN.md)
-- [docs/PLATFORM_RESEARCH_2026-03-03.md](docs/PLATFORM_RESEARCH_2026-03-03.md)
-- [docs/PLUGIN_DISTRIBUTION.md](docs/PLUGIN_DISTRIBUTION.md)
-- [docs/AUTONOMOUS_GITOPS.md](docs/AUTONOMOUS_GITOPS.md)
+MIT. See [LICENSE](LICENSE).

package/adapters/mcp/server-stdio.js

@@ -31,6 +31,9 @@ const {
   getAllowedTools,
   assertToolAllowed,
 } = require('../../scripts/mcp-policy');
+const {
+  searchSimilar,
+} = require('../../scripts/vector-store');
 
 const SERVER_INFO = {
   name: 'rlhf-feedback-loop-mcp',
@@ -212,6 +215,18 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'recall',
+    description: 'Recall relevant past feedback, memories, and prevention rules for the current task. Call this at the start of any task to inject past learnings into the conversation.',
+    inputSchema: {
+      type: 'object',
+      required: ['query'],
+      properties: {
+        query: { type: 'string', description: 'Describe the current task or context to find relevant past feedback' },
+        limit: { type: 'number', description: 'Max memories to return (default 5)' },
+      },
+    },
+  },
 ];
 
 function toText(result) {
@@ -237,6 +252,56 @@ function parseOptionalObject(input, name) {
 async function callTool(name, args = {}) {
   assertToolAllowed(name, getActiveMcpProfile());
 
+  if (name === 'recall') {
+    const query = args.query || '';
+    const limit = Number(args.limit || 5);
+    const parts = [];
+
+    // 1. Vector search for similar past feedback
+    try {
+      const similar = await searchSimilar(query, limit);
+      if (similar.length > 0) {
+        parts.push('## Relevant Past Feedback\n');
+        for (const mem of similar) {
+          const signal = mem.signal === 'positive' ? 'GOOD' : 'BAD';
+          parts.push(`**[${signal}]** ${mem.context}`);
+          if (mem.tags) parts.push(`  Tags: ${mem.tags}`);
+          parts.push('');
+        }
+      }
+    } catch (_) {
+      // Vector store may not be initialized yet — fall back to JSONL
+    }
+
+    // 2. Load prevention rules
+    try {
+      const rulesPath = path.join(SAFE_DATA_DIR, 'prevention-rules.md');
+      if (fs.existsSync(rulesPath)) {
+        const rules = fs.readFileSync(rulesPath, 'utf8').trim();
+        if (rules.length > 50) {
+          parts.push('## Active Prevention Rules\n');
+          parts.push(rules);
+          parts.push('');
+        }
+      }
+    } catch (_) {}
+
+    // 3. Recent feedback summary
+    try {
+      const summary = feedbackSummary(10);
+      if (summary) {
+        parts.push('## Recent Feedback Summary\n');
+        parts.push(summary);
+      }
+    } catch (_) {}
+
+    const text = parts.length > 0
+      ? parts.join('\n')
+      : 'No past feedback found. This appears to be a fresh start.';
+
+    return { content: [{ type: 'text', text }] };
+  }
+
   if (name === 'capture_feedback') {
     const result = captureFeedback({
       signal: args.signal,
@@ -249,7 +314,22 @@ async function callTool(name, args = {}) {
       tags: args.tags || [],
       skill: args.skill,
     });
-    return { content: [{ type: 'text', text: toText(result) }] };
+
+    // Auto-recall: after capturing, return relevant context so the agent
+    // can immediately adjust behavior based on past learnings
+    let recallText = '';
+    try {
+      const similar = await searchSimilar(args.context || '', 3);
+      if (similar.length > 0) {
+        recallText = '\n\n---\n## Related Past Feedback (auto-recall)\n';
+        for (const mem of similar) {
+          const signal = mem.signal === 'positive' ? 'GOOD' : 'BAD';
+          recallText += `- **[${signal}]** ${mem.context}\n`;
+        }
+      }
+    } catch (_) {}
+
+    return { content: [{ type: 'text', text: toText(result) + recallText }] };
   }
 
   if (name === 'feedback_summary') {

package/bin/cli.js

@@ -3,23 +3,131 @@
  * rlhf-feedback-loop CLI
  *
  * Usage:
- *   npx rlhf-feedback-loop init
- *
- * Creates a .rlhf/ directory with config and capture script for local use.
+ *   npx rlhf-feedback-loop init          # scaffold .rlhf/ config + .mcp.json
+ *   npx rlhf-feedback-loop capture       # capture feedback
+ *   npx rlhf-feedback-loop export-dpo    # export DPO training pairs
+ *   npx rlhf-feedback-loop stats         # feedback analytics
+ *   npx rlhf-feedback-loop rules         # generate prevention rules
+ *   npx rlhf-feedback-loop self-heal     # run self-healing check + fix
+ *   npx rlhf-feedback-loop prove         # run proof harness
+ *   npx rlhf-feedback-loop start-api     # start HTTPS API server
  */
 
 'use strict';
 
 const fs = require('fs');
 const path = require('path');
+const { execSync } = require('child_process');
 
 const COMMAND = process.argv[2];
 const CWD = process.cwd();
+const PKG_ROOT = path.join(__dirname, '..');
+
+function parseArgs(argv) {
+  const args = {};
+  argv.forEach((arg) => {
+    if (!arg.startsWith('--')) return;
+    const [key, ...rest] = arg.slice(2).split('=');
+    args[key] = rest.length ? rest.join('=') : true;
+  });
+  return args;
+}
+
+function pkgVersion() {
+  const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8'));
+  return pkg.version;
+}
+
+// --- Platform auto-detection helpers ---
+
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+const MCP_SERVER_ENTRY = {
+  command: 'node',
+  args: [path.relative(CWD, path.join(PKG_ROOT, 'adapters', 'mcp', 'server-stdio.js'))],
+};
+
+function mergeMcpJson(filePath, label) {
+  if (!fs.existsSync(filePath)) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify({ mcpServers: { 'rlhf-feedback-loop': MCP_SERVER_ENTRY } }, null, 2) + '\n');
+    console.log(`  ${label}: wrote ${path.relative(CWD, filePath)}`);
+    return true;
+  }
+  const existing = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  if (existing.mcpServers && existing.mcpServers['rlhf-feedback-loop']) return false;
+  existing.mcpServers = existing.mcpServers || {};
+  existing.mcpServers['rlhf-feedback-loop'] = MCP_SERVER_ENTRY;
+  fs.writeFileSync(filePath, JSON.stringify(existing, null, 2) + '\n');
+  console.log(`  ${label}: updated ${path.relative(CWD, filePath)}`);
+  return true;
+}
+
+function detectPlatform(name, checks) {
+  for (const check of checks) {
+    try { if (check()) return true; } catch (_) {}
+  }
+  return false;
+}
+
+function whichExists(cmd) {
+  try { execSync(`which ${cmd}`, { stdio: 'pipe' }); return true; } catch (_) { return false; }
+}
+
+function setupClaude() {
+  return mergeMcpJson(path.join(CWD, '.mcp.json'), 'Claude Code');
+}
+
+function setupCodex() {
+  const configPath = path.join(HOME, '.codex', 'config.toml');
+  const block = `\n[mcp_servers.rlhf_feedback_loop]\ncommand = "node"\nargs = ["${MCP_SERVER_ENTRY.args[0]}"]\n`;
+  if (!fs.existsSync(configPath)) {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, block);
+    console.log('  Codex: created ~/.codex/config.toml');
+    return true;
+  }
+  const content = fs.readFileSync(configPath, 'utf8');
+  if (content.includes('[mcp_servers.rlhf_feedback_loop]')) return false;
+  fs.appendFileSync(configPath, block);
+  console.log('  Codex: appended MCP server to ~/.codex/config.toml');
+  return true;
+}
+
+function setupGemini() {
+  const settingsPath = path.join(HOME, '.gemini', 'settings.json');
+  if (fs.existsSync(settingsPath)) {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    if (settings.mcpServers && settings.mcpServers['rlhf-feedback-loop']) return false;
+    settings.mcpServers = settings.mcpServers || {};
+    settings.mcpServers['rlhf-feedback-loop'] = MCP_SERVER_ENTRY;
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+    console.log('  Gemini: updated ~/.gemini/settings.json');
+    return true;
+  }
+  // Fallback: project-level .gemini/settings.json
+  return mergeMcpJson(path.join(CWD, '.gemini', 'settings.json'), 'Gemini');
+}
+
+function setupAmp() {
+  const skillDir = path.join(CWD, '.amp', 'skills', 'rlhf-feedback');
+  const destPath = path.join(skillDir, 'SKILL.md');
+  if (fs.existsSync(destPath)) return false;
+  const srcPath = path.join(PKG_ROOT, 'plugins', 'amp-skill', 'SKILL.md');
+  if (!fs.existsSync(srcPath)) return false;
+  fs.mkdirSync(skillDir, { recursive: true });
+  fs.copyFileSync(srcPath, destPath);
+  console.log('  Amp: installed .amp/skills/rlhf-feedback/SKILL.md');
+  return true;
+}
+
+function setupCursor() {
+  return mergeMcpJson(path.join(CWD, '.cursor', 'mcp.json'), 'Cursor');
+}
 
 function init() {
   const rlhfDir = path.join(CWD, '.rlhf');
 
-  // Create directory
   if (!fs.existsSync(rlhfDir)) {
     fs.mkdirSync(rlhfDir, { recursive: true });
     console.log('Created .rlhf/');
@@ -27,130 +135,236 @@ function init() {
     console.log('.rlhf/ already exists — updating config');
   }
 
-  // Write config.json
   const config = {
-    version: '0.5.0',
+    version: pkgVersion(),
     apiUrl: process.env.RLHF_API_URL || 'http://localhost:3000',
     logPath: '.rlhf/feedback-log.jsonl',
     memoryPath: '.rlhf/memory-log.jsonl',
     createdAt: new Date().toISOString(),
   };
 
-  const configPath = path.join(rlhfDir, 'config.json');
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+  fs.writeFileSync(path.join(rlhfDir, 'config.json'), JSON.stringify(config, null, 2) + '\n');
   console.log('Wrote .rlhf/config.json');
 
-  // Copy capture-feedback script (inline minimal version for standalone use)
-  const captureScript = `#!/usr/bin/env node
-/**
- * Standalone feedback capture script — created by npx rlhf-feedback-loop init
- * Full version: https://github.com/IgorGanapolsky/rlhf-feedback-loop
- *
- * Usage:
- *   node .rlhf/capture-feedback.js --feedback=up --context="that worked great" --tags="testing"
- *   node .rlhf/capture-feedback.js --feedback=down --context="missed edge case" --what-went-wrong="..." --what-to-change="..."
- */
+  // Always create .mcp.json (project-level MCP config used by Claude, Codex, Cursor)
+  mergeMcpJson(path.join(CWD, '.mcp.json'), 'MCP');
 
-'use strict';
+  // Auto-detect and configure platform-specific locations
+  console.log('');
+  console.log('Detecting platforms...');
+  let configured = 0;
 
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
+  const platforms = [
+    { name: 'Codex', detect: [() => whichExists('codex'), () => fs.existsSync(path.join(HOME, '.codex'))], setup: setupCodex },
+    { name: 'Gemini', detect: [() => whichExists('gemini'), () => fs.existsSync(path.join(HOME, '.gemini'))], setup: setupGemini },
+    { name: 'Amp', detect: [() => whichExists('amp'), () => fs.existsSync(path.join(HOME, '.amp'))], setup: setupAmp },
+    { name: 'Cursor', detect: [() => fs.existsSync(path.join(HOME, '.cursor', 'mcp.json')), () => fs.existsSync(path.join(CWD, '.cursor'))], setup: setupCursor },
+  ];
 
-const CONFIG_PATH = path.join(__dirname, 'config.json');
-const config = fs.existsSync(CONFIG_PATH) ? JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8')) : {};
-const LOG_PATH = path.join(process.cwd(), config.logPath || '.rlhf/feedback-log.jsonl');
+  for (const p of platforms) {
+    if (detectPlatform(p.name, p.detect)) {
+      const didSetup = p.setup();
+      if (didSetup) configured++;
+      else console.log(`  ${p.name}: already configured`);
+    }
+  }
 
-function parseArgs(argv) {
-  const args = {};
-  argv.forEach((arg) => {
-    if (!arg.startsWith('--')) return;
-    const [key, ...rest] = arg.slice(2).split('=');
-    args[key] = rest.length ? rest.join('=') : true;
-  });
-  return args;
-}
+  // ChatGPT — cannot be automated
+  const chatgptSpec = path.join(PKG_ROOT, 'adapters', 'chatgpt', 'openapi.yaml');
+  if (fs.existsSync(chatgptSpec)) {
+    console.log(`  ChatGPT: import ${path.relative(CWD, chatgptSpec)} in GPT Builder > Actions`);
+  }
 
-const args = parseArgs(process.argv.slice(2));
-const signal = args.feedback || args.signal;
+  if (configured === 0) console.log('  All detected platforms already configured.');
 
-if (!signal) {
-  console.error('Error: --feedback=up or --feedback=down required');
-  console.error('Usage: node .rlhf/capture-feedback.js --feedback=up --context="..."');
-  process.exit(1);
+  // .gitignore
+  const gitignorePath = path.join(CWD, '.gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    const gitignore = fs.readFileSync(gitignorePath, 'utf8');
+    const entries = ['.rlhf/feedback-log.jsonl', '.rlhf/memory-log.jsonl'];
+    const missing = entries.filter((e) => !gitignore.includes(e));
+    if (missing.length > 0) {
+      fs.appendFileSync(gitignorePath, '\n# RLHF local feedback data\n' + missing.join('\n') + '\n');
+      console.log('Updated .gitignore');
+    }
+  }
+
+  console.log('');
+  console.log(`rlhf-feedback-loop v${pkgVersion()} initialized.`);
+  console.log('Run: npx rlhf-feedback-loop help');
 }
 
-const normalized = ['up', 'thumbs_up', 'positive'].includes(signal) ? 'up' : 'down';
+function capture() {
+  const args = parseArgs(process.argv.slice(3));
 
-const entry = {
-  id: \`fb-\${Date.now()}-\${Math.random().toString(36).slice(2, 7)}\`,
-  signal: normalized,
-  context: args.context || '',
-  whatWentWrong: args['what-went-wrong'] || undefined,
-  whatToChange: args['what-to-change'] || undefined,
-  whatWorked: args['what-worked'] || undefined,
-  tags: args.tags ? args.tags.split(',').map((t) => t.trim()) : [],
-  timestamp: new Date().toISOString(),
-  hostname: os.hostname(),
-};
+  // Delegate to the full engine
+  const { captureFeedback, analyzeFeedback, feedbackSummary, writePreventionRules } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
+
+  if (args.stats) {
+    console.log(JSON.stringify(analyzeFeedback(), null, 2));
+    return;
+  }
 
-// Remove undefined fields
-Object.keys(entry).forEach((k) => entry[k] === undefined && delete entry[k]);
+  if (args.summary) {
+    console.log(feedbackSummary(Number(args.recent || 20)));
+    return;
+  }
 
-// Ensure log directory exists
-const logDir = path.dirname(LOG_PATH);
-if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+  // Normalize signal with fuzzy matching (uses the full engine's normalize)
+  const captureScript = require(path.join(PKG_ROOT, '.claude', 'scripts', 'feedback', 'capture-feedback.js'));
+  // The capture-feedback.js runs as main when required directly, so we call via subprocess
+  const scriptArgs = process.argv.slice(3).join(' ');
+  try {
+    const output = execSync(
+      `node "${path.join(PKG_ROOT, '.claude', 'scripts', 'feedback', 'capture-feedback.js')}" ${scriptArgs}`,
+      { encoding: 'utf8', stdio: 'pipe', cwd: CWD }
+    );
+    process.stdout.write(output);
+  } catch (err) {
+    process.stderr.write(err.stderr || err.stdout || err.message);
+    process.exit(err.status || 1);
+  }
+}
 
-fs.appendFileSync(LOG_PATH, JSON.stringify(entry) + '\\n');
-console.log(\`Feedback captured [\${normalized}]: \${entry.id}\`);
-console.log(\`Logged to: \${LOG_PATH}\`);
-`;
+function stats() {
+  const { analyzeFeedback } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
+  console.log(JSON.stringify(analyzeFeedback(), null, 2));
+}
+
+function summary() {
+  const args = parseArgs(process.argv.slice(3));
+  const { feedbackSummary } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
+  console.log(feedbackSummary(Number(args.recent || 20)));
+}
 
-  const scriptPath = path.join(rlhfDir, 'capture-feedback.js');
-  fs.writeFileSync(scriptPath, captureScript);
-  // Make executable
+function exportDpo() {
   try {
-    fs.chmodSync(scriptPath, '755');
-  } catch (_) {
-    // chmod may not be available on all platforms — not fatal
+    const output = execSync(
+      `node "${path.join(PKG_ROOT, 'scripts', 'export-dpo-pairs.js')}"`,
+      { encoding: 'utf8', stdio: 'pipe', cwd: CWD }
+    );
+    process.stdout.write(output);
+  } catch (err) {
+    process.stderr.write(err.stderr || err.stdout || err.message);
+    process.exit(err.status || 1);
   }
-  console.log('Wrote .rlhf/capture-feedback.js');
+}
 
-  // Add .rlhf/feedback-log.jsonl to .gitignore if it exists
-  const gitignorePath = path.join(CWD, '.gitignore');
-  if (fs.existsSync(gitignorePath)) {
-    const gitignore = fs.readFileSync(gitignorePath, 'utf8');
-    const entries = ['.rlhf/feedback-log.jsonl', '.rlhf/memory-log.jsonl'];
-    const missing = entries.filter((e) => !gitignore.includes(e));
-    if (missing.length > 0) {
-      fs.appendFileSync(gitignorePath, '\n# RLHF local feedback data\n' + missing.join('\n') + '\n');
-      console.log('Updated .gitignore with RLHF data paths');
-    }
+function rules() {
+  const args = parseArgs(process.argv.slice(3));
+  const { writePreventionRules } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
+  const outPath = args.output || path.join(CWD, '.rlhf', 'prevention-rules.md');
+  const result = writePreventionRules(outPath, Number(args.min || 2));
+  console.log(`Wrote prevention rules to ${result.path}`);
+}
+
+function selfHeal() {
+  try {
+    const output = execSync(
+      `node "${path.join(PKG_ROOT, 'scripts', 'self-healing-check.js')}" && node "${path.join(PKG_ROOT, 'scripts', 'self-heal.js')}"`,
+      { encoding: 'utf8', stdio: 'inherit', cwd: CWD }
+    );
+  } catch (err) {
+    process.exit(err.status || 1);
   }
+}
 
-  console.log('');
-  console.log('Setup complete! Run:');
-  console.log("  node .rlhf/capture-feedback.js --feedback=up --context='test'");
-  console.log('');
-  console.log('Full docs: https://github.com/IgorGanapolsky/rlhf-feedback-loop');
+function prove() {
+  const args = parseArgs(process.argv.slice(3));
+  const target = args.target || 'adapters';
+  const script = path.join(PKG_ROOT, 'scripts', `prove-${target}.js`);
+  if (!fs.existsSync(script)) {
+    console.error(`Unknown proof target: ${target}`);
+    console.error('Available: adapters, automation, attribution, lancedb, data-quality, intelligence, loop-closure, training-export');
+    process.exit(1);
+  }
+  try {
+    execSync(`node "${script}"`, { encoding: 'utf8', stdio: 'inherit', cwd: CWD });
+  } catch (err) {
+    process.exit(err.status || 1);
+  }
+}
+
+function serve() {
+  // Start MCP server over stdio — used by `claude mcp add`, `codex mcp add`, `gemini mcp add`
+  const mcpServer = path.join(PKG_ROOT, 'adapters', 'mcp', 'server-stdio.js');
+  require(mcpServer);
+}
+
+function startApi() {
+  const serverPath = path.join(PKG_ROOT, 'src', 'api', 'server.js');
+  try {
+    execSync(`node "${serverPath}"`, { stdio: 'inherit', cwd: CWD });
+  } catch (err) {
+    process.exit(err.status || 1);
+  }
 }
 
 function help() {
-  console.log('rlhf-feedback-loop CLI');
+  const v = pkgVersion();
+  console.log(`rlhf-feedback-loop v${v}`);
   console.log('');
   console.log('Commands:');
-  console.log('  init    Scaffold .rlhf/ config and capture script in current directory');
-  console.log('  help    Show this help message');
+  console.log('  init                  Scaffold .rlhf/ config + MCP server in current project');
+  console.log('  serve                 Start MCP server (stdio) — for claude/codex/gemini mcp add');
+  console.log('  capture [flags]       Capture feedback (--feedback=up|down --context="..." --tags="...")');
+  console.log('  stats                 Show feedback analytics');
+  console.log('  summary               Human-readable feedback summary');
+  console.log('  export-dpo            Export DPO training pairs (prompt/chosen/rejected JSONL)');
+  console.log('  rules                 Generate prevention rules from repeated failures');
+  console.log('  self-heal             Run self-healing check and auto-fix');
+  console.log('  prove [--target=X]    Run proof harness (adapters|automation|attribution|lancedb|...)');
+  console.log('  start-api             Start the RLHF HTTPS API server');
+  console.log('  help                  Show this help message');
   console.log('');
   console.log('Examples:');
   console.log('  npx rlhf-feedback-loop init');
-  console.log('  node .rlhf/capture-feedback.js --feedback=up --context="great result"');
+  console.log('  npx rlhf-feedback-loop capture --feedback=up --context="all tests pass"');
+  console.log('  npx rlhf-feedback-loop capture --feedback=down --context="broke prod" --what-went-wrong="no tests"');
+  console.log('  npx rlhf-feedback-loop export-dpo');
+  console.log('  npx rlhf-feedback-loop stats');
+  console.log('');
+  console.log('MCP install (one command per platform):');
+  console.log('  claude mcp add rlhf -- npx -y rlhf-feedback-loop serve');
+  console.log('  codex mcp add rlhf -- npx -y rlhf-feedback-loop serve');
+  console.log('  gemini mcp add rlhf -- npx -y rlhf-feedback-loop serve');
 }
 
 switch (COMMAND) {
   case 'init':
     init();
     break;
+  case 'serve':
+  case 'mcp':
+    serve();
+    break;
+  case 'capture':
+  case 'feedback':
+    capture();
+    break;
+  case 'stats':
+    stats();
+    break;
+  case 'summary':
+    summary();
+    break;
+  case 'export-dpo':
+  case 'dpo':
+    exportDpo();
+    break;
+  case 'rules':
+    rules();
+    break;
+  case 'self-heal':
+    selfHeal();
+    break;
+  case 'prove':
+    prove();
+    break;
+  case 'start-api':
+  case 'serve':
+    startApi();
+    break;
   case 'help':
   case '--help':
   case '-h':

package/config/mcp-allowlists.json

@@ -2,6 +2,7 @@
   "version": 1,
   "profiles": {
     "default": [
+      "recall",
       "capture_feedback",
       "feedback_summary",
       "feedback_stats",
@@ -14,6 +15,7 @@
       "context_provenance"
     ],
     "readonly": [
+      "recall",
       "feedback_summary",
       "feedback_stats",
       "list_intents",

package/package.json

@@ -1,7 +1,15 @@
 {
   "name": "rlhf-feedback-loop",
-  "version": "0.5.0",
-  "description": "Production-grade RLHF feedback operations for coding agents: capture thumbs signals, enforce schema quality, prevent repeated mistakes, and export DPO pairs.",
+  "version": "0.6.1",
+  "description": "Make your AI agent learn from mistakes. Capture thumbs up/down feedback, block repeated failures, export DPO training data. Works with ChatGPT, Claude, Codex, Gemini, Amp.",
+  "homepage": "https://github.com/IgorGanapolsky/rlhf-feedback-loop#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/IgorGanapolsky/rlhf-feedback-loop.git"
+  },
+  "bugs": {
+    "url": "https://github.com/IgorGanapolsky/rlhf-feedback-loop/issues"
+  },
   "main": "scripts/feedback-loop.js",
   "bin": {
     "rlhf-feedback-loop": "./bin/cli.js"
@@ -25,8 +33,8 @@
     "test:schema": "node scripts/feedback-schema.js --test",
     "test:loop": "node scripts/feedback-loop.js --test",
     "test:dpo": "node scripts/export-dpo-pairs.js --test",
-    "test:api": "node --test tests/api-server.test.js tests/api-auth-config.test.js tests/mcp-server.test.js tests/adapters.test.js tests/openapi-parity.test.js tests/budget-guard.test.js tests/contextfs.test.js tests/mcp-policy.test.js tests/subagent-profiles.test.js tests/intent-router.test.js tests/rubric-engine.test.js tests/self-healing-check.test.js tests/self-heal.test.js tests/feedback-schema.test.js tests/thompson-sampling.test.js tests/feedback-sequences.test.js tests/diversity-tracking.test.js tests/vector-store.test.js tests/feedback-attribution.test.js tests/hybrid-feedback-context.test.js tests/loop-closure.test.js tests/code-reasoning.test.js",
-    "test:proof": "node --test tests/prove-adapters.test.js tests/prove-automation.test.js",
+    "test:api": "node --test tests/api-server.test.js tests/api-auth-config.test.js tests/mcp-server.test.js tests/adapters.test.js tests/openapi-parity.test.js tests/budget-guard.test.js tests/contextfs.test.js tests/mcp-policy.test.js tests/subagent-profiles.test.js tests/intent-router.test.js tests/rubric-engine.test.js tests/self-healing-check.test.js tests/self-heal.test.js tests/feedback-schema.test.js tests/thompson-sampling.test.js tests/feedback-sequences.test.js tests/diversity-tracking.test.js tests/vector-store.test.js tests/feedback-attribution.test.js tests/hybrid-feedback-context.test.js tests/loop-closure.test.js tests/code-reasoning.test.js tests/feedback-loop.test.js tests/feedback-inbox-read.test.js tests/feedback-to-memory.test.js",
+    "test:proof": "node --test tests/prove-adapters.test.js tests/prove-automation.test.js tests/prove-attribution.test.js tests/prove-lancedb.test.js tests/prove-data-quality.test.js tests/prove-intelligence.test.js tests/prove-loop-closure.test.js tests/prove-subway-upgrades.test.js tests/prove-training-export.test.js",
     "test:rlaif": "node --test tests/rlaif-self-audit.test.js tests/dpo-optimizer.test.js tests/meta-policy.test.js",
     "test:attribution": "node --test tests/feedback-attribution.test.js tests/hybrid-feedback-context.test.js",
     "test:quality": "node --test tests/validate-feedback.test.js",
@@ -79,13 +87,24 @@
     "claude",
     "codex",
     "gemini",
+    "chatgpt",
+    "amp",
+    "mcp",
+    "model-context-protocol",
     "agent-evaluation",
-    "prompt-engineering"
+    "prompt-engineering",
+    "context-engineering",
+    "ai-safety",
+    "machine-learning",
+    "openapi",
+    "developer-tools"
   ],
   "license": "MIT",
   "dependencies": {
     "@huggingface/transformers": "^3.8.1",
     "@lancedb/lancedb": "^0.26.2",
-    "apache-arrow": "^18.1.0"
-  }
+    "apache-arrow": "^18.1.0",
+    "stripe": "^20.4.0"
+  },
+  "mcpName": "io.github.igorganapolsky/rlhf-feedback-loop"
 }

package/plugins/amp-skill/SKILL.md

@@ -1,31 +1,64 @@
 ---
 name: rlhf-feedback
-description: Capture thumbs feedback and apply prevention rules before coding
+description: Dual-write feedback to Amp MCP memory AND rlhf-feedback-loop for DPO export, analytics, and cross-platform portability
 ---
 
-# Amp RLHF Skill
+# RLHF Feedback Skill (Dual-Write)
 
-On explicit user feedback:
+This skill captures feedback in TWO places simultaneously:
+1. **Amp MCP memory** — for immediate in-session recall (native to Amp)
+2. **rlhf-feedback-loop** — for DPO export, LanceDB vectors, prevention rules, and cross-platform analytics
 
+## On thumbs up / positive feedback
+
+First, store in Amp's native memory for in-session recall:
+```
+Use mcp__memory__remember to store: "GOOD: {context}. What worked: {details}"
+```
+
+Then, pipe to rlhf-feedback-loop for DPO export and analytics:
+```bash
+npx -y rlhf-feedback-loop capture --feedback=up --context="..." --what-worked="..." --tags="..."
+```
+
+## On thumbs down / negative feedback
+
+First, store in Amp's native memory so the mistake is recalled immediately:
+```
+Use mcp__memory__remember to store: "BAD: {context}. What went wrong: {details}. Fix: {what to change}"
+```
+
+Then, pipe to rlhf-feedback-loop for prevention rules and DPO pairs:
 ```bash
-node .rlhf/capture-feedback.js --feedback=up --context="..." --tags="..."
-node .rlhf/capture-feedback.js --feedback=down --context="..." --what-went-wrong="..." --what-to-change="..." --tags="..."
+npx -y rlhf-feedback-loop capture --feedback=down --context="..." --what-went-wrong="..." --what-to-change="..." --tags="..."
 ```
 
-Before major implementation:
+## Before starting a new task
+
+Recall from Amp's memory (instant, in-session):
+```
+Use mcp__memory__recall with query describing the current task
+```
 
+Also check rlhf-feedback-loop for cross-session prevention rules:
 ```bash
-node .rlhf/capture-feedback.js --feedback=up --context="session start" --tags="session" 2>/dev/null || true
+npx -y rlhf-feedback-loop rules
 ```
 
 ## Triggers
 
-- "thumbs up" / "that worked" / "looks good"
-- "thumbs down" / "that failed" / "that was wrong"
+- "thumbs up" / "that worked" / "looks good" / "nice" / "perfect"
+- "thumbs down" / "that failed" / "that was wrong" / "no" / "fix this"
 
 ## Negative Triggers (do NOT activate for)
 
-- "generate code"
-- "search files"
-- "explain this"
-- "run tests"
+- "generate code" / "search files" / "explain this" / "run tests"
+
+## Why dual-write?
+
+Amp's MCP memory gives you instant in-session recall. rlhf-feedback-loop gives you:
+- **DPO training pairs** for fine-tuning your model
+- **Prevention rules** that block repeated mistakes
+- **Cross-platform portability** — same feedback works in Claude, Codex, Gemini
+- **LanceDB vector search** for semantic similarity across sessions
+- **REST API** for team dashboards and analytics

package/scripts/code-reasoning.js

@@ -305,3 +305,4 @@ module.exports = {
   aggregateTraces,
   DEFAULT_CONFIDENCE_THRESHOLD,
 };
+// test coverage: 573 tests