@orangepro/orangepro-mcp 0.2.44 → 0.2.46

package/dist/local/operations.js

@@ -152,6 +152,19 @@ function defaultDynamicProofRunner(args, opts = {}) {
         exitCode: child.status ?? 1
     };
 }
+/** Metadata only. A runner process exiting zero is not a mutation proof. */
+function runnerProcessDiagnostics(run, args, cwd, scriptPath, startedAt, oracle) {
+    const tail = (text) => redactSecrets(text).split(/\r?\n/).filter(Boolean).slice(-20).map((line) => line.slice(0, 500));
+    return {
+        command: redactSecrets([process.execPath, scriptPath, ...args].join(" ")).slice(0, 4096),
+        cwd: redactSecrets(cwd),
+        exit_code: Number.isInteger(run.exitCode) ? run.exitCode : null,
+        duration_ms: Math.max(0, Date.now() - startedAt),
+        ...((oracle.baseline?.timedOut || oracle.mutant?.timedOut) ? { failure_class: "timeout" } : {}),
+        stdout_tail: run.exitCode === 0 ? [] : tail(run.stdout),
+        stderr_tail: tail(run.stderr)
+    };
+}
 function parseDynamicProofJson(stdout, stderr) {
     try {
         return JSON.parse(stdout);
@@ -1084,11 +1097,14 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
         // match the exact receiver, never a same-named decl on another type.
         if (symbolTarget.memberQualifier)
             args.push("--recv", symbolTarget.memberQualifier);
+        const scriptPath = dynamicProofSpikePathFor("go");
+        const startedAt = Date.now();
         const run = (deps.dynamicProofRunner ?? defaultDynamicProofRunner)(args, {
             cwd: goRoot,
-            scriptPath: dynamicProofSpikePathFor("go")
+            scriptPath
         });
         oracle = mapGoOracle(parseDynamicProofJson(run.stdout, run.stderr));
+        oracle.diagnostics = runnerProcessDiagnostics(run, args, goRoot, scriptPath, startedAt, oracle);
         testRel = opts.test_run;
         replacementMode = GO_SENTINEL_LABEL;
         runner = "go";
@@ -1127,11 +1143,14 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
         ];
         if (opts.timeout_ms !== undefined)
             args.push("--timeout-ms", String(opts.timeout_ms));
+        const scriptPath = dynamicProofSpikePathFor("java");
+        const startedAt = Date.now();
         const run = (deps.dynamicProofRunner ?? defaultDynamicProofRunner)(args, {
             cwd: javaRoot,
-            scriptPath: dynamicProofSpikePathFor("java")
+            scriptPath
         });
         oracle = mapJavaOracle(parseDynamicProofJson(run.stdout, run.stderr));
+        oracle.diagnostics = runnerProcessDiagnostics(run, args, javaRoot, scriptPath, startedAt, oracle);
         testRel = opts.test_run;
         replacementMode = JAVA_SENTINEL_LABEL;
         runner = "junit";
@@ -1144,6 +1163,10 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
         testRel = toWorkspaceRel(sourceRoot, resolveContained(sourceRoot, opts.test_path));
         replacementMode = opts.replacement_mode ?? "return-json";
         runner = opts.runner ?? "auto";
+        const configuredPythonRunner = loadRiskConfig(sourceRoot).config.proof.python_runner;
+        const pythonRunner = opts.runner !== undefined
+            ? (opts.runner === "pytest" ? "python -m pytest" : "auto")
+            : (opts.python_runner?.trim() || configuredPythonRunner);
         if (replacementMode !== "return-json") {
             throw new Error("prove --replacement-mode promise-json is not supported for Python targets.");
         }
@@ -1153,26 +1176,28 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
         if ((opts.test_env?.length ?? 0) > 0) {
             throw new Error("prove --test-env is not supported for Python targets yet.");
         }
-        // G2: narrow the copied sandbox to the owning Python project when both the
-        // target and the test live inside it (bounded copy — no full-repo OOM).
-        const pyRoot = pythonModuleRoot(sourceRoot, targetRel, testRel);
-        if (pyRoot !== resolve(sourceRoot)) {
-            proofModuleRoot = pyRoot;
-            reportProgress(`proof scope: Python project root ${pyRoot} (narrowed from the analyzed path)`);
-        }
+        // R7.1: pass the bounded analyzed root to the Python spike. The spike derives
+        // the nearest project from the TEST (not the target), then refuses a target
+        // outside that explicit project boundary. Narrowing here from the target would
+        // silently erase that boundary evidence in monorepos.
+        const pyRoot = resolve(sourceRoot);
         const args = [
             "--root",
             pyRoot,
             "--test",
-            relative(pyRoot, resolve(sourceRoot, testRel)).split(sep).join("/"),
+            testRel,
             "--target",
-            relative(pyRoot, resolve(sourceRoot, targetRel)).split(sep).join("/"),
+            targetRel,
             "--func",
             method,
             "--mode",
             "sentinel",
+            "--python-runner",
+            pythonRunner,
             "--json"
         ];
+        if (opts.skip_preflight)
+            args.push("--skip-preflight");
         if (opts.timeout_ms !== undefined)
             args.push("--timeout-ms", String(opts.timeout_ms));
         const run = (deps.dynamicProofRunner ?? defaultDynamicProofRunner)(args, {
@@ -1180,6 +1205,9 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
             scriptPath: dynamicProofSpikePathFor("python")
         });
         oracle = parseDynamicProofJson(run.stdout, run.stderr);
+        if (run.exitCode !== 0 && (oracle.status === "proven" || oracle.proven === true)) {
+            throw new Error(`Python proof runner exited ${run.exitCode}; no dynamic proof can be credited. ${redactSecrets(run.stderr).slice(0, 300)}`);
+        }
     }
     else {
         if (!opts.test_path)
@@ -1225,13 +1253,17 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
             args.push("--jest-config", toWorkspaceRel(sourceRoot, resolveContained(sourceRoot, opts.jest_config)));
         for (const entry of opts.test_env ?? [])
             args.push("--test-env", entry);
+        const scriptPath = dynamicProofSpikePath();
+        const startedAt = Date.now();
         const run = (deps.dynamicProofRunner ?? defaultDynamicProofRunner)(args, { cwd: sourceRoot });
         oracle = parseDynamicProofJson(run.stdout, run.stderr);
+        oracle.diagnostics = runnerProcessDiagnostics(run, args, sourceRoot, scriptPath, startedAt, oracle);
     }
     const closed = dynamicProofSucceeded(oracle);
     const baselineGreen = oracle.baseline?.exitCode === 0 && oracle.baseline?.timedOut !== true;
     const mutantFailedAssertion = oracle.mutant?.assertionFailure === true && oracle.mutant?.timedOut !== true;
     const artifactIdentity = artifactIdentityFor(graph, sourceRoot);
+    const proofDiagnostics = oracle.diagnostics;
     const dynamicProof = {
         proof_kind: "dynamic_targeted",
         baseline_green: baselineGreen,
@@ -1239,12 +1271,14 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
         // Derived from the targeted mutation kill: if the credited subject is mocked/replaced,
         // mutating its real body cannot cause the same test to fail at an assertion.
         target_not_mocked: closed,
-        sentinel: oracle.replacementMode ?? replacementMode,
+        sentinel: oracle.mutation?.sentinel ?? oracle.replacementMode ?? replacementMode,
+        ...(oracle.mutation?.source ? { sentinel_source: oracle.mutation.source } : {}),
         runner: oracle.runner ?? runner,
         test_path: oracle.test ?? testRel,
         mutant_status: oracle.status,
         oracle_version: PROOF_ORACLE_VERSION,
-        run_fingerprint: artifactIdentity.run_fingerprint
+        run_fingerprint: artifactIdentity.run_fingerprint,
+        ...(proofDiagnostics ? proofDiagnostics : {})
     };
     const result = appendLedgerRecord(root, {
         run_id: opts.run_id,
@@ -1274,6 +1308,9 @@ export function opDynamicProof(root, opts, deps = defaultDeps()) {
             test: oracle.test,
             target: oracle.target,
             method: oracle.method,
+            category: oracle.category,
+            diagnostics: oracle.diagnostics,
+            mutation: oracle.mutation,
             baseline: oracle.baseline
                 ? {
                     exitCode: oracle.baseline.exitCode,
@@ -1389,6 +1426,8 @@ export function opProveLoop(root, opts, deps = defaultDeps()) {
         replacement: opts.replacement,
         replacement_mode: opts.replacement_mode,
         runner: opts.runner,
+        python_runner: opts.python_runner,
+        skip_preflight: opts.skip_preflight,
         timeout_ms: opts.timeout_ms,
         link_node_modules: opts.link_node_modules,
         vitest_config: opts.vitest_config,
@@ -1583,7 +1622,8 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
     reportProgress("start: deterministic graph is ready", { current: 4, total: 8 });
     // A per-repo/user risk config that fails to parse must announce itself here, not
     // silently revert to defaults (round-three review finding #1).
-    for (const w of loadRiskConfig(scanRoot).warnings)
+    const loadedRiskConfig = loadRiskConfig(scanRoot);
+    for (const w of loadedRiskConfig.warnings)
         warnings.push(w);
     const staticSnapshot = writeStartStaticSnapshot(root, opts.baseRef, warnings);
     const aiProviderConfigured = deps.aiProvider !== undefined || resolveProviderConfig(providerEnv, providerOpts) !== null;
@@ -1650,14 +1690,28 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
         : "auto-prove: driving generate → prove on the top provable targets", { current: 6, total: 8 });
     let autoProveResult;
     try {
-        autoProveResult = await autoProve(root, {
+        const scopedFiles = autoProveChangedScope(loadGraph(workspacePaths(root).graphPath), changed, opts.baseRef);
+        const runAutoProve = (changedFiles) => autoProve(root, {
             autoLimit: opts.proofLimit ?? opts.autoLimit,
+            proof_existing_limit: opts.proofLimit ?? opts.autoLimit ?? loadedRiskConfig.config.proof.attempt_limit,
+            proof_gen_limit: loadedRiskConfig.config.proof.baseline_green_target,
             noAuto: opts.noAuto,
             provider: providerOpts.provider,
             model: providerOpts.model,
             prompt_version: opts.promptVersion,
-            changedFiles: autoProveChangedScope(loadGraph(workspacePaths(root).graphPath), changed, opts.baseRef)
+            changedFiles
         }, { ...providerDeps, proveLoop: opProveLoop });
+        autoProveResult = await runAutoProve(scopedFiles);
+        if (scopedFiles && autoProveResult.attempted === 0 && !opts.baseRef && !opts.noAuto) {
+            // An uncommitted working tree implicitly scoped the pass, but nothing in that
+            // scope was provable. Fall back to the global top targets instead of reporting
+            // "not attempted" for a reason the user cannot see. --base keeps strict scoping.
+            warnings.push(`auto-prove: none of the ${scopedFiles.length} uncommitted changed file(s) had a provable target with a linked test; ran the global top targets instead.`);
+            autoProveResult = await runAutoProve(undefined);
+        }
+        else if (scopedFiles) {
+            autoProveResult = { ...autoProveResult, scoped_changed_files: scopedFiles.length };
+        }
         for (const skip of autoProveResult.skipped)
             warnings.push(`auto-prove skipped ${skip.target_symbol ?? skip.title}: ${skip.reason}`);
     }
@@ -1902,7 +1956,12 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
         const dynForReport = {
             attempted: autoProveResult.attempted,
             proven: autoProveResult.proven,
-            needsSetup: autoProveResult.needs_setup.map((a) => ({ category: a.category, reason: a.reason }))
+            status: autoProveResult.status,
+            reason: autoProveResult.reason,
+            ...(autoProveResult.scoped_changed_files !== undefined ? { scopedChangedFiles: autoProveResult.scoped_changed_files } : {}),
+            needsSetup: autoProveResult.needs_setup
+                .filter((a) => !a.deduped)
+                .map((a) => ({ category: a.category, reason: a.reason }))
         };
         coverageHtml = opBehaviorCoverageHtml(root, `${WORKSPACE_DIR}/behavior-coverage.html`, dynForReport).behavior_coverage_path;
     }
@@ -1956,6 +2015,11 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
     else if (autoProveResult.ran) {
         nextActions.push(`Dynamic proof: attempted the top ${autoProveResult.attempted} target(s); ${autoProveResult.proven} dynamically proven. Static breadth (behaviors, flows, Associated signals) is mapped regardless.`);
         if (autoProveResult.proven === 0) {
+            const allEnvironmentUnavailable = autoProveResult.attempts.length > 0
+                && autoProveResult.attempts.every((attempt) => attempt.category === "environment_unavailable" || attempt.category === "collection_error");
+            if (allEnvironmentUnavailable) {
+                nextActions.push("Proof not run: test environment could not be started (see ledger)");
+            }
             const dom = dominantBlockReason(autoProveResult.needs_setup);
             if (dom)
                 nextActions.push(`Dynamic proof closed 0: blocked because ${dom.label} (${dom.count}/${dom.total}). This is a sandbox setup gap, not a static-test failure; Static Associated signals are still shown.`);
@@ -2328,7 +2392,7 @@ function sidecarDynamicProof(root, graph) {
             attempted: attempts.attempted,
             proven: attempts.proven,
             needsSetup: attempts.attempts
-                .filter((a) => a.classification === "needs_setup")
+                .filter((a) => a.classification === "needs_setup" && !a.deduped)
                 .map((a) => ({ category: a.category, reason: a.reason }))
         };
     }

package/dist/local/proofDoctor.js

@@ -107,7 +107,10 @@ export function distillProofAttempts(auto, meta) {
         artifact_identity: meta.graph.artifact_identity,
         attempted: auto.attempted,
         proven: auto.proven,
-        attempts: auto.attempts.map((a) => ({
+        ...(auto.status ? { status: auto.status } : {}),
+        ...(auto.reason ? { reason: redactSecrets(auto.reason) } : {}),
+        ...(auto.scoped_changed_files !== undefined ? { scoped_changed_files: auto.scoped_changed_files } : {}),
+        attempts: auto.attempts.filter((a) => !a.deduped).map((a) => ({
             target_symbol: a.target_symbol,
             test_path: a.test_path || undefined,
             classification: a.classification,
@@ -117,12 +120,29 @@ export function distillProofAttempts(auto, meta) {
             deduped: a.deduped,
             language: targetLanguage(a.target_symbol),
             project_root: a.project_root,
-            blocked_by: a.blocked_by
+            blocked_by: a.blocked_by,
+            command: a.command,
+            cwd: a.cwd,
+            exit_code: a.exit_code,
+            duration_ms: a.duration_ms,
+            failure_class: a.failure_class,
+            stdout_tail: a.stdout_tail?.slice(-40).map((line) => redactSecrets(line)),
+            stderr_tail: a.stderr_tail?.slice(-40).map((line) => redactSecrets(line)),
+            runner_fallback: a.runner_fallback?.map((line) => redactSecrets(line))
         })),
-        skipped: auto.skipped.map((s) => ({
+        skipped: [...auto.skipped, ...auto.attempts.filter((a) => a.deduped).map((a) => ({
+                target_symbol: a.target_symbol,
+                title: a.target_symbol,
+                reason: a.reason ?? "Skipped after a classified project-wide proof failure.",
+                language: targetLanguage(a.target_symbol),
+                project_root: a.project_root,
+                blocked_by: a.blocked_by,
+                category: a.category
+            }))].map((s) => ({
             target_symbol: s.target_symbol,
             title: s.title,
             reason: redactSecrets(s.reason),
+            category: s.category,
             language: s.language,
             project_root: s.project_root,
             blocked_by: s.blocked_by

package/dist/local/provenance.js

@@ -3,8 +3,8 @@ 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.v3";
-export const PROOF_ORACLE_VERSION = "orangepro.targeted_mutation_oracle.v1";
+export const ANALYZER_VERSION = "orangepro.analyzer.v6";
+export const PROOF_ORACLE_VERSION = "orangepro.targeted_mutation_oracle.v3";
 function stable(value) {
     if (value === null || typeof value !== "object")
         return JSON.stringify(value);