@orangepro/orangepro-mcp 0.2.32 → 0.2.33

package/dist/local/generate/generator.js

@@ -2312,7 +2312,7 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                 continue;
             }
             try {
-                const result = parsePlannedScenariosStrict(rawPlan, 20);
+                const result = parsePlannedScenariosStrict(rawPlan, 2);
                 scenarios = result.scenarios;
                 if (result.dropped > 0) {
                     warnings.push(`Dropped ${result.dropped} invalid v5 planned scenario(s) for "${gc.ctx.behavior_title}": ${result.dropSummary.join("; ")}.`);
@@ -2343,7 +2343,7 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                         maxTokens: 1600,
                         temperature: 0
                     });
-                    const result = parsePlannedScenariosStrict(repaired, 20);
+                    const result = parsePlannedScenariosStrict(repaired, 2);
                     // Keep ONLY repaired scenarios that tie back to the ORIGINAL malformed text; drop any the
                     // model invented. If none tie back, fail closed — never generate from an invented plan.
                     const tiedBack = result.scenarios.filter((s) => scenarioTiesBackToRaw(s, rawPlan));
@@ -2393,6 +2393,36 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
             // with several scenarios, leaving later high-risk behaviors untouched.
             const targetLimit = explicitMulti ? Math.max(1, Math.floor(remainingSlots / remainingTargets)) : remainingSlots;
             const selected = scenarios.slice(0, targetLimit);
+            const manualDraftForScenario = (scenario, reason) => {
+                const manualBody = sanitizeGeneratedBody([
+                    `Scenario: ${scenario.title}`,
+                    ...(scenario.steps && scenario.steps.length
+                        ? ["Steps:", ...scenario.steps.map((st, n) => `  ${n + 1}. ${st}`)]
+                        : []),
+                    ...(scenario.test_data ? [`Test data: ${scenario.test_data}`] : []),
+                    ...(scenario.assertion_targets.length ? [`Expected: ${scenario.assertion_targets.join("; ")}`] : []),
+                    ...(scenario.rationale ? [`Why this test: ${scenario.rationale}`] : []),
+                    "",
+                    `Blocked by: ${reason.split(" — ")[0]}`,
+                    `Fix: ${generatedDraftRemediation(reason)}`
+                ].join("\n"), gc.ctx.source_excerpts, "//").body;
+                return {
+                    id: `${run_id}-t${generated.length + 1}`,
+                    run_id,
+                    title: `${gc.ctx.behavior_title} — ${scenario.title}`,
+                    test_type: gc.ctx.test_layer,
+                    framework_hint: framework,
+                    body: manualBody,
+                    bucket: bucketForV5Scenario(scenario),
+                    prompt_version: PROMPT_VERSION_V5,
+                    grounding: { entity_ids: gc.entityIds, source_refs: [], weak_relationships_used: [] },
+                    weak_evidence_used: false,
+                    target_symbol_external_id: behavior.external_id,
+                    ...(fingerprintOf(behavior) ? { target_fingerprint: fingerprintOf(behavior) } : {}),
+                    runnable: false,
+                    unresolved_reason: reason
+                };
+            };
             const completions = [];
             try {
                 reportProgress(`Generating "${gc.ctx.behavior_title}" [v5 batch: ${selected.length}]…`);
@@ -2422,6 +2452,8 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
             const scenarioById = new Map(selected.map((s) => [s.id, s]));
             const parsed = completions.flatMap(parseBatchGeneratedTests);
             const seenScenarioIds = new Set();
+            const emittedScenarioIds = new Set();
+            const failureReasonByScenarioId = new Map();
             const relatedFiles = relatedFilePaths(graph, behavior).files;
             for (let i = 0; i < parsed.length && generated.length < limit; i++) {
                 const parsedTest = parsed[i];
@@ -2455,23 +2487,27 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                     warnings.push(`Redacted ${sanitized.redactedLines} echoed source-excerpt line(s) from the v5 generated test for "${gc.ctx.behavior_title}".`);
                 }
                 if (!hasExecutableContent(sanitized.body, framework)) {
+                    const reason = `V5 generated no executable code for scenario "${scenario.title}".`;
                     warnings.push(`Dropped v5 generated test for "${gc.ctx.behavior_title}" / "${scenario.title}": no executable test code.`);
                     missing.push({
                         external_id: behavior.external_id,
                         title: gc.ctx.behavior_title,
-                        reason: `V5 generated no executable code for scenario "${scenario.title}".`,
+                        reason,
                         needed: ["a non-empty runnable test body"]
                     });
+                    failureReasonByScenarioId.set(scenario.id, reason);
                     continue;
                 }
                 if (!generatedBodyAlignsWithScenario(sanitized.body, scenario)) {
+                    const reason = `V5 generated test did not align with scenario "${scenario.title}".`;
                     warnings.push(`Dropped v5 generated test for "${gc.ctx.behavior_title}" / "${scenario.title}": body did not reference the planned assertion target.`);
                     missing.push({
                         external_id: behavior.external_id,
                         title: gc.ctx.behavior_title,
-                        reason: `V5 generated test did not align with scenario "${scenario.title}".`,
+                        reason,
                         needed: ["a generated test body that asserts the planned scenario target"]
                     });
+                    failureReasonByScenarioId.set(scenario.id, reason);
                     continue;
                 }
                 let cleanBody = sanitized.body;
@@ -2540,43 +2576,8 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                         reason,
                         needed: ["a compiling generated test with a real assertion and resolvable subject import"]
                     });
-                    // Preserve the grounded INTENT in English, never the rejected code.
-                    // The scenario fields were authored by a model that saw source
-                    // excerpts — scrub the composed body with the same guard as code.
-                    // The scenario plan (title / assertion targets / rationale) is the
-                    // reviewable half of the draft; withholding the body entirely also
-                    // removes any residual source-echo risk. runnable:false + the reason
-                    // keep this honestly a draft — it ships with no run command and can
-                    // never enter the proof-ready set.
-                    const manualBody = sanitizeGeneratedBody([
-                        `Scenario: ${scenario.title}`,
-                        ...(scenario.steps && scenario.steps.length
-                            ? ["Steps:", ...scenario.steps.map((st, n) => `  ${n + 1}. ${st}`)]
-                            : []),
-                        ...(scenario.test_data ? [`Test data: ${scenario.test_data}`] : []),
-                        ...(scenario.assertion_targets.length ? [`Expected: ${scenario.assertion_targets.join("; ")}`] : []),
-                        ...(scenario.rationale ? [`Why this test: ${scenario.rationale}`] : []),
-                        "",
-                        // Concise blocker: first clause only — the full remedy is one line.
-                        `Blocked by: ${reason.split(" — ")[0]}`,
-                        `Fix: ${generatedDraftRemediation(reason)}`
-                    ].join("\n"), gc.ctx.source_excerpts, "//").body;
-                    generated.push({
-                        id: `${run_id}-t${generated.length + 1}`,
-                        run_id,
-                        title: `${gc.ctx.behavior_title} — ${scenario.title}`,
-                        test_type: gc.ctx.test_layer,
-                        framework_hint: framework,
-                        body: manualBody,
-                        bucket: bucketForV5Scenario(scenario),
-                        prompt_version: PROMPT_VERSION_V5,
-                        grounding: { entity_ids: gc.entityIds, source_refs: [], weak_relationships_used: [] },
-                        weak_evidence_used: false,
-                        target_symbol_external_id: behavior.external_id,
-                        ...(fingerprintOf(behavior) ? { target_fingerprint: fingerprintOf(behavior) } : {}),
-                        runnable: false,
-                        unresolved_reason: reason
-                    });
+                    generated.push(manualDraftForScenario(scenario, reason));
+                    emittedScenarioIds.add(scenario.id);
                     continue;
                 }
                 generated.push({
@@ -2600,6 +2601,17 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                         : {}),
                     runnable: true
                 });
+                emittedScenarioIds.add(scenario.id);
+            }
+            // A valid plan is still useful when code generation is empty, malformed,
+            // or rejected. Retain that grounded scenario as an honest manual test so
+            // the report never loses the test idea merely because code was unusable.
+            for (const scenario of selected) {
+                if (generated.length >= limit || emittedScenarioIds.has(scenario.id))
+                    continue;
+                const reason = failureReasonByScenarioId.get(scenario.id) ??
+                    `No accepted codified test was returned for planned scenario "${scenario.title}".`;
+                generated.push(manualDraftForScenario(scenario, reason));
             }
         }
     }

package/dist/local/generate/promptV5.js

@@ -74,8 +74,8 @@ export function buildPlanningSystemPromptV5() {
         "- Only propose scenarios justified by evidence. No evidence = skip concern.",
         "- Each scenario must be distinct.",
         "- Existing tests are already covered. Never re-propose them.",
-        "- Rank all scenarios by risk_rank (1 = highest blast radius × likelihood × coverage absence).",
-        "- Find all gaps. No cap. If evidence justifies 3, output 3. If 30, output 30.",
+        "- Rank scenarios by risk_rank (1 = highest blast radius × likelihood × coverage absence).",
+        "- Return at most 2 scenarios: the two most critical missing tests justified by the evidence.",
         "- When FLOW CHAIN exists, prioritize gaps at service boundaries.",
         `- technique must be exactly one of: ${Object.keys(TECHNIQUE_DESC).join(", ")}.`,
         "",

package/dist/local/operations.js

@@ -548,6 +548,45 @@ function preserveCandidateFlows(graphPath, graph) {
         return graph;
     }
 }
+/**
+ * Carry generated tests across a deterministic re-analysis only while the exact
+ * target still exists and its source fingerprint is unchanged. This keeps
+ * `opro start` additive for unchanged code without presenting an old draft as
+ * current after its target changes or disappears.
+ */
+function preserveGeneratedArtifacts(graphPath, graph) {
+    let previous;
+    try {
+        if (!existsSync(graphPath))
+            return graph;
+        previous = loadGraph(graphPath);
+    }
+    catch {
+        return graph;
+    }
+    const currentSymbols = new Set(graph.nodes.filter((node) => node.kind === "CodeSymbol").map((node) => node.external_id));
+    const byId = new Map();
+    for (const test of previous.generated_tests ?? []) {
+        const target = test.target_symbol_external_id;
+        if (!target || !currentSymbols.has(target) || !test.target_fingerprint || test.stale === true)
+            continue;
+        if (targetFingerprint(graph, target) !== test.target_fingerprint)
+            continue;
+        if (!byId.has(test.id))
+            byId.set(test.id, { ...test, pinned: undefined });
+    }
+    const generatedTests = [...byId.values()];
+    if (generatedTests.length === 0)
+        return graph;
+    const retainedIds = new Set(generatedTests.map((test) => test.id));
+    const generationRuns = (previous.generation_runs ?? [])
+        .map((run) => ({
+        ...run,
+        generated_test_ids: run.generated_test_ids.filter((id) => retainedIds.has(id))
+    }))
+        .filter((run) => run.generated_test_ids.length > 0);
+    return { ...graph, generation_runs: generationRuns, generated_tests: generatedTests };
+}
 export function opAnalyze(root, opts = {}, deps = defaultDeps()) {
     const now = deps.clock();
     const paths = workspacePaths(root);
@@ -605,7 +644,7 @@ export function opAnalyze(root, opts = {}, deps = defaultDeps()) {
     // Applied AI candidate flows must SURVIVE re-analysis, but the stored lane is
     // untrusted (any process can rewrite graph.json) — preserve+re-validate it
     // without ever letting a malformed lane fail analyze.
-    const graph = preserveCandidateFlows(paths.graphPath, builtGraph);
+    const graph = preserveGeneratedArtifacts(paths.graphPath, preserveCandidateFlows(paths.graphPath, builtGraph));
     if (!opts.suppressProgress) {
         reportProgress("analyze: writing graph.json", { current: opts.generateCoverage ? 4 : 3, total: opts.generateCoverage ? 4 : 3 });
     }
@@ -1648,12 +1687,13 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
             else {
                 reportProgress(`generate: drafting tests for top ${targetIds.length} risk target(s)`, { current: 6, total: 8 });
                 const generatedDrafts = [];
-                for (let i = 0; i < targetIds.length; i += START_GENERATE_BATCH_LIMIT) {
-                    const batch = targetIds.slice(i, i + START_GENERATE_BATCH_LIMIT);
+                for (const targetId of targetIds) {
                     const generated = await opGenerate(root, {
                         ...providerOpts,
-                        target_ids: batch,
-                        limit: batch.length,
+                        // One ranked flow per generation run. Give each flow room for its
+                        // two highest-risk missing tests instead of sharing a batch budget.
+                        target_ids: [targetId],
+                        limit: 2,
                         // The offline deterministic stand-in emits the established v2 scaffold; v5 is
                         // a two-phase model planning protocol and must not be selected implicitly for it.
                         prompt_version: opts.promptVersion ?? (deterministicGeneration ? "v2" : "v5")
@@ -1856,7 +1896,6 @@ 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,
@@ -1925,8 +1964,8 @@ export async function opGenerate(root, opts = {}, deps = defaultDeps()) {
         };
         saveGraph(paths.graphPath, next);
         // Keep the behavior report in sync with the freshly persisted generated
-        // tests — analyze/start would REBUILD the graph and drop them, so this is
-        // the only command that can surface them. Display-only refresh; a render
+        // tests immediately. A later analyze/start preserves them only while their
+        // exact target fingerprint remains current. Display-only refresh; a render
         // failure must never fail generate.
         try {
             opBehaviorCoverageHtml(root, `${WORKSPACE_DIR}/behavior-coverage.html`, undefined, { persistBaseline: false });

package/dist/local/viz/behaviorReportData.js

@@ -413,12 +413,10 @@ function riskGeneratedTests(graph, gap, riskIds, isFirstRowForFile) {
             return [];
         return fileOf(t.target_symbol_external_id) === gap.file ? [{ t, sameFile: true }] : [];
     });
-    // Mutually exclusive display: when ANY runnable generated test exists for
-    // this target, English intents are suppressed — intents are strictly the
-    // fallback for environments where runnable code was withheld. Never mix.
-    const runnableLinked = linked.filter(({ t }) => t.runnable !== false);
-    const shown = runnableLinked.length > 0 ? runnableLinked : linked;
-    return shown.slice(0, 2).map(({ t, sameFile }) => ({
+    // Keep the two generated scenarios visible even when only one survives
+    // compile validation. Hiding the manual sibling makes an unchanged rerun
+    // appear to have lost a generated test and obscures the real blocker.
+    return linked.slice(0, 2).map(({ t, sameFile }) => ({
         name: t.title,
         concern: t.test_type && t.test_type !== "unknown" ? t.test_type : undefined,
         bucket: t.bucket,
@@ -436,11 +434,6 @@ function riskGeneratedTests(graph, gap, riskIds, isFirstRowForFile) {
         ...(t.runnable === false ? { blocker: classifyGeneratedDraftBlocker(t.unresolved_reason) } : {})
     }));
 }
-/** Incoming refs are method-attributed and can be fractional when a file-level
- * reference is split across its symbols. Preserve that weighting honestly. */
-function fmtRefs(n) {
-    return Number.isInteger(n) ? String(n) : n.toFixed(1);
-}
 function displayTitle(title, file) {
     if (title.includes("."))
         return title;
@@ -461,13 +454,12 @@ function riskContext(risk) {
         : (risk.flow_position ?? 0) >= 3
             ? `${5 - (risk.flow_position ?? 0)} call${5 - (risk.flow_position ?? 0) === 1 ? "" : "s"} from the nearest entry point`
             : "deep in the call graph";
-    const refs = fmtRefs(risk.incoming_refs);
     const churn = risk.churn_available !== false
         ? `${risk.git_churn} line${risk.git_churn === 1 ? "" : "s"} changed in 180 days`
         : "Git churn unavailable (provisional static-only ranking)";
     const parts = [
         `Sits at ${pos}${sens ? ` on ${sens} paths` : ""}.`,
-        `${refs} weighted incoming reference${risk.incoming_refs === 1 ? "" : "s"}, ${risk.fan_out ?? 0} downstream call${(risk.fan_out ?? 0) === 1 ? "" : "s"}, ${churn} — and no test proves its behavior.`
+        `ORS ${risk.risk_score} (P${risk.probability ?? "?"} × I${risk.impact ?? "?"} × D${risk.detection_difficulty ?? "?"}) reflects flow position, change activity, complexity, impact, and test evidence; ${risk.fan_out ?? 0} downstream call${(risk.fan_out ?? 0) === 1 ? "" : "s"}, ${churn} — and no test proves this flow.`
     ];
     return parts.join(" ");
 }
@@ -749,7 +741,7 @@ function riskApplicableConcerns(risk, verb) {
         out.add("authorization_safety");
     if (sens >= 6)
         out.add("data_integrity");
-    if (risk.entry_point || verb !== "BEHAVIOR")
+    if (risk.entry_point || verb !== "FLOW")
         out.add("boundary_limits"); // external inputs cross here
     if ((risk.flow_position ?? 0) >= 3 || (risk.fan_out ?? 0) >= 1)
         out.add("integration_flow");
@@ -775,6 +767,10 @@ function riskTodo(risk, verb, path, generatedTests) {
     if (generatedTests.length && generatedTests.every((t) => t.runnable !== false)) {
         return "Run the generated test below in your repo; follow its prove handoff so a mutation failure can mint Dynamically Proven.";
     }
+    if (generatedTests.some((t) => t.runnable !== false) &&
+        generatedTests.some((t) => t.runnable === false)) {
+        return "Run the validated generated test below, and review the second scenario's blocker before repairing or regenerating its draft. Both generated scenarios remain visible so an unchanged rerun does not appear to lose work.";
+    }
     if (generatedTests.length) {
         const blockers = new Set(generatedTests.map((t) => t.blocker ?? "unknown"));
         if (blockers.size === 1) {
@@ -794,7 +790,7 @@ function riskTodo(risk, verb, path, generatedTests) {
         }
         return "OrangePro withheld generated code for the reasons shown below. Review each blocker, then repair or regenerate the drafts; do not assume repository dependencies are missing.";
     }
-    const call = verb !== "BEHAVIOR"
+    const call = verb !== "FLOW"
         ? `issues ${verb} ${path}`
         : risk.entry_point
             ? `invokes ${displayTitle(risk.title, risk.file)} through its entry point`
@@ -843,14 +839,14 @@ function riskRows(risks, graph) {
             tags.push(["provisional rank", "info"]);
         else if (bucket)
             tags.push([`${bucket} risk`, "risk"]);
-        tags.push([`${fmtRefs(risk.incoming_refs)} weighted refs`, "info"]);
+        tags.push([`ORS ${risk.risk_score}`, "info"]);
         if (risk.entry_point)
             tags.push(["Entry point", "entry"]);
         return {
             rank: idx + 1,
             ...(() => {
                 const generatedTests = riskGeneratedTests(graph, risk, riskIds, firstRowForFile.get(risk.file) === risk.id);
-                const verb = methodMatch?.[1]?.toUpperCase() ?? "BEHAVIOR";
+                const verb = methodMatch?.[1]?.toUpperCase() ?? "FLOW";
                 const path = qualify(risk, methodMatch?.[2] ?? displayTitle(risk.title, risk.file));
                 const generatedCategories = [...new Set([
                         ...generatedTests.map((t) => (t.bucket ? BUCKET_TO_CONCERN[t.bucket] : undefined)),

package/dist/local/viz/behaviorReportHtml.js

@@ -935,8 +935,8 @@ function riskMatchesFilter(r){
 function renderRiskFilters(){
   const options=[
     ["all","All",D.risks.length],
-    ["generated","Flows with generated output",generatedRiskCount+"/"+D.risks.length],
-    ["missing","Flows without generated output",D.risks.filter(r=>!(r.generatedTests&&r.generatedTests.length)).length+"/"+D.risks.length]
+    ["generated","Flows with tests",generatedRiskCount],
+    ["missing","No generated tests",D.risks.filter(r=>!(r.generatedTests&&r.generatedTests.length)).length]
   ];
   riskTools.innerHTML=options.map(([key,label,count])=>\`<button class="risk-filter" type="button" data-risk-filter="\${key}" aria-pressed="\${key===activeRiskFilter}">\${label} <span class="gc">\${count}</span></button>\`).join("");
 }
@@ -989,7 +989,7 @@ function renderRisks(){
     riskList.append(el("div","paywall",
       hiddenGeneratedFlows
         ? \`<div class="paywall-num">\${hiddenGeneratedFlows} more flows with generated output</div>
-           <div class="paywall-txt">OrangePro produced \${generatedOutputCopy} across \${generatedRiskCount} high-risk flow\${generatedRiskCount===1?"":"s"}. Use the “Flows with generated output” filter to review them first.</div>
+           <div class="paywall-txt">OrangePro produced \${generatedOutputCopy} across \${generatedRiskCount} high-risk flow\${generatedRiskCount===1?"":"s"}. Use the “Flows with tests” filter to review them first.</div>
            <a class="paywall-btn" href="https://orangepro.ai/get-started" target="_blank">View all on OrangePro Platform &rarr;</a>\`
         : remainingRiskFlows
           ? \`<div class="paywall-num">\${remainingRiskFlows} high-risk flows left</div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orangepro/orangepro-mcp",
-  "version": "0.2.32",
+  "version": "0.2.33",
   "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",