@orangepro/orangepro-mcp 0.2.43 → 0.2.44

package/dist/local/analyze/analyzer.js

@@ -1935,10 +1935,36 @@ export function analyzeRepo(root, opts = {}) {
             const targetRel = resolvePythonImport(testRel, binding.module) ?? undefined;
             return { targetRel, imported: binding.imported, kind: binding.kind };
         };
-        const resolvePythonProofTarget = (testRel, structure, qualifier, callee, shadowed) => {
+        const resolvePythonClassTarget = (testRel, structure, classLocal) => {
+            const binding = pythonProofImportBinding(testRel, structure, classLocal);
+            if (!binding)
+                return null;
+            if (binding.kind !== "named" || !binding.targetRel || !binding.imported || isNonProductFile(binding.targetRel))
+                return null;
+            if (symbolKind(binding.targetRel, binding.imported) === "class") {
+                return { targetRel: binding.targetRel, className: binding.imported };
+            }
+            // One explicit, unique package re-export hop (`pkg.__init__: from .impl import Cls`).
+            // Ambiguity, wildcard exports, cycles, or a second hop fail closed.
+            const exportStructure = nonTsStructureByFile.get(binding.targetRel)?.structure;
+            const exports = (exportStructure?.imports ?? []).filter((candidate) => candidate.kind === "named" && candidate.local === binding.imported && candidate.imported === binding.imported);
+            if (exports.length !== 1)
+                return null;
+            const targetRel = resolvePythonImport(binding.targetRel, exports[0].module);
+            return targetRel && targetRel !== binding.targetRel && !isNonProductFile(targetRel) && symbolKind(targetRel, binding.imported) === "class"
+                ? { targetRel, className: binding.imported }
+                : null;
+        };
+        const resolvePythonProofTarget = (testRel, structure, qualifier, callee, shadowed, instanceClass) => {
             const conv = conventionSibling(testRel, "python", codeFileSet);
             const conventionTargetRel = conv?.relPath && !isNonProductFile(conv.relPath) ? conv.relPath : null;
             const hasWildcardImport = structure.imports.some((i) => i.imported === "*");
+            if (instanceClass) {
+                if (!qualifier || shadowed.has(instanceClass) || hasWildcardImport)
+                    return null;
+                const resolved = resolvePythonClassTarget(testRel, structure, instanceClass);
+                return resolved ? pythonQualifiedMemberId(resolved.targetRel, resolved.className, callee) : null;
+            }
             if (!qualifier) {
                 if (shadowed.has(callee))
                     return null;
@@ -2377,7 +2403,7 @@ export function analyzeRepo(root, opts = {}) {
             const testExternalId = `test:${testRel}`;
             for (const proof of structure.pythonProofCalls ?? []) {
                 pythonProofAttempted++;
-                const symId = resolvePythonProofTarget(testRel, structure, proof.qualifier, proof.callee, new Set(proof.shadowed));
+                const symId = resolvePythonProofTarget(testRel, structure, proof.qualifier, proof.callee, new Set(proof.shadowed), proof.instanceClass);
                 if (!symId)
                     continue;
                 const edgeKey = `${testExternalId}|${symId}`;

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

@@ -1856,19 +1856,195 @@ function singlePythonComparisonCall(comparison) {
     const calls = namedChildren(comparison).filter((child) => child.type === "call");
     return calls.length === 1 ? calls[0] ?? null : null;
 }
+function pythonDirectAssignment(stmt) {
+    const assignment = stmt.type === "assignment" || stmt.type === "annotated_assignment"
+        ? stmt
+        : namedChildren(stmt).find((child) => child.type === "assignment" || child.type === "annotated_assignment");
+    if (!assignment)
+        return null;
+    const target = assignment.childForFieldName("left");
+    const value = assignment.childForFieldName("right");
+    return target && value ? { target, value } : null;
+}
+function pythonSingleCall(node) {
+    const calls = [...(node.type === "call" ? [node] : []), ...node.descendantsOfType("call").filter((call) => Boolean(call))];
+    const unique = [...new Map(calls.map((call) => [`${call.startIndex}:${call.endIndex}`, call])).values()];
+    return unique.length === 1 ? unique[0] ?? null : null;
+}
+function pythonExactCall(node) {
+    if (!node)
+        return null;
+    if (node.type === "call")
+        return node;
+    if (node.type === "await" || node.type === "parenthesized_expression") {
+        const children = namedChildren(node);
+        return children.length === 1 ? pythonExactCall(children[0] ?? null) : null;
+    }
+    return null;
+}
+function pythonDirectAssertedResult(assertion, results) {
+    const subject = namedChildren(assertion)[0];
+    if (subject?.type !== "comparison_operator")
+        return null;
+    const operands = namedChildren(subject);
+    if (operands.length !== 2)
+        return null;
+    const candidates = operands.filter((operand) => operand.type === "identifier" && results.has(operand.text));
+    if (candidates.length !== 1)
+        return null;
+    const name = candidates[0].text;
+    const occurrences = subject.descendantsOfType("identifier")
+        .filter((identifier) => Boolean(identifier))
+        .filter((identifier) => identifier.text === name);
+    return occurrences.length === 1 ? name : null;
+}
+function pythonLexicalNodes(root) {
+    const out = [];
+    const visit = (node) => {
+        for (const child of namedChildren(node)) {
+            if (child.type === "function_definition" || child.type === "class_definition" || child.type === "lambda")
+                continue;
+            out.push(child);
+            visit(child);
+        }
+    };
+    visit(root);
+    return out;
+}
+function pythonBindingNames(node) {
+    if (node.type === "assignment" || node.type === "annotated_assignment" || node.type === "augmented_assignment" || node.type === "named_expression") {
+        const target = node.childForFieldName("left") ?? node.childForFieldName("name");
+        if (target?.type === "attribute") {
+            const dotted = pythonDottedName(target);
+            return dotted ? [dotted.split(".")[0] ?? dotted] : [];
+        }
+        return target ? pythonBindingTargetNames(target) : [];
+    }
+    if (node.type === "for_statement") {
+        const target = node.childForFieldName("left");
+        return target ? pythonBindingTargetNames(target) : [];
+    }
+    if (node.type === "delete_statement") {
+        return namedChildren(node).flatMap((target) => {
+            if (target.type === "attribute") {
+                const dotted = pythonDottedName(target);
+                return dotted ? [dotted.split(".")[0] ?? dotted] : [];
+            }
+            return pythonBindingTargetNames(target);
+        });
+    }
+    return [];
+}
+function pythonAssignedInstanceProofCalls(block) {
+    const testFunction = block.parent;
+    const decorated = testFunction?.parent?.type === "decorated_definition" ? testFunction.parent : testFunction;
+    const parameterNames = testFunction?.childForFieldName("parameters")?.descendantsOfType("identifier").map((node) => node?.text).filter(Boolean) ?? [];
+    if (parameterNames.some((name) => name !== "self" && name !== "cls"))
+        return [];
+    if (/\b(?:monkeypatch|mocker|patch|Mock|MagicMock|AsyncMock|create_autospec)\b/.test(decorated?.text ?? ""))
+        return [];
+    const lexicalNodes = pythonLexicalNodes(block);
+    const assignments = lexicalNodes.filter((node) => node.type === "assignment" || node.type === "annotated_assignment");
+    const assertions = lexicalNodes.filter((node) => node.type === "assert_statement");
+    if (assertions.length !== 1)
+        return [];
+    const mutationCounts = new Map();
+    for (const node of lexicalNodes) {
+        for (const name of pythonBindingNames(node))
+            mutationCounts.set(name, (mutationCounts.get(name) ?? 0) + 1);
+    }
+    const instances = new Map();
+    const orderedAssignments = assignments.map(pythonDirectAssignment).filter((assignment) => Boolean(assignment));
+    for (const { target, value } of orderedAssignments) {
+        if (target.type !== "identifier" || mutationCounts.get(target.text) !== 1)
+            continue;
+        const constructor = pythonSingleCall(value);
+        const parts = constructor ? callParts(constructor, "python") : null;
+        if (!parts || parts.qualifier || !/^[A-Za-z_]\w*$/.test(parts.callee))
+            continue;
+        if ((mutationCounts.get(parts.callee) ?? 0) > 0)
+            continue;
+        instances.set(target.text, { className: parts.callee, assignedAt: target.startIndex });
+    }
+    for (const { target, value } of orderedAssignments) {
+        if (target.type === "identifier" && value.type === "identifier" && instances.has(value.text))
+            return [];
+    }
+    const trackedNames = new Set([
+        ...instances.keys(),
+        ...[...instances.values()].map((instance) => instance.className)
+    ]);
+    for (const callNode of lexicalNodes.filter((node) => node.type === "call")) {
+        const call = callParts(callNode, "python");
+        const receiver = call?.qualifier?.split(".")[0] ?? "";
+        if (instances.has(receiver))
+            continue;
+        const args = callNode.childForFieldName("arguments");
+        const argumentNames = args
+            ? [
+                ...(args.type === "identifier" ? [args] : []),
+                ...args.descendantsOfType("identifier").filter((identifier) => Boolean(identifier))
+            ].map((identifier) => identifier.text)
+            : [];
+        if (argumentNames.some((name) => trackedNames.has(name)))
+            return [];
+    }
+    const results = new Map();
+    const instanceCalls = lexicalNodes.filter((node) => node.type === "call").filter((callNode) => {
+        const call = callParts(callNode, "python");
+        const receiver = call?.qualifier?.split(".")[0] ?? "";
+        return instances.has(receiver);
+    });
+    if (instanceCalls.length !== 1)
+        return [];
+    for (const { target, value } of orderedAssignments) {
+        if (target.type !== "identifier" || mutationCounts.get(target.text) !== 1)
+            continue;
+        const callNode = pythonExactCall(value);
+        const call = callNode ? callParts(callNode, "python") : null;
+        const receiver = call?.qualifier?.split(".")[0] ?? "";
+        const instance = instances.get(receiver);
+        if (call && instance && instance.assignedAt < value.startIndex) {
+            results.set(target.text, { call, instanceClass: instance.className });
+        }
+    }
+    const out = [];
+    for (const stmt of assertions) {
+        const direct = directPythonAssertCall(stmt);
+        const directReceiver = direct?.qualifier?.split(".")[0] ?? "";
+        const directInstance = instances.get(directReceiver);
+        if (direct && directInstance && directInstance.assignedAt < stmt.startIndex) {
+            out.push({ assertion: stmt, call: direct, instanceClass: directInstance.className });
+        }
+        const subject = namedChildren(stmt)[0];
+        const assertionCalls = subject
+            ? [...(subject.type === "call" ? [subject] : []), ...subject.descendantsOfType("call").filter((call) => Boolean(call))]
+            : [];
+        if (assertionCalls.length > 0)
+            continue;
+        const observed = pythonDirectAssertedResult(stmt, results);
+        const result = observed ? results.get(observed) : undefined;
+        if (result)
+            out.push({ assertion: stmt, ...result });
+    }
+    return out;
+}
 function extractPythonProofCalls(root) {
     const out = [];
     const seen = new Set();
-    const add = (testName, shadowed, call) => {
+    const add = (testName, shadowed, call, instanceClass) => {
         if (!call)
             return;
-        const key = `${testName}|${call.qualifier ?? ""}|${call.callee}`;
+        const key = `${testName}|${instanceClass ?? ""}|${call.qualifier ?? ""}|${call.callee}`;
         if (seen.has(key))
             return;
         seen.add(key);
-        out.push({ caller: testName, testName, ...call, shadowed: [...shadowed], assertion: "pytest_assert" });
+        out.push({ caller: testName, testName, ...call, shadowed: [...shadowed], assertion: "pytest_assert", ...(instanceClass ? { instanceClass } : {}) });
     };
     const processBlock = (block, testName, shadowed) => {
+        for (const associated of pythonAssignedInstanceProofCalls(block)) {
+            add(testName, shadowed, associated.call, associated.instanceClass);
+        }
         for (const stmt of blockStatements(block)) {
             if (stmt.type === "assert_statement")
                 add(testName, shadowed, directPythonAssertCall(stmt));

package/dist/local/autoProve.js

@@ -13,7 +13,7 @@
  * No key ⇒ writes NO files, mints NO proof, returns explicit guidance.
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, posix, resolve, sep } from "node:path";
+import { basename, dirname, join, posix, relative, resolve, sep } from "node:path";
 import { generateTests, readDeclaredDeps, unresolvedLocalImports } from "./generate/generator.js";
 import { GENERATED_DIR, runHintsFor } from "./generate/runHints.js";
 import { rankRiskGaps } from "./score/risk.js";
@@ -21,12 +21,12 @@ 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 } from "./ledger.js";
+import { loadLedger, targetLanguage } 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";
-import { classifyBaselineFailure, EXPERIMENTAL_SQLITE_TEST_ENV, IMPORT_TIME_CATEGORIES, isNeedsSetupCategory, readEnginesNode, targetNeedsExperimentalSqlite } from "./proofRunnability.js";
+import { classifyBaselineFailure, EXPERIMENTAL_SQLITE_TEST_ENV, isNeedsSetupCategory, readEnginesNode, targetNeedsExperimentalSqlite } from "./proofRunnability.js";
 /** Real dynamic proof is profile-gated; only wired runner targets are attemptable. */
 function isTsJsFile(file) {
     return /\.[cm]?[jt]sx?$/i.test(file);
@@ -372,7 +372,74 @@ const GEN_WINDOW = 5;
 // file (every eligible symbol × every importing test) cannot starve the shared budget before
 // a provable hard-edge symbol is tried. Small K; promote to a flag if a repo needs a wider sweep.
 const EXISTING_LANE_MAX_WEAK_PER_SYMBOL = 3;
+const RUNNER_ROOT_MARKERS = {
+    typescript: ["package.json"],
+    javascript: ["package.json"],
+    python: ["pyproject.toml", "setup.cfg", "setup.py", "pytest.ini", ".pytest.ini", "tox.ini"],
+    go: ["go.mod"],
+    java: ["pom.xml", "build.gradle", "build.gradle.kts"],
+    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.
+ */
+export function proofRunnerRoot(sourceRoot, targetRel, testRel) {
+    const stop = resolve(sourceRoot);
+    const targetAbs = resolve(stop, targetRel);
+    if (targetAbs !== stop && !targetAbs.startsWith(stop + sep))
+        return ".";
+    const language = targetLanguage(`sym:${targetRel}#target`);
+    const markers = RUNNER_ROOT_MARKERS[language] ?? [];
+    let dir = dirname(targetAbs);
+    let found = stop;
+    for (;;) {
+        if (markers.some((marker) => existsSync(join(dir, marker)))) {
+            found = dir;
+            break;
+        }
+        if (dir === stop)
+            break;
+        const parent = dirname(dir);
+        if (parent === dir || (parent !== stop && !parent.startsWith(stop + sep)))
+            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 || ".";
+}
+/** Dominant-language order from all denominator-eligible code behaviors. */
+export function proofLanguageOrder(graph) {
+    const counts = new Map();
+    const first = new Map();
+    for (const node of graph.nodes) {
+        if (node.kind !== "CodeSymbol" || node.denominator_eligible !== true)
+            continue;
+        const language = targetLanguage(node.external_id);
+        if (!first.has(language))
+            first.set(language, first.size);
+        counts.set(language, (counts.get(language) ?? 0) + 1);
+    }
+    return [...counts.keys()].sort((a, b) => (counts.get(b) - counts.get(a)) || (first.get(a) - first.get(b)));
+}
 export const NO_KEY_MESSAGE = "No provider key; auto-prove skipped — add OPENAI_API_KEY / ANTHROPIC_API_KEY, or use the OrangePro MCP in your coding agent.";
+/** Only failures proven to apply across a runner project may quarantine its siblings. */
+const PROJECT_WIDE_BLOCKERS = new Set([
+    "engine_mismatch",
+    "tsconfig_missing",
+    "runner_missing",
+    "module_root_missing",
+    "go_package_build_failure"
+]);
 export function isRoastSurvivor(attempt) {
     return attempt.classification === "non_killing" && attempt.mutant_status === "associated_survived";
 }
@@ -434,7 +501,13 @@ function fileReaderFor(root) {
 function classifyProof(result, ctx) {
     if ("status" in result && result.status === "unrunnable") {
         // Setup did not run (env non-event) — nothing was minted, target needs setup.
-        return { classification: "needs_setup", reason: result.reason };
+        const reason = result.reason;
+        const category = /runner binary not found|unsupported or unknown test runner/i.test(reason)
+            ? "runner_missing"
+            : /no go\.mod found|no pom\.xml|no maven or gradle|build\.gradle|no python project root/i.test(reason)
+                ? "module_root_missing"
+                : undefined;
+        return { classification: "needs_setup", reason, category };
     }
     const dyn = result;
     const record = dyn.record;
@@ -442,8 +515,16 @@ function classifyProof(result, ctx) {
         return { classification: "proven" };
     const cert = record.dynamic_proof;
     if (cert && cert.baseline_green === false) {
+        const failureSummary = dyn.oracle.baseline?.failureSummary;
+        if (ctx.targetFileRel.endsWith(".go") && /^#\s+\S+/m.test(failureSummary ?? "")) {
+            return {
+                classification: "needs_setup",
+                reason: "The Go package did not compile before the selected test could run.",
+                category: "go_package_build_failure"
+            };
+        }
         const { category, reason } = classifyBaselineFailure({
-            failureSummary: dyn.oracle.baseline?.failureSummary,
+            failureSummary,
             enginesNode: readEnginesNode(ctx.sourceRoot, ctx.targetFileRel),
             runnerNode: ctx.runnerNode ?? process.version
         });
@@ -457,27 +538,30 @@ function mutantStatusOf(result) {
         return "unrunnable";
     return result.record.dynamic_proof?.mutant_status;
 }
-/**
- * R-1 sibling-dedup key: a baseline-red import-time failure is a deterministic property of
- * loading the TARGET FILE with a given runner, independent of which test runs it — so
- * same-file siblings share it. Keyed on the TARGET FILE only (every caller pins runner to
- * undefined): the sole deduped cause is engine_mismatch, a package-level fact both lanes
- * classify against the SAME process.version, so the runner must not be in the key. The old
- * {runner, target file} key split the cache across lanes (lane 1 wrote "auto <file>", the
- * generation lane read "<runner> <file>" -> never matched), silently disabling cross-lane
- * dedup. NEVER merges across different files or a different failure class.
- */
-function dedupKey(runner, targetFileRel) {
-    return `${runner ?? "auto"}\u0000${targetFileRel}`;
+function projectBlockKey(language, projectRoot) {
+    return `${language}\u0000${projectRoot}`;
 }
-/** A same-file sibling deduped WITHOUT re-running: shares the first attempt's redacted reason. */
-function dedupedAttempt(targetSymbol, testPath, targetFileRel, blocked) {
+function projectBlockKeys(language, projectRoot, targetFileRel) {
+    return [
+        projectBlockKey(language, projectRoot),
+        `${projectBlockKey(language, projectRoot)}\u0000package:${dirname(targetFileRel).split(sep).join("/")}`
+    ];
+}
+function classifiedProjectBlockKey(category, language, projectRoot, targetFileRel) {
+    return category === "go_package_build_failure"
+        ? projectBlockKeys(language, projectRoot, targetFileRel)[1]
+        : projectBlockKey(language, projectRoot);
+}
+/** A same-project candidate skipped WITHOUT re-running after a classified project-wide failure. */
+function dedupedAttempt(targetSymbol, testPath, projectRoot, blocked) {
     return {
         target_symbol: targetSymbol,
         test_path: testPath,
         classification: "needs_setup",
-        reason: `${blocked.reason} (shared root cause with a sibling in ${targetFileRel}; not re-run).`,
+        reason: `${blocked.reason} (shared project/toolchain cause in ${blocked.scopeLabel}; not re-run).`,
         category: blocked.category,
+        project_root: projectRoot,
+        blocked_by: blocked.blockedBy,
         deduped: true
     };
 }
@@ -616,7 +700,7 @@ export function existingAssociatedTests(graph, nodeById) {
  * the budget. Order within each tier follows the Map's insertion order (graph node/edge order),
  * so the result is deterministic.
  */
-export function orderExistingAttempts(testsBySymbol, maxWeakPerSymbol = EXISTING_LANE_MAX_WEAK_PER_SYMBOL) {
+export function orderExistingAttempts(testsBySymbol, maxWeakPerSymbol = EXISTING_LANE_MAX_WEAK_PER_SYMBOL, schedule) {
     const hard = [];
     const weak = [];
     for (const [symId, tests] of testsBySymbol) {
@@ -628,7 +712,60 @@ export function orderExistingAttempts(testsBySymbol, maxWeakPerSymbol = EXISTING
                 weak.push({ symId, testRel: t.test, hard: false });
         }
     }
-    return [...hard, ...weak];
+    if (!schedule)
+        return [...hard, ...weak];
+    const languageOrder = proofLanguageOrder(schedule.graph);
+    const languageRank = new Map(languageOrder.map((language, index) => [language, index]));
+    const decorate = (attempt, index) => {
+        const node = schedule.nodeById.get(attempt.symId);
+        const targetRel = node ? symbolFileOf(node) : attempt.symId.replace(/^sym:/, "").split("#")[0];
+        return {
+            ...attempt,
+            language: targetLanguage(attempt.symId),
+            projectRoot: proofRunnerRoot(schedule.sourceRoot, targetRel, attempt.testRel),
+            index
+        };
+    };
+    const stableProjectOrder = (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))
+            || (a.index - b.index))
+            .map(({ index: _index, ...attempt }) => attempt);
+    };
+    return [...stableProjectOrder(hard), ...stableProjectOrder(weak)];
+}
+/**
+ * Stable scheduling view over the existing ORS-ranked candidate list. This changes
+ * only which runner receives a scarce proof attempt first; it never changes scores,
+ * 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);
 }
 /**
  * PR 1.5 lane — prove the repo's OWN existing tests, NO provider key. For each eligible
@@ -642,7 +779,7 @@ export function orderExistingAttempts(testsBySymbol, maxWeakPerSymbol = EXISTING
  * — 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, importTimeBlocked, budget) {
+function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, proveLoop, proveDeps, alreadyProven, projectBlocked, budget) {
     const attempts = [];
     const needsSetup = [];
     const provenSymbols = new Set();
@@ -651,8 +788,12 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
     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.
-    const queue = orderExistingAttempts(existingAssociatedTests(graph, nodeById));
-    for (const { symId, testRel, hard, testName } of queue) {
+    const queue = orderExistingAttempts(existingAssociatedTests(graph, nodeById), EXISTING_LANE_MAX_WEAK_PER_SYMBOL, {
+        graph,
+        nodeById,
+        sourceRoot
+    });
+    for (const { symId, testRel, hard, testName, language, projectRoot } of queue) {
         if (attempted >= budget)
             break;
         const node = nodeById.get(symId);
@@ -671,10 +812,10 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         if (provenSymbols.has(symId))
             continue;
         const targetFileRel = symbolFileOf(node);
-        // R-1 sibling dedup: a prior same-file attempt hit a package-level env root cause
-        // (engine_mismatch: runner Node outside the declared engines range). Every sibling in this
-        // file fails baseline identically → mark it
-        // needs_setup WITHOUT re-running (and WITHOUT consuming the attempt budget).
+        const targetLanguageName = language ?? targetLanguage(symId);
+        const runnerRoot = projectRoot ?? proofRunnerRoot(sourceRoot, targetFileRel, testRel);
+        // 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);
         const candidateTestRels = isPython
             ? pytestNodeidsForTarget(sourceRoot, testRel, testName).filter((candidate) => isRunnableTestForTarget(node, candidate))
@@ -682,9 +823,10 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         if (candidateTestRels.length === 0)
             continue;
         const proofTestRel = candidateTestRels[0];
-        const blocked = importTimeBlocked.get(dedupKey(undefined, targetFileRel));
+        const blockedKey = projectBlockKeys(targetLanguageName, runnerRoot, targetFileRel).find((key) => projectBlocked.has(key));
+        const blocked = blockedKey ? projectBlocked.get(blockedKey) : undefined;
         if (blocked) {
-            const attempt = dedupedAttempt(symId, proofTestRel, targetFileRel, blocked);
+            const attempt = dedupedAttempt(symId, proofTestRel, runnerRoot, blocked);
             attempts.push(attempt);
             needsSetup.push(attempt);
             continue;
@@ -745,7 +887,8 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
                 target_symbol: symId,
                 test_path: displayTest,
                 classification: "needs_setup",
-                reason: `Proof could not run: ${redactSecrets(errMsg(e))}`
+                reason: `Proof could not run: ${redactSecrets(errMsg(e))}`,
+                project_root: runnerRoot
             };
             attempts.push(attempt);
             needsSetup.push(attempt);
@@ -758,6 +901,7 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
             classification,
             reason,
             category,
+            project_root: runnerRoot,
             mutant_status: mutantStatusOf(result)
         };
         attempts.push(attempt);
@@ -768,9 +912,18 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         }
         if (classification === "needs_setup") {
             needsSetup.push(attempt);
-            // Cache an import-time root cause so same-file siblings dedup instead of re-running.
-            if (category && IMPORT_TIME_CATEGORIES.has(category)) {
-                importTimeBlocked.set(dedupKey(undefined, targetFileRel), { category, reason: reason ?? "" });
+            // Quarantine only a classified project-wide root cause. Target/test-specific
+            // red baselines and surviving mutants never suppress siblings.
+            if (category && PROJECT_WIDE_BLOCKERS.has(category)) {
+                const scopeLabel = category === "go_package_build_failure"
+                    ? dirname(targetFileRel).split(sep).join("/") || "."
+                    : runnerRoot;
+                projectBlocked.set(classifiedProjectBlockKey(category, targetLanguageName, runnerRoot, targetFileRel), {
+                    category,
+                    reason: reason ?? "",
+                    blockedBy: symId,
+                    scopeLabel
+                });
             }
         }
         // non_killing → keep trying this symbol's other associated tests, if any.
@@ -810,16 +963,17 @@ export async function autoProve(root, opts, deps) {
         .filter((r) => r.evidence_tier === "proven")
         .map((r) => r.code_symbol)
         .filter(Boolean));
-    // R-1: shared sibling-dedup cache of import-time baseline failures. Spans BOTH lanes so a
-    // node:sqlite-style root cause found once is never re-run across same-file siblings.
-    const importTimeBlocked = new Map();
+    // Shared, run-local quarantine for classified project-wide toolchain failures.
+    // 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.
     const autoLimit = Math.max(1, Math.min(MAX_AUTO_LIMIT, Math.floor(opts.autoLimit ?? DEFAULT_AUTO_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, importTimeBlocked, autoLimit);
+    const ex = proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, proveLoop, proveDeps, alreadyProven, projectBlocked, autoLimit);
     if (opts.existingOnly) {
         const status = ex.proven > 0 ? "proven-run" : ex.attempted > 0 ? "ran-no-proof" : "no-targets";
         return {
@@ -872,6 +1026,7 @@ export async function autoProve(root, opts, deps) {
         const changed = new Set(opts.changedFiles);
         candidates = candidates.filter((g) => changed.has(g.file));
     }
+    candidates = orderRankedProofCandidates(candidates, graph, sourceRoot);
     const attempts = [];
     const needsSetup = [];
     const skipped = [];
@@ -917,14 +1072,24 @@ export async function autoProve(root, opts, deps) {
             }
             const { target_symbol, replacement, runner } = hint.prove_run.args;
             const targetFileRel = symbolFile(target_symbol);
-            // R-1 sibling dedup (cross-lane): a same-file target already hit an import-time env root
-            // cause → a fresh generated test importing the same module fails identically. Skip it
-            // WITHOUT generating/writing/running or consuming the attempt budget.
-            const blocked = importTimeBlocked.get(dedupKey(undefined, targetFileRel));
+            const language = targetLanguage(target_symbol);
+            const projectRoot = proofRunnerRoot(sourceRoot, targetFileRel);
+            // Cross-lane quarantine: a classified project-wide runner failure already
+            // explains why this generated candidate cannot run. Skip without spending budget.
+            const blockedKey = projectBlockKeys(language, projectRoot, targetFileRel).find((key) => projectBlocked.has(key));
+            const blocked = blockedKey ? projectBlocked.get(blockedKey) : undefined;
             if (blocked) {
-                const attempt = dedupedAttempt(target_symbol, "", targetFileRel, blocked);
+                const attempt = dedupedAttempt(target_symbol, "", projectRoot, blocked);
                 attempts.push(attempt);
                 needsSetup.push(attempt);
+                skipped.push({
+                    target_symbol,
+                    title: test.title,
+                    reason: attempt.reason ?? "Skipped after a project-wide proof failure.",
+                    language,
+                    project_root: projectRoot,
+                    blocked_by: blocked.blockedBy
+                });
                 continue;
             }
             const filename = basename(hint.prove_run.args.test_path);
@@ -984,7 +1149,8 @@ export async function autoProve(root, opts, deps) {
                     target_symbol,
                     test_path: writeRel,
                     classification: "needs_setup",
-                    reason: `Proof could not run: ${redactSecrets(errMsg(e))}`
+                    reason: `Proof could not run: ${redactSecrets(errMsg(e))}`,
+                    project_root: projectRoot
                 };
                 attempts.push(attempt);
                 needsSetup.push(attempt);
@@ -997,6 +1163,7 @@ export async function autoProve(root, opts, deps) {
                 classification,
                 reason,
                 category,
+                project_root: projectRoot,
                 mutant_status: mutantStatusOf(result)
             };
             attempts.push(attempt);
@@ -1004,9 +1171,16 @@ export async function autoProve(root, opts, deps) {
                 proven++;
             else if (classification === "needs_setup") {
                 needsSetup.push(attempt);
-                // Cache an import-time root cause so same-file siblings dedup instead of re-running.
-                if (category && IMPORT_TIME_CATEGORIES.has(category)) {
-                    importTimeBlocked.set(dedupKey(undefined, targetFileRel), { category, reason: reason ?? "" });
+                if (category && PROJECT_WIDE_BLOCKERS.has(category)) {
+                    const scopeLabel = category === "go_package_build_failure"
+                        ? dirname(targetFileRel).split(sep).join("/") || "."
+                        : projectRoot;
+                    projectBlocked.set(classifiedProjectBlockKey(category, language, projectRoot, targetFileRel), {
+                        category,
+                        reason: reason ?? "",
+                        blockedBy: target_symbol,
+                        scopeLabel
+                    });
                 }
             }
             // non_killing stays in `attempts` only — an honest skip, never Proven.

package/dist/local/proofDoctor.js

@@ -23,7 +23,7 @@ import { workspacePaths } from "./workspace.js";
 import { redactSecrets } from "./util/redact.js";
 import { targetLanguage } from "./ledger.js";
 import { readEnginesNode, satisfiesNodeRange } from "./proofRunnability.js";
-export const PROOF_ATTEMPTS_SCHEMA_VERSION = "orangepro.proof_attempts.v1";
+export const PROOF_ATTEMPTS_SCHEMA_VERSION = "orangepro.proof_attempts.v2";
 export const PROOF_ATTEMPTS_FILE = "proof-attempts.json";
 export const PROOF_DOCTOR_SCHEMA_VERSION = "orangepro.proof_doctor.v1";
 /** Languages with a shipped dynamic-proof profile. Everything else is honest "not yet". */
@@ -115,12 +115,17 @@ export function distillProofAttempts(auto, meta) {
             category: a.category,
             reason: a.reason ? redactSecrets(a.reason) : undefined,
             deduped: a.deduped,
-            language: targetLanguage(a.target_symbol)
+            language: targetLanguage(a.target_symbol),
+            project_root: a.project_root,
+            blocked_by: a.blocked_by
         })),
         skipped: auto.skipped.map((s) => ({
             target_symbol: s.target_symbol,
             title: s.title,
-            reason: redactSecrets(s.reason)
+            reason: redactSecrets(s.reason),
+            language: s.language,
+            project_root: s.project_root,
+            blocked_by: s.blocked_by
         }))
     };
 }

package/dist/local/provenance.js

@@ -3,7 +3,7 @@ import { ORS_VERSION } from "./score/risk.js";
 import { ORANGEPRO_VERSION } from "./version.js";
 import { hashString } from "./util/hash.js";
 export const ARTIFACT_IDENTITY_VERSION = "orangepro.artifact_identity.v1";
-export const ANALYZER_VERSION = "orangepro.analyzer.v2";
+export const ANALYZER_VERSION = "orangepro.analyzer.v3";
 export const PROOF_ORACLE_VERSION = "orangepro.targeted_mutation_oracle.v1";
 function stable(value) {
     if (value === null || typeof value !== "object")

package/package.json

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