@rvry/mcp 0.1.0

package/README.md

@@ -0,0 +1,66 @@
+# @rvry/mcp
+
+The thin client for the **RVRY Reasoning Depth Enforcement (RDE) Engine**.
+
+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.
+
+## Quick Start
+
+The setup wizard handles everything -- token configuration, Claude Code registration, and slash command installation:
+
+```bash
+npx @rvry/mcp setup
+```
+
+The wizard will:
+1. Prompt for your RVRY token (hidden input) -- or open rvry.ai/dashboard to generate one
+2. Register RVRY as an MCP server in Claude Code (`-s user` scope)
+3. Install slash commands (`/deepthink`, `/problem-solve`) to `.claude/commands/`
+
+### Manual Installation
+
+If you prefer to configure manually, or the `claude` CLI is not available:
+
+```bash
+claude mcp add -e RVRY_TOKEN=rvry_your_token -s user rvry -- npx @rvry/mcp
+```
+
+Or add the following to your Claude Desktop `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "RVRY": {
+      "command": "npx",
+      "args": ["@rvry/mcp"],
+      "env": {
+        "RVRY_TOKEN": "rvry_your_token_here"
+      }
+    }
+  }
+}
+```
+
+## Configuration
+
+RVRY requires an API token to communicate with the reasoning engine.
+
+1.  Generate a token at [rvry.ai/dashboard](https://rvry.ai/dashboard).
+2.  The setup wizard sets `RVRY_TOKEN` automatically. For manual setup, set it in your MCP config.
+
+## Tools Provided
+
+*   **`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.
+
+## 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.
+
+Learn more at [rvry.ai](https://rvry.ai).

package/commands/deepthink.md

@@ -0,0 +1,54 @@
+---
+description: Deep structured analysis for high-stakes questions via RVRY
+argument-hint: [--auto] <question>
+allowed-tools:
+  - mcp__RVRY__RVRY_deepthink
+  - AskUserQuestion
+---
+
+# /deepthink - Deep Structured Analysis
+
+**Input**: $ARGUMENTS
+
+## Parse Flags
+
+- If `$ARGUMENTS` is empty or `--help`: display usage ("Usage: /deepthink [--auto] <your question>") and stop
+- If `$ARGUMENTS` contains `--auto`: set AUTO_MODE, strip `--auto` from input
+
+## Phase 1: Start Session
+
+Call `mcp__RVRY__RVRY_deepthink` with `{ "input": "<cleaned input>", "skipScoping": <true if AUTO_MODE> }`.
+
+### If status is "scoping" (and not AUTO_MODE):
+
+The engine has returned scoping questions to help calibrate the analysis.
+
+For each question in `scopingQuestions`:
+- Present the question and its options to the user via `AskUserQuestion`
+- Format as: the question text, followed by the options (label + description)
+
+After collecting all answers, format them as a brief context summary (e.g., "Stakes: High. Looking for: risks and failure modes.") and call `mcp__RVRY__RVRY_deepthink` with `{ "input": "<formatted scoping answers>", "sessionId": "<sessionId from previous response>" }`.
+
+### If status is "active":
+
+Proceed to Phase 2.
+
+## Phase 2: Analysis Loop
+
+Repeat until `status === "complete"`:
+
+1. Read the engine's `prompt` -- this is the analytical framing for this round
+2. Read the engine's `instruction` -- this tells you what to focus on
+3. Present the analytical framing to the user before your analysis
+4. Perform your analysis based on the prompt and instruction
+5. Call `mcp__RVRY__RVRY_deepthink` with `{ "input": "<your analysis>", "sessionId": "<sessionId>" }`
+
+## Phase 3: Harvest
+
+When `status === "complete"` and `harvest` is present:
+
+Present to the user:
+- **Summary**: harvest.summary
+- **Key Findings**: harvest.keyFindings as bullet list
+- **Open Questions**: harvest.openQuestions (if any)
+- **Suggested Next Steps**: harvest.followUps with question + rationale

package/commands/problem-solve.md

@@ -0,0 +1,54 @@
+---
+description: Structured decision-making via RVRY
+argument-hint: [--auto] <problem or decision>
+allowed-tools:
+  - mcp__RVRY__RVRY_problem_solve
+  - AskUserQuestion
+---
+
+# /problem-solve - Structured Decision-Making
+
+**Input**: $ARGUMENTS
+
+## Parse Flags
+
+- If `$ARGUMENTS` is empty or `--help`: display usage ("Usage: /problem-solve [--auto] <your problem or decision>") and stop
+- If `$ARGUMENTS` contains `--auto`: set AUTO_MODE, strip `--auto` from input
+
+## Phase 1: Start Session
+
+Call `mcp__RVRY__RVRY_problem_solve` with `{ "input": "<cleaned input>", "skipScoping": <true if AUTO_MODE> }`.
+
+### If status is "scoping" (and not AUTO_MODE):
+
+The engine has returned scoping questions to help calibrate the analysis.
+
+For each question in `scopingQuestions`:
+- Present the question and its options to the user via `AskUserQuestion`
+- Format as: the question text, followed by the options (label + description)
+
+After collecting all answers, format them as a brief context summary (e.g., "Options: multiple, need to narrow. Priority: risk minimization.") and call `mcp__RVRY__RVRY_problem_solve` with `{ "input": "<formatted scoping answers>", "sessionId": "<sessionId from previous response>" }`.
+
+### If status is "active":
+
+Proceed to Phase 2.
+
+## Phase 2: Analysis Loop
+
+Repeat until `status === "complete"`:
+
+1. Read the engine's `prompt` -- this is the analytical framing for this round
+2. Read the engine's `instruction` -- this tells you what to focus on
+3. Present the analytical framing to the user before your analysis
+4. Perform your analysis based on the prompt and instruction
+5. Call `mcp__RVRY__RVRY_problem_solve` with `{ "input": "<your analysis>", "sessionId": "<sessionId>" }`
+
+## Phase 3: Harvest
+
+When `status === "complete"` and `harvest` is present:
+
+Present to the user:
+- **Summary**: harvest.summary
+- **Key Findings**: harvest.keyFindings as bullet list
+- **Open Questions**: harvest.openQuestions (if any)
+- **Suggested Next Steps**: harvest.followUps with question + rationale

package/dist/client.d.ts

@@ -0,0 +1,45 @@
+/**
+ * RVRY MCP Client -- HTTP client for the RVRY engine /api/v1/think endpoint.
+ */
+/** Valid tool names for the RVRY engine */
+export type RvryTool = 'deepthink' | 'think' | 'problem_solve' | 'challenge' | 'meta';
+export interface ScopingQuestion {
+    question: string;
+    options: Array<{
+        label: string;
+        description: string;
+    }>;
+    default: string;
+}
+export interface ThinkResponse {
+    sessionId: string;
+    status: 'scoping' | 'active' | 'complete';
+    round: number;
+    prompt: string;
+    instruction: string;
+    scopingQuestions?: ScopingQuestion[];
+    usage?: {
+        used: number;
+        limit: number;
+        tier: string;
+        resetsAt: string;
+    };
+    harvest?: {
+        summary: string;
+        keyFindings: string[];
+        openQuestions: string[];
+        followUps: Array<{
+            question: string;
+            rationale: string;
+        }>;
+    };
+}
+/**
+ * Call the RVRY engine /api/v1/think endpoint with a specific tool.
+ * Start a new session by omitting sessionId, or continue by providing one.
+ */
+export declare function callTool(tool: RvryTool, input: string, token: string, sessionId?: string, skipScoping?: boolean): Promise<ThinkResponse>;
+/**
+ * @deprecated Use callTool('think', input, token, sessionId) instead.
+ */
+export declare function callThink(input: string, token: string, sessionId?: string): Promise<ThinkResponse>;

package/dist/client.js

@@ -0,0 +1,36 @@
+/**
+ * RVRY MCP Client -- HTTP client for the RVRY engine /api/v1/think endpoint.
+ */
+const DEFAULT_ENGINE_URL = 'https://engine.rvry.ai';
+/**
+ * Call the RVRY engine /api/v1/think endpoint with a specific tool.
+ * Start a new session by omitting sessionId, or continue by providing one.
+ */
+export async function callTool(tool, input, token, sessionId, skipScoping) {
+    const baseUrl = process.env.RVRY_ENGINE_URL ?? DEFAULT_ENGINE_URL;
+    const body = { input, tool };
+    if (sessionId) {
+        body.sessionId = sessionId;
+    }
+    if (skipScoping) {
+        body.skipScoping = true;
+    }
+    const res = await fetch(`${baseUrl}/api/v1/think`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        throw new Error(await res.text());
+    }
+    return res.json();
+}
+/**
+ * @deprecated Use callTool('think', input, token, sessionId) instead.
+ */
+export async function callThink(input, token, sessionId) {
+    return callTool('think', input, token, sessionId);
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * @rvry/mcp -- MCP server entry point (stdio transport)
+ *
+ * Thin client that proxies tool calls to the RVRY engine HTTP API.
+ * Auth via RVRY_TOKEN env var (static rvry_ token).
+ *
+ * Exposes 5 tools (RVRY_ prefixed) + backward-compat aliases + 5 MCP Prompts.
+ *
+ * Also supports `npx @rvry/mcp setup` to install Claude Code commands.
+ */
+import { type Tool } from '@modelcontextprotocol/sdk/types.js';
+import { type RvryTool, type ThinkResponse } from './client.js';
+/** Cache original question per session for response enrichment */
+declare const questionCache: Map<string, string>;
+/**
+ * Map tool name to RvryTool.
+ * Primary entries use rvry_ prefix; unprefixed entries are backward-compat aliases.
+ */
+declare const TOOL_MAP: Record<string, RvryTool>;
+declare const TOOL_DEFS: Tool[];
+/** Strip response fields based on status for context-efficient MCP responses */
+declare function stripResponse(result: ThinkResponse, question: string): Record<string, unknown>;
+export { TOOL_MAP, TOOL_DEFS, stripResponse, questionCache };

package/dist/index.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+/**
+ * @rvry/mcp -- MCP server entry point (stdio transport)
+ *
+ * Thin client that proxies tool calls to the RVRY engine HTTP API.
+ * Auth via RVRY_TOKEN env var (static rvry_ token).
+ *
+ * Exposes 5 tools (RVRY_ prefixed) + backward-compat aliases + 5 MCP Prompts.
+ *
+ * Also supports `npx @rvry/mcp setup` to install Claude Code commands.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { callTool } from './client.js';
+/** Cache original question per session for response enrichment */
+const questionCache = new Map();
+/**
+ * Map tool name to RvryTool.
+ * Primary entries use rvry_ prefix; unprefixed entries are backward-compat aliases.
+ */
+const TOOL_MAP = {
+    // Primary (rvry_ prefixed)
+    RVRY_think: 'think',
+    RVRY_deepthink: 'deepthink',
+    RVRY_problem_solve: 'problem_solve',
+    RVRY_challenge: 'challenge',
+    RVRY_meta: 'meta',
+    // Backward-compat aliases (unprefixed)
+    think: 'think',
+    deepthink: 'deepthink',
+    problem_solve: 'problem_solve',
+    challenge: 'challenge',
+    meta: 'meta',
+};
+const TOOL_DEFS = [
+    {
+        name: 'RVRY_think',
+        description: 'Carefully examine questions through guided rounds and self-checks. ' +
+            'Use for questions that need thorough examination but don\'t fit a specific pattern. ' +
+            'For high-stakes deep analysis, use RVRY_deepthink. ' +
+            'For choosing between options, use RVRY_problem_solve. ' +
+            'For stress-testing proposals, use RVRY_challenge. ' +
+            'For reflective examination of defaults and shifts, use RVRY_meta. ' +
+            '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_deepthink',
+        description: 'Extended analysis for high-stakes problems using pre-mortem failure analysis and structural constraints. ' +
+            'Use when RVRY_think reveals the question needs more depth. ' +
+            '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_problem_solve',
+        description: 'Structured decision-making: Orient, Anticipate, Generate, Evaluate, and Commit. ' +
+            'Use when you need to choose between options. Produces a recommendation with clear safeguards. ' +
+            'Call with your problem to start, then send your analysis with the returned sessionId to continue.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                input: {
+                    type: 'string',
+                    description: 'The problem to solve (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 evaluation of a proposal using causal analysis and edge-case auditing. ' +
+            'Returns a rigorous assessment of the proposal\'s viability. ' +
+            '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: 'Reflect on defaults, shifts, and reasoning posture across a session or topic. ' +
+            'Use to inspect what changed under reflection and what remained stable. ' +
+            'Call with your topic or session context to start, then send your reflection with the returned sessionId to continue.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                input: {
+                    type: 'string',
+                    description: 'The topic or session context to reflect on (new session) or your reflective 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'],
+        },
+    },
+];
+/** Strip response fields based on status for context-efficient MCP responses */
+function stripResponse(result, question) {
+    const stripped = {
+        sessionId: result.sessionId,
+        status: result.status,
+        round: result.round,
+        question,
+    };
+    if (result.status === 'scoping' && result.scopingQuestions) {
+        stripped.scopingQuestions = result.scopingQuestions;
+    }
+    if (result.status === 'active') {
+        stripped.prompt = result.prompt;
+        stripped.instruction = result.instruction;
+    }
+    if (result.status === 'complete' && result.harvest) {
+        stripped.harvest = result.harvest;
+    }
+    if (result.usage) {
+        const { used, limit } = result.usage;
+        if (used >= limit * 0.8 || result.status === 'complete') {
+            stripped.usage = result.usage;
+        }
+    }
+    return stripped;
+}
+async function main() {
+    // Check for setup CLI mode before starting MCP server
+    if (process.argv[2] === 'setup') {
+        const { runSetup } = await import('./setup.js');
+        await runSetup();
+        return;
+    }
+    const token = process.env.RVRY_TOKEN;
+    if (!token) {
+        console.error('[rvry-mcp] RVRY_TOKEN environment variable is required.');
+        console.error('[rvry-mcp] Generate one at https://rvry.ai/dashboard');
+        process.exit(1);
+    }
+    const server = new Server({ name: 'RVRY', version: '0.1.0' }, { capabilities: { tools: {}, prompts: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: TOOL_DEFS,
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const rvryTool = TOOL_MAP[name];
+        if (!rvryTool) {
+            return {
+                content: [{ type: 'text', text: `Error: Unknown tool: ${name}` }],
+                isError: true,
+            };
+        }
+        const typedArgs = args;
+        const input = typedArgs?.input;
+        if (!input || typeof input !== 'string') {
+            return {
+                content: [{ type: 'text', text: 'Error: input is required and must be a string.' }],
+                isError: true,
+            };
+        }
+        const sessionId = typeof typedArgs?.sessionId === 'string' ? typedArgs.sessionId : undefined;
+        const skipScoping = typedArgs?.skipScoping === true;
+        // Cache question on first call (no sessionId = new session)
+        // On continuation calls, read from cache
+        let question = input;
+        if (!sessionId) {
+            // New session -- will cache after we get the sessionId from the response
+        }
+        else {
+            question = questionCache.get(sessionId) ?? input;
+        }
+        try {
+            const result = await callTool(rvryTool, input, token, sessionId, skipScoping || undefined);
+            // Cache question on first call (now we have the sessionId)
+            if (!sessionId) {
+                questionCache.set(result.sessionId, input);
+                question = input;
+            }
+            // Clean up cache on completion
+            if (result.status === 'complete') {
+                questionCache.delete(result.sessionId);
+            }
+            const stripped = stripResponse(result, question);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(stripped) }],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error.';
+            return {
+                content: [{ type: 'text', text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // MCP Prompts for GUI discoverability
+    server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+        prompts: [
+            {
+                name: 'RVRY_deepthink',
+                description: 'Deep structured analysis for high-stakes questions',
+                arguments: [{ name: 'question', description: 'The question to analyze deeply', required: true }],
+            },
+            {
+                name: 'RVRY_think',
+                description: 'Structured analysis for questions needing careful examination',
+                arguments: [{ name: 'question', description: 'The question to think through', required: true }],
+            },
+            {
+                name: 'RVRY_problem_solve',
+                description: 'Structured decision-making for problems with multiple options',
+                arguments: [{ name: 'problem', description: 'The problem or decision to analyze', required: true }],
+            },
+            {
+                name: 'RVRY_challenge',
+                description: 'Adversarial evaluation of a proposal or plan',
+                arguments: [{ name: 'proposal', description: 'The proposal or plan to challenge', required: true }],
+            },
+            {
+                name: 'RVRY_meta',
+                description: 'Reflective examination of defaults, shifts, and reasoning posture',
+                arguments: [{ name: 'topic', description: 'The topic or session context to reflect on', required: true }],
+            },
+        ],
+    }));
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const promptMap = {
+            RVRY_deepthink: `Use the RVRY_deepthink tool to analyze this question in depth: ${args?.question ?? ''}`,
+            RVRY_think: `Use the RVRY_think tool to analyze this question: ${args?.question ?? ''}`,
+            RVRY_problem_solve: `Use the RVRY_problem_solve tool to work through this decision: ${args?.problem ?? ''}`,
+            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 or session context: ${args?.topic ?? ''}`,
+        };
+        const text = promptMap[name] ?? `Unknown prompt: ${name}`;
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: { type: 'text', text },
+                },
+            ],
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('[rvry-mcp] Connected via stdio. Tools: RVRY_think, RVRY_deepthink, RVRY_problem_solve, RVRY_challenge, RVRY_meta');
+}
+// Export internals for testing
+export { TOOL_MAP, TOOL_DEFS, stripResponse, questionCache };
+// Run server when executed directly (not when imported by tests).
+// import.meta.main: true in Bun direct, false in Bun imports, undefined in Node ESM.
+// @ts-ignore -- import.meta.main is a Bun extension, not in TS lib types
+if (import.meta.main !== false) {
+    main().catch((err) => {
+        console.error('[rvry-mcp] Fatal:', err);
+        process.exit(1);
+    });
+}

package/dist/setup.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @rvry/mcp setup wizard
+ *
+ * Interactive setup: token input, Claude Code MCP registration, slash command installation.
+ * Usage: npx @rvry/mcp setup
+ */
+export declare function runSetup(): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,337 @@
+/**
+ * @rvry/mcp setup wizard
+ *
+ * Interactive setup: token input, Claude Code MCP registration, slash command installation.
+ * Usage: npx @rvry/mcp setup
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { createInterface } from 'readline';
+import { execSync } from 'child_process';
+import { platform } from 'os';
+const COMMAND_FILES = [
+    'deepthink.md',
+    'problem-solve.md',
+];
+const TOKEN_REGEX = /^rvry_[0-9a-f]{32,}$/;
+// ── Utility functions ──────────────────────────────────────────────
+/**
+ * Find the commands directory shipped with this package.
+ * Walks up from this file's directory to find the commands/ folder.
+ */
+function findCommandsDir() {
+    let dir = dirname(new URL(import.meta.url).pathname);
+    for (let i = 0; i < 5; i++) {
+        const candidate = join(dir, 'commands');
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+        dir = dirname(dir);
+    }
+    throw new Error('Could not find commands/ directory in @rvry/mcp package.');
+}
+/**
+ * Find or create the .claude/commands/ directory.
+ * Walks up from cwd looking for an existing .claude/ directory.
+ * If not found, creates .claude/commands/ in cwd.
+ */
+function findOrCreateTargetDir() {
+    const cwd = process.cwd();
+    let dir = cwd;
+    for (let i = 0; i < 10; i++) {
+        const claudeDir = join(dir, '.claude');
+        if (existsSync(claudeDir)) {
+            const commandsDir = join(claudeDir, 'commands');
+            if (!existsSync(commandsDir)) {
+                mkdirSync(commandsDir, { recursive: true });
+            }
+            return commandsDir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    const commandsDir = join(cwd, '.claude', 'commands');
+    mkdirSync(commandsDir, { recursive: true });
+    return commandsDir;
+}
+/**
+ * Create a readline interface for prompting.
+ */
+function createRL() {
+    return createInterface({ input: process.stdin, output: process.stdout });
+}
+/**
+ * Prompt with a question and return the answer.
+ */
+function ask(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer));
+    });
+}
+/**
+ * Read a token with hidden input (password-style).
+ * Characters are not echoed; asterisks are printed instead.
+ */
+function readHiddenInput(prompt) {
+    return new Promise((resolve) => {
+        process.stdout.write(prompt);
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw;
+        if (typeof stdin.setRawMode === 'function') {
+            stdin.setRawMode(true);
+        }
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        let input = '';
+        const onData = (ch) => {
+            const charCode = ch.charCodeAt(0);
+            // Enter
+            if (ch === '\r' || ch === '\n') {
+                if (typeof stdin.setRawMode === 'function') {
+                    stdin.setRawMode(wasRaw ?? false);
+                }
+                stdin.removeListener('data', onData);
+                stdin.pause();
+                process.stdout.write('\n');
+                resolve(input);
+                return;
+            }
+            // Ctrl+C
+            if (charCode === 3) {
+                if (typeof stdin.setRawMode === 'function') {
+                    stdin.setRawMode(wasRaw ?? false);
+                }
+                stdin.removeListener('data', onData);
+                process.stdout.write('\n');
+                process.exit(1);
+            }
+            // Backspace / Delete
+            if (charCode === 127 || charCode === 8) {
+                if (input.length > 0) {
+                    input = input.slice(0, -1);
+                    process.stdout.write('\b \b');
+                }
+                return;
+            }
+            // Printable characters (including pasted text)
+            if (charCode >= 32) {
+                input += ch;
+                // Print asterisks for each character (handles paste of multiple chars)
+                process.stdout.write('*'.repeat(ch.length));
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
+/**
+ * Validate token format: must start with rvry_ followed by 32+ hex chars.
+ */
+function isValidToken(token) {
+    return TOKEN_REGEX.test(token);
+}
+/**
+ * Format token for display: rvry_...last8
+ */
+function maskToken(token) {
+    const last8 = token.slice(-8);
+    return `rvry_...${last8}`;
+}
+/**
+ * Open a URL in the default browser, platform-aware.
+ */
+function openBrowser(url) {
+    const plat = platform();
+    try {
+        if (plat === 'darwin') {
+            execSync(`open "${url}"`, { stdio: 'pipe' });
+        }
+        else if (plat === 'win32') {
+            execSync(`start "" "${url}"`, { stdio: 'pipe' });
+        }
+        else {
+            execSync(`xdg-open "${url}"`, { stdio: 'pipe' });
+        }
+    }
+    catch {
+        // Non-fatal: browser open failed
+        console.log('  Could not open browser automatically.');
+        console.log(`  Visit: ${url}`);
+    }
+}
+/**
+ * Check if the `claude` CLI is available in PATH.
+ */
+function isClaudeCLIAvailable() {
+    try {
+        const cmd = platform() === 'win32' ? 'where claude' : 'which claude';
+        execSync(cmd, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Register RVRY as an MCP server in Claude Code.
+ * Removes existing registration first for idempotency.
+ */
+function registerMCP(token) {
+    try {
+        // Remove existing (ignore error if not registered)
+        try {
+            execSync('claude mcp remove rvry', { stdio: 'pipe' });
+        }
+        catch {
+            // Not registered yet, that's fine
+        }
+        // Add with token
+        execSync(`claude mcp add -e RVRY_TOKEN="${token}" -s user rvry -- npx @rvry/mcp`, { stdio: 'inherit' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Print manual JSON config block for users without the Claude CLI.
+ */
+function printManualConfig(token) {
+    const config = {
+        mcpServers: {
+            RVRY: {
+                command: 'npx',
+                args: ['@rvry/mcp'],
+                env: {
+                    RVRY_TOKEN: token,
+                },
+            },
+        },
+    };
+    console.log('');
+    console.log('  Claude CLI not found. Add this to your MCP config manually:');
+    console.log('');
+    console.log(JSON.stringify(config, null, 2));
+    console.log('');
+    const plat = platform();
+    if (plat === 'darwin') {
+        console.log('  Claude Desktop config location:');
+        console.log('  ~/Library/Application Support/Claude/claude_desktop_config.json');
+    }
+    else if (plat === 'win32') {
+        console.log('  Claude Desktop config location:');
+        console.log('  %APPDATA%\\Claude\\claude_desktop_config.json');
+    }
+    else {
+        console.log('  Claude Desktop config location:');
+        console.log('  ~/.config/Claude/claude_desktop_config.json');
+    }
+}
+// ── Token input flow ───────────────────────────────────────────────
+async function getToken() {
+    while (true) {
+        const token = (await readHiddenInput('  Enter your RVRY token: ')).trim();
+        if (!token) {
+            console.log('');
+            const rl = createRL();
+            const openDash = await ask(rl, '  No token entered. Open rvry.ai/dashboard to generate one? [Y/n] ');
+            rl.close();
+            if (openDash.toLowerCase() !== 'n') {
+                openBrowser('https://rvry.ai/dashboard');
+                console.log('');
+                console.log('  Generate a token, then come back here.');
+                console.log('');
+            }
+            continue;
+        }
+        if (!isValidToken(token)) {
+            console.log('  Invalid token format. Expected: rvry_ followed by 32+ hex characters.');
+            console.log('');
+            continue;
+        }
+        console.log(`  Token: ${maskToken(token)}`);
+        return token;
+    }
+}
+// ── Slash command installation ─────────────────────────────────────
+async function installCommands() {
+    const sourceDir = findCommandsDir();
+    const targetDir = findOrCreateTargetDir();
+    let installed = 0;
+    for (const filename of COMMAND_FILES) {
+        const sourcePath = join(sourceDir, filename);
+        const targetPath = join(targetDir, filename);
+        if (!existsSync(sourcePath)) {
+            continue;
+        }
+        if (existsSync(targetPath)) {
+            const rl = createRL();
+            const answer = await ask(rl, `  ${filename} already exists. Overwrite? [y/N] `);
+            rl.close();
+            if (answer.toLowerCase() !== 'y') {
+                continue;
+            }
+        }
+        const content = readFileSync(sourcePath, 'utf-8');
+        writeFileSync(targetPath, content, 'utf-8');
+        installed++;
+    }
+    return installed;
+}
+// ── Main setup flow ────────────────────────────────────────────────
+const BANNER = `
+░█████████  ░██    ░██ ░█████████  ░██     ░██
+░██     ░██ ░██    ░██ ░██     ░██  ░██   ░██
+░██     ░██ ░██    ░██ ░██     ░██   ░██ ░██
+░█████████  ░██    ░██ ░█████████     ░████
+░██   ░██    ░██  ░██  ░██   ░██       ░██
+░██    ░██    ░██░██   ░██    ░██      ░██
+░██     ░██    ░███    ░██     ░██     ░██
+`;
+export async function runSetup() {
+    console.log(BANNER);
+    console.log('Setup');
+    console.log('');
+    // Step 1: Token input
+    console.log('[1/3] Token');
+    const token = await getToken();
+    console.log('');
+    // Step 2: Claude Code MCP registration
+    console.log('[2/3] Claude Code MCP Registration');
+    let claudeConfigured = false;
+    if (isClaudeCLIAvailable()) {
+        const success = registerMCP(token);
+        if (success) {
+            claudeConfigured = true;
+            console.log('  Registered RVRY in Claude Code (user scope).');
+        }
+        else {
+            console.log('  Failed to register with Claude CLI.');
+            printManualConfig(token);
+        }
+    }
+    else {
+        printManualConfig(token);
+    }
+    console.log('');
+    // Step 3: Slash command installation
+    console.log('[3/3] Slash Commands');
+    const commandCount = await installCommands();
+    if (commandCount > 0) {
+        console.log(`  Installed ${commandCount} commands to .claude/commands/`);
+    }
+    else {
+        console.log('  No new commands installed.');
+    }
+    console.log('');
+    // Summary
+    console.log('RVRY Setup Complete');
+    console.log('');
+    console.log(`  Token:        ${maskToken(token)}`);
+    console.log(`  Claude Code:  ${claudeConfigured ? 'Configured (user scope)' : 'Manual config required'}`);
+    console.log(`  Commands:     ${commandCount} installed to .claude/commands/`);
+    console.log('');
+    console.log('Try: /deepthink "your question"');
+    console.log('');
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@rvry/mcp",
+  "version": "0.1.0",
+  "description": "RVRY reasoning depth enforcement (RDE) engine client.",
+  "type": "module",
+  "bin": {
+    "rvry-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "commands",
+    "!dist/**/*.test.*"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest"
+  },
+  "devDependencies": {
+    "typescript": "latest",
+    "@types/node": "latest"
+  },
+  "keywords": [
+    "mcp",
+    "rvry",
+    "reasoning",
+    "rde",
+    "claude"
+  ],
+  "license": "MIT"
+}