@rvry/mcp 0.2.0 → 0.3.0

package/commands/deepthink.md

@@ -15,32 +15,54 @@ allowed-tools:
 - If `$ARGUMENTS` is empty or `--help`: display usage ("Usage: /deepthink [--auto] <your question>") and stop
 - If `$ARGUMENTS` contains `--auto`: set AUTO_MODE, strip `--auto` from input
 
-## Phase 1: Start Session
+## Phase 1: ORIENT (before calling the engine)
 
-Call `mcp__rvry-dev__deepthink` with `{ "input": "<cleaned input>", "skipScoping": <true if AUTO_MODE> }`.
+Orient directly -- no engine calls yet. Analyze the user's question and identify:
 
-### If status is "scoping" (and not AUTO_MODE):
+1. **What I know**: Key facts, evidence, and context apparent from the question
+2. **What I'm uncertain about**: Gaps, assumptions, unknowns (list each specifically)
+3. **What I'm avoiding**: Uncomfortable angles, taboo options, things that would be inconvenient if true
 
-The engine has returned scoping questions to help calibrate the analysis.
+Translate each uncertainty into a binary question with a smart default. Generate up to 3 questions, each with exactly 2 options. The recommended option comes first.
 
-**IMPORTANT: You MUST call AskUserQuestion as a tool to collect answers. Do NOT render the questions as plain text — the user's answers will be lost.**
+### If AUTO_MODE:
 
-Call `AskUserQuestion` with the scoping questions mapped to its format. Each `scopingQuestions` entry becomes a question:
+State your assumptions visibly in your reasoning (e.g., "Assuming focus on architectural trade-offs rather than implementation details. Assuming risk analysis is more valuable than landscape mapping."). Proceed directly to Phase 1b.
+
+### If NOT AUTO_MODE:
+
+Ask scope questions via `AskUserQuestion` (up to 3 questions, each with 2 options, smart default first marked "(Recommended)").
 
 ```
 AskUserQuestion({
-  questions: scopingQuestions.map(sq => ({
-    question: sq.question,
-    header: sq.question.slice(0, 12),  // short label
-    options: sq.options.map(o => ({ label: o.label, description: o.description })),
-    multiSelect: false
-  }))
+  questions: [
+    {
+      question: "<derived from uncertainty>",
+      header: "<short label>",
+      options: [
+        { label: "<recommended option> (Recommended)", description: "<why this is the smart default>" },
+        { label: "<alternative option>", description: "<when this makes sense>" }
+      ],
+      multiSelect: false
+    }
+  ]
 })
 ```
 
-After collecting all answers from AskUserQuestion, format them as a brief context summary (e.g., "Stakes: High. Looking for: risks and failure modes.") and call `mcp__rvry-dev__deepthink` with `{ "input": "<formatted scoping answers>", "sessionId": "<sessionId from previous response>" }`.
+If AskUserQuestion returns blank or fails, state assumptions visibly and proceed.
+
+Record the answers (or stated assumptions) as a brief context summary.
+
+## Phase 1b: Start Engine Session
 
-### If status is "active":
+Format the user's original question enriched with scope context.
+
+Call `mcp__rvry-dev__deepthink` with:
+```
+{
+  "input": "<original question>\n\nContext: <brief summary of scope answers, e.g. 'Focus: architectural trade-offs. Priority: risk analysis. No time constraint.'>"
+}
+```
 
 Proceed to Phase 2.
 
@@ -49,13 +71,21 @@ Proceed to Phase 2.
 
 Repeat until `status === "complete"`:
 
-1. Read the engine's `prompt` and `instruction` — these guide YOUR analysis. **Do not show either to the user.**
+1. Read the engine's `question` field -- this is the analytical direction for this round. Read `constraints`, `gate`, and `detection` to understand the engine's assessment. Read `constraintBlock` for constraint update instructions. **Do not show any of these to the user.**
 2. Show the user a brief status line:
-   - Format: `Round {round} — {what you're doing this round}`
-   - Example: `Round 3 — stress-testing the current position`
-   - Derive the description from the engine's phase indicator or your own summary of the round's focus. One line only.
-3. Perform your analysis in your internal reasoning. The engine's prompt contains analytical framings, self-check questions, and constraint tracking — use all of these to guide your thinking, but they are YOUR instructions, not user output.
-4. In your internal reasoning, end your analysis with the constraint update block the engine expects:
+   - Format: `Round {round} -- {what you're doing this round}`
+   - Example: `Round 3 -- stress-testing the current position`
+   - Derive the description from the engine's question focus. One line only.
+3. Perform your analysis in your internal reasoning. The engine's question and constraint data guide your thinking, but they are YOUR instructions, not user output.
+4. Run a 7-question self-check internally (not shown to user):
+   - Is this shallow or predictable?
+   - What am I avoiding?
+   - Why not the uncomfortable option?
+   - What would I critique if someone else wrote this?
+   - What would a skeptical expert challenge?
+   - Any verifiable claims that should be checked?
+   - What factual premise have I not verified?
+5. In your internal reasoning, end your analysis with the constraint update block the engine expects:
    ```
    Constraint Updates
    RESOLVE: C1, C2
@@ -64,16 +94,15 @@ Repeat until `status === "complete"`:
    MILESTONE: <milestone> | <evidence>
    End Constraint Updates
    ```
-5. Call the engine tool with your full analysis (including constraint updates) as the `input`. **The full analysis text goes ONLY in the tool call, never in visible output.**
+6. Call the engine tool with your full analysis (including constraint updates) as the `input`. **The full analysis text goes ONLY in the tool call, never in visible output.**
 
 ### What NEVER appears in user-visible output:
-- The engine's `prompt` field content
-- Constraint tables (`C1 [ACTIVE] FORWARD: ...`)
-- Constraint update blocks (`RESOLVE: C1`, `MILESTONE: ...`)
+- The engine's `question` field content
+- Constraint views or constraint update blocks
 - Self-check questions or responses
-- Gate verdicts (`SOFT_FAIL`, `HARD_FAIL`, `PASS`)
+- Gate verdicts or detection results
 - Milestone markers
-- Protocol surface elements (session awareness text, phase indicators from engine)
+- The `constraintBlock` content
 
 ### What the user sees per round:
 - The one-line status (step 2 above)
@@ -83,7 +112,7 @@ Repeat until `status === "complete"`:
 
 When `status === "complete"`:
 
-Synthesize the analysis for the user based on your accumulated reasoning across all rounds. Do NOT simply echo the engine's `harvest` fields — they are structured data, not a finished presentation.
+Synthesize the analysis for the user based on your accumulated reasoning across all rounds. Do NOT simply echo the engine's `harvest` fields -- they are structured data, not a finished presentation.
 
 Present to the user:
 1. **Default Starting Point**: What the obvious answer was and why it was insufficient
@@ -91,4 +120,4 @@ Present to the user:
 3. **Open Questions**: What remains genuinely uncertain (if any)
 4. **Suggested Next Steps**: Concrete follow-up actions or investigations
 
-Use the engine's `harvest.summary`, `harvest.keyFindings`, `harvest.openQuestions`, and `harvest.followUps` as source material, but write the synthesis in your own words with the depth your analysis produced. The harvest fields are often terse — your synthesis should reflect the full depth of the multi-round analysis.
+Use the engine's `harvest.summary`, `harvest.keyFindings`, `harvest.openQuestions`, and `harvest.followUps` as source material, but write the synthesis in your own words with the depth your analysis produced. The harvest fields are often terse -- your synthesis should reflect the full depth of the multi-round analysis.

package/commands/problem-solve.md

@@ -15,32 +15,54 @@ allowed-tools:
 - If `$ARGUMENTS` is empty or `--help`: display usage ("Usage: /problem-solve [--auto] <your problem or decision>") and stop
 - If `$ARGUMENTS` contains `--auto`: set AUTO_MODE, strip `--auto` from input
 
-## Phase 1: Start Session
+## Phase 1: ORIENT (before calling the engine)
 
-Call `mcp__rvry-dev__problem_solve` with `{ "input": "<cleaned input>", "skipScoping": <true if AUTO_MODE> }`.
+Orient directly -- no engine calls yet. Analyze the user's problem and identify:
 
-### If status is "scoping" (and not AUTO_MODE):
+1. **What I know**: Key facts, constraints, and context apparent from the problem statement
+2. **What I'm uncertain about**: Gaps, assumptions, unknowns (list each specifically)
+3. **What I'm avoiding**: Uncomfortable options, risky paths, things that would be inconvenient if true
 
-The engine has returned scoping questions to help calibrate the analysis.
+Translate each uncertainty into a binary question with a smart default. Generate up to 3 questions, each with exactly 2 options. The recommended option comes first.
 
-**IMPORTANT: You MUST call AskUserQuestion as a tool to collect answers. Do NOT render the questions as plain text — the user's answers will be lost.**
+### If AUTO_MODE:
 
-Call `AskUserQuestion` with the scoping questions mapped to its format. Each `scopingQuestions` entry becomes a question:
+State your assumptions visibly in your reasoning (e.g., "Assuming risk minimization over speed. Assuming known options need evaluation rather than generating new alternatives."). Proceed directly to Phase 1b.
+
+### If NOT AUTO_MODE:
+
+Ask scope questions via `AskUserQuestion` (up to 3 questions, each with 2 options, smart default first marked "(Recommended)").
 
 ```
 AskUserQuestion({
-  questions: scopingQuestions.map(sq => ({
-    question: sq.question,
-    header: sq.question.slice(0, 12),  // short label
-    options: sq.options.map(o => ({ label: o.label, description: o.description })),
-    multiSelect: false
-  }))
+  questions: [
+    {
+      question: "<derived from uncertainty>",
+      header: "<short label>",
+      options: [
+        { label: "<recommended option> (Recommended)", description: "<why this is the smart default>" },
+        { label: "<alternative option>", description: "<when this makes sense>" }
+      ],
+      multiSelect: false
+    }
+  ]
 })
 ```
 
-After collecting all answers from AskUserQuestion, format them as a brief context summary (e.g., "Options: multiple, need to narrow. Priority: risk minimization.") and call `mcp__rvry-dev__problem_solve` with `{ "input": "<formatted scoping answers>", "sessionId": "<sessionId from previous response>" }`.
+If AskUserQuestion returns blank or fails, state assumptions visibly and proceed.
+
+Record the answers (or stated assumptions) as a brief context summary.
+
+## Phase 1b: Start Engine Session
 
-### If status is "active":
+Format the user's original problem enriched with scope context.
+
+Call `mcp__rvry-dev__problem_solve` with:
+```
+{
+  "input": "<original problem>\n\nContext: <brief summary of scope answers, e.g. 'Priority: risk minimization. Options: evaluate known ones. Single decision-maker.'>"
+}
+```
 
 Proceed to Phase 2.
 
@@ -49,12 +71,12 @@ Proceed to Phase 2.
 
 Repeat until `status === "complete"`:
 
-1. Read the engine's `prompt` and `instruction` — these guide YOUR analysis. **Do not show either to the user.**
+1. Read the engine's `question` field -- this is the analytical direction for this round. Read `constraints`, `gate`, and `detection` to understand the engine's assessment. Read `constraintBlock` for constraint update instructions. **Do not show any of these to the user.**
 2. Show the user a brief status line:
-   - Format: `Round {round} — {what you're doing this round}`
-   - Example: `Round 3 — stress-testing the current position`
-   - Derive the description from the engine's phase indicator or your own summary of the round's focus. One line only.
-3. Perform your analysis in your internal reasoning. The engine's prompt contains analytical framings, self-check questions, and constraint tracking — use all of these to guide your thinking, but they are YOUR instructions, not user output.
+   - Format: `Round {round} -- {what you're doing this round}`
+   - Example: `Round 3 -- stress-testing the current position`
+   - Derive the description from the engine's question focus. One line only.
+3. Perform your analysis in your internal reasoning. The engine's question and constraint data guide your thinking, but they are YOUR instructions, not user output.
 4. In your internal reasoning, end your analysis with the constraint update block the engine expects:
    ```
    Constraint Updates
@@ -67,13 +89,12 @@ Repeat until `status === "complete"`:
 5. Call the engine tool with your full analysis (including constraint updates) as the `input`. **The full analysis text goes ONLY in the tool call, never in visible output.**
 
 ### What NEVER appears in user-visible output:
-- The engine's `prompt` field content
-- Constraint tables (`C1 [ACTIVE] FORWARD: ...`)
-- Constraint update blocks (`RESOLVE: C1`, `MILESTONE: ...`)
+- The engine's `question` field content
+- Constraint views or constraint update blocks
 - Self-check questions or responses
-- Gate verdicts (`SOFT_FAIL`, `HARD_FAIL`, `PASS`)
+- Gate verdicts or detection results
 - Milestone markers
-- Protocol surface elements (session awareness text, phase indicators from engine)
+- The `constraintBlock` content
 
 ### What the user sees per round:
 - The one-line status (step 2 above)
@@ -83,7 +104,7 @@ Repeat until `status === "complete"`:
 
 When `status === "complete"`:
 
-Synthesize the analysis for the user based on your accumulated reasoning across all rounds. Do NOT simply echo the engine's `harvest` fields — they are structured data, not a finished presentation.
+Synthesize the analysis for the user based on your accumulated reasoning across all rounds. Do NOT simply echo the engine's `harvest` fields -- they are structured data, not a finished presentation.
 
 Present to the user:
 1. **Default Starting Point**: What the obvious answer was and why it was insufficient
@@ -91,4 +112,4 @@ Present to the user:
 3. **Open Questions**: What remains genuinely uncertain (if any)
 4. **Suggested Next Steps**: Concrete follow-up actions or investigations
 
-Use the engine's `harvest.summary`, `harvest.keyFindings`, `harvest.openQuestions`, and `harvest.followUps` as source material, but write the synthesis in your own words with the depth your analysis produced. The harvest fields are often terse — your synthesis should reflect the full depth of the multi-round analysis.
+Use the engine's `harvest.summary`, `harvest.keyFindings`, `harvest.openQuestions`, and `harvest.followUps` as source material, but write the synthesis in your own words with the depth your analysis produced. The harvest fields are often terse -- your synthesis should reflect the full depth of the multi-round analysis.

package/dist/client.d.ts

@@ -2,22 +2,36 @@
  * RVRY MCP Client -- HTTP client for the RVRY engine /api/v1/think endpoint.
  */
 /** Valid tool names for the RVRY engine */
-export type RvryTool = 'deepthink' | 'think' | 'problem_solve' | 'challenge' | 'meta';
-export interface ScopingQuestion {
-    question: string;
-    options: Array<{
-        label: string;
-        description: string;
-    }>;
-    default: string;
+export type RvryTool = 'deepthink' | 'problem_solve';
+export interface ConstraintView {
+    id: string;
+    type: 'FORWARD' | 'FORBIDDEN' | 'QUESTION';
+    text: string;
+    status: 'active' | 'resolved' | 'acknowledged' | 'deferred';
+}
+export interface DetectionView {
+    overallSeverity: 'low' | 'medium' | 'high' | null;
+    interventionHint: string | null;
+}
+export interface GateView {
+    verdict: 'PASS' | 'SOFT_FAIL' | 'HARD_FAIL' | null;
+    blocked: boolean;
+    reason: string | null;
+}
+export interface MilestoneView {
+    key: string;
+    status: 'missing' | 'satisfied';
 }
 export interface ThinkResponse {
     sessionId: string;
-    status: 'scoping' | 'active' | 'complete';
+    status: 'active' | 'complete';
     round: number;
-    prompt: string;
-    instruction: string;
-    scopingQuestions?: ScopingQuestion[];
+    question: string;
+    constraints: ConstraintView[];
+    detection: DetectionView;
+    gate: GateView;
+    milestones: MilestoneView[];
+    constraintBlock: string;
     usage?: {
         used: number;
         limit: number;
@@ -38,8 +52,4 @@ export interface ThinkResponse {
  * Call the RVRY engine /api/v1/think endpoint with a specific tool.
  * Start a new session by omitting sessionId, or continue by providing one.
  */
-export declare function callTool(tool: RvryTool, input: string, token: string, sessionId?: string, skipScoping?: boolean): Promise<ThinkResponse>;
-/**
- * @deprecated Use callTool('think', input, token, sessionId) instead.
- */
-export declare function callThink(input: string, token: string, sessionId?: string): Promise<ThinkResponse>;
+export declare function callTool(tool: RvryTool, input: string, token: string, sessionId?: string): Promise<ThinkResponse>;

package/dist/client.js

@@ -6,15 +6,12 @@ const DEFAULT_ENGINE_URL = 'https://engine.rvry.ai';
  * Call the RVRY engine /api/v1/think endpoint with a specific tool.
  * Start a new session by omitting sessionId, or continue by providing one.
  */
-export async function callTool(tool, input, token, sessionId, skipScoping) {
+export async function callTool(tool, input, token, sessionId) {
     const baseUrl = process.env.RVRY_ENGINE_URL ?? DEFAULT_ENGINE_URL;
     const body = { input, tool };
     if (sessionId) {
         body.sessionId = sessionId;
     }
-    if (skipScoping) {
-        body.skipScoping = true;
-    }
     const res = await fetch(`${baseUrl}/api/v1/think`, {
         method: 'POST',
         headers: {
@@ -28,9 +25,3 @@ export async function callTool(tool, input, token, sessionId, skipScoping) {
     }
     return res.json();
 }
-/**
- * @deprecated Use callTool('think', input, token, sessionId) instead.
- */
-export async function callThink(input, token, sessionId) {
-    return callTool('think', input, token, sessionId);
-}

package/dist/index.js

@@ -48,10 +48,6 @@ const TOOL_DEFS = [
                     type: 'string',
                     description: 'Session ID for continuing an existing session. Omit to start a new session.',
                 },
-                skipScoping: {
-                    type: 'boolean',
-                    description: 'Skip the scoping questions phase and begin analysis immediately.',
-                },
             },
             required: ['input'],
         },
@@ -72,10 +68,6 @@ const TOOL_DEFS = [
                     type: 'string',
                     description: 'Session ID for continuing an existing session. Omit to start a new session.',
                 },
-                skipScoping: {
-                    type: 'boolean',
-                    description: 'Skip the scoping questions phase and begin analysis immediately.',
-                },
             },
             required: ['input'],
         },
@@ -89,12 +81,12 @@ function stripResponse(result, question) {
         round: result.round,
         question,
     };
-    if (result.status === 'scoping' && result.scopingQuestions) {
-        stripped.scopingQuestions = result.scopingQuestions;
-    }
     if (result.status === 'active') {
-        stripped.prompt = result.prompt;
-        stripped.instruction = result.instruction;
+        stripped.constraints = result.constraints;
+        stripped.detection = result.detection;
+        stripped.gate = result.gate;
+        stripped.milestones = result.milestones;
+        stripped.constraintBlock = result.constraintBlock;
     }
     if (result.status === 'complete' && result.harvest) {
         stripped.harvest = result.harvest;
@@ -142,7 +134,6 @@ async function main() {
             };
         }
         const sessionId = typeof typedArgs?.sessionId === 'string' ? typedArgs.sessionId : undefined;
-        const skipScoping = typedArgs?.skipScoping === true;
         // Cache question on first call (no sessionId = new session)
         // On continuation calls, read from cache
         let question = input;
@@ -153,7 +144,7 @@ async function main() {
             question = questionCache.get(sessionId) ?? input;
         }
         try {
-            const result = await callTool(rvryTool, input, token, sessionId, skipScoping || undefined);
+            const result = await callTool(rvryTool, input, token, sessionId);
             // Cache question on first call (now we have the sessionId)
             if (!sessionId) {
                 questionCache.set(result.sessionId, input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rvry/mcp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "RVRY reasoning depth enforcement (RDE) engine client.",
   "type": "module",
   "bin": {