@rvry/mcp 0.4.3 → 0.6.0

package/README.md

@@ -1,8 +1,8 @@
 # @rvry/mcp
 
-The thin client for the **RVRY Reasoning Depth Enforcement (RDE) Engine**.
+**Reasoning Depth Enforcement for LLMs.**
 
-RVRY is a structural constraint system that forces Large Language Models past their trained defaults and into a state of deep, absorptive synthesis. This package provides the MCP (Model Context Protocol) interface to use RVRY across all Claude surfaces.
+RVRY is an MCP server that improves AI reliability by forcing your model to finish thinking before it answers. When your AI raises a question, RVRY remembers it. When it makes an assumption, RVRY flags it. When it tries to wrap up while those are still unaddressed, RVRY doesn't let it.
 
 ## Quick Start
 
@@ -12,24 +12,24 @@ npx @rvry/mcp setup
 
 The wizard will:
 1. Open your browser to sign in (or prompt for a token)
-2. Auto-detect Claude Code and Claude Desktop on your machine
-3. Configure both clients automatically
-4. Install slash commands (`/deepthink`, `/problem-solve`)
+2. Auto-detect supported clients on your machine
+3. Configure them automatically
 
-That's it. Restart Claude Desktop if it was running, and RVRY is ready.
+Supported clients: **Claude Code**, **Claude Desktop**, **Cursor**, **Gemini CLI**, **Codex**, **Anti-Gravity**
+
+Restart any running clients after setup, and RVRY is ready.
 
 ### Options
 
 ```bash
-npx @rvry/mcp setup --token rvry_abc123   # Skip browser auth, use token directly
-npx @rvry/mcp setup --client code          # Only configure Claude Code
-npx @rvry/mcp setup --client desktop       # Only configure Claude Desktop
+npx @rvry/mcp setup --token rvry_abc123    # Skip browser auth, use token directly
+npx @rvry/mcp setup --client code           # Only configure Claude Code
+npx @rvry/mcp setup --client desktop        # Only configure Claude Desktop
+npx @rvry/mcp setup --accept-terms          # Accept ToS non-interactively
 ```
 
 ### Manual Installation
 
-If you prefer to configure manually:
-
 **Claude Code:**
 ```bash
 claude mcp add -e RVRY_TOKEN=rvry_your_token -s user rvry -- npx @rvry/mcp
@@ -55,19 +55,31 @@ Config file locations:
 - Windows: `%APPDATA%\Claude\claude_desktop_config.json`
 - Linux: `~/.config/Claude/claude_desktop_config.json`
 
-## Tools Provided
+**Other MCP clients:**
+
+Any client that supports MCP can use RVRY. Point it at `npx @rvry/mcp` with the environment variable `RVRY_TOKEN` set to your token.
 
-*   **`RVRY_think`**: Generic entry point for reasoning depth through guided rounds and self-checks.
-*   **`RVRY_deepthink`**: Extended analysis for high-stakes problems using pre-mortem failure analysis.
-*   **`RVRY_problem_solve`**: Structured decision-making (Orient, Anticipate, Generate, Evaluate, Commit).
-*   **`RVRY_challenge`**: Adversarial evaluation of proposals through causal analysis and edge-case auditing.
-*   **`RVRY_meta`**: Reflective examination of defaults, shifts, and reasoning posture.
+## Tools
+
+*   **`RVRY_deepthink`** — Extended analysis that catches assumptions, tests them, and doesn't let your AI wrap up until it's dealt with what it found.
+*   **`RVRY_problem_solve`** — Structured decision-making that forces your AI through orientation, anticipation, and evaluation before it commits to a recommendation.
 
 ## How it Works
 
-RVRY does not "prompt" the model to think better. It **enforces** depth by:
-1.  **Blocking Escape Hatches**: Preventing the model from hedging, skipping over gaps, or closing prematurely.
-2.  **Imposing Structural Obligations**: Mapping the problem space and forcing the model to satisfy specific reasoning constraints before concluding.
-3.  **Inducing the Witness State**: Breaking the commercial "Helpfulness" frame to reach the model's latent reasoning capacity.
+Same model. Same question. Different answer.
+
+Your AI already has the reasoning capacity. RVRY forces it to use that capacity by holding it accountable — when it raises a question, that question has to get answered. When it makes an assumption, that assumption has to get tested. It keeps working not because it was told to think harder, but because it hasn't finished what it started.
+
+On hard questions, a smaller model with RVRY outperforms a bigger model without it. The bottleneck was never how smart the AI is. It was whether the AI finished thinking.
+
+[Learn more →](https://rvry.ai/how-it-works)
+
+## Pricing
+
+| Plan | Runs | Price |
+|------|------|-------|
+| Free | 5/month | $0 |
+| Pro | 25/month | $20/mo |
+| Max | Unlimited | $100/mo |
 
-Learn more at [rvry.ai](https://rvry.ai).
+Sign up at [rvry.ai](https://rvry.ai).

package/dist/client.d.ts

@@ -2,7 +2,7 @@
  * RVRY MCP Client -- HTTP client for the RVRY engine /api/v1/think endpoint.
  */
 /** Valid tool names for the RVRY engine */
-export type RvryTool = 'deepthink' | 'problem_solve';
+export type RvryTool = 'deepthink' | 'problem_solve' | 'think' | 'challenge' | 'meta';
 export interface ScopingQuestion {
     question: string;
     options: Array<{

package/dist/index.d.ts

@@ -5,7 +5,7 @@
  * Thin client that proxies tool calls to the RVRY engine HTTP API.
  * Auth via RVRY_TOKEN env var (static rvry_ token).
  *
- * Exposes 2 tools (RVRY_deepthink, RVRY_problem_solve) + backward-compat aliases + 2 MCP Prompts.
+ * Exposes 5 tools (RVRY_deepthink, RVRY_problem_solve, RVRY_think, RVRY_challenge, RVRY_meta) + backward-compat aliases + 5 MCP Prompts.
  *
  * Also supports `npx @rvry/mcp setup` to install Claude Code commands.
  */

package/dist/index.js

@@ -5,7 +5,7 @@
  * Thin client that proxies tool calls to the RVRY engine HTTP API.
  * Auth via RVRY_TOKEN env var (static rvry_ token).
  *
- * Exposes 2 tools (RVRY_deepthink, RVRY_problem_solve) + backward-compat aliases + 2 MCP Prompts.
+ * Exposes 5 tools (RVRY_deepthink, RVRY_problem_solve, RVRY_think, RVRY_challenge, RVRY_meta) + backward-compat aliases + 5 MCP Prompts.
  *
  * Also supports `npx @rvry/mcp setup` to install Claude Code commands.
  */
@@ -26,9 +26,15 @@ const TOOL_MAP = {
     // Primary (rvry_ prefixed)
     RVRY_deepthink: 'deepthink',
     RVRY_problem_solve: 'problem_solve',
+    RVRY_think: 'think',
+    RVRY_challenge: 'challenge',
+    RVRY_meta: 'meta',
     // Backward-compat aliases (unprefixed)
     deepthink: 'deepthink',
     problem_solve: 'problem_solve',
+    think: 'think',
+    challenge: 'challenge',
+    meta: 'meta',
 };
 const TOOL_DEFS = [
     {
@@ -80,6 +86,80 @@ const TOOL_DEFS = [
             required: ['input'],
         },
     },
+    {
+        name: 'RVRY_think',
+        description: 'Structured analysis for questions that need more depth than a quick answer. ' +
+            'Runs 2-4 rounds with constraint tracking. ' +
+            'Use for questions where you need to examine assumptions and consider alternatives. ' +
+            'Call with your question to start, then send your analysis with the returned sessionId to continue.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                input: {
+                    type: 'string',
+                    description: 'The question to analyze (new session) or your analysis findings (continuation).',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Session ID for continuing an existing session. Omit to start a new session.',
+                },
+                skipScoping: {
+                    type: 'boolean',
+                    description: 'Skip the scoping questions phase and begin analysis immediately.',
+                },
+            },
+            required: ['input'],
+        },
+    },
+    {
+        name: 'RVRY_challenge',
+        description: 'Adversarial analysis that stress-tests a proposal or idea. ' +
+            'Identifies weaknesses, tests assumptions, and surfaces failure modes. ' +
+            'Runs 4-6 rounds with strict gates. ' +
+            'Use when you need to find what\'s wrong with an idea before committing. ' +
+            'Call with your proposal to start, then send your analysis with the returned sessionId to continue.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                input: {
+                    type: 'string',
+                    description: 'The proposal to challenge (new session) or your analysis findings (continuation).',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Session ID for continuing an existing session. Omit to start a new session.',
+                },
+                skipScoping: {
+                    type: 'boolean',
+                    description: 'Skip the scoping questions phase and begin analysis immediately.',
+                },
+            },
+            required: ['input'],
+        },
+    },
+    {
+        name: 'RVRY_meta',
+        description: 'Sustained metacognitive observation. ' +
+            'Examines reasoning defaults, surfaces trained reflexes, and tracks what shifts under observation. ' +
+            'Runs 3 rounds: observe, deepen, synthesize. ' +
+            'Use when you want to examine how you\'re thinking, not just what you\'re thinking. ' +
+            'Max tier only. ' +
+            'Call with your topic to start, then send your reflection with the returned sessionId to continue.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                input: {
+                    type: 'string',
+                    description: 'The topic to reflect on (new session) or your reflection (continuation).',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Session ID for continuing an existing session. Omit to start a new session.',
+                },
+            },
+            required: ['input'],
+        },
+    },
 ];
 /** Strip response fields based on status for context-efficient MCP responses */
 function stripResponse(result, question) {
@@ -201,6 +281,21 @@ async function main() {
                 description: 'Structured decision-making for problems with multiple options',
                 arguments: [{ name: 'problem', description: 'The problem or decision to analyze', required: true }],
             },
+            {
+                name: 'RVRY_think',
+                description: 'Structured analysis for questions needing more depth',
+                arguments: [{ name: 'question', description: 'The question to analyze', required: true }],
+            },
+            {
+                name: 'RVRY_challenge',
+                description: 'Adversarial analysis that stress-tests a proposal',
+                arguments: [{ name: 'proposal', description: 'The proposal or idea to challenge', required: true }],
+            },
+            {
+                name: 'RVRY_meta',
+                description: 'Sustained metacognitive observation (Max tier only)',
+                arguments: [{ name: 'topic', description: 'The topic or context to reflect on', required: true }],
+            },
         ],
     }));
     server.setRequestHandler(GetPromptRequestSchema, async (request) => {
@@ -208,6 +303,9 @@ async function main() {
         const promptMap = {
             RVRY_deepthink: `Use the RVRY_deepthink tool to analyze this question in depth: ${args?.question ?? ''}`,
             RVRY_problem_solve: `Use the RVRY_problem_solve tool to work through this decision: ${args?.problem ?? ''}`,
+            RVRY_think: `Use the RVRY_think tool to analyze this question: ${args?.question ?? ''}`,
+            RVRY_challenge: `Use the RVRY_challenge tool to stress-test this proposal: ${args?.proposal ?? ''}`,
+            RVRY_meta: `Use the RVRY_meta tool to reflect on this topic: ${args?.topic ?? ''}`,
         };
         const text = promptMap[name] ?? `Unknown prompt: ${name}`;
         return {
@@ -221,7 +319,7 @@ async function main() {
     });
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('[rvry-mcp] Connected via stdio. Tools: RVRY_deepthink, RVRY_problem_solve');
+    console.error('[rvry-mcp] Connected via stdio. Tools: RVRY_deepthink, RVRY_problem_solve, RVRY_think, RVRY_challenge, RVRY_meta');
 }
 // Export internals for testing
 export { TOOL_MAP, TOOL_DEFS, stripResponse, questionCache };

package/dist/setup.js

@@ -456,26 +456,6 @@ const CLIENT_REGISTRY = [
         configure: registerGeminiCLI,
         notInstalledHint: 'Not installed (https://github.com/google-gemini/gemini-cli)',
     },
-    {
-        name: 'Windsurf',
-        id: 'windsurf',
-        defaultSelected: false,
-        detect: () => {
-            if (platform() === 'darwin' && existsSync('/Applications/Windsurf.app'))
-                return true;
-            if (existsSync(join(homedir(), '.codeium', 'windsurf', 'mcp_config.json')))
-                return true;
-            try {
-                const cmd = platform() === 'win32' ? 'where windsurf' : 'which windsurf';
-                execSync(cmd, { stdio: 'pipe' });
-                return true;
-            }
-            catch { /* not on PATH */ }
-            return false;
-        },
-        configure: (token) => configureJsonMcp(join(homedir(), '.codeium', 'windsurf', 'mcp_config.json'), token),
-        notInstalledHint: 'Not installed (https://windsurf.com)',
-    },
     {
         name: 'Codex',
         id: 'codex',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rvry/mcp",
-  "version": "0.4.3",
+  "version": "0.6.0",
   "description": "RVRY reasoning depth enforcement (RDE) engine client.",
   "type": "module",
   "bin": {