@orangepro/orangepro-mcp 0.2.44 → 0.2.46

package/dist/local/autoProve.js

@@ -21,7 +21,7 @@ import { resolveProviderConfig } from "./localConfig.js";
 import { buildProvider, DeterministicProvider } from "./generate/providers.js";
 import { resolveContained } from "./reprove/paths.js";
 import { buildRtm } from "./rtm.js";
-import { loadLedger, targetLanguage } from "./ledger.js";
+import { loadLedger, proofEdgesFor, targetLanguage } from "./ledger.js";
 import { reportProgress } from "./util/progress.js";
 import { loadGraph, workspacePaths } from "./workspace.js";
 import { systemClock } from "./util/time.js";
@@ -82,7 +82,7 @@ function pytestNodeidsForFile(sourceRoot, testRel) {
         }
         if (currentClass && indent <= classIndent && line.trim() !== "" && !line.startsWith(" "))
             currentClass = null;
-        const fnMatch = /^(\s*)def\s+(test_[A-Za-z0-9_]*)\s*\(/.exec(line);
+        const fnMatch = /^(\s*)(?:async\s+)?def\s+(test_[A-Za-z0-9_]*)\s*\(/.exec(line);
         if (!fnMatch)
             continue;
         const fnIndent = fnMatch[1].length;
@@ -358,13 +358,12 @@ export function javaTestForTarget(nodeById, graph, symId) {
     return selectors.size === 1 ? [...selectors][0] : null;
 }
 const GENERATED_HEADER = "// Generated by OrangePro — do not edit";
-// "Static map first, dynamically prove top 5": ONE unified dynamic-proof budget spans
-// BOTH lanes (existing-tests first, then generation for the remaining eligible gaps).
-// TOTAL attempts (existing + generation) are capped at this budget; `--auto-limit N`
-// overrides it (clamped to MAX_AUTO_LIMIT) for deeper runs (`opro start --auto-limit 25`,
-// `opro prove`, `opro prove-loop`). Static breadth (behaviors/flows/associated/risk) is
-// never gated on this budget — only the dynamic verification pass is.
+// Released v0.2.44 generic dynamic-proof limit. Python's existing-test lane has its
+// own retry limit below; do not widen this generic default or TS/JS, Go, Java, and
+// generated-test scheduling changes before a caller opts in.
 const DEFAULT_AUTO_LIMIT = 5;
+const DEFAULT_PROOF_EXISTING_LIMIT = 20;
+const DEFAULT_PROOF_GEN_LIMIT = 5;
 const MAX_AUTO_LIMIT = 50;
 /** Generator caps a single call at 5 (MAX_LIMIT); page candidates in windows of that. */
 const GEN_WINDOW = 5;
@@ -381,10 +380,10 @@ const RUNNER_ROOT_MARKERS = {
     rs: ["Cargo.toml"]
 };
 /**
- * The nearest language runner root for a target, bounded by the analyzed source root.
- * A nested root is accepted only when the selected existing test is inside it too;
- * otherwise proof execution falls back to the analyzed root, matching the oracle's
- * containment rule rather than inventing a cross-project plan.
+ * The nearest language runner root, bounded by the analyzed source root. Python is
+ * test-owned: pytest configuration/environment follows the selected test file even when
+ * that test exercises a target elsewhere in the same repository. Other languages keep
+ * their target-owned v0.2.44 behavior.
  */
 export function proofRunnerRoot(sourceRoot, targetRel, testRel) {
     const stop = resolve(sourceRoot);
@@ -393,7 +392,11 @@ export function proofRunnerRoot(sourceRoot, targetRel, testRel) {
         return ".";
     const language = targetLanguage(`sym:${targetRel}#target`);
     const markers = RUNNER_ROOT_MARKERS[language] ?? [];
-    let dir = dirname(targetAbs);
+    const testFile = testRel?.split("::", 1)[0] ?? testRel;
+    const testAbs = testFile ? resolve(stop, testFile) : undefined;
+    if (language === "python" && testAbs && testAbs !== stop && !testAbs.startsWith(stop + sep))
+        return ".";
+    let dir = dirname(language === "python" && testAbs ? testAbs : targetAbs);
     let found = stop;
     for (;;) {
         if (markers.some((marker) => existsSync(join(dir, marker)))) {
@@ -407,13 +410,6 @@ export function proofRunnerRoot(sourceRoot, targetRel, testRel) {
             break;
         dir = parent;
     }
-    if (testRel && found !== stop) {
-        const testFile = testRel.split("::", 1)[0] ?? testRel;
-        const testAbs = resolve(stop, testFile);
-        if ((testAbs !== stop && !testAbs.startsWith(stop + sep))
-            || (testAbs !== found && !testAbs.startsWith(found + sep)))
-            found = stop;
-    }
     const rel = relative(stop, found).split(sep).join("/");
     return rel || ".";
 }
@@ -438,7 +434,9 @@ const PROJECT_WIDE_BLOCKERS = new Set([
     "tsconfig_missing",
     "runner_missing",
     "module_root_missing",
-    "go_package_build_failure"
+    "go_package_build_failure",
+    "environment_unavailable",
+    "collection_error"
 ]);
 export function isRoastSurvivor(attempt) {
     return attempt.classification === "non_killing" && attempt.mutant_status === "associated_survived";
@@ -513,6 +511,14 @@ function classifyProof(result, ctx) {
     const record = dyn.record;
     if (record.closed)
         return { classification: "proven" };
+    // Language spikes may refuse before a baseline exists (for example, Python's
+    // collection preflight, an explicit project boundary, or a type-unsafe mutation).
+    // These are structured runner outcomes, not a raw-stderr heuristic. Never mint a
+    // proof and never mislabel a mutation refusal as a surviving test.
+    const runnerCategory = dyn.oracle.category;
+    if (runnerCategory === "environment_unavailable" || runnerCategory === "collection_error" || runnerCategory === "project_boundary" || runnerCategory === "mutation_unsupported") {
+        return { classification: "needs_setup", reason: dyn.oracle.reason, category: runnerCategory };
+    }
     const cert = record.dynamic_proof;
     if (cert && cert.baseline_green === false) {
         const failureSummary = dyn.oracle.baseline?.failureSummary;
@@ -538,6 +544,29 @@ function mutantStatusOf(result) {
         return "unrunnable";
     return result.record.dynamic_proof?.mutant_status;
 }
+/** A baseline-green target consumes the conservative generated-proof target quota. */
+function baselineGreenOf(result) {
+    if ("status" in result && result.status === "unrunnable")
+        return false;
+    return result.record.dynamic_proof?.baseline_green === true;
+}
+function proofDiagnosticsOf(result) {
+    if ("status" in result && result.status === "unrunnable")
+        return {};
+    const cert = result.record.dynamic_proof;
+    if (!cert?.command || !cert.cwd || cert.duration_ms === undefined)
+        return {};
+    return {
+        command: cert.command,
+        cwd: cert.cwd,
+        exit_code: cert.exit_code,
+        duration_ms: cert.duration_ms,
+        failure_class: cert.failure_class,
+        stdout_tail: cert.stdout_tail,
+        stderr_tail: cert.stderr_tail,
+        runner_fallback: cert.runner_fallback
+    };
+}
 function projectBlockKey(language, projectRoot) {
     return `${language}\u0000${projectRoot}`;
 }
@@ -690,15 +719,56 @@ export function existingAssociatedTests(graph, nodeById) {
                     add(symId, testRel, false);
         }
     }
+    // Python proof must have an exact hard edge carrying a test selector. A weak
+    // file relation (or an empty pre-edge set) is not a runnable assertion link.
+    for (const [symId, tests] of out) {
+        if (!isPythonFile(symId.split("#")[0].slice(4)))
+            continue;
+        const preEdges = new Set(proofEdgesFor(graph, symId));
+        const linked = tests.filter((t) => t.hard && !!t.testName && PYTHON_TEST_NODEID_SUFFIX_RE.test(t.testName) && preEdges.has(`test:${t.test}->${symId}`));
+        if (linked.length)
+            out.set(symId, linked);
+        else
+            out.delete(symId);
+    }
     return out;
 }
+function declaredPytestTestpaths(sourceRoot, projectRoot) {
+    const declared = new Set();
+    const root = resolve(sourceRoot, projectRoot);
+    for (const config of ["pyproject.toml", "pytest.ini", ".pytest.ini", "tox.ini", "setup.cfg"]) {
+        let text = "";
+        try {
+            text = readFileSync(join(root, config), "utf8");
+        }
+        catch {
+            continue;
+        }
+        const testpaths = /(?:^|\n)\s*testpaths\s*=\s*([^\n]*(?:\n(?:\s+[^\n#;][^\n]*)?)*)/im.exec(text)?.[1];
+        if (!testpaths)
+            continue;
+        for (const path of testpaths.match(/['"][^'"]+['"]|[^\s,\[\]]+/g) ?? []) {
+            const normalized = path.trim().replace(/^['"]|['"]$/g, "").replace(/^\.\//, "").replace(/\/+$/, "");
+            if (normalized)
+                declared.add(normalized);
+        }
+    }
+    return declared;
+}
+function isInDeclaredPytestTestpath(sourceRoot, projectRoot, testRel, testpaths) {
+    const file = testRel.split("::", 1)[0] ?? testRel;
+    const projectAbs = resolve(sourceRoot, projectRoot);
+    const testAbs = resolve(sourceRoot, file);
+    if (testAbs !== projectAbs && !testAbs.startsWith(projectAbs + sep))
+        return false;
+    const projectTestRel = relative(projectAbs, testAbs).split(sep).join("/");
+    return [...testpaths].some((path) => projectTestRel === path || projectTestRel.startsWith(`${path}/`));
+}
 /**
- * Fix 3 — deterministic hard-first, weak-capped attempt order. Every hard TESTED_BY/COVERS
- * pair precedes ANY weak MAY_* pair (a provable hard-edge symbol is tried before weak fan-out
- * burns the shared budget), and each symbol contributes at most `maxWeakPerSymbol` weak pairs
- * so one hot MAY_RELATE_TO file (its every eligible symbol × every importing test) can't starve
- * the budget. Order within each tier follows the Map's insertion order (graph node/edge order),
- * so the result is deterministic.
+ * Deterministic hard-first, weak-capped attempt order. Python is the sole exception to the
+ * legacy source order: its existing-test retries are ordered by the unpersisted ORS worklist
+ * (including Associated symbols), then direct hard-edge tests, declared pytest `testpaths`, and
+ * original source order. Non-Python entries retain the v0.2.44 queue exactly.
  */
 export function orderExistingAttempts(testsBySymbol, maxWeakPerSymbol = EXISTING_LANE_MAX_WEAK_PER_SYMBOL, schedule) {
     const hard = [];
@@ -714,33 +784,53 @@ export function orderExistingAttempts(testsBySymbol, maxWeakPerSymbol = EXISTING
     }
     if (!schedule)
         return [...hard, ...weak];
-    const languageOrder = proofLanguageOrder(schedule.graph);
-    const languageRank = new Map(languageOrder.map((language, index) => [language, index]));
+    const rankedPython = rankRiskGaps(schedule.graph, { repoRoot: schedule.sourceRoot, limit: 500, includeAssociated: true });
+    const pythonRank = new Map(rankedPython.map((gap, index) => [gap.id, { score: gap.risk_score, rank: index }]));
     const decorate = (attempt, index) => {
         const node = schedule.nodeById.get(attempt.symId);
         const targetRel = node ? symbolFileOf(node) : attempt.symId.replace(/^sym:/, "").split("#")[0];
+        const python = isPythonFile(targetRel);
+        const risk = pythonRank.get(attempt.symId);
+        const projectRoot = proofRunnerRoot(schedule.sourceRoot, targetRel, attempt.testRel);
+        const pytestTestpaths = python ? declaredPytestTestpaths(schedule.sourceRoot, projectRoot) : new Set();
         return {
             ...attempt,
             language: targetLanguage(attempt.symId),
-            projectRoot: proofRunnerRoot(schedule.sourceRoot, targetRel, attempt.testRel),
-            index
+            projectRoot,
+            index,
+            python,
+            score: risk?.score ?? Number.NEGATIVE_INFINITY,
+            rank: risk?.rank ?? Number.MAX_SAFE_INTEGER,
+            declaredTestpath: python && isInDeclaredPytestTestpath(schedule.sourceRoot, projectRoot, attempt.testRel, pytestTestpaths)
         };
     };
-    const stableProjectOrder = (attempts) => {
+    const pythonOrsOrder = (attempts) => {
         const decorated = attempts.map(decorate);
-        const firstProject = new Map();
-        for (const item of decorated) {
-            const key = `${item.language}\u0000${item.projectRoot}`;
-            if (!firstProject.has(key))
-                firstProject.set(key, firstProject.size);
-        }
         return decorated
-            .sort((a, b) => ((languageRank.get(a.language) ?? Number.MAX_SAFE_INTEGER) - (languageRank.get(b.language) ?? Number.MAX_SAFE_INTEGER))
-            || ((firstProject.get(`${a.language}\u0000${a.projectRoot}`) ?? 0) - (firstProject.get(`${b.language}\u0000${b.projectRoot}`) ?? 0))
+            .sort((a, b) => 
+        // Python ORS is primary. Direct hard and pytest-config testpaths are strictly
+        // equal-ORS tie breakers; project grouping deliberately has no precedence.
+        (b.score - a.score)
+            || Number(b.hard) - Number(a.hard)
+            || Number(b.declaredTestpath) - Number(a.declaredTestpath)
             || (a.index - b.index))
-            .map(({ index: _index, ...attempt }) => attempt);
+            .map(({ index: _index, python: _python, score: _score, rank: _rank, declaredTestpath: _declaredTestpath, ...attempt }) => attempt);
     };
-    return [...stableProjectOrder(hard), ...stableProjectOrder(weak)];
+    const queue = [...hard, ...weak];
+    const python = pythonOrsOrder(queue.filter((attempt) => {
+        const node = schedule.nodeById.get(attempt.symId);
+        return isPythonFile(node ? symbolFileOf(node) : attempt.symId.replace(/^sym:/, "").split("#")[0]);
+    }));
+    if (python.length === 0)
+        return queue;
+    let nextPython = 0;
+    const scheduled = queue.map((attempt) => {
+        const node = schedule.nodeById.get(attempt.symId);
+        const targetRel = node ? symbolFileOf(node) : attempt.symId.replace(/^sym:/, "").split("#")[0];
+        return isPythonFile(targetRel) ? python[nextPython++] : attempt;
+    });
+    const primary = proofLanguageOrder(schedule.graph)[0];
+    return primary ? scheduled.sort((a, b) => Number(targetLanguage(b.symId) === primary) - Number(targetLanguage(a.symId) === primary)) : scheduled;
 }
 /**
  * Stable scheduling view over the existing ORS-ranked candidate list. This changes
@@ -748,24 +838,11 @@ export function orderExistingAttempts(testsBySymbol, maxWeakPerSymbol = EXISTING
  * evidence tiers, or the persisted priority-gap order.
  */
 export function orderRankedProofCandidates(candidates, graph, sourceRoot) {
-    const languageOrder = proofLanguageOrder(graph);
-    if (languageOrder.length <= 1)
-        return candidates;
-    const languageRank = new Map(languageOrder.map((language, index) => [language, index]));
-    const firstProject = new Map();
-    const decorated = candidates.map((candidate, index) => {
-        const language = targetLanguage(candidate.id);
-        const projectRoot = proofRunnerRoot(sourceRoot, candidate.file);
-        const projectKey = `${language}\u0000${projectRoot}`;
-        if (!firstProject.has(projectKey))
-            firstProject.set(projectKey, firstProject.size);
-        return { candidate, index, language, projectKey };
-    });
-    return decorated
-        .sort((a, b) => ((languageRank.get(a.language) ?? Number.MAX_SAFE_INTEGER) - (languageRank.get(b.language) ?? Number.MAX_SAFE_INTEGER))
-        || ((firstProject.get(a.projectKey) ?? 0) - (firstProject.get(b.projectKey) ?? 0))
-        || (a.index - b.index))
-        .map(({ candidate }) => candidate);
+    // Generation was v0.2.44 source-ranking order. Python retries are scheduled separately
+    // in `orderExistingAttempts`; leave this queue untouched for every language.
+    void graph;
+    void sourceRoot;
+    return candidates;
 }
 /**
  * PR 1.5 lane — prove the repo's OWN existing tests, NO provider key. For each eligible
@@ -779,12 +856,17 @@ export function orderRankedProofCandidates(candidates, graph, sourceRoot) {
  * — the generation lane gets whatever this lane leaves unspent, so TOTAL attempts
  * (existing + generation) never exceed the budget.
  */
-function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, proveLoop, proveDeps, alreadyProven, projectBlocked, budget) {
+function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, proveLoop, proveDeps, alreadyProven, projectBlocked, pythonAttemptLimit, pythonGreenTarget, nonPythonAttemptLimit) {
     const attempts = [];
     const needsSetup = [];
     const provenSymbols = new Set();
     let proven = 0;
     let attempted = 0;
+    let pythonCountedAttempts = 0;
+    let pythonGreenBaselines = 0;
+    let nonPythonCountedAttempts = 0;
+    const pythonPreflightGreen = new Set();
+    const pythonBlockedCounts = new Map();
     const changed = opts.changedFiles && opts.changedFiles.length > 0 ? new Set(opts.changedFiles) : null;
     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.
@@ -794,8 +876,6 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         sourceRoot
     });
     for (const { symId, testRel, hard, testName, language, projectRoot } of queue) {
-        if (attempted >= budget)
-            break;
         const node = nodeById.get(symId);
         // Redundant with existingAssociatedTests' own filter, but the eligibility barrier is
         // the sole guard against handing plumbing to the guard-less prove path — assert it here too.
@@ -817,8 +897,10 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         // A prior candidate in this exact runner project hit a classified project-wide
         // toolchain/environment failure. Preserve the budget and explain the skip.
         const isPython = isPythonFile(targetFileRel);
+        if (isPython ? (pythonCountedAttempts >= pythonAttemptLimit || pythonGreenBaselines >= pythonGreenTarget) : nonPythonCountedAttempts >= nonPythonAttemptLimit)
+            continue;
         const candidateTestRels = isPython
-            ? pytestNodeidsForTarget(sourceRoot, testRel, testName).filter((candidate) => isRunnableTestForTarget(node, candidate))
+            ? (hard && testName && PYTHON_TEST_NODEID_SUFFIX_RE.test(testName) ? [`${testRel}::${testName}`] : []).filter((candidate) => isRunnableTestForTarget(node, candidate))
             : [testRel];
         if (candidateTestRels.length === 0)
             continue;
@@ -826,6 +908,15 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         const blockedKey = projectBlockKeys(targetLanguageName, runnerRoot, targetFileRel).find((key) => projectBlocked.has(key));
         const blocked = blockedKey ? projectBlocked.get(blockedKey) : undefined;
         if (blocked) {
+            // Python preflight is once per project root. The first classified failure
+            // is already persisted with full diagnostics; siblings are skipped without
+            // becoming fake attempts or thousands of duplicate sidecar rows.
+            if (isPython) {
+                const key = blockedKey;
+                const prior = pythonBlockedCounts.get(key);
+                pythonBlockedCounts.set(key, { count: (prior?.count ?? 0) + 1, block: blocked, root: runnerRoot });
+                continue;
+            }
             const attempt = dedupedAttempt(symId, proofTestRel, runnerRoot, blocked);
             attempts.push(attempt);
             needsSetup.push(attempt);
@@ -852,6 +943,8 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
                 continue;
         }
         attempted++;
+        if (!isPython)
+            nonPythonCountedAttempts++;
         // R-2: inject NODE_OPTIONS=--experimental-sqlite via the existing test_env path when the
         // target references node:sqlite. Makes the baseline runnable only; never mints Proven.
         const testEnv = isGo || isJava || isPython ? undefined : experimentalSqliteTestEnv(reader, targetFileRel);
@@ -868,7 +961,7 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         let result;
         try {
             result = proveLoop(root, nativeTestRun
-                ? { target_symbol: symId, source: sourceRoot, test_run: nativeTestRun, ...(goAssertionLine !== undefined ? { go_assertion_line: goAssertionLine } : {}), run_id: `auto-prove-existing-${attempted}` }
+                ? { target_symbol: symId, source: sourceRoot, test_run: nativeTestRun, ...(goAssertionLine !== undefined ? { go_assertion_line: goAssertionLine } : {}), run_id: `auto-prove-${attempted}` }
                 // link_node_modules: the isolated proof copy excludes node_modules; without linking,
                 // any target/test importing a repo dependency fails baseline → needs_setup. Linking only
                 // makes real tests runnable — Proven still requires the dynamic oracle's sentinel kill.
@@ -878,23 +971,29 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
                     test_path: proofTestRel,
                     replacement: replacementForTarget(targetFileRel),
                     link_node_modules: true,
+                    ...(isPython ? { skip_preflight: pythonPreflightGreen.has(runnerRoot) } : {}),
                     ...(testEnv ? { test_env: testEnv } : {}),
-                    run_id: `auto-prove-existing-${attempted}`
+                    run_id: `auto-prove-${attempted}`
                 }, proveDeps);
         }
         catch (e) {
-            const attempt = {
-                target_symbol: symId,
-                test_path: displayTest,
-                classification: "needs_setup",
-                reason: `Proof could not run: ${redactSecrets(errMsg(e))}`,
-                project_root: runnerRoot
-            };
-            attempts.push(attempt);
-            needsSetup.push(attempt);
+            attempted--;
+            if (!isPython)
+                nonPythonCountedAttempts--;
+            reportProgress(`proof skipped: ${symId}: ${redactSecrets(errMsg(e))}`);
             continue;
         }
         const { classification, reason, category } = classifyProof(result, { sourceRoot, targetFileRel });
+        const baselineGreen = baselineGreenOf(result);
+        if (isPython) {
+            const preflightUnavailable = category === "environment_unavailable" || category === "collection_error";
+            if (!preflightUnavailable) {
+                pythonCountedAttempts++;
+                pythonPreflightGreen.add(runnerRoot);
+            }
+            if (baselineGreen)
+                pythonGreenBaselines++;
+        }
         const attempt = {
             target_symbol: symId,
             test_path: displayTest,
@@ -902,7 +1001,8 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
             reason,
             category,
             project_root: runnerRoot,
-            mutant_status: mutantStatusOf(result)
+            mutant_status: mutantStatusOf(result),
+            ...proofDiagnosticsOf(result)
         };
         attempts.push(attempt);
         if (classification === "proven") {
@@ -928,7 +1028,15 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         }
         // non_killing → keep trying this symbol's other associated tests, if any.
     }
-    return { attempts, needsSetup, proven, attempted, provenSymbols };
+    const skipped = [...pythonBlockedCounts.values()].map(({ count, block, root }) => ({
+        title: `Python project ${root}`,
+        reason: `${count} remaining linked target${count === 1 ? " was" : "s were"} in a project root marked ${block.category}; no further runner calls were made in that root.`,
+        category: block.category,
+        language: "python",
+        project_root: root,
+        blocked_by: block.blockedBy
+    }));
+    return { attempts, needsSetup, skipped, proven, attempted, nonPythonAttempted: nonPythonCountedAttempts, provenSymbols };
 }
 /**
  * Drive prove for the top provable TS/JS targets. Two lanes: (1) prove the repo's OWN
@@ -967,13 +1075,14 @@ export async function autoProve(root, opts, deps) {
     // Keyed by language + bounded runner root; never populated by a test-specific red
     // baseline, an unknown failure, or a surviving mutant.
     const projectBlocked = new Map();
-    // ONE unified dynamic-proof budget for the whole pass (existing-first → then generation).
-    // Default 5 ("dynamically prove top 5"); `--auto-limit N` overrides it, clamped to
-    // MAX_AUTO_LIMIT. The existing lane consumes from this budget and the generation lane gets
-    // only the remainder, so TOTAL attempts (existing + generation) are ≤ budget.
+    // R7.1 adds a Python-only existing-test retry lane. Generic/non-Python calls retain
+    // the released `autoLimit`; Python can inspect more existing targets to find
+    // the requested number of baseline-green tests without widening any other language.
     const autoLimit = Math.max(1, Math.min(MAX_AUTO_LIMIT, Math.floor(opts.autoLimit ?? DEFAULT_AUTO_LIMIT)));
+    const existingLimit = Math.max(1, Math.min(MAX_AUTO_LIMIT, Math.floor(opts.proof_existing_limit ?? DEFAULT_PROOF_EXISTING_LIMIT)));
+    const genLimit = Math.max(1, Math.min(MAX_AUTO_LIMIT, Math.floor(opts.proof_gen_limit ?? DEFAULT_PROOF_GEN_LIMIT)));
     // ── Lane 1: existing associated tests — NO key required, runs FIRST (PR 1.5). ──
-    const ex = proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, proveLoop, proveDeps, alreadyProven, projectBlocked, autoLimit);
+    const ex = proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, proveLoop, proveDeps, alreadyProven, projectBlocked, existingLimit, genLimit, autoLimit);
     if (opts.existingOnly) {
         const status = ex.proven > 0 ? "proven-run" : ex.attempted > 0 ? "ran-no-proof" : "no-targets";
         return {
@@ -983,7 +1092,7 @@ export async function autoProve(root, opts, deps) {
             attempted: ex.attempted,
             proven: ex.proven,
             needs_setup: ex.needsSetup,
-            skipped: [],
+            skipped: ex.skipped,
             generated_files: [],
             attempts: ex.attempts
         };
@@ -1002,7 +1111,7 @@ export async function autoProve(root, opts, deps) {
             attempted: ex.attempted,
             proven: ex.proven,
             needs_setup: ex.needsSetup,
-            skipped: [],
+            skipped: ex.skipped,
             generated_files: [],
             attempts: ex.attempts
         };
@@ -1010,9 +1119,9 @@ export async function autoProve(root, opts, deps) {
     const provider = deterministic ? new DeterministicProvider() : buildProvider(providerConfig);
     const generate = deps.generate ?? generateTests;
     const reader = fileReaderFor(sourceRoot);
-    // Generation gets only the budget the existing-tests lane left unspent, so existing +
-    // generation attempts total ≤ autoLimit. Exhausted budget ⇒ genBudget 0 ⇒ no provider call.
-    const genBudget = Math.max(0, autoLimit - ex.attempted);
+    // Generated proofs retain the released generic limit. Python's green-target cap
+    // applies only to existing-test retries above, not to non-Python generation.
+    const generationLimit = Math.max(0, autoLimit - ex.nonPythonAttempted);
     // Candidates = ORS-ranked provable CodeSymbols. rankRiskGaps ranks by OrangePro Risk
     // Score and excludes hard-confirmed symbols; we ALSO enforce the eligibility barrier
     // explicitly (isEligibleProvableTarget) at selection so an excluded infra symbol can
@@ -1034,16 +1143,17 @@ export async function autoProve(root, opts, deps) {
     const declaredDeps = readDeclaredDeps(sourceRoot);
     let proven = 0;
     let attempted = 0;
-    for (let start = 0; start < candidates.length && attempted < genBudget; start += GEN_WINDOW) {
+    let baselineGreenTargets = 0;
+    for (let start = 0; start < candidates.length && attempted < autoLimit && baselineGreenTargets < generationLimit; start += GEN_WINDOW) {
         const window = candidates.slice(start, start + GEN_WINDOW);
-        const need = genBudget - attempted;
+        const need = Math.max(1, Math.min(GEN_WINDOW, generationLimit - baselineGreenTargets));
         const windowIds = window.map((g) => g.id);
         const gen = await generate(graph, { target_ids: windowIds, limit: Math.min(windowIds.length, need), ...(opts.prompt_version ? { prompt_version: opts.prompt_version } : {}) }, provider, reader, clock);
         const tests = gen.generated_tests;
         // Global start offset so filenames stay unique across windows — runHintsFor
         // otherwise resets its index to 0 per window and same-slug targets collide.
         const hints = runHintsFor(tests, sourceRoot, start);
-        for (let i = 0; i < tests.length && attempted < genBudget; i++) {
+        for (let i = 0; i < tests.length && attempted < autoLimit && baselineGreenTargets < generationLimit; i++) {
             const test = tests[i];
             const hint = hints[i];
             if (!hint.prove_run) {
@@ -1141,19 +1251,12 @@ export async function autoProve(root, opts, deps) {
                     // See lane 1: link node_modules so a generated test importing a repo dep can boot.
                     link_node_modules: true,
                     ...(testEnv ? { test_env: testEnv } : {}),
-                    run_id: `auto-prove-${start + i + 1}`
+                    run_id: `auto-prove-${ex.attempted + attempted}`
                 }, proveDeps);
             }
             catch (e) {
-                const attempt = {
-                    target_symbol,
-                    test_path: writeRel,
-                    classification: "needs_setup",
-                    reason: `Proof could not run: ${redactSecrets(errMsg(e))}`,
-                    project_root: projectRoot
-                };
-                attempts.push(attempt);
-                needsSetup.push(attempt);
+                attempted--;
+                skipped.push({ target_symbol, title: test.title, reason: `Proof could not run: ${redactSecrets(errMsg(e))}`, language, project_root: projectRoot });
                 continue;
             }
             const { classification, reason, category } = classifyProof(result, { sourceRoot, targetFileRel });
@@ -1164,9 +1267,12 @@ export async function autoProve(root, opts, deps) {
                 reason,
                 category,
                 project_root: projectRoot,
-                mutant_status: mutantStatusOf(result)
+                mutant_status: mutantStatusOf(result),
+                ...proofDiagnosticsOf(result)
             };
             attempts.push(attempt);
+            if (baselineGreenOf(result))
+                baselineGreenTargets++;
             if (classification === "proven")
                 proven++;
             else if (classification === "needs_setup") {
@@ -1199,7 +1305,7 @@ export async function autoProve(root, opts, deps) {
         attempted: totalAttempted,
         proven: totalProven,
         needs_setup: [...ex.needsSetup, ...needsSetup],
-        skipped,
+        skipped: [...ex.skipped, ...skipped],
         generated_files: generatedFiles,
         attempts: [...ex.attempts, ...attempts]
     };