@orangepro/orangepro-mcp 0.2.33 → 0.2.34

package/dist/local/generate/generator.js

@@ -2169,7 +2169,10 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
     const systemPrompt = opts.systemPrompt ?? buildSystemPrompt();
     const promptVersion = inputMode === "graph_grounded" && opts.prompt_version === "v5" ? PROMPT_VERSION_V5 : PROMPT_VERSION;
     const created_at = clock();
-    const runSeed = shortHash(created_at + provider.modelName + runTargets.map((t) => t.external_id).join(","));
+    const runSeed = shortHash(created_at +
+        provider.modelName +
+        runTargets.map((t) => t.external_id).join(",") +
+        JSON.stringify(opts.existing_generated_test_titles ?? []));
     const run_id = `local-gen-${runSeed}`;
     const generated = [];
     const missing = [];
@@ -2287,6 +2290,10 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
             if (generated.length >= limit)
                 break;
             const gc = gatherContext(graph, behavior, framework, fileReader);
+            const existingGeneratedTitles = dedupe(opts.existing_generated_test_titles ?? []);
+            if (existingGeneratedTitles.length) {
+                gc.ctx.existing_tests = dedupe([...gc.ctx.existing_tests, ...existingGeneratedTitles]);
+            }
             reportProgress(`Planning "${gc.ctx.behavior_title}" [v5]…`);
             let scenarios = [];
             // Transport first: a network/timeout failure is NOT malformed JSON, so it does
@@ -2377,6 +2384,19 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                     continue;
                 }
             }
+            if (existingGeneratedTitles.length) {
+                const normalizedExistingTitles = new Set(existingGeneratedTitles.map((title) => title.trim().toLowerCase()));
+                const beforeDuplicateFilter = scenarios.length;
+                scenarios = scenarios.filter((scenario) => {
+                    const scenarioTitle = scenario.title.trim().toLowerCase();
+                    const fullTitle = `${gc.ctx.behavior_title} — ${scenario.title}`.trim().toLowerCase();
+                    return !normalizedExistingTitles.has(scenarioTitle) && !normalizedExistingTitles.has(fullTitle);
+                });
+                const duplicateCount = beforeDuplicateFilter - scenarios.length;
+                if (duplicateCount > 0) {
+                    warnings.push(`Dropped ${duplicateCount} already-generated v5 scenario(s) for "${gc.ctx.behavior_title}" during top-up.`);
+                }
+            }
             if (scenarios.length === 0) {
                 missing.push({
                     external_id: behavior.external_id,

package/dist/local/operations.js

@@ -1669,37 +1669,67 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
     else if (!opts.noAuto && generationProviderConfigured && opts.ai !== false && generationLimit > 0) {
         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 = rankPriorityGaps(graphForGeneration, {
+            const generatedTestsByTarget = new Map();
+            for (const test of graphForGeneration.generated_tests ?? []) {
+                const targetId = test.target_symbol_external_id;
+                if (!targetId || test.stale === true)
+                    continue;
+                const tests = generatedTestsByTarget.get(targetId) ?? [];
+                tests.push(test);
+                generatedTestsByTarget.set(targetId, tests);
+            }
+            const targetPlans = rankPriorityGaps(graphForGeneration, {
                 repoRoot: root,
                 limit: generationLimit,
                 provenIds: provenSymbolIds(graphForGeneration, loadLedger(root))
             })
-                .map((gap) => gap.id)
-                .filter((id) => !generatedTargets.has(id));
-            if (!targetIds.length) {
+                .map((gap) => {
+                const existingTests = generatedTestsByTarget.get(gap.id) ?? [];
+                return {
+                    id: gap.id,
+                    existingTests,
+                    deficit: Math.max(0, 2 - existingTests.length)
+                };
+            })
+                .filter((target) => target.deficit > 0);
+            if (!targetPlans.length) {
                 generationResult = {
                     ...generationResult,
                     status: "no_targets",
-                    reason: "No eligible ungenerated risk targets were found."
+                    reason: "Every eligible priority flow already has two generated tests."
                 };
             }
             else {
-                reportProgress(`generate: drafting tests for top ${targetIds.length} risk target(s)`, { current: 6, total: 8 });
+                reportProgress(`generate: filling test gaps for ${targetPlans.length} priority flow(s)`, { current: 6, total: 8 });
                 const generatedDrafts = [];
-                for (const targetId of targetIds) {
-                    const generated = await opGenerate(root, {
-                        ...providerOpts,
-                        // 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")
-                    }, providerDeps);
-                    generatedDrafts.push(...generated.generated_tests);
-                    warnings.push(...generated.warnings.map((w) => `generate: ${w}`));
+                const incompleteTargets = [];
+                for (const target of targetPlans) {
+                    let remaining = target.deficit;
+                    const existingTitles = target.existingTests.map((test) => test.title);
+                    // A provider can return one accepted scenario when two were requested.
+                    // Make at most one bounded follow-up for the remaining slot, carrying
+                    // prior titles so the planner cannot silently duplicate the first test.
+                    for (let attempt = 0; attempt < 2 && remaining > 0; attempt++) {
+                        const generated = await opGenerate(root, {
+                            ...providerOpts,
+                            target_ids: [target.id],
+                            limit: remaining,
+                            pin_unchanged: false,
+                            existing_generated_test_titles: existingTitles,
+                            // 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")
+                        }, providerDeps);
+                        const freshForTarget = generated.generated_tests.filter((test) => test.target_symbol_external_id === target.id && !test.pinned);
+                        generatedDrafts.push(...freshForTarget);
+                        warnings.push(...generated.warnings.map((w) => `generate: ${w}`));
+                        if (freshForTarget.length === 0)
+                            break;
+                        existingTitles.push(...freshForTarget.map((test) => test.title));
+                        remaining = Math.max(0, remaining - freshForTarget.length);
+                    }
+                    if (remaining > 0)
+                        incompleteTargets.push(target.id);
                 }
                 const blockers = {};
                 for (const draft of generatedDrafts.filter((test) => test.runnable === false)) {
@@ -1707,22 +1737,27 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
                     blockers[blocker] = (blockers[blocker] ?? 0) + 1;
                 }
                 const runnable = generatedDrafts.filter((test) => test.runnable !== false).length;
+                const shortfallReason = incompleteTargets.length
+                    ? `${incompleteTargets.length} priority flow(s) remain below two generated tests because the provider returned no additional accepted distinct scenario.`
+                    : undefined;
                 generationResult = {
                     status: generatedDrafts.length === 0
                         ? "no_results"
-                        : generatedDrafts.some((test) => test.runnable === false)
+                        : generatedDrafts.some((test) => test.runnable === false) || incompleteTargets.length > 0
                             ? "completed_with_blockers"
                             : "completed",
-                    requested: targetIds.length,
+                    requested: targetPlans.length,
                     generated: generatedDrafts.length,
                     runnable,
                     drafts: generatedDrafts.length - runnable,
                     blockers,
                     ...(generatedDrafts.length === 0
-                        ? { reason: "The provider returned no generated-test drafts for the selected risk targets." }
-                        : {})
+                        ? { reason: shortfallReason ?? "The provider returned no generated-test drafts for the selected risk targets." }
+                        : shortfallReason
+                            ? { reason: shortfallReason }
+                            : {})
                 };
-                if (generatedDrafts.length === 0)
+                if (generationResult.reason)
                     warnings.push(`generate: ${generationResult.reason}`);
             }
         }
@@ -1948,6 +1983,7 @@ export async function opGenerate(root, opts = {}, deps = defaultDeps()) {
         limit: opts.limit,
         input_mode: opts.input_mode,
         prompt_version: opts.prompt_version,
+        existing_generated_test_titles: opts.existing_generated_test_titles,
         // Persisting lane: a runnable draft for an unchanged target is reused as-is
         // rather than re-bought from the model on every run.
         pin_unchanged: opts.pin_unchanged ?? true

package/package.json

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