@orangepro/orangepro-mcp 0.2.42 → 0.2.44

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/graph/ontology.js

@@ -9,9 +9,9 @@
  * The graph is built directly by OrangePro; it does not depend on any
  * third-party graph product or format.
  */
-// v2: Go method symbol ids are receiver-qualified (`sym:file.go#Recv.M`) — old
-// graphs hold bare-name method ids and must force-rebuild (loadGraph hard-fails).
-export const LOCAL_GRAPH_SCHEMA_VERSION = "orangepro.local_graph.v2";
+// v3: Python method symbol ids are owner-qualified (`sym:file.py#Class.method`) —
+// old graphs hold collision-prone bare method ids and must force-rebuild.
+export const LOCAL_GRAPH_SCHEMA_VERSION = "orangepro.local_graph.v3";
 /** Node kinds that map to behaviors/requirements for scoring + gaps + generation. */
 export const BEHAVIOR_KINDS = new Set([
     "Requirement",

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.v1";
+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/dist/local/score/risk.js

@@ -446,6 +446,7 @@ export function rankRiskGaps(graph, opts = {}) {
     // worklist but do not rescale an unchanged peer.
     const normalizationSymbols = graph.nodes.filter((n) => n.kind === "CodeSymbol" && n.denominator_eligible === true && !n.stale && rankEligible(n) && !isSuppressed(n.external_id));
     const symbols = normalizationSymbols.filter((n) => !confirmed.has(n.external_id));
+    const worklistSymbols = symbols.filter((n) => n.properties.ranking_exclusion_reason !== "python_structural_container");
     const symbolIds = new Set(normalizationSymbols.map((s) => s.external_id));
     const symbolsByFile = new Map();
     for (const s of normalizationSymbols) {
@@ -603,7 +604,7 @@ export function rankRiskGaps(graph, opts = {}) {
             for (const s of syms)
                 legacyIncoming.set(s.external_id, (legacyIncoming.get(s.external_id) ?? 0) + share);
         }
-        return symbols
+        return worklistSymbols
             .map((s) => {
             const file = symbolFile(s);
             const incoming_refs = legacyIncoming.get(s.external_id) ?? 0;
@@ -649,7 +650,7 @@ export function rankRiskGaps(graph, opts = {}) {
     const rawById = new Map(normalizationSymbols.map((s, idx) => [s.external_id, rawScores[idx]]));
     const pById = new Map(normalizationSymbols.map((s, idx) => [s.external_id, pScores[idx]]));
     const iById = new Map(normalizationSymbols.map((s, idx) => [s.external_id, iScores[idx]]));
-    const ranked = symbols
+    const ranked = worklistSymbols
         .map((s) => {
         const file = symbolFile(s);
         const incoming_refs = Math.round((incoming.get(s.external_id) ?? 0) * 10) / 10;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orangepro/orangepro-mcp",
-  "version": "0.2.42",
+  "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",
@@ -101,7 +101,7 @@
     "smoke:generate-prove-v5": "npm run build && node scripts/smoke-generate-prove-v5.mjs",
     "smoke:db-sqljs": "npm run build && node scripts/smoke-db-sqljs-prove.mjs",
     "release": "node scripts/release.mjs",
-    "prepublishOnly": "npm run build && npm test"
+    "prepublishOnly": "npm run typecheck && npm run build && npm test"
   },
   "engines": {
     "node": ">=20"