@rvry/mcp 0.12.2 → 1.0.0

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 (RVRY_deepthink, RVRY_problem_solve, RVRY_think, RVRY_challenge, RVRY_meta) + 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,28 +21,31 @@ 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: 'RVRY_deepthink',
+        name: 'deepthink',
         description: 'Deep, multi-round structured analysis for high-stakes or complex questions. ' +
-            'Runs 5-7 rounds of rigorous analysis with self-checks and adversarial stress-testing. ' +
+            'Runs 4 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\'). ' +
@@ -71,14 +76,51 @@ const TOOL_DEFS = [
                     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'],
         },
     },
     {
-        name: 'RVRY_problem_solve',
+        name: 'problem_solve',
         description: 'Structured decision-making that forces thorough evaluation before commitment. ' +
-            'Runs 5-8 rounds through orient, anticipate, generate, evaluate, and commit phases. ' +
+            'Runs 5 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\'). ' +
@@ -109,14 +151,88 @@ const TOOL_DEFS = [
                     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' },
+                                },
+                            },
+                        },
+                        biasAudit: {
+                            type: 'object',
+                            description: 'Bias audit of the leading direction, linked to SHIMMER observations.',
+                            properties: {
+                                biasesOperating: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            bias: { type: 'string', enum: ['anchoring', 'framing', 'authority', 'sunk_cost', 'availability', 'confirmation'] },
+                                            evidence: { type: 'string' },
+                                            sourceReflex: { type: 'string', description: 'Which SHIMMER reflex surfaced this bias, if any.' },
+                                            correction: { type: 'string' },
+                                        },
+                                    },
+                                },
+                                decisionStable: { type: 'boolean' },
+                                frameReversal: {
+                                    type: 'object',
+                                    properties: {
+                                        originalFraming: { type: 'string' },
+                                        invertedFraming: { type: 'string' },
+                                        wouldReachSameConclusion: { type: 'boolean' },
+                                    },
+                                },
+                            },
+                        },
+                        adversarialVerdict: {
+                            type: 'string',
+                            enum: ['PASSED', 'CAVEATS', 'NEEDS_REVISION'],
+                            description: 'Outcome of the adversarial stress-test against the leading direction.',
+                        },
+                        reversalConditions: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Conditions under which this decision would be reversed (kill switches, escalation triggers, review timeline). 3-5 entries.',
+                        },
+                    },
+                },
+                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: 'RVRY_think',
+        name: 'rvry',
         description: 'Structured analysis for questions needing more depth than a quick answer. ' +
-            'Runs 2-4 rounds with tracking to ensure assumptions are examined. ' +
+            '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. ' +
             '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. ' +
@@ -146,14 +262,51 @@ const TOOL_DEFS = [
                     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'],
         },
     },
     {
-        name: 'RVRY_challenge',
+        name: 'challenge',
         description: 'Adversarial analysis that stress-tests a proposal or idea before commitment. ' +
-            'Runs 4-6 rounds identifying weaknesses, testing assumptions, and surfacing failure modes. ' +
+            'Runs 5 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. ' +
@@ -183,12 +336,108 @@ const TOOL_DEFS = [
                     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' },
+                                },
+                            },
+                        },
+                        verdict: {
+                            type: 'string',
+                            enum: ['GO', 'CONDITIONAL_GO', 'NO_GO'],
+                            description: 'Tri-state adversarial verdict on the proposal.',
+                        },
+                        confidence: {
+                            type: 'number',
+                            minimum: 0,
+                            maximum: 1,
+                            description: '0.0-1.0 strength of the verdict.',
+                        },
+                        mitigations: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Required mitigations for CONDITIONAL_GO verdicts. Conditions that must be met for GO.',
+                        },
+                        assumptions: {
+                            type: 'array',
+                            description: 'Assumption audit with bias attribution. 3-4 entries typical.',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    assumption: { type: 'string' },
+                                    confidence: { type: 'string', enum: ['high', 'medium', 'low'] },
+                                    ifWrong: { type: 'string', description: 'Consequence if the assumption is wrong.' },
+                                    bias: { type: 'string', enum: ['anchoring', 'framing', 'authority', 'sunk_cost', 'availability', 'confirmation', 'none'] },
+                                    biasEvidence: { type: 'string', description: 'Evidence that the named bias is operating. Use empty string when bias is "none".' },
+                                },
+                            },
+                        },
+                        edgeCases: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Boundary conditions and hostile scenarios the proposal needs to survive. 5-10 entries.',
+                        },
+                        failureModes: {
+                            type: 'array',
+                            description: 'Failure mode catalog with blast radius and detection. 3-5 entries.',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    component: { type: 'string' },
+                                    howItFails: { type: 'string' },
+                                    blastRadius: { type: 'string', enum: ['contained', 'cascading'] },
+                                    detection: { type: 'string', description: 'How you would notice this failure.' },
+                                },
+                            },
+                        },
+                        counterArguments: {
+                            type: 'array',
+                            description: 'Steelman + rebuttal pairs. 2-3 entries. Prevents one-sided adversarial output.',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    argument: { type: 'string', description: 'Strongest argument FOR the proposal (steelmanned).' },
+                                    rebuttal: { type: 'string', description: 'Why it is flawed or insufficient.' },
+                                },
+                            },
+                        },
+                    },
+                },
+                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: 'RVRY_meta',
+        name: 'meta',
         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. ' +
@@ -211,13 +460,139 @@ const TOOL_DEFS = [
                     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'],
         },
     },
+    {
+        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,
@@ -231,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;
     }
@@ -265,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 {
@@ -272,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') {
@@ -286,6 +674,15 @@ async function main() {
         const userConstraints = Array.isArray(typedArgs?.userConstraints)
             ? typedArgs.userConstraints.filter(s => typeof s === 'string')
             : 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
+            : undefined;
+        const clientRounds = Array.isArray(typedArgs?.rounds)
+            ? typedArgs.rounds.filter((r) => r && typeof r === 'object' && typeof r.round === 'number')
+            : undefined;
+        // `record` is a shim-side flag; not needed by server or writer directly.
+        void typedArgs?.record;
         // Cache question on first call (no sessionId = new session)
         // On continuation calls, read from cache
         let question = input;
@@ -306,19 +703,22 @@ async function main() {
             if (result.status === 'complete') {
                 questionCache.delete(result.sessionId);
             }
-            // Write local session summary on completion (non-blocking, silent failure)
-            if (result.status === 'complete' && result.harvest) {
+            // Write local session folder on completion (non-blocking, silent failure).
+            // Client-owned harvest (Path B): prefer client-supplied `harvest` + `rounds`.
+            if (result.status === 'complete') {
                 import('./local-writer.js').then(({ writeLocalSession }) => {
                     writeLocalSession({
                         sessionId: result.sessionId,
-                        operationType: rvryTool,
+                        operationType: publicTool,
                         question,
                         rounds: result.round,
                         harvest: result.harvest,
+                        clientHarvest,
+                        clientRounds,
                     }).catch(() => { });
                 }).catch(() => { });
             }
-            const stripped = stripResponse(result, question);
+            const stripped = stripResponse(result, question, publicTool);
             return {
                 content: [{ type: 'text', text: JSON.stringify(stripped) }],
             };
@@ -335,27 +735,32 @@ async function main() {
     server.setRequestHandler(ListPromptsRequestSchema, async () => ({
         prompts: [
             {
-                name: 'RVRY_deepthink',
+                name: 'deepthink',
                 description: 'Deep structured analysis for high-stakes questions',
                 arguments: [{ name: 'question', description: 'The question to analyze deeply', required: true }],
             },
             {
-                name: 'RVRY_problem_solve',
+                name: 'problem_solve',
                 description: 'Structured decision-making for problems with multiple options',
                 arguments: [{ name: 'problem', description: 'The problem or decision to analyze', required: true }],
             },
             {
-                name: 'RVRY_think',
+                name: 'rvry',
                 description: 'Structured analysis for questions needing more depth',
                 arguments: [{ name: 'question', description: 'The question to analyze', required: true }],
             },
             {
-                name: 'RVRY_challenge',
+                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',
                 arguments: [{ name: 'proposal', description: 'The proposal or idea to challenge', required: true }],
             },
             {
-                name: 'RVRY_meta',
+                name: 'meta',
                 description: 'Sustained metacognitive observation (Max tier only)',
                 arguments: [{ name: 'topic', description: 'The topic or context to reflect on', required: true }],
             },
@@ -364,11 +769,12 @@ async function main() {
     server.setRequestHandler(GetPromptRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
         const promptMap = {
-            RVRY_deepthink: `Use the RVRY_deepthink tool to analyze this question in depth: ${args?.question ?? ''}`,
-            RVRY_problem_solve: `Use the RVRY_problem_solve tool to work through this decision: ${args?.problem ?? ''}`,
-            RVRY_think: `Use the RVRY_think tool to analyze this question: ${args?.question ?? ''}`,
-            RVRY_challenge: `Use the RVRY_challenge tool to stress-test this proposal: ${args?.proposal ?? ''}`,
-            RVRY_meta: `Use the RVRY_meta tool to reflect on this topic: ${args?.topic ?? ''}`,
+            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 ?? ''}`,
+            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 ?? ''}`,
         };
         const text = promptMap[name] ?? `Unknown prompt: ${name}`;
         return {
@@ -382,10 +788,10 @@ async function main() {
     });
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('[rvry-mcp] Connected via stdio. Tools: RVRY_deepthink, RVRY_problem_solve, RVRY_think, RVRY_challenge, RVRY_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