@orangepro/orangepro-mcp 0.2.29 → 0.2.31

package/dist/local/analyze/coverage.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
+const COVERAGE_SUITE_MANIFEST = ".orangepro/coverage-suites.json";
 const GO_COVERAGE_CANDIDATES = new Set([
     "coverage.out",
     "cover.out",
@@ -47,6 +48,48 @@ function symbolLanguage(n) {
         return "java";
     return "other";
 }
+function normalizedArtifactPath(value) {
+    const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (!normalized || path.posix.isAbsolute(normalized) || normalized.split("/").includes(".."))
+        return null;
+    return normalized;
+}
+function coverageSuiteManifest(root) {
+    const out = new Map();
+    try {
+        const raw = JSON.parse(readFileSync(path.join(root, COVERAGE_SUITE_MANIFEST), "utf8"));
+        for (const [artifactPath, value] of Object.entries(raw.artifacts ?? {})) {
+            const rel = normalizedArtifactPath(artifactPath);
+            if (!rel || !value || typeof value !== "object")
+                continue;
+            const suite = value.suite;
+            if (suite !== "unit" && suite !== "integration")
+                continue;
+            const command = value.command;
+            out.set(rel, { suite, ...(typeof command === "string" && command.trim() ? { command: command.trim() } : {}) });
+        }
+    }
+    catch {
+        // Missing or malformed provenance is fail-visible as unclassified coverage.
+    }
+    return out;
+}
+function inferredCoverageSuite(rel) {
+    const normalized = `/${rel.toLowerCase().replace(/[^a-z0-9/._-]+/g, "-")}/`;
+    if (/(?:^|[/_.-])(integration|e2e|end-to-end)(?:[/_.-]|$)/.test(normalized))
+        return "integration";
+    if (/(?:^|[/_.-])unit(?:[/_.-]|$)/.test(normalized))
+        return "unit";
+    return null;
+}
+export function coverageSuiteForArtifact(root, rel) {
+    const normalized = normalizedArtifactPath(rel) ?? rel.replace(/\\/g, "/");
+    const declared = coverageSuiteManifest(root).get(normalized);
+    if (declared)
+        return { suite: declared.suite, suite_source: "manifest", ...(declared.command ? { command: declared.command } : {}) };
+    const inferred = inferredCoverageSuite(normalized);
+    return inferred ? { suite: inferred, suite_source: "inferred" } : { suite: "unclassified", suite_source: "unclassified" };
+}
 function artifactCandidates(root, files) {
     const out = new Map();
     const add = (candidate) => {
@@ -79,7 +122,11 @@ function artifactCandidates(root, files) {
     catch {
         /* no generated coverage dir */
     }
-    return [...out.values()].sort((a, b) => a.path.localeCompare(b.path));
+    return [...out.values()]
+        .map((candidate) => {
+        return { ...candidate, ...coverageSuiteForArtifact(root, candidate.path) };
+    })
+        .sort((a, b) => a.path.localeCompare(b.path));
 }
 function discoverNestedCoverageArtifacts(root) {
     const out = [];
@@ -109,7 +156,7 @@ function discoverNestedCoverageArtifacts(root) {
         }
     };
     visit("");
-    return out;
+    return out.map((candidate) => ({ ...candidate, ...coverageSuiteForArtifact(root, candidate.path) }));
 }
 function goModuleForDir(dir, goModulesByDir) {
     for (;;) {
@@ -424,13 +471,14 @@ function parseJacocoXml(root, rel, codeFiles) {
     };
 }
 function parseCoverageArtifact(root, candidate, goModulesByDir, codeFiles) {
-    if (candidate.format === "go-coverprofile")
-        return parseGoCoverprofile(root, candidate.path, goModulesByDir, codeFiles);
-    if (candidate.format === "lcov")
-        return parseLcov(root, candidate.path, codeFiles);
-    if (candidate.format === "coverage-py")
-        return parseCoveragePyXml(root, candidate.path, codeFiles);
-    return parseJacocoXml(root, candidate.path, codeFiles);
+    const parsed = candidate.format === "go-coverprofile"
+        ? parseGoCoverprofile(root, candidate.path, goModulesByDir, codeFiles)
+        : candidate.format === "lcov"
+            ? parseLcov(root, candidate.path, codeFiles)
+            : candidate.format === "coverage-py"
+                ? parseCoveragePyXml(root, candidate.path, codeFiles)
+                : parseJacocoXml(root, candidate.path, codeFiles);
+    return { ...parsed, ranges: parsed.ranges.map((range) => ({ ...range, suite: candidate.suite })) };
 }
 function overlaps(aStart, aEnd, bStart, bEnd) {
     return aStart <= bEnd && bStart <= aEnd;
@@ -451,7 +499,14 @@ export function applyRuntimeCoverage(root, files, nodes, goModulesByDir) {
             skippedArtifacts.push(skipped);
         if (ranges.length === 0)
             continue;
-        const stat = artifactStats.get(artifact.path) ?? { files: new Set(), covered_ranges: 0, format: artifact.format };
+        const stat = artifactStats.get(artifact.path) ?? {
+            files: new Set(),
+            covered_ranges: 0,
+            format: artifact.format,
+            suite: artifact.suite,
+            suite_source: artifact.suite_source,
+            ...(artifact.command ? { command: artifact.command } : {})
+        };
         for (const range of ranges) {
             const list = rangesByFile.get(range.file);
             if (list)
@@ -467,6 +522,9 @@ export function applyRuntimeCoverage(root, files, nodes, goModulesByDir) {
         return undefined;
     const byLanguage = {};
     const coveredSymbols = new Set();
+    const unitSymbols = new Set();
+    const integrationSymbols = new Set();
+    const unclassifiedSymbols = new Set();
     let totalEligible = 0;
     let symbolsWithSpans = 0;
     const ingestedLanguages = new Set([...artifactStats.values()].map((s) => languageForFormat(s.format)));
@@ -491,12 +549,20 @@ export function applyRuntimeCoverage(root, files, nodes, goModulesByDir) {
         if (overlapping.length === 0)
             continue;
         const formats = [...new Set(overlapping.map((r) => r.format))].sort();
+        const suites = [...new Set(overlapping.map((r) => r.suite ?? "unclassified"))].sort();
         coveredSymbols.add(n.external_id);
+        if (suites.includes("unit"))
+            unitSymbols.add(n.external_id);
+        if (suites.includes("integration"))
+            integrationSymbols.add(n.external_id);
+        if (suites.includes("unclassified"))
+            unclassifiedSymbols.add(n.external_id);
         bucket.covered++;
         n.properties = {
             ...n.properties,
             runtime_covered: true,
-            runtime_coverage_formats: formats
+            runtime_coverage_formats: formats,
+            runtime_coverage_suites: suites
         };
     }
     for (const bucket of Object.values(byLanguage))
@@ -505,6 +571,9 @@ export function applyRuntimeCoverage(root, files, nodes, goModulesByDir) {
         artifacts: [...artifactStats.entries()].map(([path, s]) => ({
             path,
             format: s.format,
+            suite: s.suite,
+            suite_source: s.suite_source,
+            ...(s.command ? { command: s.command } : {}),
             files: s.files.size,
             covered_ranges: s.covered_ranges
         })),
@@ -513,6 +582,18 @@ export function applyRuntimeCoverage(root, files, nodes, goModulesByDir) {
         symbols_with_spans: symbolsWithSpans,
         covered_symbols: coveredSymbols.size,
         covered_pct: pct(coveredSymbols.size, totalEligible),
-        by_language: byLanguage
+        by_language: byLanguage,
+        by_suite: {
+            unit: unitSymbols.size,
+            integration: integrationSymbols.size,
+            overlap: [...unitSymbols].filter((id) => integrationSymbols.has(id)).length,
+            unclassified: unclassifiedSymbols.size,
+            union: coveredSymbols.size,
+            unit_pct: pct(unitSymbols.size, totalEligible),
+            integration_pct: pct(integrationSymbols.size, totalEligible),
+            overlap_pct: pct([...unitSymbols].filter((id) => integrationSymbols.has(id)).length, totalEligible),
+            unclassified_pct: pct(unclassifiedSymbols.size, totalEligible),
+            union_pct: pct(coveredSymbols.size, totalEligible)
+        }
     };
 }

package/dist/local/analyze/coverageArtifacts.js

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { reportProgress } from "../util/progress.js";
+import { coverageSuiteForArtifact } from "./coverage.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
 const DEFAULT_BUDGET_MS = 600_000;
 const GENERATED_COVERAGE_DIR = ".orangepro/coverage";
@@ -129,6 +130,10 @@ export function prepareRuntimeCoverage(root, opts = {}) {
             warnings.push("No local coverage generators found, so OrangePro did not generate runtime coverage.");
     }
     const artifacts = detectCoverageArtifacts(absRoot);
+    const unclassified = artifacts.filter((artifact) => artifact.ingestible && artifact.suite === "unclassified");
+    if (unclassified.length > 0) {
+        warnings.push(`${unclassified.length} ingestible coverage artifact(s) have no unit/integration provenance. Add ${COVERAGE_SUITE_MANIFEST_HELP} so OrangePro reports the suites separately.`);
+    }
     const suggested_commands = suggestCoverageCommands(absRoot);
     return {
         root: absRoot,
@@ -139,10 +144,12 @@ export function prepareRuntimeCoverage(root, opts = {}) {
         warnings
     };
 }
+const COVERAGE_SUITE_MANIFEST_HELP = ".orangepro/coverage-suites.json with an artifacts map, for example {\"coverage/unit.coverprofile\":{\"suite\":\"unit\",\"command\":\"make unit-test-coverage\"}}";
 export function detectCoverageArtifacts(root) {
     const absRoot = path.resolve(root);
     const out = new Map();
-    const add = (info) => {
+    const add = (raw) => {
+        const info = { ...raw, ...coverageSuiteForArtifact(absRoot, raw.path) };
         const abs = path.join(absRoot, info.path);
         if (!existsSync(abs))
             return;

package/dist/local/autoProve.js

@@ -18,7 +18,7 @@ import { generateTests, readDeclaredDeps, unresolvedLocalImports } from "./gener
 import { GENERATED_DIR, runHintsFor } from "./generate/runHints.js";
 import { rankRiskGaps } from "./score/risk.js";
 import { resolveProviderConfig } from "./localConfig.js";
-import { buildProvider } from "./generate/providers.js";
+import { buildProvider, DeterministicProvider } from "./generate/providers.js";
 import { resolveContained } from "./reprove/paths.js";
 import { buildRtm } from "./rtm.js";
 import { loadLedger } from "./ledger.js";
@@ -834,10 +834,12 @@ export async function autoProve(root, opts, deps) {
             attempts: ex.attempts
         };
     }
-    // Key gate applies ONLY to the generation lane. No provider key ⇒ generation is skipped
-    // (no files, no fake proof) with explicit guidance; the existing-tests lane still counts.
-    const providerConfig = resolveProviderConfig(deps.env, { provider: opts.provider, model: opts.model });
-    if (!providerConfig) {
+    // Provider gate applies ONLY to the generation lane. Explicit deterministic mode is a
+    // valid offline provider; otherwise a real provider key/config is required.
+    const deterministic = opts.provider === "deterministic"
+        || /^(1|true|yes)$/i.test(String(deps.env.ORANGEPRO_ALLOW_DETERMINISTIC ?? ""));
+    const providerConfig = deterministic ? null : resolveProviderConfig(deps.env, { provider: opts.provider, model: opts.model });
+    if (!providerConfig && !deterministic) {
         const status = ex.proven > 0 ? "proven-run" : ex.attempted > 0 ? "ran-no-proof" : "skipped-no-key";
         return {
             ran: ex.attempted > 0,
@@ -851,7 +853,7 @@ export async function autoProve(root, opts, deps) {
             attempts: ex.attempts
         };
     }
-    const provider = buildProvider(providerConfig);
+    const provider = deterministic ? new DeterministicProvider() : buildProvider(providerConfig);
     const generate = deps.generate ?? generateTests;
     const reader = fileReaderFor(sourceRoot);
     // Generation gets only the budget the existing-tests lane left unspent, so existing +

package/dist/local/cli.js

@@ -78,7 +78,7 @@ const HELP = `opro — OrangePro (local-first, BYOK, metadata-only artifacts)
 
 Usage:
   opro                                       # one-command start: analyze, optional AI links + flows, report, RTM, agent handoff
-  opro start [path] [--base <ref>] [--no-ai] [--no-ai-flows] [--generate-coverage] [--prompt-version v5] [--json]
+  opro start [path] [--base <ref>] [--no-ai] [--no-ai-flows] [--generate-coverage] [--proof-limit 5] [--generate-limit 20] [--prompt-version v5] [--json]
   opro roast [path] [--limit 5] [--json]     # keyless: find passing tests whose targeted mutant still survives
   opro init
   opro setup                                 # interactive: choose a default model provider + model (saved locally)
@@ -199,6 +199,8 @@ async function main() {
                     aiAll: asBool(flags["ai-all"], false),
                     aiFlows: !asBool(flags["no-ai-flows"], false),
                     autoLimit: numericFlag(flags["auto-limit"]),
+                    proofLimit: numericFlag(flags["proof-limit"]),
+                    generateLimit: numericFlag(flags["generate-limit"]),
                     noAuto: asBool(flags["no-auto"], false),
                     promptVersion: flags["prompt-version"] === "v5" ? "v5" : undefined,
                     provider: typeof flags.provider === "string" ? flags.provider : undefined,
@@ -225,6 +227,10 @@ async function main() {
                     out("  Proof next:            no behavior is dynamically proven yet; run from a coding agent with a model key and follow the generated-test proof handoff.");
                 }
                 const ap = res.auto_prove;
+                const gen = res.generation;
+                out(`  Test generation:       ${gen.status} — ${gen.runnable}/${gen.generated} runnable, ${Math.max(0, gen.drafts - gen.runnable)} blocked draft(s)`);
+                if (gen.reason)
+                    out(`    generation reason:   ${gen.reason}`);
                 if (ap.status === "skipped-no-key") {
                     out(`  Dynamic proof:         skipped — ${ap.reason ?? "no provider key"}`);
                 }
@@ -527,7 +533,9 @@ async function main() {
                 if (res.artifacts.length) {
                     out("  found:");
                     for (const a of res.artifacts) {
-                        out(`    ${a.path} (${a.language}, ${a.format}${a.ingestible ? ", ingestible now" : ", detected only"})`);
+                        out(`    ${a.path} (${a.language}, ${a.format}, suite=${a.suite} [${a.suite_source}]${a.ingestible ? ", ingestible now" : ", detected only"})`);
+                        if (a.command)
+                            out(`      command: ${a.command}`);
                     }
                 }
                 else {

package/dist/local/cliArgs.js

@@ -13,6 +13,8 @@
 export const VALUE_FLAGS = new Set([
     "agent-pass",
     "auto-limit",
+    "proof-limit",
+    "generate-limit",
     "base",
     "client",
     "coverage-timeout-ms",

package/dist/local/generate/draftGuidance.js

@@ -0,0 +1,30 @@
+/** Classify only high-confidence generator/validator diagnostics. Ambiguous
+ * failures stay unknown rather than being mislabeled as a repo setup problem. */
+export function classifyGeneratedDraftBlocker(reason) {
+    const text = reason ?? "";
+    if (/timed?\s*out|timeout|ETIMEDOUT|signal:\s*killed/i.test(text))
+        return "validation_timeout";
+    if (/(?:^|\b)(?:go|gofmt|python3|pytest|mvn|gradle|node|npm|vitest|jest|mocha)(?:\b[^.\n]*)?(?:not found|ENOENT|not installed)/i.test(text) ||
+        /(?:test runner|toolchain).*(?:missing|not found|not installed)/i.test(text))
+        return "toolchain_or_runner";
+    if (/no required module provides package|cannot find module|module not found|unresolved import|imports module-path package/i.test(text)) {
+        return "unresolved_import";
+    }
+    if (/syntax check failed|undefined:|unknown field|redeclared in this block|expected (?:declaration|operand|'[^']+'|"[^"]+"|[^ ]+),? found|literal not terminated|cannot assign/i.test(text))
+        return "generated_code";
+    return "unknown";
+}
+export function generatedDraftRemediation(reason) {
+    switch (classifyGeneratedDraftBlocker(reason)) {
+        case "generated_code":
+            return "Regenerate or repair the draft using symbols and APIs that exist in this package; installing dependencies will not fix this compiler error.";
+        case "unresolved_import":
+            return "Verify that the generated import path exists and is already declared by this repo; install dependencies only when the repo expects that import, then regenerate.";
+        case "toolchain_or_runner":
+            return "Install or configure the named toolchain/test runner, then re-run `opro start`.";
+        case "validation_timeout":
+            return "Warm the dependency cache or raise the relevant OrangePro validation timeout, then re-run `opro start`.";
+        default:
+            return "Review the named blocker, repair or regenerate the draft as needed, then re-run `opro start`; do not assume dependencies are missing.";
+    }
+}

package/dist/local/generate/generator.js

@@ -19,6 +19,7 @@ import { languageOf } from "../analyze/classify.js";
 import { buildGroundedUserPrompt, buildRawUserPrompt, buildSystemPrompt, PROMPT_VERSION } from "./prompt.js";
 import { buildBatchGenerationSystemPromptV5, buildBatchGenerationUserPromptV5, buildPlanningRepairSystemPromptV5, buildPlanningRepairUserPromptV5, buildPlanningSystemPromptV5, buildPlanningUserPromptV5, hasRepairableScenarioStructure, parseBatchGeneratedTests, parsePlannedScenariosStrict, scenarioTiesBackToRaw, PROMPT_VERSION_V5 } from "./promptV5.js";
 import { BUCKET_LABEL, deriveBucketSignals, selectLocalBuckets } from "./buckets.js";
+import { generatedDraftRemediation } from "./draftGuidance.js";
 const MAX_LIMIT = 5;
 const DEFAULT_LIMIT = 3;
 const MAX_RELATED_FILES = 4;
@@ -26,7 +27,11 @@ const SYMBOL_EXCERPT_CONTEXT_LINES = 3;
 const MAX_EXCERPT_CHARS = 8000;
 const MAX_TARGET_TYPE_EXCERPT_CHARS = 5000;
 const STATIC_CHECK_TIMEOUT_MS = 3000;
-const GO_COMPILE_CHECK_TIMEOUT_MS = 20000;
+// Large Go monorepos can spend tens of seconds populating a cold module cache
+// before the target package is compiled. Keep the check authoritative instead
+// of downgrading valid generated tests while dependencies are still downloading.
+const GO_COMPILE_CHECK_TIMEOUT_MS = 120000;
+const V5_GENERATION_MAX_TOKENS = 4000;
 /** A source ref that names a test file (used to place a generated test next to it). */
 const TEST_REF_RE = /(\.(test|spec)\.[cm]?[jt]sx?$)|((^|\/)test\.[cm]?[jt]sx?$)|(_test\.[a-z]+$)|(_spec\.[a-z]+$)|((^|\/)test_[^/]+\.[a-z]+$)/i;
 function areaOf(relPath) {
@@ -518,6 +523,9 @@ export function gatherContext(graph, behavior, framework, fileReader) {
     // Subject imports are TS/JS lines — feeding them to a pytest/go target would
     // produce an unparseable test in the other language.
     const fwLower = framework.toLowerCase();
+    const goContext = fwLower.includes("go")
+        ? goGenerationImportContext(graph.workspace.root, [...relatedFiles, ...testFiles], fileReader)
+        : { go_import_paths: [], go_module_paths: [], go_target_package_paths: [] };
     const subjectImports = fwLower.includes("pytest") || fwLower.includes("python") || fwLower.includes("go") || fwLower.includes("junit") || fwLower.includes("java")
         ? []
         : subjectImportsFor(graph, testFiles);
@@ -561,6 +569,9 @@ export function gatherContext(graph, behavior, framework, fileReader) {
         // MISSING, never a re-derivation of a test that already exists.
         existing_tests: examples.slice(0, 10),
         subject_imports: subjectImports,
+        ...(goContext.go_import_paths.length ? { go_import_paths: goContext.go_import_paths } : {}),
+        ...(goContext.go_module_paths.length ? { go_module_paths: goContext.go_module_paths } : {}),
+        ...(goContext.go_target_package_paths.length ? { go_target_package_paths: goContext.go_target_package_paths } : {}),
         ...(flowChain ? { flow_chain: flowChain } : {})
     };
     // entity_ids are graph external_ids: the behavior plus related file paths. A
@@ -1578,10 +1589,6 @@ function goStaticIssue(body) {
     if (!/\bfunc\s+Test[A-Za-z0-9_]*\s*\(\s*t\s+\*testing\.T\s*\)/m.test(body)) {
         return "Go test is missing a func Test...(t *testing.T) entrypoint.";
     }
-    const external = imports.filter((spec) => spec.split("/")[0].includes("."));
-    if (external.length) {
-        return `Go test imports module-path package(s) ${external.join(", ")}; OrangePro cannot verify module imports resolve from the generated file. Prefer same-package or stdlib-only code.`;
-    }
     if (!commandAvailable("gofmt"))
         return "gofmt not found; cannot verify Go syntax.";
     const { dir, file } = writeTempStaticFile("go", body);
@@ -1611,26 +1618,58 @@ function findGoModuleRoot(startDir, workspaceRoot) {
     }
     return null;
 }
-function goCompileIssue(body, workspaceRoot, relatedFiles) {
+function unusedImportLineNumbers(output, tempRel) {
+    const escaped = tempRel.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const diagnostic = new RegExp(`(?:^|\\n)(?:\\./)?${escaped}:(\\d+):\\d+:\\s+[^\\n]*\\bimported\\b[^\\n]*\\bnot used\\b`, "g");
+    return new Set([...output.matchAll(diagnostic)].map((match) => Number(match[1])).filter(Number.isFinite));
+}
+function removeLines(body, lineNumbers) {
+    if (!lineNumbers.size)
+        return body;
+    return body
+        .split(/\r?\n/)
+        .filter((_line, index) => !lineNumbers.has(index + 1))
+        .join("\n");
+}
+function goCompile(body, workspaceRoot, relatedFiles) {
+    const externalImports = goImportSpecs(body).filter((spec) => spec.split("/")[0].includes("."));
+    const unverifiedImportIssue = externalImports.length
+        ? `Go test imports module-path package(s) ${externalImports.join(", ")}, but OrangePro could not run the target-package compile check to verify they resolve.`
+        : null;
     const sourceFile = relatedFiles.find((rel) => /\.go$/i.test(rel) && !TEST_REF_RE.test(rel));
     if (!sourceFile)
-        return null;
+        return { body, issue: unverifiedImportIssue };
     const packageDir = path.resolve(workspaceRoot, path.dirname(sourceFile));
     if (!existsSync(packageDir) || !findGoModuleRoot(packageDir, workspaceRoot))
-        return null;
+        return { body, issue: unverifiedImportIssue };
     if (!commandAvailable("go"))
-        return "go not found; cannot verify generated Go test compiles.";
+        return { body, issue: "go not found; cannot verify generated Go test compiles." };
     const tempRel = `orangepro_compile_${process.pid}_${shortHash(body)}_test.go`;
     const tempFile = path.join(packageDir, tempRel);
+    let checkedBody = body;
     try {
-        writeFileSync(tempFile, body);
+        writeFileSync(tempFile, checkedBody);
         execFileSync("go", ["test", "-run", "^$", "."], { cwd: packageDir, stdio: "pipe", timeout: GO_COMPILE_CHECK_TIMEOUT_MS });
-        return null;
+        return { body: checkedBody, issue: null };
     }
     catch (e) {
         const err = e;
         const output = `${err.stdout?.toString() ?? ""}${err.stderr?.toString() ?? ""}`;
-        return `Go compile check failed: ${shortStaticDiag(output || err.message || "unknown error")}`;
+        const withoutUnusedImports = removeLines(checkedBody, unusedImportLineNumbers(output, tempRel));
+        if (withoutUnusedImports !== checkedBody) {
+            checkedBody = withoutUnusedImports;
+            try {
+                writeFileSync(tempFile, checkedBody);
+                execFileSync("go", ["test", "-run", "^$", "."], { cwd: packageDir, stdio: "pipe", timeout: GO_COMPILE_CHECK_TIMEOUT_MS });
+                return { body: checkedBody, issue: null };
+            }
+            catch (retryError) {
+                const retry = retryError;
+                const retryOutput = `${retry.stdout?.toString() ?? ""}${retry.stderr?.toString() ?? ""}`;
+                return { body: checkedBody, issue: `Go compile check failed: ${shortStaticDiag(retryOutput || retry.message || "unknown error")}` };
+            }
+        }
+        return { body: checkedBody, issue: `Go compile check failed: ${shortStaticDiag(output || err.message || "unknown error")}` };
     }
     finally {
         rmSync(tempFile, { force: true });
@@ -1659,6 +1698,37 @@ function goImportSpecs(body) {
     }
     return specs;
 }
+function goGenerationImportContext(workspaceRoot, files, fileReader) {
+    const goFiles = files.filter((file) => /\.go$/i.test(file));
+    const moduleRoots = dedupe(goFiles
+        .map((file) => findGoModuleRoot(path.resolve(workspaceRoot, path.dirname(file)), workspaceRoot))
+        .filter((root) => Boolean(root)));
+    const modulePathByRoot = new Map(moduleRoots.map((root) => {
+        try {
+            return [root, readFileSync(path.join(root, "go.mod"), "utf8").match(/^\s*module\s+(\S+)/m)?.[1] ?? ""];
+        }
+        catch {
+            return [root, ""];
+        }
+    }));
+    const go_module_paths = dedupe([...modulePathByRoot.values()].filter(Boolean));
+    const go_target_package_paths = dedupe(goFiles
+        .map((file) => {
+        const sourceDir = path.resolve(workspaceRoot, path.dirname(file));
+        const moduleRoot = findGoModuleRoot(sourceDir, workspaceRoot);
+        const modulePath = moduleRoot ? modulePathByRoot.get(moduleRoot) : "";
+        if (!moduleRoot || !modulePath)
+            return "";
+        const packageDir = path.relative(moduleRoot, sourceDir).split(path.sep).join("/");
+        return packageDir && packageDir !== "." ? `${modulePath}/${packageDir}` : modulePath;
+    })
+        .filter(Boolean));
+    const targetPaths = new Set(go_target_package_paths);
+    const go_import_paths = dedupe(goFiles
+        .flatMap((file) => goImportSpecs(fileReader(file) ?? ""))
+        .filter((spec) => spec.split("/")[0].includes(".") && !targetPaths.has(spec))).slice(0, 40);
+    return { go_import_paths, go_module_paths, go_target_package_paths };
+}
 function hasBalancedBraces(body) {
     let depth = 0;
     let stringQuote = null;
@@ -2176,8 +2246,13 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                 body = applyPythonSrcLayoutImports(body, relatedFiles);
             }
             body = ensureFrameworkScaffold(body, framework);
+            let compileIssue = null;
+            if (framework.toLowerCase().includes("go")) {
+                const checked = goCompile(body, graph.workspace.root, relatedFiles);
+                body = checked.body;
+                compileIssue = checked.issue;
+            }
             const staticIssue = staticFormatIssue(body, framework);
-            const compileIssue = framework.toLowerCase().includes("go") ? goCompileIssue(body, graph.workspace.root, relatedFiles) : null;
             const runnable = hasAssertion(body, framework) && !staticIssue && !compileIssue;
             generated.push({
                 id: `${run_id}-t${generated.length + 1}`,
@@ -2309,7 +2384,8 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                 reportProgress(`Generating "${gc.ctx.behavior_title}" [v5 batch: ${selected.length}]…`);
                 completions.push(await provider.complete({
                     system: buildBatchGenerationSystemPromptV5(),
-                    user: buildBatchGenerationUserPromptV5({ ...gc.ctx, scenarios: selected })
+                    user: buildBatchGenerationUserPromptV5({ ...gc.ctx, scenarios: selected }),
+                    maxTokens: V5_GENERATION_MAX_TOKENS
                 }));
             }
             catch (e) {
@@ -2319,7 +2395,8 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                     try {
                         completions.push(await provider.complete({
                             system: buildBatchGenerationSystemPromptV5(),
-                            user: buildBatchGenerationUserPromptV5({ ...gc.ctx, scenarios: [scenario] })
+                            user: buildBatchGenerationUserPromptV5({ ...gc.ctx, scenarios: [scenario] }),
+                            maxTokens: V5_GENERATION_MAX_TOKENS
                         }));
                     }
                     catch (singleErr) {
@@ -2433,7 +2510,12 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                     }
                 }
                 const importErrors = isResolverFramework(framework) ? unresolvedLocalImports(body, genTestAbs, graph.workspace.root, declaredDeps) : [];
-                const compileIssue = framework.toLowerCase().includes("go") ? goCompileIssue(body, graph.workspace.root, relatedFiles) : null;
+                let compileIssue = null;
+                if (framework.toLowerCase().includes("go")) {
+                    const checked = goCompile(body, graph.workspace.root, relatedFiles);
+                    body = checked.body;
+                    compileIssue = checked.issue;
+                }
                 const runnable = isRunnable(body, framework, import_provenance, importErrors) && !compileIssue;
                 if (!runnable) {
                     const reason = unresolved_reason ?? compileIssue ?? runnableFailureReason(body, framework, import_provenance, importErrors, declaredDeps);
@@ -2463,7 +2545,7 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
                         "",
                         // Concise blocker: first clause only — the full remedy is one line.
                         `Blocked by: ${reason.split(" — ")[0]}`,
-                        "Fix: install this repo's dependencies / configure the test runner, then re-run \`opro start\`."
+                        `Fix: ${generatedDraftRemediation(reason)}`
                     ].join("\n"), gc.ctx.source_excerpts, "//").body;
                     generated.push({
                         id: `${run_id}-t${generated.length + 1}`,
@@ -2651,7 +2733,12 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
             // from where the test will live. A test whose own import won't load is never
             // marked runnable.
             const importErrors = isResolverFramework(framework) ? unresolvedLocalImports(body, genTestAbs, graph.workspace.root, declaredDeps) : [];
-            const compileIssue = framework.toLowerCase().includes("go") ? goCompileIssue(body, graph.workspace.root, relatedFiles) : null;
+            let compileIssue = null;
+            if (framework.toLowerCase().includes("go")) {
+                const checked = goCompile(body, graph.workspace.root, relatedFiles);
+                body = checked.body;
+                compileIssue = checked.issue;
+            }
             const runnable = isRunnable(body, framework, import_provenance, importErrors) && !compileIssue;
             if (!runnable && !unresolved_reason) {
                 unresolved_reason = compileIssue ?? runnableFailureReason(body, framework, import_provenance, importErrors, declaredDeps);

package/dist/local/generate/prompt.js

@@ -32,8 +32,10 @@ export function buildSystemPrompt() {
         "- Framework format rules:",
         "  - pytest: output a valid Python file with pytest-style `def test_...` functions and `assert` statements.",
         "  - Go: output a same-package `_test.go` body. Include `package <same package>`, `import \"testing\"`,",
-        "    and `func Test...(t *testing.T)`. Avoid third-party or module-path imports; use stdlib-only unless",
-        "    the evidence gives an existing same-package helper.",
+        "    and `func Test...(t *testing.T)`. Do not import packages you do not use. Prefer stdlib and exact",
+        "    OBSERVED GO IMPORT PATHS; never derive or invent a package subpath from a module name.",
+        "    Do not qualify lowercase (unexported) identifiers from imported packages. Bare same-package",
+        "    identifiers may be unexported because the generated test is rewritten into the target package.",
         "  - Java/JUnit: output a complete `.java` file, not a method fragment. Include a `class <Name>Test { ... }`,",
         "    the requested JUnit version's `@Test` import, and a JUnit assertion.",
         "  - TS/JS: output valid framework code for the named framework and use complete imports.",
@@ -78,6 +80,21 @@ export function buildGroundedUserPrompt(ctx, bucket) {
         for (const imp of ctx.subject_imports)
             lines.push(imp);
     }
+    if (ctx.go_module_paths?.length) {
+        lines.push("GO MODULE IDENTITIES (module roots only — never guess package subpaths from these):");
+        for (const modulePath of ctx.go_module_paths)
+            lines.push(`- ${modulePath}`);
+    }
+    if (ctx.go_import_paths?.length) {
+        lines.push("OBSERVED GO IMPORT PATHS (exact repo-evidenced package paths; prefer these for non-stdlib imports):");
+        for (const importPath of ctx.go_import_paths)
+            lines.push(`- ${importPath}`);
+    }
+    if (ctx.go_target_package_paths?.length) {
+        lines.push("TARGET GO PACKAGE PATHS (do not import these; the test is rewritten into the same package):");
+        for (const targetPath of ctx.go_target_package_paths)
+            lines.push(`- ${targetPath}`);
+    }
     if (ctx.source_excerpts.length) {
         lines.push("SOURCE EXCERPTS:");
         lines.push("Use these for understanding only; do not copy their lines verbatim into the test body.");
@@ -97,8 +114,10 @@ export function buildGroundedUserPrompt(ctx, bucket) {
     }
     else if (fw.includes("go")) {
         lines.push("- Emit same-package Go test code only: `package ...`, `import \"testing\"`, and `func Test...(t *testing.T)`.");
-        lines.push("- Do not import third-party or module-path packages such as `github.com/...`; prefer stdlib-only tests.");
-        lines.push("- Do not use testify/assert/require unless an existing same-package helper in the evidence clearly requires it.");
+        lines.push("- Do not import packages you do not use.");
+        lines.push("- Prefer stdlib and exact OBSERVED GO IMPORT PATHS. Never invent a package path or derive a subpath from a GO MODULE IDENTITY.");
+        lines.push("- Never import a TARGET GO PACKAGE PATH; call its identifiers directly because this is a same-package test.");
+        lines.push("- Do not qualify lowercase (unexported) identifiers from imported packages; bare same-package identifiers may be unexported.");
     }
     else if (fw.includes("junit") || fw.includes("java")) {
         if (fw.includes("junit4")) {

package/dist/local/generate/promptV5.js

@@ -33,7 +33,15 @@ export function getFrameworkRules(framework) {
         return "Python: `def test_...` with `assert`. Use `# Concern:` and `# Technique:` comments.";
     }
     if (fw.includes("go")) {
-        return "Go: same-package `_test.go`, `func Test...(t *testing.T)`. Stdlib preferred.";
+        return [
+            "Go: same-package `_test.go` file. `func Test...(t *testing.T)`.",
+            "MUST start with `package <name>` matching the package under test.",
+            "MUST import `\"testing\"`; do not import any package you do not use.",
+            "Prefer stdlib and exact OBSERVED GO IMPORT PATHS. Never invent a package path or derive a subpath from a GO MODULE IDENTITY.",
+            "Never import a TARGET GO PACKAGE PATH; call its identifiers directly because this is a same-package test.",
+            "Do not qualify lowercase (unexported) identifiers from imported packages; bare same-package identifiers may be unexported.",
+            "Prefer stdlib `testing` over testify unless testify appears in OBSERVED GO IMPORT PATHS."
+        ].join(" ");
     }
     if (fw.includes("junit4") || fw.includes("java4")) {
         return "JUnit 4: `import org.junit.Test;` + `import static org.junit.Assert.*;`. Complete .java file.";
@@ -179,6 +187,21 @@ export function buildBatchGenerationUserPromptV5(ctx) {
         lines.push(`ACTORS: ${ctx.actors.join(", ")}`);
     lines.push(`FRAMEWORK: ${ctx.framework} | LAYER: ${ctx.test_layer}`);
     lines.push(`FRAMEWORK RULES: ${getFrameworkRules(ctx.framework)}`);
+    if (ctx.go_module_paths?.length) {
+        lines.push("GO MODULE IDENTITIES (module roots only — never guess package subpaths from these):");
+        for (const modulePath of ctx.go_module_paths)
+            lines.push(`  ${modulePath}`);
+    }
+    if (ctx.go_import_paths?.length) {
+        lines.push("OBSERVED GO IMPORT PATHS (exact repo-evidenced package paths):");
+        for (const importPath of ctx.go_import_paths)
+            lines.push(`  ${importPath}`);
+    }
+    if (ctx.go_target_package_paths?.length) {
+        lines.push("TARGET GO PACKAGE PATHS (do not import; this is a same-package test):");
+        for (const targetPath of ctx.go_target_package_paths)
+            lines.push(`  ${targetPath}`);
+    }
     lines.push("");
     if (ctx.flow_chain?.length) {
         lines.push("FLOW CHAIN:");