@orangepro/orangepro-mcp 0.2.0 → 0.2.2

package/README.md

@@ -5,7 +5,7 @@
 `opro` builds a knowledge graph from your local checkout, maps every behavior in your code, shows which ones are tested and which aren't, and generates integration-level tests grounded in real symbols — not hallucinated imports. Runs as a CLI and an MCP server.
 
 ```bash
-npx @orangepro/orangepro-mcp
+npx @orangepro/mcp-server
 cd /path/to/your/repo
 opro
 ```
@@ -25,7 +25,7 @@ That's it. You get:
 
 ```bash
 # No install needed (npx)
-npx @orangepro/orangepro-mcp
+npx @orangepro/mcp-server
 
 # Or global install
 npm install -g @orangepro/orangepro-mcp
@@ -50,7 +50,7 @@ Add to your client's MCP config:
   "mcpServers": {
     "orangepro-local": {
       "command": "npx",
-      "args": ["-y", "-p", "@orangepro/orangepro-mcp@latest", "opro", "mcp"]
+      "args": ["-y", "@orangepro/mcp-server@latest", "mcp"]
     }
   }
 }

package/dist/local/analyze/analyzer.js

@@ -1592,9 +1592,7 @@ export function analyzeRepo(root, opts = {}) {
         };
         const resolvePythonProofTarget = (testRel, structure, qualifier, callee, shadowed) => {
             const conv = conventionSibling(testRel, "python", codeFileSet);
-            const targetRel = conv?.relPath ?? null;
-            if (!targetRel || isNonProductFile(targetRel))
-                return null;
+            const conventionTargetRel = conv?.relPath && !isNonProductFile(conv.relPath) ? conv.relPath : null;
             const hasWildcardImport = structure.imports.some((i) => i.imported === "*");
             if (!qualifier) {
                 if (shadowed.has(callee))
@@ -1603,13 +1601,15 @@ export function analyzeRepo(root, opts = {}) {
                 if (binding === null)
                     return null;
                 if (binding) {
-                    if (binding.kind !== "named" || binding.targetRel !== targetRel || binding.imported !== callee)
+                    if (binding.kind !== "named" || !binding.targetRel || isNonProductFile(binding.targetRel) || binding.imported !== callee)
                         return null;
-                    return eligiblePythonSymbol(targetRel, callee);
+                    return eligiblePythonSymbol(binding.targetRel, callee);
                 }
+                if (!conventionTargetRel)
+                    return null;
                 if (hasWildcardImport)
                     return null;
-                return eligiblePythonSymbol(targetRel, callee);
+                return eligiblePythonSymbol(conventionTargetRel, callee);
             }
             const rootQualifier = pythonQualifierRoot(qualifier);
             if (shadowed.has(rootQualifier))
@@ -1618,13 +1618,14 @@ export function analyzeRepo(root, opts = {}) {
             if (binding === null)
                 return null;
             if (binding?.kind === "module") {
-                return binding.targetRel === targetRel ? eligiblePythonSymbol(targetRel, callee) : null;
+                return binding.targetRel && !isNonProductFile(binding.targetRel) ? eligiblePythonSymbol(binding.targetRel, callee) : null;
             }
-            if (binding?.kind === "named" && (binding.targetRel !== targetRel || binding.imported !== rootQualifier))
+            const classTargetRel = binding?.kind === "named" ? binding.targetRel : conventionTargetRel;
+            if (binding?.kind === "named" && (!classTargetRel || isNonProductFile(classTargetRel) || binding.imported !== rootQualifier))
                 return null;
-            if (symbolKind(targetRel, rootQualifier) !== "class")
+            if (!classTargetRel || symbolKind(classTargetRel, rootQualifier) !== "class")
                 return null;
-            return eligiblePythonSymbol(targetRel, callee);
+            return eligiblePythonSymbol(classTargetRel, callee);
         };
         for (const [rel, { language, structure }] of nonTsStructureByFile) {
             for (const i of structure.imports) {
@@ -1814,11 +1815,15 @@ export function analyzeRepo(root, opts = {}) {
                     continue;
                 seenPythonProof.add(edgeKey);
                 pythonProofConfirmedPairs++;
+                const pythonEdgeProps = /^(?:Test[A-Za-z0-9_]*::)?test_[A-Za-z0-9_]+$/.test(proof.testName)
+                    ? { test_name: proof.testName }
+                    : undefined;
                 edges.push(...makeProofEdges({
                     testRel,
                     symId,
                     provenance: prov(testRel, hashString(`${symId}:${proof.assertion}`)),
-                    lastVerified: proofVerifiedAt
+                    lastVerified: proofVerifiedAt,
+                    ...(pythonEdgeProps ? { properties: pythonEdgeProps } : {})
                 }));
             }
         }

package/dist/local/analyze/treeSitter/engine.js

@@ -1333,19 +1333,27 @@ function extractPythonProofCalls(root) {
             }
         }
     };
-    const walk = (node, insideFunction) => {
+    const walk = (node, insideFunction, testClass) => {
+        if (!insideFunction && node.type === "class_definition") {
+            const name = node.childForFieldName("name")?.text;
+            const nextTestClass = name && /^Test[A-Za-z0-9_]*$/.test(name) ? name : null;
+            for (const child of namedChildren(node))
+                walk(child, false, nextTestClass);
+            return;
+        }
         if (node.type === "function_definition") {
             const name = functionName(node, "python");
             const body = node.childForFieldName("body");
-            if (name && /^test_/.test(name) && body)
-                processBlock(body, name, localBindings(node, "python"));
+            if (name && /^test_[A-Za-z0-9_]*$/.test(name) && body) {
+                processBlock(body, testClass ? `${testClass}::${name}` : name, localBindings(node, "python"));
+            }
             if (insideFunction)
                 return;
         }
         for (const child of namedChildren(node))
-            walk(child, insideFunction || node.type === "function_definition");
+            walk(child, insideFunction || node.type === "function_definition", testClass);
     };
-    walk(root, false);
+    walk(root, false, null);
     return out;
 }
 export function extractTreeSitterStructure(content, language) {

package/dist/local/autoProve.js

@@ -22,6 +22,7 @@ import { buildProvider } from "./generate/providers.js";
 import { resolveContained } from "./reprove/paths.js";
 import { buildRtm } from "./rtm.js";
 import { loadLedger } from "./ledger.js";
+import { reportProgress } from "./util/progress.js";
 import { loadGraph, workspacePaths } from "./workspace.js";
 import { systemClock } from "./util/time.js";
 import { redactSecrets } from "./util/redact.js";
@@ -49,6 +50,7 @@ function isRunnablePythonTestPath(testRel) {
     const file = testRel.split("::", 1)[0] ?? testRel;
     return /(^|\/)(test_[^/]+|[^/]+_test)\.py$/i.test(file);
 }
+const PYTHON_TEST_NODEID_SUFFIX_RE = /^(?:Test[A-Za-z0-9_]*::)?test_[A-Za-z0-9_]+$/;
 function isRunnableTestForTarget(node, testRel) {
     const file = codeSymbolFile(node);
     if (isPythonFile(file))
@@ -91,6 +93,12 @@ function pytestNodeidsForFile(sourceRoot, testRel) {
     }
     return out.length ? out.slice(0, 25) : [testRel];
 }
+function pytestNodeidsForTarget(sourceRoot, testRel, testName) {
+    if (testName && PYTHON_TEST_NODEID_SUFFIX_RE.test(testName) && !testRel.includes("::")) {
+        return [`${testRel}::${testName}`];
+    }
+    return pytestNodeidsForFile(sourceRoot, testRel);
+}
 /**
  * SOLE trust barrier for auto-prove target selection. `opDynamicProof` has NO
  * eligibility guard — `resolveTargetSymbol` resolves ANY CodeSymbol and the prove
@@ -512,7 +520,7 @@ export function existingAssociatedTests(graph, nodeById) {
     // `hard` = TESTED_BY/COVERS (the confirmer's structural links); weak = MAY_* candidate
     // edges. Hard is recorded before weak (graph.edges scanned first), so a test already
     // linked hard is never downgraded; a later weak dup only upgrades an existing weak to hard.
-    const add = (symId, testRel, hard) => {
+    const add = (symId, testRel, hard, testName) => {
         // A HARD TESTED_BY/COVERS edge is a real derivable test; admit it even when the symbol
         // is not_entry_point_adjacent (relaxed shape-only guard). Weak MAY_* fan-out stays strict.
         const node = nodeById.get(symId);
@@ -520,26 +528,26 @@ export function existingAssociatedTests(graph, nodeById) {
             return;
         const list = out.get(symId);
         if (!list) {
-            out.set(symId, [{ test: testRel, hard }]);
+            out.set(symId, [{ test: testRel, hard, ...(testName ? { testName } : {}) }]);
             return;
         }
-        const existing = list.find((t) => t.test === testRel);
+        const existing = list.find((t) => t.test === testRel && t.testName === testName);
         if (existing) {
             if (hard)
                 existing.hard = true;
             return;
         }
-        list.push({ test: testRel, hard });
+        list.push({ test: testRel, hard, ...(testName ? { testName } : {}) });
     };
     // A sym↔test edge joins one TestCase endpoint to one CodeSymbol endpoint; resolve
     // whichever side is the symbol so both edge directions are handled uniformly.
-    const link = (a, b, hard) => {
+    const link = (a, b, hard, testName) => {
         const tb = testFileOf(b);
         if (tb && nodeById.get(a)?.kind === "CodeSymbol")
-            return add(a, tb, hard);
+            return add(a, tb, hard, testName);
         const ta = testFileOf(a);
         if (ta && nodeById.get(b)?.kind === "CodeSymbol")
-            add(b, ta, hard);
+            add(b, ta, hard, testName);
     };
     // Eligible symbols grouped by source file, for the file-level MAY_RELATE_TO expansion.
     const eligibleByFile = new Map();
@@ -560,8 +568,10 @@ export function existingAssociatedTests(graph, nodeById) {
         return n && n.kind === "TestCase" ? relPath : null;
     };
     for (const e of graph.edges) {
-        if (e.relationship_type === "TESTED_BY" || e.relationship_type === "COVERS")
-            link(e.from_external_id, e.to_external_id, true);
+        if (e.relationship_type === "TESTED_BY" || e.relationship_type === "COVERS") {
+            const testName = typeof e.properties?.test_name === "string" ? e.properties.test_name : undefined;
+            link(e.from_external_id, e.to_external_id, true, testName);
+        }
     }
     for (const e of graph.candidate_edges ?? []) {
         if (e.review_status === "ai_suggested")
@@ -595,7 +605,7 @@ export function orderExistingAttempts(testsBySymbol, maxWeakPerSymbol = EXISTING
         let weakCount = 0;
         for (const t of tests) {
             if (t.hard)
-                hard.push({ symId, testRel: t.test, hard: true });
+                hard.push({ symId, testRel: t.test, hard: true, ...(t.testName ? { testName: t.testName } : {}) });
             else if (weakCount++ < maxWeakPerSymbol)
                 weak.push({ symId, testRel: t.test, hard: false });
         }
@@ -624,7 +634,7 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
     const reader = fileReaderFor(sourceRoot); // R-2: source scan for the node:sqlite env profile
     // Fix 3: hard TESTED_BY/COVERS pairs first, weak MAY_* pairs after and capped per symbol.
     const queue = orderExistingAttempts(existingAssociatedTests(graph, nodeById));
-    for (const { symId, testRel, hard } of queue) {
+    for (const { symId, testRel, hard, testName } of queue) {
         if (attempted >= budget)
             break;
         const node = nodeById.get(symId);
@@ -649,7 +659,7 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         // needs_setup WITHOUT re-running (and WITHOUT consuming the attempt budget).
         const isPython = isPythonFile(targetFileRel);
         const candidateTestRels = isPython
-            ? pytestNodeidsForFile(sourceRoot, testRel).filter((candidate) => isRunnableTestForTarget(node, candidate))
+            ? pytestNodeidsForTarget(sourceRoot, testRel, testName).filter((candidate) => isRunnableTestForTarget(node, candidate))
             : [testRel];
         if (candidateTestRels.length === 0)
             continue;
@@ -686,6 +696,15 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         // target references node:sqlite. Makes the baseline runnable only; never mints Proven.
         const testEnv = isGo || isJava || isPython ? undefined : experimentalSqliteTestEnv(reader, targetFileRel);
         const displayTest = nativeTestRun ?? proofTestRel;
+        // G5: name the plan before the attempt — detected runner/selector + target —
+        // so a detection miss is a visible, named thing instead of a mysterious 0.
+        reportProgress(`proof plan: ${symId} → ${isGo
+            ? `go test -run '${nativeTestRun}'`
+            : isJava
+                ? `mvn test -Dtest=${nativeTestRun}`
+                : isPython
+                    ? `pytest ${displayTest}`
+                    : `js test file ${displayTest}`}`);
         let result;
         try {
             result = proveLoop(root, nativeTestRun
@@ -923,6 +942,8 @@ export async function autoProve(root, opts, deps) {
             attempted++;
             // R-2: inject the node:sqlite env profile when the TARGET source references the builtin.
             const testEnv = experimentalSqliteTestEnv(reader, targetFileRel);
+            // G5: plan line for the generated-test attempt (runner from the run hint).
+            reportProgress(`proof plan: ${hint.prove_run.args.target_symbol} → ${hint.prove_run.args.runner ?? "auto"} on ${writeRel}`);
             let result;
             try {
                 result = proveLoop(root, {

package/dist/local/operations.js

@@ -64,9 +64,23 @@ function dynamicProofSpikePath() {
  * never sandboxes a directory outside the trusted checkout.
  * ponytail: nearest-ancestor go.mod; multi-module edge cases (nested/replace) resolve to G-INT-3.
  */
-function goModuleRoot(sourceRoot, targetRel) {
+/**
+ * G2 — confinement bound for module-root walk-up: the walk may pass ABOVE the
+ * analyzed source path (fixing `opro start ./subpkg` inside a bigger module)
+ * but never escapes the INVOCATION root the user ran opro from. If the analyzed
+ * path lies outside the invocation root, keep the old sourceRoot confinement.
+ * Discovery/scoping only — the proof gate is untouched, and when the chosen
+ * module root differs from the analyzed path it is named in progress output
+ * and on the result (module_root).
+ */
+function moduleRootBound(sourceRoot, workspaceRoot) {
+    const src = resolve(sourceRoot);
+    const ws = resolve(workspaceRoot);
+    return src === ws || src.startsWith(ws + sep) ? ws : src;
+}
+function goModuleRoot(sourceRoot, targetRel, workspaceRoot) {
     let dir = dirname(resolve(sourceRoot, targetRel));
-    const stop = resolve(sourceRoot);
+    const stop = moduleRootBound(sourceRoot, workspaceRoot);
     for (;;) {
         if (existsSync(join(dir, "go.mod")))
             return dir;
@@ -77,7 +91,7 @@ function goModuleRoot(sourceRoot, targetRel) {
             break;
         dir = parent;
     }
-    throw new Error(`No go.mod found for Go target ${targetRel} under ${sourceRoot}.`);
+    throw new Error(`No go.mod found for Go target ${targetRel} under ${stop}.`);
 }
 /**
  * Resolve the Java MODULE root: the nearest `pom.xml` (or `build.gradle` /
@@ -87,9 +101,9 @@ function goModuleRoot(sourceRoot, targetRel) {
  * spike never sandboxes a directory outside the trusted checkout.
  * ponytail: nearest-ancestor build file; multi-module reactor edge cases resolve to J-INT-3.
  */
-function javaModuleRoot(sourceRoot, targetRel) {
+function javaModuleRoot(sourceRoot, targetRel, workspaceRoot) {
     let dir = dirname(resolve(sourceRoot, targetRel));
-    const stop = resolve(sourceRoot);
+    const stop = moduleRootBound(sourceRoot, workspaceRoot);
     for (;;) {
         if (existsSync(join(dir, "pom.xml")) || existsSync(join(dir, "build.gradle")) || existsSync(join(dir, "build.gradle.kts"))) {
             return dir;
@@ -101,7 +115,7 @@ function javaModuleRoot(sourceRoot, targetRel) {
             break;
         dir = parent;
     }
-    throw new Error(`No pom.xml or build.gradle found for Java target ${targetRel} under ${sourceRoot}.`);
+    throw new Error(`No pom.xml or build.gradle found for Java target ${targetRel} under ${stop}.`);
 }
 /** Route to the per-language spike. TS/JS keeps the original path; native profiles use their own mechanisms. */
 function dynamicProofSpikePathFor(language) {
@@ -908,6 +922,33 @@ export function opRecordRun(root, opts, deps = defaultDeps()) {
         ts: deps.clock()
     });
 }
+/**
+ * G2 — Python sandbox NARROWING: the nearest pyproject.toml/setup.py/setup.cfg
+ * ancestor of the target, confined to sourceRoot, used only when the test also
+ * lives inside it. Falls back to sourceRoot (today's behavior) otherwise —
+ * this only ever shrinks the copied sandbox, never widens or breaks it.
+ */
+function pythonModuleRoot(sourceRoot, targetRel, testRel) {
+    const stop = resolve(sourceRoot);
+    let dir = dirname(resolve(sourceRoot, targetRel));
+    let found = null;
+    for (;;) {
+        if (existsSync(join(dir, "pyproject.toml")) || existsSync(join(dir, "setup.py")) || existsSync(join(dir, "setup.cfg"))) {
+            found = dir;
+            break;
+        }
+        if (dir === stop)
+            break;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    if (!found || found === stop)
+        return stop;
+    const testAbs = resolve(sourceRoot, testRel);
+    return testAbs === found || testAbs.startsWith(found + sep) ? found : stop;
+}
 export function opDynamicProof(root, opts, deps = defaultDeps()) {
     const paths = workspacePaths(root);
     const graph = loadGraph(paths.graphPath);
@@ -932,6 +973,7 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
     // DynamicProofOracleSummary shape. Everything from `closed` onward (the trust gate,
     // the cert, appendLedgerRecord, the return summary) is language-agnostic and unchanged.
     let oracle;
+    let proofModuleRoot;
     let testRel;
     let replacementMode;
     let runner;
@@ -944,7 +986,11 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
         if (!/^\^.+\$$/.test(opts.test_run)) {
             throw new Error("prove --test-run must be a fully-anchored test name, e.g. '^TestName$'.");
         }
-        const goRoot = goModuleRoot(sourceRoot, targetRel);
+        const goRoot = goModuleRoot(sourceRoot, targetRel, root);
+        if (goRoot !== resolve(sourceRoot)) {
+            proofModuleRoot = goRoot;
+            reportProgress(`proof scope: Go module root ${goRoot} (above the analyzed path)`);
+        }
         const args = [
             "--root",
             goRoot,
@@ -984,7 +1030,11 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
         }
         const testClass = opts.test_run.slice(0, hash);
         const testMethod = opts.test_run.slice(hash + 1);
-        const javaRoot = javaModuleRoot(sourceRoot, targetRel);
+        const javaRoot = javaModuleRoot(sourceRoot, targetRel, root);
+        if (javaRoot !== resolve(sourceRoot)) {
+            proofModuleRoot = javaRoot;
+            reportProgress(`proof scope: Java module root ${javaRoot} (above the analyzed path)`);
+        }
         const args = [
             "--root",
             javaRoot,
@@ -1026,13 +1076,20 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
         if ((opts.test_env?.length ?? 0) > 0) {
             throw new Error("prove --test-env is not supported for Python targets yet.");
         }
+        // G2: narrow the copied sandbox to the owning Python project when both the
+        // target and the test live inside it (bounded copy — no full-repo OOM).
+        const pyRoot = pythonModuleRoot(sourceRoot, targetRel, testRel);
+        if (pyRoot !== resolve(sourceRoot)) {
+            proofModuleRoot = pyRoot;
+            reportProgress(`proof scope: Python project root ${pyRoot} (narrowed from the analyzed path)`);
+        }
         const args = [
             "--root",
-            sourceRoot,
+            pyRoot,
             "--test",
-            testRel,
+            relative(pyRoot, resolve(sourceRoot, testRel)).split(sep).join("/"),
             "--target",
-            targetRel,
+            relative(pyRoot, resolve(sourceRoot, targetRel)).split(sep).join("/"),
             "--func",
             method,
             "--mode",
@@ -1042,7 +1099,7 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
         if (opts.timeout_ms !== undefined)
             args.push("--timeout-ms", String(opts.timeout_ms));
         const run = (deps.dynamicProofRunner ?? defaultDynamicProofRunner)(args, {
-            cwd: sourceRoot,
+            cwd: pyRoot,
             scriptPath: dynamicProofSpikePathFor("python")
         });
         oracle = parseDynamicProofJson(run.stdout, run.stderr);
@@ -1126,6 +1183,7 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
     });
     return {
         ...result,
+        ...(proofModuleRoot ? { module_root: proofModuleRoot } : {}),
         oracle: {
             status: oracle.status,
             proven: oracle.proven,
@@ -1502,6 +1560,36 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
         };
         warnings.push(`auto-prove skipped: ${reason}`);
     }
+    if (!opts.noAuto && providerConfigured && opts.ai !== false) {
+        try {
+            const graphForGeneration = loadGraph(workspacePaths(root).graphPath);
+            const generatedTargets = new Set((graphForGeneration.generated_tests ?? []).map((t) => t.target_symbol_external_id).filter((id) => Boolean(id)));
+            const targetIds = rankRiskGaps(graphForGeneration, { repoRoot: root, limit: START_GENERATE_RISK_LIMIT })
+                .map((gap) => gap.id)
+                .filter((id) => !generatedTargets.has(id));
+            if (targetIds.length) {
+                reportProgress(`generate: drafting tests for top ${targetIds.length} risk target(s)`, { current: 6, total: 8 });
+                let accepted = 0;
+                for (let i = 0; i < targetIds.length; i += START_GENERATE_BATCH_LIMIT) {
+                    const batch = targetIds.slice(i, i + START_GENERATE_BATCH_LIMIT);
+                    const generated = await opGenerate(root, {
+                        ...providerOpts,
+                        target_ids: batch,
+                        limit: batch.length,
+                        prompt_version: opts.promptVersion ?? "v5"
+                    }, providerDeps);
+                    accepted += generated.generated_tests.length;
+                    warnings.push(...generated.warnings.map((w) => `generate: ${w}`));
+                }
+                if (accepted === 0)
+                    warnings.push("generate: provider returned no accepted tests for the top risk targets.");
+            }
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            warnings.push(`generate skipped: ${reason}`);
+        }
+    }
     // G1: persist the distilled, already-redacted attempt classifications so
     // `opro doctor --proof` and standalone report regens can explain blockers
     // after this process exits. Sidecar only — never read by the oracle, RTM,
@@ -1622,6 +1710,8 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
 }
 const NO_PROVIDER_MESSAGE = 'No model provider configured. Set OPENAI_API_KEY (or OLLAMA_BASE_URL / ANTHROPIC_API_KEY) in your shell environment or a .env.provider.local file to generate with your own model, or pass provider="deterministic" (or set ORANGEPRO_ALLOW_DETERMINISTIC=1) to use the offline deterministic stand-in. No tests were generated.';
 const START_RTM_LIMIT = 500;
+const START_GENERATE_RISK_LIMIT = 20;
+const START_GENERATE_BATCH_LIMIT = 5;
 const EMPTY_EVIDENCE_SUMMARY = {
     tests: 0,
     tests_with_proof: 0,
@@ -1653,7 +1743,7 @@ export async function opGenerate(root, opts = {}, deps = defaultDeps()) {
     // deterministic stand-in is opt-in only; otherwise return setup guidance
     // instead of silently degrading.
     const providerEnv = loadProviderEnv([root], deps.env);
-    const provider = resolveGenerationProvider(providerEnv, opts);
+    const provider = deps.aiProvider ?? resolveGenerationProvider(providerEnv, opts);
     if (!provider) {
         return {
             run_id: null,

package/dist/local/viz/behaviorReportHtml.js

@@ -167,7 +167,6 @@ nav.tabs{display:flex;gap:2px;margin:18px 0 0;border-bottom:1px solid var(--bd)}
 .risk-rank{font-size:10px;color:var(--orange);font-weight:700;margin-bottom:3px}
 .risk-ep{font-family:var(--mono);font-size:13px;margin:0 0 6px}
 .risk-ep .v{color:var(--green);font-weight:700}
-.risk-desc{font-size:12px;color:var(--muted);margin:0 0 8px;max-width:72ch}
 .risk-tags{display:flex;gap:5px;flex-wrap:wrap;margin-bottom:8px}
 .todo{background:var(--gbg);border:1px solid var(--gbd);border-radius:6px;padding:8px 11px;font-size:11.5px;color:var(--ink2)}
 
@@ -365,7 +364,7 @@ function tierOf(b){
 }
 function ctaOf(b){
   if(b.tier==="proven")return"This method is Dynamically Proven. A test breaks if you mutate it. Keep it green.";
-  if(b.tier==="assoc")return"A test calls this method, but doesn't prove breakage. Run <code>npx -y @orangepro/orangepro-mcp opro start</code> to attempt dynamic proof.";
+  if(b.tier==="assoc")return"A test calls this method, but doesn't prove breakage. Run <code>npx -y @orangepro/orangepro-mcp start</code> to attempt dynamic proof.";
   if(b.tier==="none"&&b.reachable)return"This method is reachable from a tested path but has no direct test. Write one.";
   return"Nothing in your test suite touches this method. Write a test that calls it and asserts the output.";
 }
@@ -513,7 +512,6 @@ function riskCardHtml(r){
   }
   return \`<div class="risk-rank">#\${r.rank}</div>
      <div class="risk-ep"><span class="v">\${esc(r.verb)}</span> \${esc(r.path)}</div>
-     <div class="risk-desc">\${esc(r.desc)}</div>
      <div class="risk-tags">\${tags}</div>
      <div class="todo">\${esc(r.todo)}</div>\${testsHtml}\${catHtml}\`;
 }

package/docs/agents/cursor.md

@@ -18,7 +18,7 @@ Install OrangePro from the Cursor Marketplace when it is listed. Until then, use
 plugins/orangepro
 ```
 
-The plugin starts the `orangepro-local` MCP server through `npx -y -p @orangepro/orangepro-mcp@latest opro mcp` and applies OrangePro rules for gap/test workflows. It does not pin a model; provider keys and model defaults come from your environment, `.env.provider.local`, `.env.local`, `.env`, or `opro setup`.
+The plugin starts the `orangepro-local` MCP server through `npx -y @orangepro/mcp-server@latest mcp` and applies OrangePro rules for gap/test workflows. It does not pin a model; provider keys and model defaults come from your environment, `.env.provider.local`, `.env.local`, `.env`, or `opro setup`.
 
 ## MCP Setup
 

package/docs/agents/opencode.md

@@ -28,7 +28,7 @@ For a direct OpenCode config, add this server under `mcp`:
     "orangepro-local": {
       "enabled": true,
       "command": "npx",
-      "args": ["-y", "-p", "@orangepro/orangepro-mcp@latest", "opro", "mcp"]
+      "args": ["-y", "@orangepro/mcp-server@latest", "mcp"]
     }
   }
 }

package/docs/agents/vscode.md

@@ -19,7 +19,7 @@ Add OrangePro as an MCP server in your user or workspace MCP config:
   "servers": {
     "orangepro-local": {
       "command": "npx",
-      "args": ["-y", "-p", "@orangepro/orangepro-mcp@latest", "opro", "mcp"]
+      "args": ["-y", "@orangepro/mcp-server@latest", "mcp"]
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orangepro/orangepro-mcp",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "private": false,
   "description": "OrangePro (`opro`) — a local-first, BYOK CLI + MCP server that builds an evidence graph from a local checkout, ingests runtime coverage, and generates grounded tests. Metadata-only exports; no source upload; generated tests stay local.",
   "license": "MIT",

package/scripts/spikes/python-dynamic-proof-spike.mjs

@@ -99,7 +99,8 @@ function runPytest(repoRoot, nodeid, timeoutMs) {
 
 function exactNodeIdPattern(nodeid) {
   const escaped = nodeid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\//g, "[/\\\\]");
-  return new RegExp(`FAILED\\s+${escaped}(?:\\s|$)`);
+  const selectedParamSet = /\[[^\]]+\]$/.test(nodeid);
+  return new RegExp(`FAILED\\s+${escaped}${selectedParamSet ? "" : "(?:\\[[^\\]\\n]+\\])?"}(?:\\s|$)`);
 }
 
 function isExactPytestNodeId(nodeid) {