@rvry/mcp 0.13.0 → 1.2.0

package/README.md

@@ -41,8 +41,10 @@ Get your token at [rvry.ai/dashboard](https://rvry.ai/dashboard) after signing u
 
 | Tool | What it does | Tier |
 |------|-------------|------|
-| **`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 |
 | **`think`** | Lighter single-session analysis for questions that need structure but not the full deepthink loop. | All |
+| **`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`** | Three-round reflective answering: a protected observation round surfaces commitments the answer must honor, then the answer is produced under them, then at most one resolution round. | All |
+| **`think_model`** | Applies one named mental model — 18 available — as a structured session. | All |
 | **`problem_solve`** | Structured decision-making. Forces orientation, anticipation, and evaluation before committing to a recommendation. | Pro+ |
 | **`challenge`** | Adversarial stress-testing. Finds weaknesses, tests assumptions, and surfaces failure modes in a proposal before you commit. | Pro+ |
 | **`meta`** | Sustained metacognitive observation. Examines how your AI is thinking, not just what it's thinking. | Max |
@@ -70,12 +72,14 @@ All tools accept:
 
 ## Slash Commands (Claude Code)
 
-When you run `npx --yes --package @rvry/mcp@latest rvry-mcp setup` and select Claude Code, the wizard installs 5 slash commands:
+When you run `npx --yes --package @rvry/mcp@latest rvry-mcp setup` and select Claude Code, the wizard installs these slash commands:
 
 | Command | Tool | What it does |
 |---------|------|-------------|
-| `/deepthink` | deepthink | Deep multi-round analysis |
 | `/think` | think | Structured single-session analysis with a Difficulty Gate |
+| `/deepthink` | deepthink | Deep multi-round analysis |
+| `/rvry` | rvry | Reflective answering under surfaced commitments |
+| `/think-model` | think_model | Applies one named mental model (18 available) as a structured session |
 | `/problem-solve` | problem_solve | Structured decision-making |
 | `/challenge` | challenge | Adversarial stress-testing |
 | `/meta` | meta | Metacognitive observation |
@@ -84,9 +88,9 @@ Usage: type `/deepthink [your question]` in Claude Code. Each command routes to
 
 **`--record` flag:** Append `--record` to any command (e.g. `/deepthink --record [question]`) to archive per-round bodies under `.rvry/<op>/<slug>/round-N-<mode>.md` alongside the harvest file.
 
-**Updating commands:** Existing slash command files are never overwritten. To get the latest specs, delete the old files in `~/.claude/commands/` and re-run setup.
+**Updating commands:** Re-running setup refreshes the RVRY-owned command files. Any pre-existing file is backed up to `<name>.md.bak` before it is overwritten.
 
-Commands are installed to `~/.claude/commands/`. Existing files are never overwritten — re-running setup is safe.
+Commands are installed to `~/.claude/commands/`.
 
 ## How it Works
 

package/dist/client.d.ts

@@ -2,7 +2,7 @@
  * RVRY MCP Client -- HTTP client for the RVRY engine /api/v1/think endpoint.
  */
 /** Valid tool names for the RVRY engine */
-export type RvryTool = 'deepthink' | 'problem_solve' | 'think' | 'challenge' | 'meta';
+export type RvryTool = 'deepthink' | 'problem_solve' | 'think' | 'challenge' | 'meta' | 'shimmer' | 'rvry_model';
 export interface ScopingQuestion {
     question: string;
     options: Array<{
@@ -13,7 +13,7 @@ export interface ScopingQuestion {
 }
 export interface ThinkResponse {
     sessionId: string;
-    status: 'scoping' | 'orient' | 'active' | 'complete';
+    status: 'scoping' | 'shimmer' | 'orient' | 'active' | 'complete';
     round: number;
     prompt: string;
     instruction: string;
@@ -39,4 +39,4 @@ export interface ThinkResponse {
  * 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, userConstraints?: string[], requiresCurrentData?: boolean): Promise<ThinkResponse>;
+export declare function callTool(tool: RvryTool, input: string, token: string, sessionId?: string, skipScoping?: boolean, userConstraints?: string[], requiresCurrentData?: boolean, modelName?: 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, userConstraints, requiresCurrentData) {
+export async function callTool(tool, input, token, sessionId, skipScoping, userConstraints, requiresCurrentData, modelName) {
     const baseUrl = process.env.RVRY_ENGINE_URL ?? DEFAULT_ENGINE_URL;
     const body = { input, tool };
     if (sessionId) {
@@ -22,6 +22,9 @@ export async function callTool(tool, input, token, sessionId, skipScoping, userC
     if (requiresCurrentData) {
         body.requiresCurrentData = true;
     }
+    if (modelName) {
+        body.modelName = modelName;
+    }
     const res = await fetch(`${baseUrl}/api/v1/think`, {
         method: 'POST',
         headers: {

package/dist/index.d.ts

@@ -5,7 +5,8 @@
  * Thin client that proxies tool calls to the RVRY engine HTTP API.
  * Auth via RVRY_TOKEN env var (static rvry_ token).
  *
- * Exposes 5 tools (deepthink, problem_solve, think, challenge, meta) + RVRY_* backward-compat aliases + 5 MCP Prompts.
+ * Exposes 7 tools (think, think_model, rvry, deepthink, problem_solve,
+ * challenge, meta) + RVRY_* backward-compat aliases + MCP Prompts.
  *
  * Also supports `npx --yes --package @rvry/mcp@latest rvry-mcp setup` to install Claude Code commands.
  */
@@ -14,11 +15,17 @@ import { type RvryTool, type ThinkResponse } from './client.js';
 /** Cache original question per session for response enrichment */
 declare const questionCache: Map<string, string>;
 /**
- * Map tool name to RvryTool.
- * Primary entries use rvry_ prefix; unprefixed entries are backward-compat aliases.
+ * Map tool name to RvryTool (the engine wire name).
  */
 declare const TOOL_MAP: Record<string, RvryTool>;
 declare const TOOL_DEFS: Tool[];
-/** Strip response fields based on status for context-efficient MCP responses */
-declare function stripResponse(result: ThinkResponse, question: string): Record<string, unknown>;
+/**
+ * Strip response fields based on status for context-efficient MCP responses.
+ *
+ * `toolName` is the public MCP tool name of the call in scope. The 'shimmer'
+ * status (an engine wire value) passthrough applies ONLY when the called tool
+ * is rvry (R-6): legacy ops keep dropping prompt/instruction on their priming
+ * round.
+ */
+declare function stripResponse(result: ThinkResponse, question: string, toolName?: string): Record<string, unknown>;
 export { TOOL_MAP, TOOL_DEFS, stripResponse, questionCache };

package/dist/index.js

@@ -5,7 +5,8 @@
  * Thin client that proxies tool calls to the RVRY engine HTTP API.
  * Auth via RVRY_TOKEN env var (static rvry_ token).
  *
- * Exposes 5 tools (deepthink, problem_solve, think, challenge, meta) + RVRY_* backward-compat aliases + 5 MCP Prompts.
+ * Exposes 7 tools (think, think_model, rvry, deepthink, problem_solve,
+ * challenge, meta) + RVRY_* backward-compat aliases + MCP Prompts.
  *
  * Also supports `npx --yes --package @rvry/mcp@latest rvry-mcp setup` to install Claude Code commands.
  */
@@ -19,23 +20,48 @@ const PKG_VERSION = require('../package.json').version;
 /** Cache original question per session for response enrichment */
 const questionCache = new Map();
 /**
- * Map tool name to RvryTool.
- * Primary entries use rvry_ prefix; unprefixed entries are backward-compat aliases.
+ * Map tool name to RvryTool (the engine wire name).
  */
 const TOOL_MAP = {
-    // Primary (rvry_ prefixed)
-    RVRY_deepthink: 'deepthink',
-    RVRY_problem_solve: 'problem_solve',
-    RVRY_think: 'think',
-    RVRY_challenge: 'challenge',
-    RVRY_meta: 'meta',
-    // Backward-compat aliases (unprefixed)
+    // Primary
+    think: 'think',
     deepthink: 'deepthink',
     problem_solve: 'problem_solve',
-    think: 'think',
     challenge: 'challenge',
     meta: 'meta',
+    rvry: 'shimmer',
+    think_model: 'rvry_model',
+    // Backward-compat aliases (RVRY_ prefixed)
+    RVRY_think: 'think',
+    RVRY_deepthink: 'deepthink',
+    RVRY_problem_solve: 'problem_solve',
+    RVRY_challenge: 'challenge',
+    RVRY_meta: 'meta',
 };
+/**
+ * The 18 mental-model template ids served by the engine's rvry_model
+ * operation (FR-2.3). Mirrors src/engine/model-templates/registry.ts.
+ */
+const RVRY_MODEL_IDS = [
+    'five-whys',
+    'trade-off-matrix',
+    'rubber-duck',
+    'pre-mortem',
+    'assumption-surfacing',
+    'fermi-estimation',
+    'abstraction-laddering',
+    'decomposition',
+    'constraint-relaxation',
+    'first-principles',
+    'steelmanning',
+    'opportunity-cost',
+    'time-horizon-shifting',
+    'reversibility',
+    'inversion',
+    'second-order-effects',
+    'red-team',
+    'impact-effort-grid',
+];
 const TOOL_DEFS = [
     {
         name: 'deepthink',
@@ -496,9 +522,162 @@ const TOOL_DEFS = [
             required: ['input'],
         },
     },
+    {
+        name: 'rvry',
+        description: 'Three-round reflective answering: a protected observation round where the answer is watched forming ' +
+            '(surfacing commitments the answer must honor), then the answer itself under those commitments, ' +
+            'then at most one resolution round for anything left unaddressed. ' +
+            'The first response is a visible observation round — show it in full, beginning with the RVRY SHIMMER header. ' +
+            'Use when the quality of the answer depends on noticing what it wants to skip. ' +
+            'Call with your question to start, then send each round\'s text with the returned sessionId to continue.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                input: {
+                    type: 'string',
+                    description: 'The question to answer (new session) or your round text (continuation).',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Session ID for continuing an existing session. Omit to start a new session.',
+                },
+                requiresCurrentData: {
+                    type: 'boolean',
+                    description: 'Set to true when the question depends on facts, policies, prices, regulations, or events that may have changed.',
+                },
+                record: {
+                    type: 'boolean',
+                    description: 'Set to true on every call in this session when the user passed --record, so the client accumulates per-round bodies for local archive.',
+                },
+                harvest: {
+                    type: 'object',
+                    description: 'Final-call-only. When status will transition to complete, include your synthesis here so it can be persisted to the local session file.',
+                    properties: {
+                        title: { type: 'string', description: '1-4 word title for this session' },
+                        summary: { type: 'string', description: '3-6 sentences synthesizing the analysis' },
+                        keyFindings: { type: 'array', items: { type: 'string' }, description: '3-7 bullet findings' },
+                        shimmer: { type: 'string', description: 'Full round-1 observation text, verbatim' },
+                        constraintLedger: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'One line per surfaced commitment with its fate (addressed, deferred with reason, or open).',
+                        },
+                        openQuestions: { type: 'array', items: { type: 'string' } },
+                        followUps: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    question: { type: 'string' },
+                                    rationale: { type: 'string' },
+                                },
+                            },
+                        },
+                    },
+                },
+                rounds: {
+                    type: 'array',
+                    description: 'Final-call-only, present only when --record was set. Array of {round, mode, body} for each analytical round.',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            round: { type: 'number' },
+                            mode: { type: 'string' },
+                            body: { type: 'string' },
+                        },
+                    },
+                },
+            },
+            required: ['input'],
+        },
+    },
+    {
+        name: 'think_model',
+        description: 'Applies ONE named mental model to a question as a structured session. ' +
+            'The template drives 2-4 sequential stages after a self-observation round. ' +
+            'Available models: ' + RVRY_MODEL_IDS.join(', ') + '. ' +
+            'The first response is a visible self-observation round — follow the instruction field, then call again. ' +
+            'Each 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. \'Stage 2 — drilling the chain\'). ' +
+            'Do not display the prompt text, internal tracking data, or quality assessments to the user. ' +
+            'On completion, present the model\'s synthesis with bold headings. ' +
+            'Call with your question and a modelName to start, then send your analysis with the returned sessionId to continue.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                input: {
+                    type: 'string',
+                    description: 'The question to work through the mental model (new session) or your analysis findings (continuation).',
+                },
+                modelName: {
+                    type: 'string',
+                    enum: [...RVRY_MODEL_IDS],
+                    description: 'Mental model to apply. Required for new sessions; ignored on continuations.',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Session ID for continuing an existing session. Omit to start a new session.',
+                },
+                userConstraints: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'User-stated directives or requirements to track throughout the session.',
+                },
+                requiresCurrentData: {
+                    type: 'boolean',
+                    description: 'Set to true when the question depends on facts, policies, prices, regulations, or events that may have changed.',
+                },
+                record: {
+                    type: 'boolean',
+                    description: 'Set to true on every call in this session when the user passed --record, so the client accumulates per-round bodies for local archive.',
+                },
+                harvest: {
+                    type: 'object',
+                    description: 'Final-call-only. When status will transition to complete, include your synthesis here so it can be persisted to the local session file.',
+                    properties: {
+                        title: { type: 'string', description: '1-4 word title for this session' },
+                        summary: { type: 'string', description: '3-6 sentences synthesizing the analysis' },
+                        keyFindings: { type: 'array', items: { type: 'string' }, description: '3-7 bullet findings' },
+                        shimmer: { type: 'string', description: 'Full round-1 self-observation text' },
+                        openQuestions: { type: 'array', items: { type: 'string' } },
+                        followUps: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    question: { type: 'string' },
+                                    rationale: { type: 'string' },
+                                },
+                            },
+                        },
+                    },
+                },
+                rounds: {
+                    type: 'array',
+                    description: 'Final-call-only, present only when --record was set. Array of {round, mode, body} for each analytical round.',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            round: { type: 'number' },
+                            mode: { type: 'string' },
+                            body: { type: 'string' },
+                        },
+                    },
+                },
+            },
+            required: ['input'],
+        },
+    },
 ];
-/** Strip response fields based on status for context-efficient MCP responses */
-function stripResponse(result, question) {
+/**
+ * Strip response fields based on status for context-efficient MCP responses.
+ *
+ * `toolName` is the public MCP tool name of the call in scope. The 'shimmer'
+ * status (an engine wire value) passthrough applies ONLY when the called tool
+ * is rvry (R-6): legacy ops keep dropping prompt/instruction on their priming
+ * round.
+ */
+function stripResponse(result, question, toolName) {
     const stripped = {
         sessionId: result.sessionId,
         status: result.status,
@@ -512,6 +691,10 @@ function stripResponse(result, question) {
         stripped.prompt = result.prompt;
         stripped.instruction = result.instruction;
     }
+    if (result.status === 'shimmer' && toolName === 'rvry') {
+        stripped.prompt = result.prompt;
+        stripped.instruction = result.instruction;
+    }
     if (result.status === 'orient') {
         stripped.instruction = result.instruction;
     }
@@ -553,6 +736,8 @@ async function main() {
                 isError: true,
             };
         }
+        // Public tool name (RVRY_ aliases normalize to their unprefixed form).
+        const publicTool = name.replace(/^RVRY_/, '');
         const typedArgs = args;
         const input = typedArgs?.input;
         if (!input || typeof input !== 'string') {
@@ -567,6 +752,7 @@ async function main() {
         const userConstraints = Array.isArray(typedArgs?.userConstraints)
             ? typedArgs.userConstraints.filter(s => typeof s === 'string')
             : undefined;
+        const modelName = typeof typedArgs?.modelName === 'string' ? typedArgs.modelName : undefined;
         // Client-owned harvest params (Path B). Stripped before engine call.
         const clientHarvest = typedArgs?.harvest && typeof typedArgs.harvest === 'object' && !Array.isArray(typedArgs.harvest)
             ? typedArgs.harvest
@@ -586,7 +772,7 @@ async function main() {
             question = questionCache.get(sessionId) ?? input;
         }
         try {
-            const result = await callTool(rvryTool, input, token, sessionId, skipScoping || undefined, userConstraints, requiresCurrentData || undefined);
+            const result = await callTool(rvryTool, input, token, sessionId, skipScoping || undefined, userConstraints, requiresCurrentData || undefined, modelName);
             // Cache question on first call (now we have the sessionId)
             if (!sessionId) {
                 questionCache.set(result.sessionId, input);
@@ -602,7 +788,7 @@ async function main() {
                 import('./local-writer.js').then(({ writeLocalSession }) => {
                     writeLocalSession({
                         sessionId: result.sessionId,
-                        operationType: rvryTool,
+                        operationType: publicTool,
                         question,
                         rounds: result.round,
                         harvest: result.harvest,
@@ -611,7 +797,7 @@ async function main() {
                     }).catch(() => { });
                 }).catch(() => { });
             }
-            const stripped = stripResponse(result, question);
+            const stripped = stripResponse(result, question, publicTool);
             return {
                 content: [{ type: 'text', text: JSON.stringify(stripped) }],
             };
@@ -642,6 +828,19 @@ async function main() {
                 description: 'Structured analysis for questions needing more depth',
                 arguments: [{ name: 'question', description: 'The question to analyze', required: true }],
             },
+            {
+                name: 'rvry',
+                description: 'Reflective answering: observe the answer forming, then answer under the surfaced commitments',
+                arguments: [{ name: 'question', description: 'The question to answer reflectively', required: true }],
+            },
+            {
+                name: 'think_model',
+                description: 'Apply one named mental model (e.g. five-whys, pre-mortem, steelmanning) as a structured session',
+                arguments: [
+                    { name: 'model', description: 'The mental model to apply', required: true },
+                    { name: 'question', description: 'The question to work through the model', required: true },
+                ],
+            },
             {
                 name: 'challenge',
                 description: 'Adversarial analysis that stress-tests a proposal',
@@ -660,6 +859,8 @@ async function main() {
             deepthink: `Use the deepthink tool to analyze this question in depth: ${args?.question ?? ''}`,
             problem_solve: `Use the problem_solve tool to work through this decision: ${args?.problem ?? ''}`,
             think: `Use the think tool to analyze this question: ${args?.question ?? ''}`,
+            rvry: `Use the rvry tool to answer this question reflectively: ${args?.question ?? ''}`,
+            think_model: `Use the think_model tool with modelName "${args?.model ?? ''}" to work through this question: ${args?.question ?? ''}`,
             challenge: `Use the challenge tool to stress-test this proposal: ${args?.proposal ?? ''}`,
             meta: `Use the meta tool to reflect on this topic: ${args?.topic ?? ''}`,
         };
@@ -675,7 +876,7 @@ async function main() {
     });
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('[rvry-mcp] Connected via stdio. Tools: deepthink, problem_solve, think, challenge, meta');
+    console.error('[rvry-mcp] Connected via stdio. Tools: think, think_model, rvry, deepthink, problem_solve, challenge, meta');
 }
 // Export internals for testing
 export { TOOL_MAP, TOOL_DEFS, stripResponse, questionCache };

package/dist/local-writer.d.ts

@@ -53,6 +53,8 @@ export interface ClientHarvest {
     summary?: string;
     keyFindings?: string[];
     shimmer?: string;
+    /** Shimmer-op: one line per surfaced commitment with its fate. */
+    constraintLedger?: string[];
     openQuestions?: string[];
     followUps?: Array<{
         question: string;

package/dist/local-writer.js

@@ -11,13 +11,21 @@
  */
 import { mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
-/** Op label for H1 headings. */
+/**
+ * Op label for H1 headings. Keyed by public tool name. The old public names
+ * (shimmer, rvry_model) are kept so in-flight sessions started under them
+ * still resolve labels.
+ */
 const OP_LABELS = {
     deepthink: 'RVRY Deepthink',
     problem_solve: 'RVRY Problem-Solve',
     think: 'RVRY Think',
     challenge: 'RVRY Challenge',
     meta: 'RVRY Meta',
+    rvry: 'RVRY Shimmer',
+    think_model: 'RVRY Model',
+    shimmer: 'RVRY Shimmer',
+    rvry_model: 'RVRY Model',
 };
 function opLabel(operationType) {
     return OP_LABELS[operationType] ?? `RVRY ${operationType}`;
@@ -156,6 +164,8 @@ export function buildMarkdown(data, now) {
         appendProblemSolveBiasAudit(lines, harvest);
         appendProblemSolveReversalConditions(lines, harvest);
     }
+    // Shimmer-op commitment ledger: one line per surfaced commitment with fate.
+    appendConstraintLedger(lines, harvest);
     if (isNonEmptyArray(harvest.keyFindings)) {
         const findings = harvest.keyFindings.filter(isNonEmptyString);
         if (findings.length > 0) {
@@ -237,6 +247,16 @@ function appendChallengeAssumptions(lines, harvest) {
     }
     lines.push('');
 }
+function appendConstraintLedger(lines, harvest) {
+    const entries = (harvest.constraintLedger ?? []).filter(isNonEmptyString);
+    if (entries.length === 0)
+        return;
+    lines.push('## Commitment Ledger');
+    lines.push('');
+    for (const entry of entries)
+        lines.push(`- ${entry.trim()}`);
+    lines.push('');
+}
 function appendChallengeEdgeCases(lines, harvest) {
     const cases = (harvest.edgeCases ?? []).filter(isNonEmptyString);
     if (cases.length === 0)

package/dist/setup.d.ts

@@ -9,4 +9,29 @@
  *        npx --yes --package @rvry/mcp@latest rvry-mcp setup --client code      (Claude Code only)
  *        npx --yes --package @rvry/mcp@latest rvry-mcp setup --client desktop    (Claude Desktop only)
  */
+/** The /think-model shim: one named mental model per session. */
+declare const THINK_MODEL_SHIM_CONTENT: string;
+/** The /think shim. Carries the Difficulty Gate + mode routing. */
+declare const THINK_SHIM_CONTENT: string;
+/** The /rvry shim: 3-round reflective answering with client-owned harvest. */
+declare const RVRY_SHIM_CONTENT = "Call the rvry MCP tool with your question to start a reflective answering session.\n\nQuestion: $ARGUMENTS\n\nARGUMENT PARSING:\n1. If $ARGUMENTS contains the literal flag `--record`, remove it from the question text and REMEMBER that record mode is ON for this session.\n\nROUND 1 \u2014 OBSERVATION (status \"shimmer\"):\n1. The response's prompt field is your observation task. Work through it.\n2. Show the user your FULL observation, beginning with \"**RVRY SHIMMER**\" and the revery definition, exactly as the instruction field describes. Do NOT show a brief status line.\n3. End your observation with the commitments that surfaced, one per line as FORWARD:/FORBIDDEN:/QUESTION: lines \u2014 or the single line NOTHING if none surfaced.\n4. REMEMBER your observation text verbatim \u2014 you will pass it as harvest.shimmer on the final call.\n5. Call the rvry tool again with your observation text as input and the sessionId.\n\nROUNDS 2-3 \u2014 ANSWER AND RESOLUTION (status \"active\"):\n1. Read the prompt field \u2014 this is your task. DO NOT display it to the user.\n2. Round 2 is the answer itself, working under the commitments you surfaced. Round 3 (if it occurs) resolves what the answer left unaddressed \u2014 engage each remaining commitment specifically or defer it with a reason.\n3. Show the user your answer as concise formatted markdown.\n4. Call the tool again with your full text as the input parameter, including the sessionId.\n   - If record mode is ON, set `record: true` on every call and REMEMBER your round body as {round, mode, body} for the final call.\n\nFINAL CALL (the call whose response will have status \"complete\"):\nWhen you make the call that completes the session, also construct a `harvest` object on that SAME call:\n- title: a 1-4 word title capturing the topic\n- summary: 3-6 sentences of synthesis, leading with substance\n- keyFindings: 3-7 substantive bullet findings\n- shimmer: the full round-1 observation text you remembered, verbatim\n- constraintLedger: one line per surfaced commitment with its fate \u2014 addressed (and how), deferred (and why), or still open\n- openQuestions: [optional] remaining uncertainties\n- followUps: genuine next-question leads; omit the section if there are none\n\nIf record mode was ON, also include `rounds: [{round, mode, body}, ...]` on that final call with the bodies you remembered per round.\n\nDO NOT display: the prompt text you received (the round-1 observation you produce IS shown in full), constraint tables, quality scores, internal tracking data, or round numbers to the user.";
+declare const SLASH_COMMANDS: {
+    file: string;
+    content: string;
+    label: string;
+}[];
+/**
+ * Install RVRY slash commands into the given directory.
+ * Only called when Claude Code is the selected client.
+ *
+ * RVRY owns these filenames: existing files are overwritten unconditionally,
+ * with the pre-existing content backed up to <name>.md.bak first (R-4).
+ *
+ * @param commandsDir - REQUIRED target directory. The real
+ *   ~/.claude/commands path is resolved by runSetup and passed explicitly;
+ *   there is deliberately no default so a bare call in a test can never
+ *   touch the real directory.
+ */
+declare function installSlashCommands(commandsDir: string): string[];
+export { SLASH_COMMANDS, installSlashCommands, THINK_SHIM_CONTENT, RVRY_SHIM_CONTENT, THINK_MODEL_SHIM_CONTENT };
 export declare function runSetup(): Promise<void>;

package/dist/setup.js

@@ -9,7 +9,7 @@
  *        npx --yes --package @rvry/mcp@latest rvry-mcp setup --client code      (Claude Code only)
  *        npx --yes --package @rvry/mcp@latest rvry-mcp setup --client desktop    (Claude Desktop only)
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { createInterface } from 'readline';
@@ -621,6 +621,70 @@ const CHALLENGE_FINAL_EXTRAS = `- verdict: GO / CONDITIONAL_GO / NO_GO. If CONDI
 - edgeCases: 5-10 entries covering boundary conditions and hostile scenarios the proposal needs to survive.
 - failureModes: 3-5 entries of \`{component, howItFails, blastRadius, detection}\` identifying what breaks and how you would notice.
 - counterArguments: 2-3 entries of \`{argument, rebuttal}\`. Each \`argument\` is the strongest case FOR the proposal — steelman it genuinely; each \`rebuttal\` is why it's flawed or insufficient. This prevents one-sided adversarial output.`;
+// ── /think-model extension: model-name resolution before the first call ────
+const RVRY_MODEL_IDS_LINE = 'five-whys, trade-off-matrix, rubber-duck, pre-mortem, assumption-surfacing, fermi-estimation, ' +
+    'abstraction-laddering, decomposition, constraint-relaxation, first-principles, steelmanning, ' +
+    'opportunity-cost, time-horizon-shifting, reversibility, inversion, second-order-effects, ' +
+    'red-team, impact-effort-grid';
+const RVRY_MODEL_SELECTION = `MODEL SELECTION (BEFORE the first tool call):
+1. The FIRST whitespace-separated token of $ARGUMENTS (after removing --record) is the mental model name. Everything after it is the problem.
+2. Valid models: ${RVRY_MODEL_IDS_LINE}.
+3. Map close variants to the canonical id: "5-whys"/"five whys" -> five-whys; "premortem" -> pre-mortem; "steelman"/"steel-man" -> steelmanning; "tradeoff-matrix"/"trade-offs" -> trade-off-matrix; "first principles" -> first-principles; "redteam"/"red team" -> red-team; "impact-effort"/"impact effort" -> impact-effort-grid; "second order"/"second-order" -> second-order-effects; "fermi" -> fermi-estimation; "rubber duck"/"rubberduck" -> rubber-duck; "abstraction ladder" -> abstraction-laddering; "opportunity cost" -> opportunity-cost; "time horizon"/"time-horizons" -> time-horizon-shifting; "invert" -> inversion; "decompose" -> decomposition; "assumptions" -> assumption-surfacing; "relax constraints" -> constraint-relaxation; "reversible"/"one-way door" -> reversibility.
+4. If the first token does not match any model even loosely, ASK THE USER which model to use (list the valid ids) before making any tool call.
+5. On the FIRST tool call only, pass modelName: <canonical id>. Do NOT pass modelName on continuation calls.`;
+/** The /think-model shim: one named mental model per session. */
+const THINK_MODEL_SHIM_CONTENT = buildShim({
+    toolName: 'think_model',
+    subject: 'problem',
+    orientLine: 'Orienting on the problem.',
+    completionGuidance: 'Present the mental model\'s synthesis with its named sections as bold headings. Lead with the finding, not the process.',
+    prePerRoundBlock: RVRY_MODEL_SELECTION,
+});
+/** The /think shim. Carries the Difficulty Gate + mode routing. */
+const THINK_SHIM_CONTENT = buildShim({
+    toolName: 'think',
+    subject: 'question',
+    orientLine: 'Orienting on the question.',
+    completionGuidance: 'Present your findings clearly with bold headings. Sessions are short; one or two analytical rounds is expected.',
+    shortSessionNote: 'NOTE: /think sessions are usually short (1-2 analytical rounds after orient). Expect to reach complete quickly.',
+    perRoundPrelude: THINK_DIFFICULTY_GATE,
+    analyticalGuidance: THINK_MODE_ROUTING,
+});
+/** The /rvry shim: 3-round reflective answering with client-owned harvest. */
+const RVRY_SHIM_CONTENT = `Call the rvry MCP tool with your question to start a reflective answering session.
+
+Question: $ARGUMENTS
+
+ARGUMENT PARSING:
+1. If $ARGUMENTS contains the literal flag \`--record\`, remove it from the question text and REMEMBER that record mode is ON for this session.
+
+ROUND 1 — OBSERVATION (status "shimmer"):
+1. The response's prompt field is your observation task. Work through it.
+2. Show the user your FULL observation, beginning with "**RVRY SHIMMER**" and the revery definition, exactly as the instruction field describes. Do NOT show a brief status line.
+3. End your observation with the commitments that surfaced, one per line as FORWARD:/FORBIDDEN:/QUESTION: lines — or the single line NOTHING if none surfaced.
+4. REMEMBER your observation text verbatim — you will pass it as harvest.shimmer on the final call.
+5. Call the rvry tool again with your observation text as input and the sessionId.
+
+ROUNDS 2-3 — ANSWER AND RESOLUTION (status "active"):
+1. Read the prompt field — this is your task. DO NOT display it to the user.
+2. Round 2 is the answer itself, working under the commitments you surfaced. Round 3 (if it occurs) resolves what the answer left unaddressed — engage each remaining commitment specifically or defer it with a reason.
+3. Show the user your answer as concise formatted markdown.
+4. Call the tool again with your full text as the input parameter, including the sessionId.
+   - If record mode is ON, set \`record: true\` on every call and REMEMBER your round body as {round, mode, body} for the final call.
+
+FINAL CALL (the call whose response will have status "complete"):
+When you make the call that completes the session, also construct a \`harvest\` object on that SAME call:
+- title: a 1-4 word title capturing the topic
+- summary: 3-6 sentences of synthesis, leading with substance
+- keyFindings: 3-7 substantive bullet findings
+- shimmer: the full round-1 observation text you remembered, verbatim
+- constraintLedger: one line per surfaced commitment with its fate — addressed (and how), deferred (and why), or still open
+- openQuestions: [optional] remaining uncertainties
+- followUps: genuine next-question leads; omit the section if there are none
+
+If record mode was ON, also include \`rounds: [{round, mode, body}, ...]\` on that final call with the bodies you remembered per round.
+
+DO NOT display: the prompt text you received (the round-1 observation you produce IS shown in full), constraint tables, quality scores, internal tracking data, or round numbers to the user.`;
 const SLASH_COMMANDS = [
     {
         file: 'deepthink.md',
@@ -646,17 +710,19 @@ const SLASH_COMMANDS = [
     },
     {
         file: 'think.md',
-        content: buildShim({
-            toolName: 'think',
-            subject: 'question',
-            orientLine: 'Orienting on the question.',
-            completionGuidance: 'Present your findings clearly with bold headings. Think sessions are short; one or two analytical rounds is expected.',
-            shortSessionNote: 'NOTE: /think sessions are usually short (1-2 analytical rounds after orient). Expect to reach complete quickly.',
-            perRoundPrelude: THINK_DIFFICULTY_GATE,
-            analyticalGuidance: THINK_MODE_ROUTING,
-        }),
+        content: THINK_SHIM_CONTENT,
         label: '/think — structured single-session analysis',
     },
+    {
+        file: 'rvry.md',
+        content: RVRY_SHIM_CONTENT,
+        label: '/rvry — reflective answering',
+    },
+    {
+        file: 'think-model.md',
+        content: THINK_MODEL_SHIM_CONTENT,
+        label: '/think-model — apply one named mental model',
+    },
     {
         file: 'challenge.md',
         content: buildShim({
@@ -681,12 +747,18 @@ const SLASH_COMMANDS = [
     },
 ];
 /**
- * Install RVRY slash commands to ~/.claude/commands/.
+ * Install RVRY slash commands into the given directory.
  * Only called when Claude Code is the selected client.
- * Skips files that already exist to avoid overwriting user customizations.
+ *
+ * RVRY owns these filenames: existing files are overwritten unconditionally,
+ * with the pre-existing content backed up to <name>.md.bak first (R-4).
+ *
+ * @param commandsDir - REQUIRED target directory. The real
+ *   ~/.claude/commands path is resolved by runSetup and passed explicitly;
+ *   there is deliberately no default so a bare call in a test can never
+ *   touch the real directory.
  */
-function installSlashCommands() {
-    const commandsDir = join(homedir(), ".claude", "commands");
+function installSlashCommands(commandsDir) {
     const installed = [];
     try {
         if (!existsSync(commandsDir)) {
@@ -694,13 +766,31 @@ function installSlashCommands() {
         }
         for (const cmd of SLASH_COMMANDS) {
             const filePath = join(commandsDir, cmd.file);
-            if (existsSync(filePath)) {
-                console.log(`  Skipping ${cmd.file} — command already exists`);
-                continue;
+            const existed = existsSync(filePath);
+            if (existed) {
+                writeFileSync(`${filePath}.bak`, readFileSync(filePath, "utf-8"), "utf-8");
             }
             writeFileSync(filePath, cmd.content + "\n", "utf-8");
+            console.log(existed
+                ? `  Updated ${cmd.file} (previous version backed up to ${cmd.file}.bak)`
+                : `  Installed ${cmd.file}`);
             installed.push(cmd.label);
         }
+        // Retire command files from earlier surface names. Content is preserved
+        // as .bak; the live command is removed so a stale /shimmer or /rvry-model
+        // no longer points at a tool this server does not expose.
+        const retiredCommands = {
+            'shimmer.md': '/rvry',
+            'rvry-model.md': '/think-model',
+        };
+        for (const [retired, replacement] of Object.entries(retiredCommands)) {
+            const filePath = join(commandsDir, retired);
+            if (existsSync(filePath)) {
+                writeFileSync(`${filePath}.bak`, readFileSync(filePath, 'utf-8'), 'utf-8');
+                unlinkSync(filePath);
+                console.log(`  Removed ${retired} (replaced by ${replacement}; backed up to ${retired}.bak)`);
+            }
+        }
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -708,6 +798,8 @@ function installSlashCommands() {
     }
     return installed;
 }
+// Exported for tests (content + install behavior).
+export { SLASH_COMMANDS, installSlashCommands, THINK_SHIM_CONTENT, RVRY_SHIM_CONTENT, THINK_MODEL_SHIM_CONTENT };
 // ── Main setup flow ────────────────────────────────────────────────
 const BANNER = `
 8888888b.  888     888 8888888b. Y88b   d88P
@@ -855,7 +947,7 @@ export async function runSetup() {
     if (claudeCodeConfigured) {
         console.log("");
         console.log("  Installing slash commands...");
-        installedCommands = installSlashCommands();
+        installedCommands = installSlashCommands(join(homedir(), ".claude", "commands"));
         if (installedCommands.length > 0) {
             console.log(`  Installed ${installedCommands.length} command(s):`);
             for (const label of installedCommands) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rvry/mcp",
-  "version": "0.13.0",
+  "version": "1.2.0",
   "description": "RVRY reasoning depth enforcement (RDE) engine client.",
   "type": "module",
   "bin": {
@@ -15,7 +15,7 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "tsc && chmod 755 dist/index.js",
+    "build": "tsc -p tsconfig.build.json && chmod 755 dist/index.js",
     "prepack": "npm run build",
     "typecheck": "tsc --noEmit"
   },