@orangepro/orangepro-mcp 0.2.29 → 0.2.31

package/dist/local/generate/providers.js

@@ -108,16 +108,17 @@ export class OpenAICompatibleProvider {
                 const data = (await postJson(this.fetchImpl, `${this.cfg.baseUrl}/chat/completions`, { Authorization: `Bearer ${this.cfg.apiKey ?? ""}` }, body, providerTimeoutMs(this.cfg.model)));
                 const choice = data.choices?.[0];
                 const content = choice?.message?.content ?? "";
-                // Reasoning starvation: the model spent the ENTIRE completion budget on
-                // hidden reasoning and returned no visible content (finish_reason
-                // "length"). Long grounded prompts trigger this on gpt-5/o-series at the
-                // 4000-token seed. Retry ONCE with 4x the budget; if it still comes back
-                // empty, return "" and let the caller refuse to emit an empty test.
-                if (!content.trim() && choice?.finish_reason === "length" && !tried.has("starved")) {
-                    tried.add("starved");
+                // A length stop means the completion is truncated even when it contains
+                // visible text. Returning that prefix turns cut-off source into a fake
+                // compiler/setup problem. Retry once with more room, then fail closed.
+                if (choice?.finish_reason === "length" && !tried.has("length-retry")) {
+                    tried.add("length-retry");
                     maxTokens = maxTokens * 4;
                     continue;
                 }
+                if (choice?.finish_reason === "length") {
+                    throw new Error("Model output was truncated at the token limit after one retry; no generated code was accepted.");
+                }
                 return content;
             }
             catch (e) {
@@ -176,14 +177,26 @@ export class AnthropicProvider {
         return this.cfg.model;
     }
     async complete(req) {
-        const data = (await postJson(this.fetchImpl, `${this.cfg.baseUrl}/messages`, { "x-api-key": this.cfg.apiKey ?? "", "anthropic-version": "2023-06-01" }, {
-            model: this.cfg.model,
-            max_tokens: req.maxTokens ?? 900,
-            temperature: req.temperature ?? 0.2,
-            system: req.system,
-            messages: [{ role: "user", content: req.user }]
-        }));
-        return (data.content ?? []).map((c) => c.text ?? "").join("");
+        let maxTokens = req.maxTokens ?? 900;
+        let retriedLength = false;
+        for (;;) {
+            const data = (await postJson(this.fetchImpl, `${this.cfg.baseUrl}/messages`, { "x-api-key": this.cfg.apiKey ?? "", "anthropic-version": "2023-06-01" }, {
+                model: this.cfg.model,
+                max_tokens: maxTokens,
+                temperature: req.temperature ?? 0.2,
+                system: req.system,
+                messages: [{ role: "user", content: req.user }]
+            }, providerTimeoutMs(this.cfg.model)));
+            if (data.stop_reason === "max_tokens" && !retriedLength) {
+                retriedLength = true;
+                maxTokens *= 4;
+                continue;
+            }
+            if (data.stop_reason === "max_tokens") {
+                throw new Error("Model output was truncated at the token limit after one retry; no generated code was accepted.");
+            }
+            return (data.content ?? []).map((c) => c.text ?? "").join("");
+        }
     }
 }
 /**

package/dist/local/operations.js

@@ -21,6 +21,7 @@ import { doctorGraph } from "./score/doctor.js";
 import { findGaps } from "./gaps/gaps.js";
 import { rankRiskGaps } from "./score/risk.js";
 import { generateTests } from "./generate/generator.js";
+import { classifyGeneratedDraftBlocker } from "./generate/draftGuidance.js";
 import { autoProve, NO_KEY_MESSAGE, isEligibleProvableTarget } from "./autoProve.js";
 import { AGENT_RUN_WORKFLOW, GROUNDING_CONTRACT, runnableRunHintsFor } from "./generate/runHints.js";
 import { buildProvider, DeterministicProvider } from "./generate/providers.js";
@@ -1514,10 +1515,13 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
     const warnings = [...analyze.warnings];
     reportProgress("start: deterministic graph is ready", { current: 4, total: 8 });
     const staticSnapshot = writeStartStaticSnapshot(root, opts.baseRef, warnings);
-    const providerConfigured = deps.aiProvider !== undefined || resolveProviderConfig(providerEnv, providerOpts) !== null;
+    const aiProviderConfigured = deps.aiProvider !== undefined || resolveProviderConfig(providerEnv, providerOpts) !== null;
+    const resolvedGenerationProvider = deps.aiProvider ?? resolveGenerationProvider(providerEnv, providerOpts);
+    const generationProviderConfigured = resolvedGenerationProvider !== null;
+    const deterministicGeneration = resolvedGenerationProvider?.providerName === "deterministic";
     let aiLinks = { status: "skipped", reason: "AI candidate links disabled for this run." };
     if (opts.ai !== false) {
-        if (!providerConfigured) {
+        if (!aiProviderConfigured) {
             reportProgress("ai: skipped — no local provider key/base URL found", { current: 5, total: 8 });
             aiLinks = {
                 status: "skipped",
@@ -1542,7 +1546,7 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
     }
     let aiFlows = { status: "skipped", reason: "AI candidate flows disabled for this run." };
     if (opts.ai !== false && opts.aiFlows !== false) {
-        if (!providerConfigured) {
+        if (!aiProviderConfigured) {
             aiFlows = {
                 status: "skipped",
                 reason: "No model provider configured; set OPENAI_API_KEY, ANTHROPIC_API_KEY, or OLLAMA_BASE_URL to auto-apply AI candidate flows."
@@ -1574,7 +1578,7 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
     let autoProveResult;
     try {
         autoProveResult = await autoProve(root, {
-            autoLimit: opts.autoLimit,
+            autoLimit: opts.proofLimit ?? opts.autoLimit,
             noAuto: opts.noAuto,
             provider: providerOpts.provider,
             model: providerOpts.model,
@@ -1599,40 +1603,115 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
         };
         warnings.push(`auto-prove skipped: ${reason}`);
     }
-    if (!opts.noAuto && providerConfigured && opts.ai !== false) {
+    const generationLimit = Math.max(0, Math.min(50, Math.floor(opts.generateLimit ?? START_GENERATE_RISK_LIMIT)));
+    let generationResult = {
+        status: "disabled",
+        requested: generationLimit,
+        generated: 0,
+        runnable: 0,
+        drafts: 0,
+        blockers: {},
+        reason: opts.noAuto
+            ? "Test generation was disabled by --no-auto."
+            : opts.ai === false
+                ? "Test generation was disabled by --no-ai."
+                : generationLimit === 0
+                    ? "Test generation budget is 0 (--generate-limit 0)."
+                    : undefined
+    };
+    if (!opts.noAuto && opts.ai !== false && generationLimit > 0 && !generationProviderConfigured) {
+        generationResult = {
+            ...generationResult,
+            status: "no_provider",
+            reason: NO_PROVIDER_MESSAGE
+        };
+        warnings.push(`generate: ${NO_PROVIDER_MESSAGE}`);
+    }
+    else if (!opts.noAuto && generationProviderConfigured && opts.ai !== false && generationLimit > 0) {
         try {
             const graphForGeneration = loadGraph(workspacePaths(root).graphPath);
             const generatedTargets = new Set((graphForGeneration.generated_tests ?? []).map((t) => t.target_symbol_external_id).filter((id) => Boolean(id)));
             const targetIds = rankRiskGaps(graphForGeneration, {
                 repoRoot: root,
-                limit: START_GENERATE_RISK_LIMIT,
+                limit: generationLimit,
                 provenIds: provenSymbolIds(graphForGeneration, loadLedger(root))
             })
                 .map((gap) => gap.id)
                 .filter((id) => !generatedTargets.has(id));
-            if (targetIds.length) {
+            if (!targetIds.length) {
+                generationResult = {
+                    ...generationResult,
+                    status: "no_targets",
+                    reason: "No eligible ungenerated risk targets were found."
+                };
+            }
+            else {
                 reportProgress(`generate: drafting tests for top ${targetIds.length} risk target(s)`, { current: 6, total: 8 });
-                let accepted = 0;
+                const generatedDrafts = [];
                 for (let i = 0; i < targetIds.length; i += START_GENERATE_BATCH_LIMIT) {
                     const batch = targetIds.slice(i, i + START_GENERATE_BATCH_LIMIT);
                     const generated = await opGenerate(root, {
                         ...providerOpts,
                         target_ids: batch,
                         limit: batch.length,
-                        prompt_version: opts.promptVersion ?? "v5"
+                        // The offline deterministic stand-in emits the established v2 scaffold; v5 is
+                        // a two-phase model planning protocol and must not be selected implicitly for it.
+                        prompt_version: opts.promptVersion ?? (deterministicGeneration ? "v2" : "v5")
                     }, providerDeps);
-                    accepted += generated.generated_tests.filter((t) => t.runnable !== false).length;
+                    generatedDrafts.push(...generated.generated_tests);
                     warnings.push(...generated.warnings.map((w) => `generate: ${w}`));
                 }
-                if (accepted === 0)
-                    warnings.push("generate: provider returned no accepted tests for the top risk targets.");
+                const blockers = {};
+                for (const draft of generatedDrafts.filter((test) => test.runnable === false)) {
+                    const blocker = classifyGeneratedDraftBlocker(draft.unresolved_reason);
+                    blockers[blocker] = (blockers[blocker] ?? 0) + 1;
+                }
+                const runnable = generatedDrafts.filter((test) => test.runnable !== false).length;
+                generationResult = {
+                    status: generatedDrafts.length === 0
+                        ? "no_results"
+                        : generatedDrafts.some((test) => test.runnable === false)
+                            ? "completed_with_blockers"
+                            : "completed",
+                    requested: targetIds.length,
+                    generated: generatedDrafts.length,
+                    runnable,
+                    drafts: generatedDrafts.length - runnable,
+                    blockers,
+                    ...(generatedDrafts.length === 0
+                        ? { reason: "The provider returned no generated-test drafts for the selected risk targets." }
+                        : {})
+                };
+                if (generatedDrafts.length === 0)
+                    warnings.push(`generate: ${generationResult.reason}`);
             }
         }
         catch (err) {
-            const reason = err instanceof Error ? err.message : String(err);
+            const reason = redactSecrets(err instanceof Error ? err.message : String(err));
+            generationResult = {
+                ...generationResult,
+                status: "failed",
+                reason
+            };
             warnings.push(`generate skipped: ${reason}`);
         }
     }
+    try {
+        const graphWithGeneration = loadGraph(workspacePaths(root).graphPath);
+        if (!graphWithGeneration.analysis)
+            throw new Error("analysis metadata is missing after analyze");
+        saveGraph(workspacePaths(root).graphPath, {
+            ...graphWithGeneration,
+            updated_at: deps.clock(),
+            analysis: {
+                ...graphWithGeneration.analysis,
+                start_generation: generationResult
+            }
+        });
+    }
+    catch (error) {
+        warnings.push(`generation outcome not persisted: ${error instanceof Error ? error.message : String(error)}`);
+    }
     // G1: persist the distilled, already-redacted attempt classifications so
     // `opro doctor --proof` and standalone report regens can explain blockers
     // after this process exits. Sidecar only — never read by the oracle, RTM,
@@ -1767,6 +1846,7 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
         changed,
         gaps,
         auto_prove: autoProveResult,
+        generation: generationResult,
         next_actions: nextActions,
         agent_workflow: AGENT_RUN_WORKFLOW,
         grounding_contract: GROUNDING_CONTRACT,

package/dist/local/pack/coverageReport.js

@@ -74,12 +74,22 @@ export function renderCoverageReport(graph, ledger = emptyLedger()) {
             lines.push(`| ${language} | ${row.covered} / ${row.eligible} | ${row.covered_pct}% | ${row.symbols_with_spans} |`);
         }
         lines.push("");
+        lines.push("Coverage by test suite (inclusive counts; unit + integration must not be added because overlap is reported separately):");
+        lines.push("");
+        lines.push("| suite | covered symbols | eligible % |");
+        lines.push("| --- | ---: | ---: |");
+        lines.push(`| unit | ${runtime.by_suite.unit} | ${runtime.by_suite.unit_pct}% |`);
+        lines.push(`| integration | ${runtime.by_suite.integration} | ${runtime.by_suite.integration_pct}% |`);
+        lines.push(`| unit + integration overlap | ${runtime.by_suite.overlap} | ${runtime.by_suite.overlap_pct}% |`);
+        lines.push(`| unclassified | ${runtime.by_suite.unclassified} | ${runtime.by_suite.unclassified_pct}% |`);
+        lines.push(`| combined union | ${runtime.by_suite.union} | ${runtime.by_suite.union_pct}% |`);
+        lines.push("");
         lines.push("Artifacts:");
         lines.push("");
-        lines.push("| artifact | format | files | covered ranges |");
-        lines.push("| --- | --- | ---: | ---: |");
+        lines.push("| artifact | suite | provenance | command | format | files | covered ranges |");
+        lines.push("| --- | --- | --- | --- | --- | ---: | ---: |");
         for (const artifact of runtime.artifacts) {
-            lines.push(`| ${escapeMd(artifact.path)} | ${artifact.format} | ${artifact.files} | ${artifact.covered_ranges} |`);
+            lines.push(`| ${escapeMd(artifact.path)} | ${artifact.suite} | ${artifact.suite_source} | ${escapeMd(artifact.command ?? "-")} | ${artifact.format} | ${artifact.files} | ${artifact.covered_ranges} |`);
         }
         lines.push("");
         if (runtime.skipped_artifacts?.length) {

package/dist/local/viz/behaviorReportData.js

@@ -4,6 +4,7 @@ import { buildRtm } from "../rtm.js";
 import { inspectRiskInputHealth, isEntryPoint, rankRiskGaps } from "../score/risk.js";
 import { ORANGEPRO_VERSION } from "../version.js";
 import { PROOF_BLOCKER_GUIDE } from "../proofDoctor.js";
+import { classifyGeneratedDraftBlocker } from "../generate/draftGuidance.js";
 /** Short human phrase per R-1 needs_setup category, for the "blocked because: …" panel copy. */
 const BLOCK_CATEGORY_LABEL = {
     module_not_found: "a missing module or dependency in the sandbox",
@@ -229,6 +230,7 @@ function scanBlock(graph, rows) {
     const integration = tests.filter((n) => n.properties.test_layer === "integration" || n.properties.test_layer === "api" || n.properties.test_layer === "e2e").length;
     const unit = tests.filter((n) => n.properties.test_layer === "unit" || n.properties.test_layer === "component").length;
     const denominator = graph.analysis?.denominator;
+    const runtime = graph.analysis?.runtime_coverage;
     const excludedCount = (denominator?.excluded_boilerplate ?? 0) +
         (denominator?.excluded_infra ?? 0) +
         (denominator?.excluded_generated ?? 0) +
@@ -236,7 +238,22 @@ function scanBlock(graph, rows) {
     return {
         services: [...services.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 50),
         serviceTotal: services.size,
-        tests: { total: tests.length, integration, unit },
+        tests: { total: tests.length, integration, unit, unclassified: Math.max(0, tests.length - integration - unit) },
+        runtimeCoverage: runtime
+            ? {
+                eligible: runtime.total_eligible_symbols,
+                unit: runtime.by_suite?.unit ?? 0,
+                integration: runtime.by_suite?.integration ?? 0,
+                overlap: runtime.by_suite?.overlap ?? 0,
+                unclassified: runtime.by_suite?.unclassified ?? runtime.covered_symbols,
+                union: runtime.by_suite?.union ?? runtime.covered_symbols,
+                unitPct: runtime.by_suite?.unit_pct ?? 0,
+                integrationPct: runtime.by_suite?.integration_pct ?? 0,
+                overlapPct: runtime.by_suite?.overlap_pct ?? 0,
+                unclassifiedPct: runtime.by_suite?.unclassified_pct ?? runtime.covered_pct,
+                unionPct: runtime.by_suite?.union_pct ?? runtime.covered_pct
+            }
+            : null,
         excluded: {
             count: excludedCount > 0 ? String(excludedCount) : "0",
             text: "non-behavior symbols were excluded from the behavior count — generated code, framework internals, test-inferred flows, and infrastructure plumbing."
@@ -415,7 +432,8 @@ function riskGeneratedTests(graph, gap, riskIds, isFirstRowForFile) {
             .filter(Boolean)
             .join(" · "),
         code: t.body,
-        runnable: t.runnable !== false
+        runnable: t.runnable !== false,
+        ...(t.runnable === false ? { blocker: classifyGeneratedDraftBlocker(t.unresolved_reason) } : {})
     }));
 }
 /** Incoming refs are method-attributed and can be fractional when a file-level
@@ -758,7 +776,23 @@ function riskTodo(risk, verb, path, generatedTests) {
         return "Run the generated test below in your repo; follow its prove handoff so a mutation failure can mint Dynamically Proven.";
     }
     if (generatedTests.length) {
-        return "Install this repo's dependencies / set up the test runner, then re-run `opro start` to turn the English intents below into runnable tests.";
+        const blockers = new Set(generatedTests.map((t) => t.blocker ?? "unknown"));
+        if (blockers.size === 1) {
+            const blocker = [...blockers][0];
+            if (blocker === "generated_code") {
+                return "OrangePro withheld the generated code because compile validation found invalid or invented generated code. Review the blocker below, then regenerate or repair the draft; installing dependencies is not the fix.";
+            }
+            if (blocker === "unresolved_import") {
+                return "OrangePro withheld the generated code because an import path did not resolve. Verify that the import exists and is declared by this repo; install dependencies only when the repo expects it, then regenerate.";
+            }
+            if (blocker === "toolchain_or_runner") {
+                return "OrangePro could not validate the generated test because the named toolchain or test runner is unavailable. Install/configure it, then re-run `opro start`.";
+            }
+            if (blocker === "validation_timeout") {
+                return "OrangePro's generated-test validation timed out. Warm the dependency cache or raise the named validation timeout, then re-run `opro start`.";
+            }
+        }
+        return "OrangePro withheld generated code for the reasons shown below. Review each blocker, then repair or regenerate the drafts; do not assume repository dependencies are missing.";
     }
     const call = verb !== "BEHAVIOR"
         ? `issues ${verb} ${path}`
@@ -908,6 +942,9 @@ export function buildBehaviorReportData(graph, ledger, opts = {}) {
             }
         },
         generatedTotal: graph.generated_tests?.length ?? 0,
+        generatedRunnableTotal: (graph.generated_tests ?? []).filter((t) => t.runnable !== false).length,
+        generatedDraftTotal: (graph.generated_tests ?? []).filter((t) => t.runnable === false).length,
+        generationOutcome: graph.analysis?.start_generation ?? null,
         shownCount: risks.reduce((acc, r) => acc + r.generatedTests.length, 0)
     };
 }

package/dist/local/viz/behaviorReportHtml.js

@@ -366,9 +366,26 @@ body[data-mode="expert"] .simple-only{display:none!important}
       <div class="split2">
         <div><div class="v vb" id="test-int">—</div><div class="k">Integration</div></div>
         <div><div class="v vp" id="test-unit">—</div><div class="k">Unit</div></div>
+        <div><div class="v" id="test-unknown">—</div><div class="k">Unclassified</div></div>
       </div>
     </div>
   </div>
+  <div class="card" id="runtime-suite-card" hidden style="margin-top:16px">
+    <p class="card-lbl">Runtime coverage by suite — inclusive symbol counts; unit + integration overlap is shown separately and must not be added.</p>
+    <div class="split2">
+      <div><div class="v vp" id="runtime-unit">—</div><div class="k">Unit</div></div>
+      <div><div class="v vb" id="runtime-integration">—</div><div class="k">Integration</div></div>
+      <div><div class="v" id="runtime-overlap">—</div><div class="k">Both</div></div>
+      <div><div class="v" id="runtime-unclassified">—</div><div class="k">Unclassified</div></div>
+      <div><div class="v vg" id="runtime-union">—</div><div class="k">Combined union</div></div>
+    </div>
+  </div>
+  <div class="card" id="generation-outcome-card" hidden style="margin-top:16px">
+    <p class="card-lbl">Latest automated test-generation run</p>
+    <div class="v" id="generation-outcome-status">—</div>
+    <p class="card-sub" id="generation-outcome-counts"></p>
+    <p class="card-sub" id="generation-outcome-reason"></p>
+  </div>
 </section>
 
 <!-- TAB 2: BEHAVIORS — bridge from "methods" to "behaviors" -->
@@ -697,6 +714,23 @@ D.scan.services.forEach(([nm,ct])=>$("#svc-list").append(el("div","svc",\`<span
 $("#test-total").textContent=D.scan.tests.total;
 $("#test-int").textContent=D.scan.tests.integration;
 $("#test-unit").textContent=D.scan.tests.unit;
+$("#test-unknown").textContent=D.scan.tests.unclassified;
+if(D.scan.runtimeCoverage){
+  const R=D.scan.runtimeCoverage;
+  $("#runtime-suite-card").hidden=false;
+  $("#runtime-unit").textContent=\`\${R.unit} (\${R.unitPct}%)\`;
+  $("#runtime-integration").textContent=\`\${R.integration} (\${R.integrationPct}%)\`;
+  $("#runtime-overlap").textContent=\`\${R.overlap} (\${R.overlapPct}%)\`;
+  $("#runtime-unclassified").textContent=\`\${R.unclassified} (\${R.unclassifiedPct}%)\`;
+  $("#runtime-union").textContent=\`\${R.union} (\${R.unionPct}%)\`;
+}
+if(D.generationOutcome){
+  const G=D.generationOutcome;
+  $("#generation-outcome-card").hidden=false;
+  $("#generation-outcome-status").textContent=String(G.status||"unknown").replaceAll("_"," ");
+  $("#generation-outcome-counts").textContent=G.generated+" draft(s): "+G.runnable+" runnable, "+Math.max(0,G.drafts-G.runnable)+" blocked; "+G.requested+" target(s) requested.";
+  $("#generation-outcome-reason").textContent=G.reason||"Generation completed; inspect each draft for its terminal validation result.";
+}
 
 // behaviors
 function humanizeSig(sig){
@@ -883,6 +917,10 @@ const riskTopBanner=el("div","platform-top-banner",
    <a class="platform-footer-btn" href="https://orangepro.ai/get-started" target="_blank">Unlock Full Analysis &rarr;</a>\`);
 riskList.before(riskTopBanner);
 const generatedRiskCount=D.risks.filter(r=>r.generatedTests&&r.generatedTests.length).length;
+const generatedOutputCopy=[
+  D.generatedRunnableTotal?\`\${D.generatedRunnableTotal} runnable generated test\${D.generatedRunnableTotal===1?"":"s"}\`:'',
+  D.generatedDraftTotal?\`\${D.generatedDraftTotal} grounded draft\${D.generatedDraftTotal===1?"":"s"} with code withheld\`:'',
+].filter(Boolean).join(' and ');
 let activeRiskFilter=generatedRiskCount?"generated":"all";
 function riskMatchesFilter(r){
   const hasGenerated=Boolean(r.generatedTests&&r.generatedTests.length);
@@ -893,7 +931,7 @@ function riskMatchesFilter(r){
 function renderRiskFilters(){
   const options=[
     ["all","All",D.risks.length],
-    ["generated","Flows with tests",generatedRiskCount],
+    ["generated","Flows with generated output",generatedRiskCount],
     ["missing","No generated tests",D.risks.filter(r=>!(r.generatedTests&&r.generatedTests.length)).length]
   ];
   riskTools.innerHTML=options.map(([key,label,count])=>\`<button class="risk-filter" type="button" data-risk-filter="\${key}" aria-pressed="\${key===activeRiskFilter}">\${label} <span class="gc">\${count}</span></button>\`).join("");
@@ -922,7 +960,7 @@ function riskCardHtml(r){
     // per-test chips whenever the generator produced unit tests.
     const allIntent=r.generatedTests.every(t=>t.runnable===false);
     const kinds=[...new Set(r.generatedTests.map(t=>t.concern).filter(Boolean))];
-    const kindLbl=allIntent?" (Manual tests — env setup needed)":kinds.length===1?" ("+kinds[0].replace(/_/g," ")+")":kinds.length>1?" (mixed)":"";
+    const kindLbl=allIntent?" (Generated drafts — code withheld)":kinds.length===1?" ("+kinds[0].replace(/_/g," ")+")":kinds.length>1?" (mixed)":"";
     testsHtml=\`<div class="gen-tests"><div class="gen-tests-lbl">Generated tests\${esc(kindLbl)}</div>\`;
     r.generatedTests.forEach(t=>{
       const cBadge=t.concern?\`<span class="badge b-info" style="margin-left:6px;font-size:9px">\${esc(t.concern.replace('_',' '))}</span>\`:'';
@@ -946,12 +984,12 @@ function renderRisks(){
     const remainingRiskFlows=Math.max(0,D.risks.length-generatedRiskCount);
     riskList.append(el("div","paywall",
       hiddenGeneratedFlows
-        ? \`<div class="paywall-num">\${hiddenGeneratedFlows} more flows with tests</div>
-           <div class="paywall-txt">OrangePro accepted \${D.generatedTotal} runnable generated test\${D.generatedTotal===1?"":"s"} across \${generatedRiskCount} high-risk flow\${generatedRiskCount===1?"":"s"}. Use the “Flows with tests” filter to review them first.</div>
+        ? \`<div class="paywall-num">\${hiddenGeneratedFlows} more flows with generated output</div>
+           <div class="paywall-txt">OrangePro produced \${generatedOutputCopy} across \${generatedRiskCount} high-risk flow\${generatedRiskCount===1?"":"s"}. Use the “Flows with generated output” filter to review them first.</div>
            <a class="paywall-btn" href="https://orangepro.ai/get-started" target="_blank">View all on OrangePro Platform &rarr;</a>\`
         : remainingRiskFlows
           ? \`<div class="paywall-num">\${remainingRiskFlows} high-risk flows left</div>
-             <div class="paywall-txt">The local MCP accepted \${D.generatedTotal} runnable generated test\${D.generatedTotal===1?"":"s"} across \${generatedRiskCount} high-risk flow\${generatedRiskCount===1?"":"s"}. Generate the remaining high-risk flow tests on OrangePro Platform.</div>
+             <div class="paywall-txt">The local MCP produced \${generatedOutputCopy} across \${generatedRiskCount} high-risk flow\${generatedRiskCount===1?"":"s"}. Generate the remaining high-risk flow tests on OrangePro Platform.</div>
              <a class="paywall-btn" href="https://orangepro.ai/get-started" target="_blank">Generate remaining tests on Platform &rarr;</a>\`
           : \`<div class="paywall-num">All generated tests are shown</div>
              <div class="paywall-txt">OrangePro generated tests for every high-risk flow in this report, and every generated test is visible here.</div>\`));

package/docs/local-proof-kit.md

@@ -264,6 +264,14 @@ local kit ingests Go coverprofiles, JS/TS `lcov.info`, Python coverage.py XML, a
 XML. These artifacts show executed lines inside symbols; they are not assertion-level proof and
 never promote Associated signal or No integration signal rows to Proven.
 
+For the highest-signal report in a repository with its own build/test workflow, bootstrap the
+repository first, run its native coverage target, optionally use `opro coverage .` to confirm the
+artifact is detected, and then run `opro start .`. The `coverage` command is discovery/generation
+only; `analyze` and `start` ingest detected artifacts while rebuilding the graph. Running
+`opro analyze .` immediately before `opro start .` is redundant. `opro start . --generate-coverage`
+is a convenience for conventional repositories; prefer the repository's native coverage command
+when it needs custom build tags, generated assets, services, or test-runner flags.
+
 ## Readiness score
 
 A 0–100 **readiness** signal (not a proof of lift), in bands: `thin` (0–39),

package/package.json

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