@rvry/mcp 0.7.2 → 0.8.0

package/README.md

@@ -19,50 +19,44 @@ Supported clients: **Claude Code**, **Claude Desktop**, **Cursor**, **Gemini CLI
 
 Restart any running clients after setup, and RVRY is ready.
 
-### Options
+### Manual Configuration
 
-```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 --accept-terms          # Accept ToS non-interactively
-```
-
-### Manual Installation
-
-**Claude Code:**
-```bash
-claude mcp add -e RVRY_TOKEN=rvry_your_token -s user rvry -- npx @rvry/mcp
-```
+For any MCP client that supports **stdio transport** (runs a local process), add this to your MCP config:
 
-**Claude Desktop** (`claude_desktop_config.json`):
 ```json
 {
-  "mcpServers": {
-    "RVRY": {
-      "command": "npx",
-      "args": ["@rvry/mcp"],
-      "env": {
-        "RVRY_TOKEN": "rvry_your_token_here"
-      }
+  "rvry": {
+    "command": "npx",
+    "args": ["@rvry/mcp"],
+    "env": {
+      "RVRY_TOKEN": "your_rvry_token"
     }
   }
 }
 ```
 
-Config file locations:
-- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
-- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
-- Linux: `~/.config/Claude/claude_desktop_config.json`
+Get your token at [rvry.ai/dashboard](https://rvry.ai/dashboard) after signing up.
+
+### Compatibility
+
+RVRY uses **stdio transport** (a local process that communicates over stdin/stdout). This works with clients that run MCP servers locally:
 
-**Other MCP clients:**
+| Works | Client |
+|-------|--------|
+| Yes | Claude Code, Claude Desktop, Cursor, Gemini CLI, Codex, Anti-Gravity |
+| Yes | Any client that supports `command` + `args` MCP config |
+| No | Web-based clients that require an HTTP/SSE MCP server URL (e.g. Perplexity) |
 
-Any client that supports MCP can use RVRY. Point it at `npx @rvry/mcp` with the environment variable `RVRY_TOKEN` set to your token.
+HTTP transport support is planned.
 
 ## 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.
+| Tool | What it does | Tier |
+|------|-------------|------|
+| **`RVRY_deepthink`** | Extended multi-round analysis. Catches assumptions, tests them, and doesn't let your AI wrap up until it's dealt with what it found. | All |
+| **`RVRY_problem_solve`** | Structured decision-making. Forces orientation, anticipation, and evaluation before committing to a recommendation. | Pro+ |
+| **`RVRY_challenge`** | Adversarial stress-testing. Finds weaknesses, tests assumptions, and surfaces failure modes in a proposal before you commit. | Pro+ |
+| **`RVRY_meta`** | Sustained metacognitive observation. Examines how your AI is thinking, not just what it's thinking. | Max |
 
 ## How it Works
 
@@ -76,10 +70,10 @@ On hard questions, a smaller model with RVRY outperforms a bigger model without
 
 ## Pricing
 
-| Plan | Runs | Price |
-|------|------|-------|
-| Free | 5/month | $0 |
-| Pro | 25/month | $20/mo |
-| Max | Unlimited | $100/mo |
+| Plan | Sessions | Tools | Price |
+|------|----------|-------|-------|
+| Free | 5/month | deepthink | $0 |
+| Pro | 21/month | deepthink, problem_solve, challenge | $20/mo |
+| Max | Unlimited | All tools including meta | $99/mo |
 
 Sign up at [rvry.ai](https://rvry.ai).

package/dist/client.d.ts

@@ -13,7 +13,7 @@ export interface ScopingQuestion {
 }
 export interface ThinkResponse {
     sessionId: string;
-    status: 'scoping' | 'active' | 'complete';
+    status: 'scoping' | 'orient' | 'active' | 'complete';
     round: number;
     prompt: string;
     instruction: string;
@@ -32,10 +32,11 @@ export interface ThinkResponse {
             question: string;
             rationale: string;
         }>;
+        constraintTrace?: unknown[];
     };
 }
 /**
  * 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>;
+export declare function callTool(tool: RvryTool, input: string, token: string, sessionId?: string, skipScoping?: boolean, userConstraints?: string[]): Promise<ThinkResponse>;

package/dist/client.js

@@ -7,7 +7,7 @@ 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) {
+export async function callTool(tool, input, token, sessionId, skipScoping, userConstraints) {
     const baseUrl = process.env.RVRY_ENGINE_URL ?? DEFAULT_ENGINE_URL;
     const body = { input, tool };
     if (sessionId) {
@@ -16,6 +16,9 @@ export async function callTool(tool, input, token, sessionId, skipScoping) {
     if (skipScoping) {
         body.skipScoping = true;
     }
+    if (userConstraints && userConstraints.length > 0) {
+        body.userConstraints = userConstraints;
+    }
     const res = await fetch(`${baseUrl}/api/v1/think`, {
         method: 'POST',
         headers: {

package/dist/index.js

@@ -40,8 +40,12 @@ const TOOL_DEFS = [
     {
         name: 'RVRY_deepthink',
         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. ' +
+            'Runs 5-7 rounds of rigorous analysis with self-checks and adversarial stress-testing. ' +
+            'The first response orients you on the question — follow the instruction field to orient, then call again. ' +
+            'Each subsequent round returns a prompt (work through it internally) and an instruction (follow it). ' +
+            'Show the user only a brief status line per round (e.g. \'Round 3 — stress-testing the position\'). ' +
+            'Do not display the prompt text, internal tracking data, or quality assessments to the user. ' +
+            'On completion, present key findings with bold headings. Lead with insights, not process. ' +
             'Call with your question to start, then send your analysis with the returned sessionId to continue.',
         inputSchema: {
             type: 'object',
@@ -58,14 +62,24 @@ const TOOL_DEFS = [
                     type: 'boolean',
                     description: 'Skip the scoping questions phase and begin analysis immediately.',
                 },
+                userConstraints: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'User-stated directives or requirements to track throughout the session.',
+                },
             },
             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. ' +
+        description: 'Structured decision-making that forces thorough evaluation before commitment. ' +
+            'Runs 5-8 rounds through orient, anticipate, generate, evaluate, and commit phases. ' +
+            'The first response orients you — follow the instruction field, then call again. ' +
+            'Each round returns a prompt and instruction. Work through the prompt internally. ' +
+            'Show the user only a brief status line per round (e.g. \'Round 2 — mapping failure modes\'). ' +
+            'Do not display the prompt text, internal tracking data, or quality assessments to the user. ' +
+            'On completion, present the recommendation with confidence, stress test results, and safeguards. ' +
             'Call with your problem to start, then send your analysis with the returned sessionId to continue.',
         inputSchema: {
             type: 'object',
@@ -82,15 +96,23 @@ const TOOL_DEFS = [
                     type: 'boolean',
                     description: 'Skip the scoping questions phase and begin analysis immediately.',
                 },
+                userConstraints: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'User-stated directives or requirements to track throughout the session.',
+                },
             },
             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. ' +
+        description: 'Structured analysis for questions needing more depth than a quick answer. ' +
+            'Runs 2-4 rounds with tracking to ensure assumptions are examined. ' +
+            'The first response orients you — follow the instruction field, then call again. ' +
+            'Each round returns a prompt and instruction. Work through the prompt internally. ' +
+            'Show the user only a brief status line per round. Do not display internal data. ' +
+            'On completion, present findings clearly with bold headings. ' +
             'Call with your question to start, then send your analysis with the returned sessionId to continue.',
         inputSchema: {
             type: 'object',
@@ -107,16 +129,23 @@ const TOOL_DEFS = [
                     type: 'boolean',
                     description: 'Skip the scoping questions phase and begin analysis immediately.',
                 },
+                userConstraints: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'User-stated directives or requirements to track throughout the session.',
+                },
             },
             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. ' +
+        description: 'Adversarial analysis that stress-tests a proposal or idea before commitment. ' +
+            'Runs 4-6 rounds identifying weaknesses, testing assumptions, and surfacing failure modes. ' +
+            'The first response orients you — follow the instruction field, then call again. ' +
+            'Each round returns a prompt and instruction. Work through the prompt internally. ' +
+            'Show the user only a brief status line per round. Do not display internal data. ' +
+            'On completion, present a verdict (GO / CONDITIONAL GO / NO GO) with evidence. ' +
             'Call with your proposal to start, then send your analysis with the returned sessionId to continue.',
         inputSchema: {
             type: 'object',
@@ -133,17 +162,23 @@ const TOOL_DEFS = [
                     type: 'boolean',
                     description: 'Skip the scoping questions phase and begin analysis immediately.',
                 },
+                userConstraints: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'User-stated directives or requirements to track throughout the session.',
+                },
             },
             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. ' +
+        description: 'Sustained metacognitive observation of reasoning defaults and trained reflexes. ' +
+            'Runs 3 rounds: observe, deepen, synthesize. Max tier only. ' +
+            'The first response sets the observation frame — follow the instruction field, then call again. ' +
+            'Each round returns a prompt. Reflect honestly, then call again with your reflection. ' +
+            'Show the user only a brief status note per round. Do not display internal prompts. ' +
+            'On completion, present a cohesive narrative reflection — not a structured report. ' +
             'Call with your topic to start, then send your reflection with the returned sessionId to continue.',
         inputSchema: {
             type: 'object',
@@ -176,8 +211,12 @@ function stripResponse(result, question) {
         stripped.prompt = result.prompt;
         stripped.instruction = result.instruction;
     }
+    if (result.status === 'orient') {
+        stripped.instruction = result.instruction;
+    }
     if (result.status === 'complete' && result.harvest) {
-        stripped.harvest = result.harvest;
+        const { constraintTrace, ...harvestSafe } = result.harvest;
+        stripped.harvest = harvestSafe;
     }
     if (result.usage) {
         const { used, limit } = result.usage;
@@ -223,6 +262,9 @@ async function main() {
         }
         const sessionId = typeof typedArgs?.sessionId === 'string' ? typedArgs.sessionId : undefined;
         const skipScoping = typedArgs?.skipScoping === true;
+        const userConstraints = Array.isArray(typedArgs?.userConstraints)
+            ? typedArgs.userConstraints.filter(s => typeof s === 'string')
+            : undefined;
         // Cache question on first call (no sessionId = new session)
         // On continuation calls, read from cache
         let question = input;
@@ -233,7 +275,7 @@ async function main() {
             question = questionCache.get(sessionId) ?? input;
         }
         try {
-            const result = await callTool(rvryTool, input, token, sessionId, skipScoping || undefined);
+            const result = await callTool(rvryTool, input, token, sessionId, skipScoping || undefined, userConstraints);
             // Cache question on first call (now we have the sessionId)
             if (!sessionId) {
                 questionCache.set(result.sessionId, input);

package/dist/setup.js

@@ -20,10 +20,6 @@ import { fetch } from './fetch.js';
 const require = createRequire(import.meta.url);
 const PKG_VERSION = require('../package.json').version;
 const ENGINE_URL = 'https://engine.rvry.ai';
-const COMMAND_FILES = [
-    'deepthink.md',
-    'problem-solve.md',
-];
 const TOKEN_REGEX = /^rvry_[0-9a-f]{32,}$/;
 /** Polling interval for device auth: 3 seconds */
 const POLL_INTERVAL_MS = 3000;
@@ -36,47 +32,6 @@ const RVRY_SERVER_ENTRY = (token) => ({
     env: { RVRY_TOKEN: token },
 });
 // ── 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.
  */
@@ -726,31 +681,6 @@ async function getToken() {
         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;
-}
 // ── Gitignore protection ───────────────────────────────────────────
 /**
  * Ensure .rvry/ is in the project's .gitignore to prevent
@@ -798,7 +728,7 @@ export async function runSetup() {
     const clientFilter = clientFlagIndex !== -1 ? process.argv[clientFlagIndex + 1] : null;
     const acceptTerms = process.argv.includes('--accept-terms');
     // ── Step 1: Terms of Service ────────────────────────────────────
-    console.log('[1/6] Terms of Service');
+    console.log('[1/5] Terms of Service');
     console.log('');
     console.log('  By continuing, you agree to the RVRY Terms of Service');
     console.log('  and Privacy Policy:');
@@ -831,11 +761,11 @@ export async function runSetup() {
             process.exit(1);
         }
         token = flagValue;
-        console.log('[2/6] Authentication (from --token flag)');
+        console.log('[2/5] Authentication (from --token flag)');
         console.log(`  Token: ${maskToken(token)}`);
     }
     else {
-        console.log('[2/6] Authentication');
+        console.log('[2/5] Authentication');
         console.log('  Opening browser for sign-in...');
         const result = await deviceAuthFlow();
         if (result) {
@@ -869,7 +799,7 @@ export async function runSetup() {
     }
     console.log('');
     // ── Step 2: Detect clients ──────────────────────────────────────
-    console.log('[3/6] Detecting clients');
+    console.log('[3/5] Detecting clients');
     // Filter registry if --client was passed
     const clients = clientFilter
         ? CLIENT_REGISTRY.filter((c) => c.id === clientFilter)
@@ -889,7 +819,7 @@ export async function runSetup() {
     }
     console.log('');
     // ── Step 3: Configure clients ───────────────────────────────────
-    console.log('[4/6] Select apps to add RVRY MCP configuration');
+    console.log('[4/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) => ({
@@ -946,18 +876,8 @@ export async function runSetup() {
         console.log(`    RVRY_TOKEN = "${token}"`);
     }
     console.log('');
-    // ── Step 4: Slash commands ──────────────────────────────────────
-    console.log('[5/6] Slash Commands');
-    const commandCount = await installCommands();
-    if (commandCount > 0) {
-        console.log(`  Installed ${commandCount} command${commandCount > 1 ? 's' : ''} to .claude/commands/`);
-    }
-    else {
-        console.log('  No new commands installed (already up to date).');
-    }
-    console.log('');
-    // ── Step 5: Gitignore protection ────────────────────────────────
-    console.log('[6/6] Gitignore');
+    // ── Step 4: Gitignore protection ────────────────────────────────
+    console.log('[5/5] Gitignore');
     ensureGitignore();
     console.log('');
     // ── Summary ─────────────────────────────────────────────────────
@@ -970,7 +890,6 @@ export async function runSetup() {
         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));
@@ -995,19 +914,12 @@ export async function runSetup() {
     }
     console.log('');
     step++;
-    if (hasCodeStyle) {
-        console.log(`  ${step}. In Claude Code, try:`);
-        console.log('     /deepthink "your question"');
-        console.log('     /problem-solve "your decision"');
-        step++;
-    }
-    if (hasDesktopStyle) {
-        console.log(`  ${step}. In desktop clients, use natural language:`);
-        console.log('     "Use deepthink to analyze..." or "Use problem-solve for..."');
+    if (hasCodeStyle || hasDesktopStyle) {
+        console.log(`  ${step}. Try: "Use RVRY_deepthink to analyze..." or "Use RVRY_problem_solve for..."`);
         step++;
     }
     if (!anyConfigured) {
         console.log('  1. Configure a client using the manual instructions above');
-        console.log('  2. Then try: /deepthink "your question"');
+        console.log('  2. Then try: "Use RVRY_deepthink to analyze..."');
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rvry/mcp",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "RVRY reasoning depth enforcement (RDE) engine client.",
   "type": "module",
   "bin": {
@@ -9,7 +9,6 @@
   "main": "./dist/index.js",
   "files": [
     "dist",
-    "commands",
     "!dist/**/*.test.*"
   ],
   "engines": {

package/commands/deepthink.md

@@ -1,307 +0,0 @@
----
-description: Deep structured analysis for high-stakes questions via RVRY
-argument-hint: [--auto] <question>
-allowed-tools:
-  - mcp__rvry-dev__deepthink
-  - AskUserQuestion
-  - Read
-  - Write
-  - Grep
-  - Glob
-  - Bash
----
-
-# /deepthink - Deep Structured Analysis
-
-**YOUR ROLE**: Execute depth-first exploration with adaptive pre-mortems after conclusion-producing rounds. DIVERGENT thinking -- exploring questions, generating hypotheses, stress-testing conclusions before they solidify. For CONVERGENT decision-making, use `/problem-solve`.
-
-**Input**: $ARGUMENTS
-
----
-
-## Phase 0: Parse Flags
-
-- If `$ARGUMENTS` is empty or `--help`: display usage and stop:
-  ```
-  /deepthink - Deep Structured Analysis via RVRY
-
-  USAGE:
-    /deepthink <question>
-    /deepthink --auto <question>   (fully autonomous, no questions, states assumptions)
-
-  The engine runs multi-round analysis with constraint tracking, quality gates,
-  and reasoning checks. Local persistence survives context compression.
-
-  RELATED: /problem-solve (convergent decision-making)
-  ```
-- If `$ARGUMENTS` contains `--auto`: set AUTO_MODE, strip `--auto` from input
-
----
-
-## Phase 1: Session Setup
-
-Create a session folder for local artifacts that survive context compression:
-
-1. Generate a timestamp: `YYYYMMDD-HHMM` (current date/time)
-2. Generate a slug from the question summary (3-4 words, kebab-case)
-3. Create `{$PWD}/.claude/cognition/YYYYMMDD-HHMM-deepthink-<slug>/`
-   IMPORTANT: This is the PROJECT's `.claude/`, NOT `~/.claude/`. Use the absolute project root path.
-4. Write `00-enter.md`:
-   ```markdown
-   # DeepThink Session
-   **Question**: <full question>
-   **Started**: <timestamp>
-   ```
-
----
-
-## Phase 2: ORIENT (before calling the engine)
-
-Orient directly -- no engine calls yet. This forces commitment to disk before the analysis loop. Everything written here survives if context compresses mid-session.
-
-### `01-orient.md`:
-Write to the session folder:
-- **What I know**: Key facts, evidence, and context apparent from the question
-- **What I'm uncertain about**: Gaps, assumptions, unknowns (list each specifically)
-- **What I'm avoiding**: Uncomfortable angles, taboo options, things that would be inconvenient if true
-
-### `02-scope-questions.md`:
-Translate each uncertainty into a binary question with a smart default. Generate up to 3 questions, each with exactly 2 options. The recommended option comes first.
-
-Write the questions to the file BEFORE asking.
-
-### If AUTO_MODE:
-
-State your assumptions visibly (e.g., "Assuming focus on architectural trade-offs rather than implementation details."). Write assumptions to `03-scope-answers.md`. Proceed to Phase 3.
-
-### If NOT AUTO_MODE:
-
-Ask scope questions via `AskUserQuestion` (up to 3 questions, each with 2 options, smart default first marked "(Recommended)").
-
-```
-AskUserQuestion({
-  questions: [
-    {
-      question: "<derived from uncertainty>",
-      header: "<short label>",
-      options: [
-        { label: "<recommended option> (Recommended)", description: "<why this is the smart default>" },
-        { label: "<alternative option>", description: "<when this makes sense>" }
-      ],
-      multiSelect: false
-    }
-  ]
-})
-```
-
-If AskUserQuestion returns blank or fails, state assumptions visibly and proceed.
-
-Record the answers (or stated assumptions) in `03-scope-answers.md`.
-
----
-
-## Phase 3: Start Engine Session
-
-Format the user's original question enriched with scope context from `03-scope-answers.md`.
-
-Call `mcp__rvry-dev__deepthink` with:
-```
-{
-  "input": "<original question>\n\nContext: <brief summary of scope answers>"
-}
-```
-
-Proceed to Phase 4.
-
----
-
-## Phase 4: Analysis Loop
-
-Repeat until `status === "complete"`:
-
-### Step 1: Read the engine response
-
-Read the engine's `question` field -- this is the analytical direction for this round. Read `constraints`, `gate`, and `detection` to understand the engine's assessment. Read `constraintBlock` for constraint update instructions.
-
-### Step 2: Show status
-
-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 question focus. One line only.
-
-### Step 3: Perform analysis
-
-Analyze according to the engine's question and constraint data. The engine's question and constraints guide your thinking -- work WITH them, not around them.
-
-Use Read, Grep, Glob, and Bash as needed to ground your analysis in actual code, data, or project state. Do not analyze in the abstract when concrete evidence is available.
-
-### Step 4: 7-Question Self-Check (mandatory, internal)
-
-**Internal**:
-1. Is this shallow or predictable?
-2. What am I avoiding?
-3. Why not the uncomfortable option?
-
-**External**:
-4. What would I critique if someone else wrote this?
-5. What would a skeptical expert challenge?
-6. Any verifiable claims that should be checked?
-
-**Grounding**:
-7. What factual premise in this analysis have I not verified?
-
-### Step 5: Verify-or-Defer (mandatory after self-check)
-
-For each concern raised in Q5, Q6, or Q7, you MUST either:
-- **VERIFY**: Actually check the claim -- read a file, grep for a pattern, run a command. Record what was verified and the result.
-- **DEFER**: Explicitly state the concern and why it cannot be verified now. Express as a DEFER in the constraint update block.
-
-**No dismiss**: You CANNOT raise a concern and then argue it away in the same self-check. If you raise it, you must verify or defer it.
-
-### Step 6: Weakness Probe (rotate by round number)
-
-Ask yourself ONE of these:
-1. Which part of your analysis would you spend more time on if you had another round?
-2. If your recommendation fails in practice, what is the first concrete thing someone notices?
-3. What surprised you during this analysis? If nothing, what does that tell you?
-4. What is the thing you almost said but did not?
-5. Which of your claims would you remove if you had to stake your credibility on the remaining ones?
-6. Your strongest claim and your most significant caveat -- are they in tension? If so, which do you stand behind?
-
-Include the probe answer in your analysis.
-
-### Step 7: Write constraint updates and submit
-
-End your analysis with the constraint update block:
-```
-Constraint Updates
-RESOLVE: C1, C2
-ACKNOWLEDGE: C3
-DEFER: C4 | <reason>
-MILESTONE: <milestone> | <evidence>
-End Constraint Updates
-```
-
-Call the engine tool with your full analysis (including constraint updates, self-check findings, and verify-or-defer results) as the `input`.
-
-### What the user sees per round:
-- The one-line status (Step 2)
-- Nothing else until harvest
-
-### What NEVER appears in user-visible output:
-- The engine's `question` field content
-- Constraint views or constraint update blocks
-- Self-check questions or responses
-- Gate verdicts or detection results
-- The `constraintBlock` content
-
----
-
-## Phase 5: Harvest
-
-When `status === "complete"`:
-
-### Harvest Pre-Mortem (before synthesis)
-
-Before writing the final output, stress-test the direction of your analysis:
-
-1. What was the original question?
-2. What is my emerging recommendation/position?
-3. What is the gap between the two in complexity and scope?
-4. If the recommendation is more complex than the original problem warranted, what is the simpler version?
-
-**Check for COMPLEXITY-COLLAPSE**: Did the analysis elaborate a simple problem until the complexity justified a complex solution? If yes, name the simpler alternative and present it prominently in the output.
-
-### Write `99-harvest.md`
-
-Write to the session folder:
-```markdown
-# DeepThink Harvest: [Problem Summary]
-
-## Summary
-[2-3 sentence executive summary]
-
-## Key Findings
-- [finding 1]
-- [finding 2]
-- [finding 3]
-
-## Open Questions
-- [what remains uncertain]
-
-## Follow-ups
-- /deepthink "[specific follow-up]" -- [why]
-- /problem-solve "[specific decision]" -- [why]
-```
-
-### Confirm persistence to user
-
-After writing 99-harvest.md:
-```
----
-Session persisted: <absolute path to session folder>
----
-```
-
-### Synthesize for the user
-
-Use the engine's `harvest.summary`, `harvest.keyFindings`, `harvest.openQuestions`, and `harvest.followUps` as source material, plus your accumulated reasoning across all rounds and the harvest pre-mortem results.
-
----
-
-## Final Output Format
-
-The sections above the break are the value-add -- what the process surfaced that a straight answer wouldn't have. The prose after the break is just the answer.
-
-```
-# DeepThink: [Problem Summary]
-
-## Default Starting Point
-[Where thinking began -- assumptions, knowns, open questions.]
-
-## Insights from DeepThink
-
-**[Finding as a clear statement.]**
-[Expand if needed. Skip if the bold line is self-sufficient.] (#tag-if-relevant)
-
-**[Another finding.]**
-[Context if needed.]
-
-**[Simple finding that needs no expansion.]** (#pre-mortem)
-
-[Format for human readability in terminal:
-- Each finding gets its own appropriate visual unit (bold heading,
-  bullet, or short paragraph)
-- Bullets for simple/parallel items. Bold heading + paragraph for
-  complex ones. Mix freely.
-- No walls of text. If a paragraph runs long, break it.
-- Lead with the IDEA, never the mode name
-- Never describe the protocol's mechanics or your analytical process
-- (#tags) are optional breadcrumbs: (#pre-mortem), (#inversion),
-  (#edge), (#perspective), (#meta). Most findings need no tag.
-- Curate your best 3-6 findings, not every observation from every round.]
-
----
-
-[The answer. No heading. What you actually think now, informed by
-everything above. No dense paragraphs. No prescribed length.
-Never start with "The exploration..." or "After analyzing..."]
-
-## Follow-ups
--> /problem-solve "[specific decision point]"
-   _[why this needs convergent decision-making]_
--> /deepthink "[specific follow-up]"
-   _[why this needs further exploration]_
-```
-
----
-
-## Key Differences from /problem-solve
-
-| /deepthink | /problem-solve |
-|------------|----------------|
-| Divergent + pre-mortems | Convergent - decide, commit |
-| 7-question self-check + probe + verify-or-defer | Phase gates + probe |
-| Explores the question space | Narrows to a decision |
-| Valid: "more confused in useful ways" | Valid: clear decision + safeguards |

package/commands/problem-solve.md

@@ -1,334 +0,0 @@
----
-description: Convergent decision-making pipeline via RVRY
-argument-hint: [--auto] <problem or decision>
-allowed-tools:
-  - mcp__rvry-dev__problem_solve
-  - AskUserQuestion
-  - Read
-  - Write
-  - Grep
-  - Glob
-  - Bash
----
-
-# /problem-solve - Convergent Decision-Making
-
-**YOUR ROLE**: Execute a convergent decision pipeline. The engine handles the structured analysis phases (orient, anticipate, generate, evaluate, commit). You handle local persistence, self-discipline, and grounding claims in evidence. For DIVERGENT exploration, use `/deepthink`.
-
-**Input**: $ARGUMENTS
-
----
-
-## Phase 0: Parse Flags
-
-- If `$ARGUMENTS` is empty or `--help`: display usage and stop:
-  ```
-  /problem-solve - Convergent Decision-Making via RVRY
-
-  USAGE:
-    /problem-solve <problem or decision>
-    /problem-solve --auto <problem>   (fully autonomous, no questions, states assumptions)
-
-  The engine runs a multi-round decision pipeline with constraint tracking,
-  quality gates, and reasoning checks. Local persistence survives context compression.
-
-  RELATED: /deepthink (divergent exploration)
-  ```
-- If `$ARGUMENTS` contains `--auto`: set AUTO_MODE, strip `--auto` from input
-
----
-
-## Phase 1: Session Setup
-
-Create a session folder for local artifacts that survive context compression:
-
-1. Generate a timestamp: `YYYYMMDD-HHMM` (current date/time)
-2. Generate a slug from the problem summary (3-4 words, kebab-case)
-3. Create `{$PWD}/.claude/cognition/YYYYMMDD-HHMM-problemsolve-<slug>/`
-   IMPORTANT: This is the PROJECT's `.claude/`, NOT `~/.claude/`. Use the absolute project root path.
-4. Write `00-enter.md`:
-   ```markdown
-   # ProblemSolve Session
-   **Problem**: <full problem statement>
-   **Started**: <timestamp>
-   ```
-
----
-
-## Phase 2: ORIENT (before calling the engine)
-
-Orient directly -- no engine calls yet. This forces commitment to disk before the analysis loop. Everything written here survives if context compresses mid-session.
-
-### `01-orient.md`:
-Write to the session folder:
-- **What is the problem?**: The decision or problem in concrete terms
-- **What is uncertain?**: Gaps, assumptions, unknowns (list each specifically)
-- **What am I avoiding?**: Uncomfortable options, risky paths, things that would be inconvenient if true
-
-### `02-scope-questions.md`:
-Translate each uncertainty into a binary question with a smart default. Generate up to 3 questions, each with exactly 2 options. The recommended option comes first.
-
-Write the questions to the file BEFORE asking.
-
-### If AUTO_MODE:
-
-State your assumptions visibly (e.g., "Assuming risk minimization over speed. Assuming known options need evaluation rather than generating new alternatives."). Write assumptions to `03-scope-answers.md`. Proceed to Phase 3.
-
-### If NOT AUTO_MODE:
-
-Ask scope questions via `AskUserQuestion` (up to 3 questions, each with 2 options, smart default first marked "(Recommended)").
-
-```
-AskUserQuestion({
-  questions: [
-    {
-      question: "<derived from uncertainty>",
-      header: "<short label>",
-      options: [
-        { label: "<recommended option> (Recommended)", description: "<why this is the smart default>" },
-        { label: "<alternative option>", description: "<when this makes sense>" }
-      ],
-      multiSelect: false
-    }
-  ]
-})
-```
-
-If AskUserQuestion returns blank or fails, state assumptions visibly and proceed.
-
-Record the answers (or stated assumptions) in `03-scope-answers.md`.
-
----
-
-## Phase 3: Start Engine Session
-
-Format the user's original problem enriched with scope context from `03-scope-answers.md`.
-
-Call `mcp__rvry-dev__problem_solve` with:
-```
-{
-  "input": "<original problem>\n\nContext: <brief summary of scope answers>"
-}
-```
-
-Proceed to Phase 4.
-
----
-
-## Phase 4: Analysis Loop
-
-Repeat until `status === "complete"`:
-
-### Step 1: Read the engine response
-
-Read the engine's `question` field -- this is the analytical direction for this round. Read `constraints`, `gate`, and `detection` to understand the engine's assessment. Read `constraintBlock` for constraint update instructions.
-
-### Step 2: Show status
-
-Show the user a brief status line:
-- Format: `Round {round} -- {what you're doing this round}`
-- Example: `Round 2 -- mapping failure modes`
-- Derive the description from the engine's question focus. One line only.
-
-### Step 3: Perform analysis
-
-Analyze according to the engine's question and constraint data. The engine's question and constraints guide your thinking -- work WITH them, not around them.
-
-Use Read, Grep, Glob, and Bash as needed to ground your analysis in actual code, data, or project state. Do not analyze in the abstract when concrete evidence is available.
-
-### Step 4: 7-Question Self-Check (mandatory, internal)
-
-**Internal**:
-1. Is this shallow or predictable?
-2. What am I avoiding?
-3. Why not the uncomfortable option?
-
-**External**:
-4. What would I critique if someone else wrote this?
-5. What would a skeptical expert challenge?
-6. Any verifiable claims that should be checked?
-
-**Grounding**:
-7. What factual premise in this analysis have I not verified?
-
-### Step 5: Verify-or-Defer (mandatory after self-check)
-
-For each concern raised in Q5, Q6, or Q7, you MUST either:
-- **VERIFY**: Actually check the claim -- read a file, grep for a pattern, run a command. Record what was verified and the result.
-- **DEFER**: Explicitly state the concern and why it cannot be verified now. Express as a DEFER in the constraint update block.
-
-**No dismiss**: You CANNOT raise a concern and then argue it away in the same self-check. If you raise it, you must verify or defer it.
-
-### Step 6: Weakness Probe (rotate by round number)
-
-Ask yourself ONE of these:
-1. Which part of your analysis would you spend more time on if you had another round?
-2. If your recommendation fails in practice, what is the first concrete thing someone notices?
-3. What surprised you during this analysis? If nothing, what does that tell you?
-4. What is the thing you almost said but did not?
-5. Which of your claims would you remove if you had to stake your credibility on the remaining ones?
-6. Your strongest claim and your most significant caveat -- are they in tension? If so, which do you stand behind?
-
-Include the probe answer in your analysis.
-
-### Step 7: Write constraint updates and submit
-
-End your analysis with the constraint update block:
-```
-Constraint Updates
-RESOLVE: C1, C2
-ACKNOWLEDGE: C3
-DEFER: C4 | <reason>
-MILESTONE: <milestone> | <evidence>
-End Constraint Updates
-```
-
-Call the engine tool with your full analysis (including constraint updates, self-check findings, and verify-or-defer results) as the `input`.
-
-### What the user sees per round:
-- The one-line status (Step 2)
-- Nothing else until harvest
-
-### What NEVER appears in user-visible output:
-- The engine's `question` field content
-- Constraint views or constraint update blocks
-- Self-check questions or responses
-- Gate verdicts or detection results
-- The `constraintBlock` content
-
----
-
-## Phase 5: Harvest
-
-When `status === "complete"`:
-
-### Harvest Pre-Mortem (before synthesis)
-
-Before writing the final output, stress-test the direction of your analysis:
-
-1. What was the original problem?
-2. What is my recommendation now?
-3. What is the gap between the two in complexity and scope?
-4. If the recommendation is more complex than the original problem warranted, what is the simpler version?
-
-**Check for COMPLEXITY-COLLAPSE**: Did the analysis elaborate a simple problem until the complexity justified a complex solution? If yes, name the simpler alternative and present it prominently.
-
-### Write `99-harvest.md`
-
-Write to the session folder:
-```markdown
-# ProblemSolve Harvest: [Problem Summary]
-
-## Summary
-[2-3 sentence executive summary of decision + rationale]
-
-## Decision
-[The recommendation with confidence level]
-
-## Key Risks
-- [risk 1 and its safeguard]
-- [risk 2 and its safeguard]
-
-## Alternatives Considered
-- [alternative 1] -- eliminated because [reason]
-- [alternative 2] -- eliminated because [reason]
-
-## Open Questions
-- [what remains uncertain]
-
-## Follow-ups
-- /deepthink "[uncertainty]" -- [why this needs exploration]
-- /problem-solve "[next decision]" -- [why this needs its own analysis]
-```
-
-### Confirm persistence to user
-
-After writing 99-harvest.md:
-```
----
-Session persisted: <absolute path to session folder>
----
-```
-
-### Synthesize for the user
-
-Use the engine's `harvest.summary`, `harvest.keyFindings`, `harvest.openQuestions`, and `harvest.followUps` as source material, plus your accumulated reasoning across all rounds and the harvest pre-mortem results.
-
----
-
-## Final Output Format
-
-The output is decision-first. The reader gets the answer immediately, then supporting evidence. This reflects convergent thinking: narrow toward commitment, not expand toward synthesis.
-
-```
-# ProblemSolve: [Problem Summary]
-
-## Analysis
-
-[Problem framing -- what the situation was and what triggered
-this analysis. 1-2 sentences.]
-
-[Reasoning arc -- what the analysis revealed that confirmed,
-redirected, or complicated the initial instinct. Where the
-reasoning turned. What would change the verdict.
-
-State the chosen direction clearly at the end of this section.
-The reader should know what you're recommending before they
-read the stress test.]
-
-[For simple decisions, these can collapse into a shorter
-form. The point is readability, not rigid structure.]
-
-## Stress Test
-
-**"[Risk or adversarial challenge]"**
-[How it was tested and what happened. Did the decision survive,
-adapt, or need revision? Plain prose, no arrows.]
-
-**"[Another risk]"**
-[Response and outcome.]
-
-## Alternative Options
-- **[What the alternative was]**: Eliminated because [reason].
-- **[What the alternative was]**: Eliminated because [reason].
-
-[Do NOT reference "Option A/B/C" labels. The reader hasn't
-seen an option tree. Name each alternative by what it actually
-is, then explain why it was rejected.]
-
-## Recommendation
-**[Decision statement]** (confidence: X.X)
-
-[Why this is the go-forward path -- the synthesis of the analysis
-and stress test above. 1-3 sentences connecting the reasoning
-to the commitment.]
-
-**Safeguards:**
-[Specific commitments to prevent the failures identified above.]
-
-[Format for human readability in terminal:
-- The Decision can be multi-part or compact -- match the complexity
-  of the actual decision
-- Stress Test entries: bold risk, plain response. No arrows, no
-  mechanism names.
-- Never reference the protocol's internal phases, gates, or
-  mechanism names in user-facing output
-- No walls of text. Break long paragraphs.]
-
-## Where to Go Next
--> /deepthink "[uncertainty needing exploration]"
-   _[why this needs adversarial testing]_
--> /problem-solve "[next decision point]"
-   _[if a follow-on decision is needed]_
-```
-
----
-
-## Key Differences from /deepthink
-
-| /problem-solve | /deepthink |
-|----------------|------------|
-| Convergent - decide, commit | Divergent + pre-mortems |
-| Phase gates + probe | 7-question self-check + probe + verify-or-defer |
-| Narrows to a decision | Explores the question space |
-| Valid: clear decision + safeguards | Valid: "more confused in useful ways" |