@rvry/mcp 0.13.0 → 1.0.0

package/README.md

@@ -41,12 +41,15 @@ Get your token at [rvry.ai/dashboard](https://rvry.ai/dashboard) after signing u
 
 | Tool | What it does | Tier |
 |------|-------------|------|
+| **`rvry`** | Lighter single-session analysis for questions that need structure but not the full deepthink loop. (Renamed from `think` in 1.0.0.) | 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 |
-| **`think`** | Lighter single-session analysis for questions that need structure but not the full deepthink loop. | All |
+| **`shimmer`** | 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 |
 | **`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 |
 
+A `think` tombstone tool remains for backward compatibility — calling it returns a notice pointing at `rvry`. It will be removed at 2.0.0.
+
 ### Parameters
 
 All tools accept:
@@ -70,23 +73,25 @@ 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 |
 |---------|------|-------------|
+| `/rvry` | rvry | Structured single-session analysis with a Difficulty Gate |
 | `/deepthink` | deepthink | Deep multi-round analysis |
-| `/think` | think | Structured single-session analysis with a Difficulty Gate |
+| `/shimmer` | shimmer | Reflective answering under surfaced commitments |
 | `/problem-solve` | problem_solve | Structured decision-making |
 | `/challenge` | challenge | Adversarial stress-testing |
 | `/meta` | meta | Metacognitive observation |
+| `/think` | rvry | Deprecated alias for `/rvry` (removed next major) |
 
 Usage: type `/deepthink [your question]` in Claude Code. Each command routes to the corresponding RVRY MCP tool and includes rendering instructions so analysis appears as visible markdown rather than hidden in tool calls.
 
 **`--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';
 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;

package/dist/index.d.ts

@@ -5,7 +5,9 @@
  * 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 6 tools (rvry, deepthink, problem_solve, challenge, meta, shimmer)
+ * + RVRY_* backward-compat aliases + a `think` tombstone (renamed to rvry,
+ * removed at 2.0.0) + MCP Prompts.
  *
  * Also supports `npx --yes --package @rvry/mcp@latest rvry-mcp setup` to install Claude Code commands.
  */
@@ -14,11 +16,20 @@ 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).
+ * `rvry` maps to the engine's think operation. `think`/`RVRY_think` are
+ * tombstones handled before this map is consulted.
  */
 declare const TOOL_MAP: Record<string, RvryTool>;
+/** Non-error tombstone notice for the renamed think tool. Removed at 2.0.0. */
+declare const THINK_TOMBSTONE_NOTICE = "The think tool has been renamed to rvry. Call the rvry tool with the same arguments (input, sessionId, ...).";
 declare const TOOL_DEFS: Tool[];
-/** Strip response fields based on status for context-efficient MCP responses */
-declare function stripResponse(result: ThinkResponse, question: string): Record<string, unknown>;
-export { TOOL_MAP, TOOL_DEFS, stripResponse, questionCache };
+/**
+ * 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 passthrough applies ONLY when the called tool is shimmer (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, THINK_TOMBSTONE_NOTICE };

package/dist/index.js

@@ -5,7 +5,9 @@
  * 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 6 tools (rvry, deepthink, problem_solve, challenge, meta, shimmer)
+ * + RVRY_* backward-compat aliases + a `think` tombstone (renamed to rvry,
+ * removed at 2.0.0) + MCP Prompts.
  *
  * Also supports `npx --yes --package @rvry/mcp@latest rvry-mcp setup` to install Claude Code commands.
  */
@@ -19,23 +21,26 @@ 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).
+ * `rvry` maps to the engine's think operation. `think`/`RVRY_think` are
+ * tombstones handled before this map is consulted.
  */
 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
+    rvry: 'think',
     deepthink: 'deepthink',
     problem_solve: 'problem_solve',
-    think: 'think',
     challenge: 'challenge',
     meta: 'meta',
+    shimmer: 'shimmer',
+    // Backward-compat aliases (RVRY_ prefixed)
+    RVRY_deepthink: 'deepthink',
+    RVRY_problem_solve: 'problem_solve',
+    RVRY_challenge: 'challenge',
+    RVRY_meta: 'meta',
 };
+/** Non-error tombstone notice for the renamed think tool. Removed at 2.0.0. */
+const THINK_TOMBSTONE_NOTICE = 'The think tool has been renamed to rvry. Call the rvry tool with the same arguments (input, sessionId, ...).';
 const TOOL_DEFS = [
     {
         name: 'deepthink',
@@ -225,7 +230,7 @@ const TOOL_DEFS = [
         },
     },
     {
-        name: 'think',
+        name: 'rvry',
         description: 'Structured analysis for questions needing more depth than a quick answer. ' +
             'Runs 1-3 rounds; simple questions can complete in a single analytical round. ' +
             'The first response orients you — follow the instruction field, then call again. ' +
@@ -496,9 +501,98 @@ const TOOL_DEFS = [
             required: ['input'],
         },
     },
+    {
+        name: 'shimmer',
+        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',
+        description: 'Renamed to rvry. Call the rvry tool instead — same arguments, same behavior. ' +
+            'This tombstone will be removed at 2.0.0.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                input: {
+                    type: 'string',
+                    description: 'Ignored. Call the rvry tool instead.',
+                },
+            },
+        },
+    },
 ];
-/** 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 passthrough applies ONLY when the called tool is shimmer (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 +606,10 @@ function stripResponse(result, question) {
         stripped.prompt = result.prompt;
         stripped.instruction = result.instruction;
     }
+    if (result.status === 'shimmer' && toolName === 'shimmer') {
+        stripped.prompt = result.prompt;
+        stripped.instruction = result.instruction;
+    }
     if (result.status === 'orient') {
         stripped.instruction = result.instruction;
     }
@@ -546,6 +644,13 @@ async function main() {
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
+        // Tombstone: the think tool was renamed to rvry. Non-error notice,
+        // returned BEFORE any engine call.
+        if (name === 'think' || name === 'RVRY_think') {
+            return {
+                content: [{ type: 'text', text: THINK_TOMBSTONE_NOTICE }],
+            };
+        }
         const rvryTool = TOOL_MAP[name];
         if (!rvryTool) {
             return {
@@ -553,6 +658,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') {
@@ -602,7 +709,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 +718,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) }],
             };
@@ -638,10 +745,15 @@ async function main() {
                 arguments: [{ name: 'problem', description: 'The problem or decision to analyze', required: true }],
             },
             {
-                name: 'think',
+                name: 'rvry',
                 description: 'Structured analysis for questions needing more depth',
                 arguments: [{ name: 'question', description: 'The question to analyze', required: true }],
             },
+            {
+                name: 'shimmer',
+                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: 'challenge',
                 description: 'Adversarial analysis that stress-tests a proposal',
@@ -659,7 +771,8 @@ async function main() {
         const promptMap = {
             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 analyze this question: ${args?.question ?? ''}`,
+            shimmer: `Use the shimmer tool to answer this question reflectively: ${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,10 +788,10 @@ 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: rvry, deepthink, problem_solve, challenge, meta, shimmer (think: renamed to rvry)');
 }
 // Export internals for testing
-export { TOOL_MAP, TOOL_DEFS, stripResponse, questionCache };
+export { TOOL_MAP, TOOL_DEFS, stripResponse, questionCache, THINK_TOMBSTONE_NOTICE };
 // Run server when executed directly (not when imported by tests).
 // import.meta.main: true in Bun direct, false in Bun imports, undefined in Node ESM.
 // @ts-ignore -- import.meta.main is a Bun extension, not in TS lib types

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,15 @@
  */
 import { mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
-/** Op label for H1 headings. */
+/** Op label for H1 headings. Keyed by public tool name (old keys kept). */
 const OP_LABELS = {
     deepthink: 'RVRY Deepthink',
     problem_solve: 'RVRY Problem-Solve',
     think: 'RVRY Think',
+    rvry: 'RVRY',
     challenge: 'RVRY Challenge',
     meta: 'RVRY Meta',
+    shimmer: 'RVRY Shimmer',
 };
 function opLabel(operationType) {
     return OP_LABELS[operationType] ?? `RVRY ${operationType}`;
@@ -156,6 +158,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 +241,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 /rvry shim (renamed from /think). Carries the Difficulty Gate + mode routing. */
+declare const RVRY_SHIM_CONTENT: string;
+/** Deprecation prefix for the /think tombstone command. */
+declare const THINK_DEPRECATION_LINE = "FIRST: Tell the user that /think is now /rvry \u2014 the /think command will be removed in the next major version. Then proceed with the flow below.";
+/** The /shimmer shim: 3-round reflective answering with client-owned harvest. */
+declare const SHIMMER_SHIM_CONTENT = "Call the shimmer 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 shimmer 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, RVRY_SHIM_CONTENT, SHIMMER_SHIM_CONTENT, THINK_DEPRECATION_LINE };
 export declare function runSetup(): Promise<void>;

package/dist/setup.js

@@ -621,6 +621,53 @@ 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.`;
+/** The /rvry shim (renamed from /think). Carries the Difficulty Gate + mode routing. */
+const RVRY_SHIM_CONTENT = buildShim({
+    toolName: 'rvry',
+    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: /rvry sessions are usually short (1-2 analytical rounds after orient). Expect to reach complete quickly.',
+    perRoundPrelude: THINK_DIFFICULTY_GATE,
+    analyticalGuidance: THINK_MODE_ROUTING,
+});
+/** Deprecation prefix for the /think tombstone command. */
+const THINK_DEPRECATION_LINE = 'FIRST: Tell the user that /think is now /rvry — the /think command will be removed in the next major version. Then proceed with the flow below.';
+/** The /shimmer shim: 3-round reflective answering with client-owned harvest. */
+const SHIMMER_SHIM_CONTENT = `Call the shimmer 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 shimmer 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',
@@ -644,18 +691,20 @@ const SLASH_COMMANDS = [
         }),
         label: '/problem-solve — structured decision-making',
     },
+    {
+        file: 'rvry.md',
+        content: RVRY_SHIM_CONTENT,
+        label: '/rvry — structured single-session analysis',
+    },
+    {
+        file: 'shimmer.md',
+        content: SHIMMER_SHIM_CONTENT,
+        label: '/shimmer — reflective answering',
+    },
     {
         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,
-        }),
-        label: '/think — structured single-session analysis',
+        content: `${THINK_DEPRECATION_LINE}\n\n${RVRY_SHIM_CONTENT}`,
+        label: '/think — renamed to /rvry (deprecated alias)',
     },
     {
         file: 'challenge.md',
@@ -681,12 +730,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,11 +749,14 @@ 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);
         }
     }
@@ -708,6 +766,8 @@ function installSlashCommands() {
     }
     return installed;
 }
+// Exported for tests (content + install behavior).
+export { SLASH_COMMANDS, installSlashCommands, RVRY_SHIM_CONTENT, SHIMMER_SHIM_CONTENT, THINK_DEPRECATION_LINE };
 // ── Main setup flow ────────────────────────────────────────────────
 const BANNER = `
 8888888b.  888     888 8888888b. Y88b   d88P
@@ -855,7 +915,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.0.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"
   },