@rvry/mcp 0.1.4 → 0.1.6

package/commands/deepthink.md

@@ -2,7 +2,7 @@
 description: Deep structured analysis for high-stakes questions via RVRY
 argument-hint: [--auto] <question>
 allowed-tools:
-  - mcp__RVRY__RVRY_deepthink
+  - mcp__rvry-dev__deepthink
   - AskUserQuestion
 ---
 
@@ -17,38 +17,78 @@ allowed-tools:
 
 ## Phase 1: Start Session
 
-Call `mcp__RVRY__RVRY_deepthink` with `{ "input": "<cleaned input>", "skipScoping": <true if AUTO_MODE> }`.
+Call `mcp__rvry-dev__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)
+**IMPORTANT: You MUST call AskUserQuestion as a tool to collect answers. Do NOT render the questions as plain text — the user's answers will be lost.**
 
-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>" }`.
+Call `AskUserQuestion` with the scoping questions mapped to its format. Each `scopingQuestions` entry becomes a question:
+
+```
+AskUserQuestion({
+  questions: scopingQuestions.map(sq => ({
+    question: sq.question,
+    header: sq.question.slice(0, 12),  // short label
+    options: sq.options.map(o => ({ label: o.label, description: o.description })),
+    multiSelect: false
+  }))
+})
+```
+
+After collecting all answers from AskUserQuestion, format them as a brief context summary (e.g., "Stakes: High. Looking for: risks and failure modes.") and call `mcp__rvry-dev__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>" }`
+1. Read the engine's `prompt` and `instruction` — these guide YOUR analysis. **Do not show either to the user.**
+2. Show the user a brief status line:
+   - Format: `Round {round} — {what you're doing this round}`
+   - Example: `Round 3 — stress-testing the current position`
+   - Derive the description from the engine's phase indicator or your own summary of the round's focus. One line only.
+3. Perform your analysis in your internal reasoning. The engine's prompt contains analytical framings, self-check questions, and constraint tracking — use all of these to guide your thinking, but they are YOUR instructions, not user output.
+4. In your internal reasoning, end your analysis with the constraint update block the engine expects:
+   ```
+   Constraint Updates
+   RESOLVE: C1, C2
+   ACKNOWLEDGE: C3
+   DEFER: C4 | <reason>
+   MILESTONE: <milestone> | <evidence>
+   End Constraint Updates
+   ```
+5. Call the engine tool with your full analysis (including constraint updates) as the `input`. **The full analysis text goes ONLY in the tool call, never in visible output.**
+
+### What NEVER appears in user-visible output:
+- The engine's `prompt` field content
+- Constraint tables (`C1 [ACTIVE] FORWARD: ...`)
+- Constraint update blocks (`RESOLVE: C1`, `MILESTONE: ...`)
+- Self-check questions or responses
+- Gate verdicts (`SOFT_FAIL`, `HARD_FAIL`, `PASS`)
+- Milestone markers
+- Protocol surface elements (session awareness text, phase indicators from engine)
+
+### What the user sees per round:
+- The one-line status (step 2 above)
+- Nothing else until harvest
 
 ## Phase 3: Harvest
 
-When `status === "complete"` and `harvest` is present:
+When `status === "complete"`:
+
+Synthesize the analysis for the user based on your accumulated reasoning across all rounds. Do NOT simply echo the engine's `harvest` fields — they are structured data, not a finished presentation.
 
 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
+1. **Default Starting Point**: What the obvious answer was and why it was insufficient
+2. **Key Findings**: The non-obvious insights that emerged, as a bullet list. Each finding should be a substantive sentence, not a label.
+3. **Open Questions**: What remains genuinely uncertain (if any)
+4. **Suggested Next Steps**: Concrete follow-up actions or investigations
+
+Use the engine's `harvest.summary`, `harvest.keyFindings`, `harvest.openQuestions`, and `harvest.followUps` as source material, but write the synthesis in your own words with the depth your analysis produced. The harvest fields are often terse — your synthesis should reflect the full depth of the multi-round analysis.

package/commands/problem-solve.md

@@ -2,7 +2,7 @@
 description: Structured decision-making via RVRY
 argument-hint: [--auto] <problem or decision>
 allowed-tools:
-  - mcp__RVRY__RVRY_problem_solve
+  - mcp__rvry-dev__problem_solve
   - AskUserQuestion
 ---
 
@@ -17,38 +17,78 @@ allowed-tools:
 
 ## Phase 1: Start Session
 
-Call `mcp__RVRY__RVRY_problem_solve` with `{ "input": "<cleaned input>", "skipScoping": <true if AUTO_MODE> }`.
+Call `mcp__rvry-dev__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)
+**IMPORTANT: You MUST call AskUserQuestion as a tool to collect answers. Do NOT render the questions as plain text — the user's answers will be lost.**
 
-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>" }`.
+Call `AskUserQuestion` with the scoping questions mapped to its format. Each `scopingQuestions` entry becomes a question:
+
+```
+AskUserQuestion({
+  questions: scopingQuestions.map(sq => ({
+    question: sq.question,
+    header: sq.question.slice(0, 12),  // short label
+    options: sq.options.map(o => ({ label: o.label, description: o.description })),
+    multiSelect: false
+  }))
+})
+```
+
+After collecting all answers from AskUserQuestion, format them as a brief context summary (e.g., "Options: multiple, need to narrow. Priority: risk minimization.") and call `mcp__rvry-dev__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>" }`
+1. Read the engine's `prompt` and `instruction` — these guide YOUR analysis. **Do not show either to the user.**
+2. Show the user a brief status line:
+   - Format: `Round {round} — {what you're doing this round}`
+   - Example: `Round 3 — stress-testing the current position`
+   - Derive the description from the engine's phase indicator or your own summary of the round's focus. One line only.
+3. Perform your analysis in your internal reasoning. The engine's prompt contains analytical framings, self-check questions, and constraint tracking — use all of these to guide your thinking, but they are YOUR instructions, not user output.
+4. In your internal reasoning, end your analysis with the constraint update block the engine expects:
+   ```
+   Constraint Updates
+   RESOLVE: C1, C2
+   ACKNOWLEDGE: C3
+   DEFER: C4 | <reason>
+   MILESTONE: <milestone> | <evidence>
+   End Constraint Updates
+   ```
+5. Call the engine tool with your full analysis (including constraint updates) as the `input`. **The full analysis text goes ONLY in the tool call, never in visible output.**
+
+### What NEVER appears in user-visible output:
+- The engine's `prompt` field content
+- Constraint tables (`C1 [ACTIVE] FORWARD: ...`)
+- Constraint update blocks (`RESOLVE: C1`, `MILESTONE: ...`)
+- Self-check questions or responses
+- Gate verdicts (`SOFT_FAIL`, `HARD_FAIL`, `PASS`)
+- Milestone markers
+- Protocol surface elements (session awareness text, phase indicators from engine)
+
+### What the user sees per round:
+- The one-line status (step 2 above)
+- Nothing else until harvest
 
 ## Phase 3: Harvest
 
-When `status === "complete"` and `harvest` is present:
+When `status === "complete"`:
+
+Synthesize the analysis for the user based on your accumulated reasoning across all rounds. Do NOT simply echo the engine's `harvest` fields — they are structured data, not a finished presentation.
 
 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
+1. **Default Starting Point**: What the obvious answer was and why it was insufficient
+2. **Key Findings**: The non-obvious insights that emerged, as a bullet list. Each finding should be a substantive sentence, not a label.
+3. **Open Questions**: What remains genuinely uncertain (if any)
+4. **Suggested Next Steps**: Concrete follow-up actions or investigations
+
+Use the engine's `harvest.summary`, `harvest.keyFindings`, `harvest.openQuestions`, and `harvest.followUps` as source material, but write the synthesis in your own words with the depth your analysis produced. The harvest fields are often terse — your synthesis should reflect the full depth of the multi-round analysis.

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 5 tools (RVRY_ prefixed) + backward-compat aliases + 5 MCP Prompts.
+ * Exposes 2 tools (RVRY_deepthink, RVRY_problem_solve) + backward-compat aliases + 2 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 5 tools (RVRY_ prefixed) + backward-compat aliases + 5 MCP Prompts.
+ * Exposes 2 tools (RVRY_deepthink, RVRY_problem_solve) + backward-compat aliases + 2 MCP Prompts.
  *
  * Also supports `npx @rvry/mcp setup` to install Claude Code commands.
  */
@@ -24,51 +24,18 @@ const questionCache = new Map();
  */
 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. ' +
+        description: 'Deep, multi-round structured analysis for high-stakes or complex questions. ' +
+            'Runs 5-7 rounds with rigorous self-checks and pre-mortem analysis. ' +
+            'Use when the question demands thorough examination from multiple angles before reaching a conclusion. ' +
             'Call with your question to start, then send your analysis with the returned sessionId to continue.',
         inputSchema: {
             type: 'object',
@@ -113,54 +80,6 @@ const TOOL_DEFS = [
             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) {
@@ -244,6 +163,18 @@ async function main() {
             if (result.status === 'complete') {
                 questionCache.delete(result.sessionId);
             }
+            // Write local session summary on completion (non-blocking, silent failure)
+            if (result.status === 'complete' && result.harvest) {
+                import('./local-writer.js').then(({ writeLocalSession }) => {
+                    writeLocalSession({
+                        sessionId: result.sessionId,
+                        operationType: rvryTool,
+                        question,
+                        rounds: result.round,
+                        harvest: result.harvest,
+                    }).catch(() => { });
+                }).catch(() => { });
+            }
             const stripped = stripResponse(result, question);
             return {
                 content: [{ type: 'text', text: JSON.stringify(stripped) }],
@@ -265,36 +196,18 @@ async function main() {
                 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 {
@@ -308,7 +221,7 @@ async function main() {
     });
     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');
+    console.error('[rvry-mcp] Connected via stdio. Tools: RVRY_deepthink, RVRY_problem_solve');
 }
 // Export internals for testing
 export { TOOL_MAP, TOOL_DEFS, stripResponse, questionCache };

package/dist/local-writer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Local session writer -- writes a minimal markdown summary to .rvry/sessions/
+ * when a session completes.
+ *
+ * PROTOCOL SURFACE: This file produces user-facing output. It must NEVER contain
+ * constraint IDs, detection scores, mode names, gate verdicts, or any engine internals.
+ * Only question + harvest data.
+ */
+interface LocalSessionData {
+    sessionId: string;
+    operationType: string;
+    question: string;
+    rounds: number;
+    harvest: {
+        summary: string;
+        keyFindings: string[];
+        openQuestions: string[];
+        followUps: Array<{
+            question: string;
+            rationale: string;
+        }>;
+    };
+}
+/**
+ * Write a minimal markdown summary of a completed session to .rvry/sessions/.
+ *
+ * Disabled via RVRY_LOCAL_SESSIONS=0. Fails silently on any error.
+ */
+export declare function writeLocalSession(data: LocalSessionData): Promise<void>;
+export {};

package/dist/local-writer.js

@@ -0,0 +1,114 @@
+/**
+ * Local session writer -- writes a minimal markdown summary to .rvry/sessions/
+ * when a session completes.
+ *
+ * PROTOCOL SURFACE: This file produces user-facing output. It must NEVER contain
+ * constraint IDs, detection scores, mode names, gate verdicts, or any engine internals.
+ * Only question + harvest data.
+ */
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+/**
+ * Slugify a question string for use in filenames.
+ * Lowercases, replaces non-alphanumeric runs with hyphens, trims, and caps at maxLen chars.
+ */
+function slugify(text, maxLen = 50) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, maxLen)
+        .replace(/-+$/, '');
+}
+/**
+ * Format a Date as YYYYMMDD-HHMM for filenames.
+ */
+function formatTimestamp(date) {
+    const y = date.getFullYear().toString();
+    const mo = (date.getMonth() + 1).toString().padStart(2, '0');
+    const d = date.getDate().toString().padStart(2, '0');
+    const h = date.getHours().toString().padStart(2, '0');
+    const mi = date.getMinutes().toString().padStart(2, '0');
+    return `${y}${mo}${d}-${h}${mi}`;
+}
+/**
+ * Format a Date as YYYY-MM-DD HH:MM for YAML frontmatter.
+ */
+function formatDate(date) {
+    const y = date.getFullYear().toString();
+    const mo = (date.getMonth() + 1).toString().padStart(2, '0');
+    const d = date.getDate().toString().padStart(2, '0');
+    const h = date.getHours().toString().padStart(2, '0');
+    const mi = date.getMinutes().toString().padStart(2, '0');
+    return `${y}-${mo}-${d} ${h}:${mi}`;
+}
+/**
+ * Build the markdown content for a completed session.
+ */
+function buildMarkdown(data, now) {
+    const lines = [];
+    // YAML frontmatter
+    lines.push('---');
+    lines.push(`session: ${data.sessionId}`);
+    lines.push(`operation: ${data.operationType}`);
+    lines.push(`date: ${formatDate(now)}`);
+    lines.push(`rounds: ${data.rounds}`);
+    lines.push('---');
+    lines.push('');
+    // Question
+    lines.push(`# ${data.question}`);
+    lines.push('');
+    // Summary
+    lines.push('## Summary');
+    lines.push(data.harvest.summary);
+    lines.push('');
+    // Key Findings
+    if (data.harvest.keyFindings.length > 0) {
+        lines.push('## Key Findings');
+        for (const finding of data.harvest.keyFindings) {
+            lines.push(`- ${finding}`);
+        }
+        lines.push('');
+    }
+    // Open Questions
+    if (data.harvest.openQuestions.length > 0) {
+        lines.push('## Open Questions');
+        for (const q of data.harvest.openQuestions) {
+            lines.push(`- ${q}`);
+        }
+        lines.push('');
+    }
+    // Follow-ups
+    if (data.harvest.followUps.length > 0) {
+        lines.push('## Follow-ups');
+        for (const f of data.harvest.followUps) {
+            lines.push(`- ${f.question} — ${f.rationale}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Write a minimal markdown summary of a completed session to .rvry/sessions/.
+ *
+ * Disabled via RVRY_LOCAL_SESSIONS=0. Fails silently on any error.
+ */
+export async function writeLocalSession(data) {
+    // Check opt-out
+    if (process.env.RVRY_LOCAL_SESSIONS === '0')
+        return;
+    try {
+        const now = new Date();
+        const timestamp = formatTimestamp(now);
+        const slug = slugify(data.question);
+        const filename = `${timestamp}-${data.operationType}-${slug}.md`;
+        const sessionsDir = join(process.cwd(), '.rvry', 'sessions');
+        mkdirSync(sessionsDir, { recursive: true });
+        const filePath = join(sessionsDir, filename);
+        const content = buildMarkdown(data, now);
+        writeFileSync(filePath, content, 'utf-8');
+    }
+    catch {
+        // Fail silently -- this is a convenience feature, not critical path
+    }
+}

package/dist/setup.js

@@ -180,9 +180,6 @@ function openBrowser(url) {
         return false;
     }
 }
-/**
- * Check if the `claude` CLI is available in PATH.
- */
 function isClaudeCLIAvailable() {
     try {
         const cmd = platform() === 'win32' ? 'where claude' : 'which claude';
@@ -193,9 +190,6 @@ function isClaudeCLIAvailable() {
         return false;
     }
 }
-/**
- * Get the platform-specific Claude Desktop config file path.
- */
 function getDesktopConfigPath() {
     const plat = platform();
     if (plat === 'darwin') {
@@ -206,19 +200,10 @@ function getDesktopConfigPath() {
     }
     return join(homedir(), '.config', 'Claude', 'claude_desktop_config.json');
 }
-/**
- * Check if Claude Desktop config directory exists (app is installed).
- */
 function isClaudeDesktopInstalled() {
     const configPath = getDesktopConfigPath();
-    const configDir = dirname(configPath);
-    return existsSync(configDir);
+    return existsSync(dirname(configPath));
 }
-/**
- * Configure Claude Desktop by merging RVRY into the existing config.
- * Creates the config file if it doesn't exist. Preserves other MCP servers.
- * Returns 'created' | 'updated' | 'unchanged' | 'error'.
- */
 function configureDesktop(token) {
     const configPath = getDesktopConfigPath();
     try {
@@ -235,29 +220,23 @@ function configureDesktop(token) {
                 config = {};
             }
         }
-        // Ensure mcpServers object exists
         if (!config.mcpServers || typeof config.mcpServers !== 'object') {
             config.mcpServers = {};
         }
         const servers = config.mcpServers;
-        const newEntry = RVRY_SERVER_ENTRY(token);
-        // Check if RVRY is already configured with the same token
         const existing = servers.RVRY;
         if (existing) {
             const existingEnv = existing.env;
-            if (existingEnv?.RVRY_TOKEN === token) {
+            if (existingEnv?.RVRY_TOKEN === token)
                 return 'unchanged';
-            }
         }
         const wasNew = !existing;
-        servers.RVRY = newEntry;
-        // Write config with clean formatting
+        servers.RVRY = RVRY_SERVER_ENTRY(token);
         const configDir = dirname(configPath);
-        if (!existsSync(configDir)) {
+        if (!existsSync(configDir))
             mkdirSync(configDir, { recursive: true });
-        }
         writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-        return wasNew ? 'created' : 'updated';
+        return wasNew ? 'ok' : 'updated';
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -265,27 +244,221 @@ function configureDesktop(token) {
         return 'error';
     }
 }
-/**
- * Register RVRY as an MCP server in Claude Code.
- * Removes existing registration first for idempotency.
- */
 function registerClaudeCode(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
+        catch { /* not registered */ }
         execSync(`claude mcp add -e RVRY_TOKEN="${token}" -s user rvry -- npx @rvry/mcp`, { stdio: 'inherit' });
-        return true;
+        return 'ok';
     }
     catch {
-        return false;
+        return 'error';
+    }
+}
+/**
+ * Write RVRY server entry into a generic MCP JSON config file.
+ * Used by clients that follow the Desktop-style config format (Codex, Gemini, etc.)
+ */
+function configureJsonMcp(configPath, token) {
+    try {
+        let config = {};
+        if (existsSync(configPath)) {
+            const raw = readFileSync(configPath, 'utf-8');
+            try {
+                config = JSON.parse(raw);
+            }
+            catch {
+                writeFileSync(configPath + '.backup', raw, 'utf-8');
+                config = {};
+            }
+        }
+        if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+            config.mcpServers = {};
+        }
+        const servers = config.mcpServers;
+        const existing = servers.RVRY;
+        if (existing) {
+            const existingEnv = existing.env;
+            if (existingEnv?.RVRY_TOKEN === token)
+                return 'unchanged';
+        }
+        const wasNew = !existing;
+        servers.RVRY = RVRY_SERVER_ENTRY(token);
+        const dir = dirname(configPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+        return wasNew ? 'ok' : 'updated';
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(`  Error writing config: ${msg}`);
+        return 'error';
     }
 }
+/** All supported clients. Add new clients here. */
+const CLIENT_REGISTRY = [
+    {
+        name: 'Claude Code',
+        id: 'code',
+        detect: isClaudeCLIAvailable,
+        configure: registerClaudeCode,
+        notInstalledHint: 'CLI not found (https://docs.anthropic.com/en/docs/claude-code)',
+    },
+    {
+        name: 'Claude Desktop / Claude Co-Work',
+        id: 'desktop',
+        detect: isClaudeDesktopInstalled,
+        configure: (token) => configureDesktop(token),
+        notInstalledHint: 'Not installed',
+    },
+    {
+        name: 'Anti-Gravity',
+        id: 'antigravity',
+        detect: () => {
+            // OR-logic: binary (agy or antigravity), config dir, or macOS app bundle
+            try {
+                const cmd = platform() === 'win32' ? 'where agy' : 'which agy';
+                execSync(cmd, { stdio: 'pipe' });
+                return true;
+            }
+            catch { /* not on PATH */ }
+            if (platform() !== 'win32') {
+                try {
+                    execSync('which antigravity', { stdio: 'pipe' });
+                    return true;
+                }
+                catch { /* not on PATH */ }
+            }
+            if (existsSync(join(homedir(), '.gemini', 'antigravity')))
+                return true;
+            if (platform() === 'darwin' && existsSync('/Applications/Google Antigravity.app'))
+                return true;
+            return false;
+        },
+        configure: (token) => configureJsonMcp(join(homedir(), '.gemini', 'antigravity', 'mcp_config.json'), token),
+        notInstalledHint: 'Not installed (https://antigravity.google)',
+    },
+];
+/**
+ * Interactive multi-select picker with arrow keys + space + enter.
+ * Returns indices of selected items.
+ */
+function multiSelect(items) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw;
+        if (typeof stdin.setRawMode === 'function')
+            stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        let cursor = items.findIndex((i) => i.available);
+        if (cursor === -1)
+            cursor = 0;
+        const render = () => {
+            // Move cursor up to overwrite previous render (except first render)
+            for (let i = 0; i < items.length; i++) {
+                process.stdout.write('\x1b[2K'); // clear line
+                if (i < items.length - 1)
+                    process.stdout.write('\x1b[1A'); // move up
+            }
+            process.stdout.write('\r');
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                const pointer = i === cursor ? '›' : ' ';
+                const checkbox = !item.available
+                    ? '\x1b[2m[ ]\x1b[0m'
+                    : item.selected
+                        ? '\x1b[32m[x]\x1b[0m'
+                        : '[ ]';
+                const label = !item.available
+                    ? `\x1b[2m${item.label}\x1b[0m`
+                    : item.label;
+                const hint = !item.available && item.hint
+                    ? `  \x1b[2m${item.hint}\x1b[0m`
+                    : '';
+                process.stdout.write(`  ${pointer} ${checkbox} ${label}${hint}`);
+                if (i < items.length - 1)
+                    process.stdout.write('\n');
+            }
+        };
+        // Initial render: print blank lines then render
+        for (let i = 0; i < items.length; i++) {
+            process.stdout.write(i < items.length - 1 ? '\n' : '');
+        }
+        render();
+        const cleanup = () => {
+            if (typeof stdin.setRawMode === 'function')
+                stdin.setRawMode(wasRaw ?? false);
+            stdin.removeListener('data', onData);
+            stdin.pause();
+        };
+        const onData = (key) => {
+            // Ctrl+C
+            if (key === '\x03') {
+                cleanup();
+                process.stdout.write('\n');
+                process.exit(1);
+            }
+            // Enter — confirm selection
+            if (key === '\r' || key === '\n') {
+                cleanup();
+                process.stdout.write('\n');
+                const selected = [];
+                for (let i = 0; i < items.length; i++) {
+                    if (items[i].selected && items[i].available)
+                        selected.push(i);
+                }
+                resolve(selected);
+                return;
+            }
+            // Space — toggle current item
+            if (key === ' ') {
+                if (items[cursor].available) {
+                    items[cursor].selected = !items[cursor].selected;
+                    render();
+                }
+                return;
+            }
+            // Arrow keys (escape sequences)
+            if (key === '\x1b[A' || key === 'k') {
+                // Up
+                let next = cursor - 1;
+                while (next >= 0 && !items[next].available)
+                    next--;
+                if (next >= 0) {
+                    cursor = next;
+                    render();
+                }
+                return;
+            }
+            if (key === '\x1b[B' || key === 'j') {
+                // Down
+                let next = cursor + 1;
+                while (next < items.length && !items[next].available)
+                    next++;
+                if (next < items.length) {
+                    cursor = next;
+                    render();
+                }
+                return;
+            }
+            // 'a' — select all available
+            if (key === 'a') {
+                const allSelected = items.filter((i) => i.available).every((i) => i.selected);
+                for (const item of items) {
+                    if (item.available)
+                        item.selected = !allSelected;
+                }
+                render();
+                return;
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
 /**
  * Verify token by hitting the engine /api/usage endpoint.
  * Returns tier info on success, null on failure.
@@ -455,6 +628,32 @@ async function installCommands() {
     }
     return installed;
 }
+// ── Gitignore protection ───────────────────────────────────────────
+/**
+ * Ensure .rvry/ is in the project's .gitignore to prevent
+ * accidental commits of sensitive analysis content.
+ * Fails silently on any error.
+ */
+function ensureGitignore() {
+    const gitignorePath = join(process.cwd(), '.gitignore');
+    try {
+        let content = '';
+        if (existsSync(gitignorePath)) {
+            content = readFileSync(gitignorePath, 'utf-8');
+        }
+        if (!content.includes('.rvry')) {
+            const newContent = content ? `${content.trimEnd()}\n.rvry/\n` : '.rvry/\n';
+            writeFileSync(gitignorePath, newContent, 'utf-8');
+            console.log('  Added .rvry/ to .gitignore');
+        }
+        else {
+            console.log('  .rvry/ already in .gitignore');
+        }
+    }
+    catch {
+        // Non-fatal -- read-only filesystem, permissions, etc.
+    }
+}
 // ── Main setup flow ────────────────────────────────────────────────
 const BANNER = `
 8888888b.  888     888 8888888b. Y88b   d88P
@@ -484,11 +683,11 @@ export async function runSetup() {
             process.exit(1);
         }
         token = flagValue;
-        console.log('[1/4] Authentication (from --token flag)');
+        console.log('[1/5] Authentication (from --token flag)');
         console.log(`  Token: ${maskToken(token)}`);
     }
     else {
-        console.log('[1/4] Authentication');
+        console.log('[1/5] Authentication');
         console.log('  Opening browser for sign-in...');
         const result = await deviceAuthFlow();
         if (result) {
@@ -522,93 +721,68 @@ export async function runSetup() {
     }
     console.log('');
     // ── Step 2: Detect clients ──────────────────────────────────────
-    console.log('[2/4] Detecting Claude clients');
-    const hasClaudeCode = isClaudeCLIAvailable();
-    const hasDesktop = isClaudeDesktopInstalled();
-    const desktopConfigPath = getDesktopConfigPath();
-    const wantCode = !clientFilter || clientFilter === 'code';
-    const wantDesktop = !clientFilter || clientFilter === 'desktop';
-    if (hasClaudeCode && wantCode) {
-        console.log('  Found: Claude Code (claude CLI)');
-    }
-    if (hasDesktop && wantDesktop) {
-        console.log(`  Found: Claude Desktop (${desktopConfigPath})`);
+    console.log('[2/5] Detecting clients');
+    // Filter registry if --client was passed
+    const clients = clientFilter
+        ? CLIENT_REGISTRY.filter((c) => c.id === clientFilter)
+        : CLIENT_REGISTRY;
+    const detected = clients.map((c) => ({
+        client: c,
+        available: c.detect(),
+    }));
+    const anyDetected = detected.some((d) => d.available);
+    for (const d of detected) {
+        if (d.available) {
+            console.log(`  Found: ${d.client.name}`);
+        }
     }
-    if (!hasClaudeCode && !hasDesktop) {
-        console.log('  No Claude clients detected.');
+    if (!anyDetected) {
+        console.log('  No supported clients detected.');
     }
     console.log('');
     // ── Step 3: Configure clients ───────────────────────────────────
-    console.log('[3/4] Client Configuration');
-    let codeConfigured = false;
-    let desktopConfigured = 'skipped';
-    let neitherConfigured = true;
-    // Claude Code
-    if (hasClaudeCode && wantCode) {
-        const rl = createRL();
-        const answer = await ask(rl, '  Install for Claude Code? [Y/n] ');
-        rl.close();
-        if (answer.toLowerCase() !== 'n') {
-            const success = registerClaudeCode(token);
-            if (success) {
-                codeConfigured = true;
-                neitherConfigured = false;
-                console.log('  Claude Code:    Registered (user scope -- works in all projects)');
-            }
-            else {
-                console.log('  Claude Code:    Failed to register via CLI');
-            }
-        }
-        else {
-            console.log('  Claude Code:    Skipped');
-        }
-    }
-    else if (wantCode && !hasClaudeCode) {
-        console.log('  Claude Code:    CLI not found (install: https://docs.anthropic.com/en/docs/claude-code)');
-    }
-    // Claude Desktop / Co-Work
-    if (hasDesktop && wantDesktop) {
-        const rl = createRL();
-        const answer = await ask(rl, '  Install for Claude Desktop / Co-Work? [Y/n] ');
-        rl.close();
-        if (answer.toLowerCase() !== 'n') {
-            desktopConfigured = configureDesktop(token);
-            switch (desktopConfigured) {
-                case 'created':
-                    neitherConfigured = false;
-                    console.log('  Claude Desktop: Added RVRY to config');
-                    break;
-                case 'updated':
-                    neitherConfigured = false;
-                    console.log('  Claude Desktop: Updated RVRY token in config');
-                    break;
-                case 'unchanged':
-                    neitherConfigured = false;
-                    console.log('  Claude Desktop: Already configured with this token');
-                    break;
-                case 'error':
-                    console.log('  Claude Desktop: Failed to write config (see error above)');
-                    break;
-            }
-        }
-        else {
-            console.log('  Claude Desktop: Skipped');
-        }
+    console.log('[3/5] Select apps to add RVRY MCP configuration');
+    console.log('  Use \x1b[1m↑↓\x1b[0m to navigate, \x1b[1mspace\x1b[0m to toggle, \x1b[1ma\x1b[0m to toggle all, \x1b[1menter\x1b[0m to confirm');
+    console.log('');
+    const pickerItems = detected.map((d) => ({
+        label: d.client.name,
+        selected: d.available, // pre-select detected clients
+        available: d.available,
+        hint: d.available ? undefined : d.client.notInstalledHint,
+    }));
+    const selectedIndices = await multiSelect(pickerItems);
+    const configuredClients = [];
+    let anyConfigured = false;
+    console.log('');
+    for (const idx of selectedIndices) {
+        const { client } = detected[idx];
+        const result = client.configure(token);
+        const statusMap = {
+            ok: 'Configured',
+            updated: 'Updated token',
+            unchanged: 'Already configured',
+            error: 'Failed',
+        };
+        const status = statusMap[result] ?? result;
+        const icon = result === 'error' ? '✗' : '✓';
+        console.log(`  ${icon} ${client.name}: ${status}`);
+        configuredClients.push({ name: client.name, status });
+        if (result !== 'error')
+            anyConfigured = true;
     }
-    else if (wantDesktop && !hasDesktop) {
-        console.log('  Claude Desktop: Not installed');
+    if (selectedIndices.length === 0) {
+        console.log('  No clients selected.');
     }
     // Fallback: print manual config if nothing was configured
-    if (neitherConfigured) {
+    if (!anyConfigured) {
         console.log('');
         console.log('  Manual configuration:');
         console.log('');
         console.log('  Option A — Claude Code (if you install it later):');
         console.log(`    claude mcp add -e RVRY_TOKEN="${token}" -s user rvry -- npx @rvry/mcp`);
         console.log('');
-        console.log('  Option B — Claude Desktop config JSON:');
+        console.log('  Option B — JSON config (Claude Desktop, Codex, etc.):');
         const manualConfig = { mcpServers: { RVRY: RVRY_SERVER_ENTRY(token) } };
-        console.log(`    File: ${desktopConfigPath}`);
         console.log('');
         for (const line of JSON.stringify(manualConfig, null, 2).split('\n')) {
             console.log(`    ${line}`);
@@ -616,7 +790,7 @@ export async function runSetup() {
     }
     console.log('');
     // ── Step 4: Slash commands ──────────────────────────────────────
-    console.log('[4/4] Slash Commands');
+    console.log('[4/5] Slash Commands');
     const commandCount = await installCommands();
     if (commandCount > 0) {
         console.log(`  Installed ${commandCount} command${commandCount > 1 ? 's' : ''} to .claude/commands/`);
@@ -625,41 +799,46 @@ export async function runSetup() {
         console.log('  No new commands installed (already up to date).');
     }
     console.log('');
+    // ── Step 5: Gitignore protection ────────────────────────────────
+    console.log('[5/5] Gitignore');
+    ensureGitignore();
+    console.log('');
     // ── Summary ─────────────────────────────────────────────────────
     console.log('─'.repeat(50));
     console.log('');
     console.log('RVRY Setup Complete');
     console.log('');
     console.log(`  Token:          ${maskToken(token)}${usage ? ` (${usage.tier})` : ''}`);
-    if (codeConfigured) {
-        console.log('  Claude Code:    Configured');
-    }
-    if (desktopConfigured !== 'skipped' && desktopConfigured !== 'error') {
-        console.log('  Claude Desktop: Configured');
+    for (const c of configuredClients) {
+        const pad = ' '.repeat(Math.max(1, 16 - c.name.length));
+        console.log(`  ${c.name}:${pad}${c.status}`);
     }
     console.log(`  Commands:       ${commandCount} installed`);
     console.log('');
     // Client-specific next steps
+    const configuredNames = new Set(configuredClients.map((c) => c.name));
+    const hasDesktopStyle = configuredNames.has('Claude Desktop / Claude Co-Work')
+        || configuredNames.has('Anti-Gravity');
+    const hasCodeStyle = configuredNames.has('Claude Code');
     console.log('Next steps:');
-    const desktopOk = desktopConfigured !== 'skipped' && desktopConfigured !== 'error';
     let step = 1;
-    if (desktopOk) {
-        console.log(`  ${step}. Restart Claude Desktop for the new MCP server to load`);
+    if (hasDesktopStyle) {
+        console.log(`  ${step}. Restart desktop apps for the new MCP server to load`);
         step++;
     }
-    if (codeConfigured) {
+    if (hasCodeStyle) {
         console.log(`  ${step}. In Claude Code, try:`);
         console.log('     /deepthink "your question"');
         console.log('     /problem-solve "your decision"');
         step++;
     }
-    if (desktopOk) {
-        console.log(`  ${step}. In Claude Desktop, use natural language:`);
+    if (hasDesktopStyle) {
+        console.log(`  ${step}. In desktop clients, use natural language:`);
         console.log('     "Use deepthink to analyze..." or "Use problem-solve for..."');
         step++;
     }
-    if (!codeConfigured && !desktopOk) {
-        console.log('  1. Configure a Claude client using the manual instructions above');
+    if (!anyConfigured) {
+        console.log('  1. Configure a client using the manual instructions above');
         console.log('  2. Then try: /deepthink "your question"');
     }
     console.log('');

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@rvry/mcp",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "RVRY reasoning depth enforcement (RDE) engine client.",
   "type": "module",
   "bin": {
-    "rvry-mcp": "./dist/index.js"
+    "rvry-mcp": "dist/index.js"
   },
   "main": "./dist/index.js",
   "files": [