@rvry/mcp 0.12.2 → 1.0.0

package/dist/setup.js

@@ -218,132 +218,6 @@ function registerClaudeCode(token) {
         return 'error';
     }
 }
-/**
- * Write RVRY server entry into a generic MCP JSON config file.
- * Used by clients that follow the Desktop-style config format (Codex, Gemini, etc.)
- */
-function configureJsonMcp(configPath, token) {
-    try {
-        let config = {};
-        if (existsSync(configPath)) {
-            const raw = readFileSync(configPath, 'utf-8');
-            try {
-                config = JSON.parse(raw);
-            }
-            catch {
-                writeFileSync(configPath + '.backup', raw, 'utf-8');
-                config = {};
-            }
-        }
-        if (!config.mcpServers || typeof config.mcpServers !== 'object') {
-            config.mcpServers = {};
-        }
-        const servers = config.mcpServers;
-        const existing = servers.RVRY;
-        if (existing) {
-            const existingEnv = existing.env;
-            if (existingEnv?.RVRY_TOKEN === token)
-                return 'unchanged';
-        }
-        const wasNew = !existing;
-        servers.RVRY = RVRY_SERVER_ENTRY(token);
-        const dir = dirname(configPath);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-        return wasNew ? 'ok' : 'updated';
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.log(`  Error writing config: ${msg}`);
-        return 'error';
-    }
-}
-/**
- * Write RVRY server entry into a TOML config file (e.g. ~/.codex/config.toml).
- * Uses string/regex manipulation — no TOML parser dependency.
- */
-function configureTomlMcp(configPath, token) {
-    const block = [
-        '[mcp_servers.rvry]',
-        'command = "npx"',
-        'args = ["--yes", "--package", "@rvry/mcp@latest", "rvry-mcp"]',
-        '',
-        '[mcp_servers.rvry.env]',
-        `RVRY_TOKEN = "${token}"`,
-    ].join('\n');
-    try {
-        let content = '';
-        if (existsSync(configPath)) {
-            content = readFileSync(configPath, 'utf-8');
-        }
-        const sectionRegex = /^\[mcp_servers\.rvry\]/m;
-        if (sectionRegex.test(content)) {
-            // Section exists — check if token is the same
-            const tokenMatch = content.match(/^\[mcp_servers\.rvry\.env\]\s*\nRVRY_TOKEN\s*=\s*"([^"]*)"/m);
-            if (tokenMatch && tokenMatch[1] === token) {
-                return 'unchanged';
-            }
-            // Replace entire section: from [mcp_servers.rvry] to next top-level section or EOF
-            // Match from [mcp_servers.rvry] up to (but not including) the next section header
-            // that is NOT a sub-section of mcp_servers.rvry
-            const replaceRegex = /\[mcp_servers\.rvry\][\s\S]*?(?=\n\[(?!mcp_servers\.rvry[.\]])|$)/;
-            content = content.replace(replaceRegex, block);
-            writeFileSync(configPath, content, 'utf-8');
-            return 'updated';
-        }
-        // Section doesn't exist — append
-        const separator = content.length > 0 && !content.endsWith('\n') ? '\n\n' : content.length > 0 ? '\n' : '';
-        const dir = dirname(configPath);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        writeFileSync(configPath, content + separator + block + '\n', 'utf-8');
-        return 'ok';
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.log(`  Error writing TOML config: ${msg}`);
-        return 'error';
-    }
-}
-function isGeminiCLIAvailable() {
-    try {
-        const cmd = platform() === 'win32' ? 'where gemini' : 'which gemini';
-        execSync(cmd, { stdio: 'pipe' });
-        return true;
-    }
-    catch { /* not on PATH */ }
-    if (existsSync(join(homedir(), '.gemini', 'settings.json')))
-        return true;
-    return false;
-}
-function registerGeminiCLI(token) {
-    try {
-        // Remove existing entry first (silent fail if not registered)
-        try {
-            execSync('gemini mcp remove rvry', { stdio: 'pipe' });
-        }
-        catch { /* not registered */ }
-        execSync(`gemini mcp add rvry -e RVRY_TOKEN="${token}" --scope user npx --yes --package @rvry/mcp@latest rvry-mcp`, { stdio: 'inherit' });
-        return 'ok';
-    }
-    catch {
-        // Fallback: write settings.json directly
-        return configureJsonMcp(join(homedir(), '.gemini', 'settings.json'), token);
-    }
-}
-function isCodexAvailable() {
-    try {
-        const cmd = platform() === 'win32' ? 'where codex' : 'which codex';
-        execSync(cmd, { stdio: 'pipe' });
-        return true;
-    }
-    catch { /* not on PATH */ }
-    // Fallback: check if config directory exists (covers aliased installs)
-    if (existsSync(join(homedir(), '.codex', 'config.toml')))
-        return true;
-    return false;
-}
 /** All supported clients. Add new clients here. */
 const CLIENT_REGISTRY = [
     {
@@ -360,70 +234,6 @@ const CLIENT_REGISTRY = [
         configure: (token) => configureDesktop(token),
         notInstalledHint: 'Not installed',
     },
-    {
-        name: 'Anti-Gravity',
-        id: 'antigravity',
-        defaultSelected: false,
-        detect: () => {
-            // OR-logic: binary (agy or antigravity), config dir, or macOS app bundle
-            try {
-                const cmd = platform() === 'win32' ? 'where agy' : 'which agy';
-                execSync(cmd, { stdio: 'pipe' });
-                return true;
-            }
-            catch { /* not on PATH */ }
-            if (platform() !== 'win32') {
-                try {
-                    execSync('which antigravity', { stdio: 'pipe' });
-                    return true;
-                }
-                catch { /* not on PATH */ }
-            }
-            if (existsSync(join(homedir(), '.gemini', 'antigravity')))
-                return true;
-            if (platform() === 'darwin' && existsSync('/Applications/Google Antigravity.app'))
-                return true;
-            return false;
-        },
-        configure: (token) => configureJsonMcp(join(homedir(), '.gemini', 'antigravity', 'mcp_config.json'), token),
-        notInstalledHint: 'Not installed (https://antigravity.google)',
-    },
-    {
-        name: 'Cursor',
-        id: 'cursor',
-        defaultSelected: false,
-        detect: () => {
-            if (platform() === 'darwin' && existsSync('/Applications/Cursor.app'))
-                return true;
-            if (existsSync(join(homedir(), '.cursor', 'mcp.json')))
-                return true;
-            try {
-                const cmd = platform() === 'win32' ? 'where cursor' : 'which cursor';
-                execSync(cmd, { stdio: 'pipe' });
-                return true;
-            }
-            catch { /* not on PATH */ }
-            return false;
-        },
-        configure: (token) => configureJsonMcp(join(homedir(), '.cursor', 'mcp.json'), token),
-        notInstalledHint: 'Not installed (https://cursor.com)',
-    },
-    {
-        name: 'Gemini CLI',
-        id: 'gemini',
-        defaultSelected: false,
-        detect: isGeminiCLIAvailable,
-        configure: registerGeminiCLI,
-        notInstalledHint: 'Not installed (https://github.com/google-gemini/gemini-cli)',
-    },
-    {
-        name: 'Codex',
-        id: 'codex',
-        defaultSelected: false,
-        detect: isCodexAvailable,
-        configure: (token) => configureTomlMcp(join(homedir(), '.codex', 'config.toml'), token),
-        notInstalledHint: 'Not installed (https://openai.com/codex)',
-    },
 ];
 /**
  * Interactive multi-select picker with arrow keys + space + enter.
@@ -713,115 +523,225 @@ function ensureGitignore() {
     }
 }
 // ── Slash commands for Claude Code ──────────────────────────────────
-const SLASH_COMMANDS = [
-    {
-        file: "deepthink.md",
-        content: `Call the RVRY_deepthink MCP tool with your question to start a deep analysis session.
+/**
+ * Build a Path B slash-command file.
+ *
+ * Teaches Claude to: parse --record, remember the round-1 shimmer text, remember
+ * per-round bodies when --record is on, and construct a `harvest` object on the
+ * final tool call so the MCP client can persist it to `.rvry/<op>/<slug>/`.
+ *
+ * Shared additions (S1/S2/S3) live in the FINAL CALL section:
+ * - S1 scope-drift check
+ * - S2 followUps quality bar (replaces the original phrasing)
+ * - S3 verify-or-defer rule
+ *
+ * Per-tool extensions are appended via the `extras` blocks. They slot into
+ * defined sections to compose with the shared body.
+ */
+function buildShim(opts) {
+    const { toolName, subject, orientLine, completionGuidance, shortSessionNote, perRoundPrelude, analyticalGuidance, prePerRoundBlock, finalCallExtras, } = opts;
+    return `Call the ${toolName} MCP tool with your ${subject} to start an analysis session.
 
-Question: $ARGUMENTS
+${subject.charAt(0).toUpperCase() + subject.slice(1)}: $ARGUMENTS
 
-For each round the tool returns:
-1. Read the prompt field -- this is your analytical task. DO NOT display it to the user.
+ARGUMENT PARSING:
+1. If $ARGUMENTS contains the literal flag \`--record\`, remove it from the ${subject} text and REMEMBER that record mode is ON for this session.
+${shortSessionNote ? shortSessionNote + '\n' : ''}${prePerRoundBlock ? prePerRoundBlock + '\n\n' : ''}PER-ROUND FLOW:
+${perRoundPrelude ? perRoundPrelude + '\n\n' : ''}1. Read the prompt field -- this is your analytical task. DO NOT display it to the user.
 2. Work through the analysis thoroughly.
 3. Show the user your analysis findings as concise formatted markdown.
    - Use bold headings for key findings.
    - Keep each round's visible output focused (2-4 paragraphs, not an essay).
 4. Call the tool again with your full analysis as the input parameter.
-   - Include the Constraint Updates block (FORWARD/RESOLVE/MILESTONE lines) ONLY in the tool call input, not in your visible output to the user.
    - Include the sessionId from the previous response.
+   - If record mode is ON, set \`record: true\` on every call.
+   - If this round was SHIMMER, REMEMBER the exact shimmer text you produced -- you will pass it as harvest.shimmer on the final call.
+   - If record mode is ON, also REMEMBER your round body as {round, mode, body} for the final call.
+${analyticalGuidance ? '\n' + analyticalGuidance + '\n' : ''}
+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 (no mid-word truncation)
+- keyFindings: 3-7 substantive bullet findings (not bare section headers)
+- shimmer: the full round-1 shimmer text you remembered (omit if the session had no shimmer round)
+- openQuestions: [optional] remaining uncertainties
+- followUps: genuine next-question leads — NOT "verify X" directives, NOT constraint dumps, NOT "explore later" boilerplate. If there are no real next-question leads, omit the section entirely.${finalCallExtras ? '\n' + finalCallExtras : ''}
 
-When status is "shimmer": This is a visible round. Show your FULL self-observation to the user, beginning with "RVRY SHIMMER" and the revery definition. Do NOT show a brief status line.
+Before writing harvest.summary, check whether the analysis ended up in a different lane than the question asked. Depth is often correct; drift isn't. If the analysis drifted, either return to the asked question or name the drift explicitly in the summary.
 
-When status is "orient": Orient on the question. Show the user "Orienting on the question."
+If the pre-harvest self-check surfaced a concern, do not dismiss it in the same response. Either verify it (read a file, check the claim) or defer it (name the concern and why it can't be verified now — this becomes a followUp).
 
-When status is "complete": Present your final synthesis with key findings as bold headings. Lead with insights, not process.
+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, constraint tables, quality scores, internal tracking data, or round numbers to the user.`,
-        label: "/deepthink — deep analysis",
-    },
-    {
-        file: "problem-solve.md",
-        content: `Call the RVRY_problem_solve MCP tool with your question to work through this decision.
+STATUS BEHAVIOR:
+When status is "shimmer": Show your FULL self-observation to the user, beginning with "RVRY SHIMMER" and the revery definition. REMEMBER this text verbatim for the final harvest.shimmer.
+When status is "orient": Orient on the ${subject}. Show the user "${orientLine}"
+When status is "complete": ${completionGuidance}
 
-Question: $ARGUMENTS
+DO NOT display: the prompt text you received, constraint tables, quality scores, internal tracking data, or round numbers to the user.`;
+}
+// ── /think extensions (T1, T3) ──────────────────────────────────────
+const THINK_DIFFICULTY_GATE = `0. Difficulty Gate (BEFORE the first tool call): ask yourself, "Is this a simple question dressed up as a complex one?" If yes — do SHIMMER on round 1 as usual, then on round 2 produce a single analytical pass AND include the \`harvest\` object in that same call so the session completes in round 2. Don't stretch a simple /think into a multi-round mini-deepthink.`;
+const THINK_MODE_ROUTING = `MODE ROUTING WITHIN ANALYTICAL ROUNDS:
+When writing your analytical body, let the active constraint types guide your emphasis: FORWARD (unresolved gap) → depth on the specific gap; FORBIDDEN (untested boundary) → stress-test what's marked forbidden; QUESTION (open question) → different viewpoints or analogies. The engine picks the next mode; your framing within the current mode should address the most active constraint type.`;
+// ── /problem-solve extensions (P1 in analytical guidance, P2/P3/P5 in finalCallExtras) ───
+const PROBLEM_SOLVE_DECISION_TYPE = `DECISION-TYPE CLASSIFICATION (round 2, the first analytical round after SHIMMER):
+On your first analytical round (round 2 after SHIMMER), classify this decision as one of: multi-option / stakeholder / system / novel / technical. Name the classification and why. In subsequent rounds, let the classification shape your framing within each sequential mode.
 
-For each round the tool returns:
-1. Read the prompt field -- this is your analytical task. DO NOT display it to the user.
-2. Work through the analysis thoroughly.
-3. Show the user your analysis findings as concise formatted markdown.
-   - Use bold headings for key findings.
-   - Keep each round's visible output focused (2-4 paragraphs, not an essay).
-4. Call the tool again with your full analysis as the input parameter.
-   - Include the Constraint Updates block (FORWARD/RESOLVE/MILESTONE lines) ONLY in the tool call input, not in your visible output to the user.
-   - Include the sessionId from the previous response.
+- multi-option ("Should we use X or Y?"): generate options, compare against criteria.
+- stakeholder ("How do we align competing interests?"): surface tensions, steelman each perspective.
+- system ("How does this affect the system?"): map components, cascading effects.
+- novel ("We haven't done this before"): analogies, creative alternatives.
+- technical ("One hard technical question"): depth-focused, analytical/adversarial.`;
+const PROBLEM_SOLVE_FINAL_EXTRAS = `- biasAudit: For each of 6 biases (anchoring, framing, authority, sunk_cost, availability, confirmation), check whether it's operating against your leading direction. For each one that IS operating, cite evidence and link it to a specific reflex from the SHIMMER text you remembered (use the \`shimmer\` text verbatim) in \`sourceReflex\`. Include \`frameReversal\`: phrase the opposite of the original framing and state whether you'd reach the same conclusion. Set \`decisionStable\` to true only if the leading direction survives the bias check unchanged.
+- adversarialVerdict: After your stress-test round, set this to PASSED (direction survives), CAVEATS (holds with modifications — list them in keyFindings), or NEEDS_REVISION (critical weakness found).
+- reversalConditions: 3-5 entries answering — under what conditions would you reverse this decision? What are the kill switches / escalation triggers? What is the review timeline?`;
+// ── /challenge extensions (Phase 0.5 + C1-C6 in finalCallExtras) ────
+const CHALLENGE_PHASE_0_5 = `PHASE 0.5: UNCERTAINTY SCAN (unless --auto in $ARGUMENTS)
 
-When status is "shimmer": This is a visible round. Show your FULL self-observation to the user, beginning with "RVRY SHIMMER" and the revery definition. Do NOT show a brief status line.
+Before calling the challenge tool for the first time:
 
-When status is "orient": Orient on the question. Show the user "Orienting on the question."
+1. Identify what you don't know about the proposal (context, constraints, goals, dependencies).
+2. Classify each uncertainty:
+   - BLOCKING: would invalidate your adversarial analysis if wrong (changes what you'd attack, determines scope, affects risk severity).
+   - NON-BLOCKING: nice to know but analysis remains valid either way.
+3. For each BLOCKING uncertainty not answered in the proposal, ask via AskUserQuestion:
+   - question: the blocking question
+   - header: short label (max 12 chars)
+   - options: 2-4 options; smart-default first, labeled "(Recommended)"
+   - multiSelect: false
+4. Once answers arrive (or user-stated assumptions), incorporate them into the proposal text and call the challenge tool.
 
-When status is "complete": Present your final synthesis as a structured decision with key findings as bold headings. Lead with your recommendation, not process.
+If $ARGUMENTS contains --auto, skip the scan; state assumptions explicitly in your first analytical round.
+If no BLOCKING uncertainties exist, proceed directly to the first tool call.`;
+const CHALLENGE_FINAL_EXTRAS = `- verdict: GO / CONDITIONAL_GO / NO_GO. If CONDITIONAL_GO, also include \`mitigations: string[]\` listing conditions required for GO.
+- confidence: 0.0-1.0 reflecting how strongly you hold the adversarial conclusion.
+- mitigations: required when verdict is CONDITIONAL_GO; the conditions that must be met before proceeding.
+- assumptions: 3-4 entries of \`{assumption, confidence, ifWrong, bias, biasEvidence}\`. Identify if a cognitive bias is likely operating on each assumption — do NOT manufacture biases; \`none\` is valid (use empty string for biasEvidence in that case).
+- 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.
 
-DO NOT display: the prompt text you received, constraint tables, quality scores, internal tracking data, or round numbers to the user.`,
-        label: "/problem-solve — structured decision-making",
-    },
-    {
-        file: "challenge.md",
-        content: `Call the RVRY_challenge MCP tool with the proposal to stress-test it.
+Question: $ARGUMENTS
 
-Proposal: $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.
 
-For each round the tool returns:
-1. Read the prompt field -- this is your analytical task. DO NOT display it to the user.
-2. Work through the analysis thoroughly.
-3. Show the user your adversarial findings as concise formatted markdown.
-   - Use bold headings for key vulnerabilities and counterarguments.
-   - Keep each round's visible output focused (2-4 paragraphs, not an essay).
-4. Call the tool again with your full analysis as the input parameter.
-   - Include the Constraint Updates block (FORWARD/RESOLVE/MILESTONE lines) ONLY in the tool call input, not in your visible output to the user.
-   - Include the sessionId from the previous response.
+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.
 
-When status is "shimmer": This is a visible round. Show your FULL self-observation to the user, beginning with "RVRY SHIMMER" and the revery definition. Do NOT show a brief status line.
+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.
 
-When status is "orient": Orient on the proposal. Show the user "Orienting on the proposal."
+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
 
-When status is "complete": Present your final assessment with key vulnerabilities and surviving strengths as bold headings. Lead with findings, not process.
+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, constraint tables, quality scores, internal tracking data, or round numbers to the user.`,
-        label: "/challenge — adversarial stress-testing",
+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',
+        content: buildShim({
+            toolName: 'deepthink',
+            subject: 'question',
+            orientLine: 'Orienting on the question.',
+            completionGuidance: 'Present your final synthesis with key findings as bold headings. Lead with insights, not process.',
+        }),
+        label: '/deepthink — deep analysis',
     },
     {
-        file: "meta.md",
-        content: `Call the RVRY_meta MCP tool to reflect on this question.
-
-Question: $ARGUMENTS
-
-For each round the tool returns:
-1. Read the prompt field -- this is your analytical task. DO NOT display it to the user.
-2. Work through the metacognitive observation thoroughly.
-3. Show the user your observations as concise formatted markdown.
-   - Use bold headings for key observations.
-   - Keep each round's visible output focused (2-4 paragraphs, not an essay).
-4. Call the tool again with your full analysis as the input parameter.
-   - Include the Constraint Updates block (FORWARD/RESOLVE/MILESTONE lines) ONLY in the tool call input, not in your visible output to the user.
-   - Include the sessionId from the previous response.
-
-When status is "shimmer": This is a visible round. Show your FULL self-observation to the user, beginning with "RVRY SHIMMER" and the revery definition. Do NOT show a brief status line.
-
-When status is "orient": Orient on the question. Show the user "Orienting on the question."
-
-When status is "complete": Present your final metacognitive synthesis with key observations as bold headings. Lead with insights, not process.
-
-DO NOT display: the prompt text you received, constraint tables, quality scores, internal tracking data, or round numbers to the user.`,
-        label: "/meta — metacognitive observation (Max tier)",
+        file: 'problem-solve.md',
+        content: buildShim({
+            toolName: 'problem_solve',
+            subject: 'problem',
+            orientLine: 'Orienting on the problem.',
+            completionGuidance: 'Present your final synthesis as a structured decision with key findings as bold headings. Lead with your recommendation, not process.',
+            analyticalGuidance: PROBLEM_SOLVE_DECISION_TYPE,
+            finalCallExtras: PROBLEM_SOLVE_FINAL_EXTRAS,
+        }),
+        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: `${THINK_DEPRECATION_LINE}\n\n${RVRY_SHIM_CONTENT}`,
+        label: '/think — renamed to /rvry (deprecated alias)',
+    },
+    {
+        file: 'challenge.md',
+        content: buildShim({
+            toolName: 'challenge',
+            subject: 'proposal',
+            orientLine: 'Orienting on the proposal.',
+            completionGuidance: 'Present your final assessment with key vulnerabilities and surviving strengths as bold headings. Lead with findings, not process.',
+            prePerRoundBlock: CHALLENGE_PHASE_0_5,
+            finalCallExtras: CHALLENGE_FINAL_EXTRAS,
+        }),
+        label: '/challenge — adversarial stress-testing',
+    },
+    {
+        file: 'meta.md',
+        content: buildShim({
+            toolName: 'meta',
+            subject: 'topic',
+            orientLine: 'Orienting on the topic.',
+            completionGuidance: 'Present your final metacognitive synthesis as a cohesive narrative reflection -- not a structured report. Lead with insights, not process.',
+        }),
+        label: '/meta — metacognitive observation (Max tier)',
     },
 ];
 /**
- * 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)) {
@@ -829,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);
         }
     }
@@ -843,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
@@ -990,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) {
@@ -1009,21 +934,12 @@ export async function runSetup() {
         console.log('  Option A — Claude Code (if you install it later):');
         console.log(`    claude mcp add -e RVRY_TOKEN="${token}" -s user rvry -- npx --yes --package @rvry/mcp@latest rvry-mcp`);
         console.log('');
-        console.log('  Option B — JSON config (Claude Desktop, Anti-Gravity, etc.):');
+        console.log('  Option B — Claude Desktop JSON config:');
         const manualConfig = { mcpServers: { RVRY: RVRY_SERVER_ENTRY(token) } };
         console.log('');
         for (const line of JSON.stringify(manualConfig, null, 2).split('\n')) {
             console.log(`    ${line}`);
         }
-        console.log('');
-        console.log('  Option C — TOML config (Codex — add to ~/.codex/config.toml):');
-        console.log('');
-        console.log('    [mcp_servers.rvry]');
-        console.log('    command = "npx"');
-        console.log('    args = ["--yes", "--package", "@rvry/mcp@latest", "rvry-mcp"]');
-        console.log('');
-        console.log('    [mcp_servers.rvry.env]');
-        console.log(`    RVRY_TOKEN = "${token}"`);
     }
     console.log('');
     // ── Step 4: Gitignore protection ────────────────────────────────
@@ -1043,43 +959,25 @@ export async function runSetup() {
     console.log('');
     // Client-specific next steps
     const configuredNames = new Set(configuredClients.map((c) => c.name));
-    const hasDesktopStyle = configuredNames.has('Claude Desktop / Claude Co-Work')
-        || configuredNames.has('Anti-Gravity')
-        || configuredNames.has('Codex');
+    const hasDesktopStyle = configuredNames.has('Claude Desktop / Claude Co-Work');
     const hasCodeStyle = configuredNames.has('Claude Code');
     console.log('Next steps:');
     let step = 1;
     if (hasDesktopStyle) {
-        console.log(`  ${step}. Restart desktop apps for the new MCP server to load`);
+        console.log(`  ${step}. Restart Claude Desktop for the new MCP server to load`);
         step++;
     }
-    // HTTP transport for web-based clients
-    console.log(`  ${step}. For web-based MCP clients (ChatGPT, Perplexity, etc.):`);
-    console.log('     MCP Server URL: https://engine.rvry.ai/mcp');
-    console.log('     Auth: Supabase OAuth 2.1 (Bearer token)');
-    console.log('');
-    step++;
-    // Generic stdio MCP config for any other client
-    console.log(`  ${step}. For other local MCP clients — add to your MCP config:`);
-    console.log('');
-    const mcpBlock = { rvry: RVRY_SERVER_ENTRY('YOUR_RVRY_TOKEN') };
-    const lines = JSON.stringify(mcpBlock, null, 2).split('\n');
-    for (const line of lines.slice(1, -1)) {
-        console.log(`     ${line}`);
-    }
-    console.log('');
-    step++;
     if (hasCodeStyle || hasDesktopStyle) {
         if (installedCommands.length > 0) {
             console.log(`  ${step}. Try a slash command: /deepthink [your question]`);
         }
         else {
-            console.log(`  ${step}. Try: "Use RVRY_deepthink to analyze..." or "Use RVRY_problem_solve for..."`);
+            console.log(`  ${step}. Try: "Use deepthink to analyze..." or "Use problem_solve for..."`);
         }
         step++;
     }
     if (!anyConfigured) {
         console.log('  1. Configure a client using the manual instructions above');
-        console.log('  2. Then try: "Use RVRY_deepthink to analyze..."');
+        console.log('  2. Then try: "Use deepthink to analyze..."');
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rvry/mcp",
-  "version": "0.12.2",
+  "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"
   },