@orangepro/orangepro-mcp 0.1.0 → 0.2.0

package/dist/local/viz/html.js

@@ -13,7 +13,7 @@ import { D3_SOURCE } from "./d3.bundle.js";
  *
  * No CDN, no network: D3 v7 is vendored inline and the gap-first DATA (the
  * curated `payload.gap` view model) is injected as JSON. This is a LOCAL artifact
- * (written to `.orangepro/graph.html`, never uploaded), so it intentionally
+ * (written by `opro export --format graph-html`, never uploaded), so it intentionally
  * includes real test/area names. It embeds NO raw source code, generated test
  * bodies, prompts, secrets, or node `properties` beyond the curated gap view.
  *

package/docs/agent-workflow.md

@@ -5,46 +5,18 @@ tests, and reports results.
 
 ## Setup
 
-For Codex, prefer the plugin when it is available:
+The public, supported path today is npm + MCP config:
 
 ```bash
-codex plugin add orangepro
-```
-
-Until OrangePro is accepted into a default marketplace, add this repo as a Codex marketplace:
-
-```bash
-codex plugin marketplace add OrangeproAI/orangepro-mcp --sparse .agents/plugins --sparse plugins/orangepro
-codex plugin add orangepro@orangepro
-```
-
-For maintainer-local development before npm publishing:
-
-```bash
-codex plugin add orangepro@personal
-```
-
-For Claude Code, add this repo as a Claude plugin marketplace and install the bundled MCP plugin:
-
-```text
-/plugin marketplace add OrangeproAI/orangepro-mcp
-/plugin install orangepro@orangepro
-/reload-plugins
+npm install -g @orangepro/orangepro-mcp
+cd /path/to/your/repo
+opro
+opro agent --client codex        # or claude-code, cursor, opencode, generic
 ```
 
-For Cursor, install OrangePro from the Cursor Marketplace when available. Until then, use the bundled plugin directory at `plugins/orangepro` for local testing, or add the MCP server manually from the Cursor doc.
-
-## Publishing Checklist
-
-Before public plugin launch:
+Paste the printed MCP block into your agent. The bundled plugin metadata in this repo is for marketplace submission and maintainer validation; do not assume bare `codex plugin add orangepro` or Claude marketplace install works until OrangePro is listed in that marketplace.
 
-1. Publish `@orangepro/orangepro-mcp` to npm so plugin MCP configs can run `npx -y -p @orangepro/orangepro-mcp@latest opro mcp`.
-2. Create and verify the fresh-history public export; do not publish a repo with private history.
-3. Codex: ship `.agents/plugins/marketplace.json` and `plugins/orangepro`; bare `codex plugin add orangepro` needs a configured/default marketplace listing.
-4. Claude Code: ship `.claude-plugin/marketplace.json` and `plugins/orangepro`; directory discovery is a separate marketplace/listing step.
-5. Cursor: submit `plugins/orangepro` to the Cursor Marketplace when ready; local testing uses that same directory.
-6. OpenCode / VS Code: keep the MCP snippets current until they expose a plugin marketplace path for this style of local server.
-7. Smoke every path in a clean checkout and verify no config pins a model or commits a provider key.
+For Cursor, install OrangePro from the Cursor Marketplace when available. Until then, use `opro agent --client cursor` or the bundled plugin directory at `plugins/orangepro` for local testing.
 
 Build the CLI and print a client-ready MCP block:
 
@@ -89,7 +61,7 @@ For PR work:
 3. Use only generated tests that include run_hints.
 4. Write each body to its suggested_path.
 5. Run the run_command from the owning package directory.
-6. After a pass, call the returned prove_run args to attempt public Proven; use record_run only for static diagnostics.
+6. After a pass, call `orangepro_prove` with the returned `prove_run` args to attempt Dynamically Proven; use `record_run` only for static diagnostics.
 7. Report pass/fail with stack traces and exact setup problems.
 
 For baseline work:
@@ -97,7 +69,7 @@ For baseline work:
 2. Pick one high-priority gap.
 3. Call orangepro_generate_tests for that target.
 4. Write, run, and report only runnable tests.
-5. After a pass, call the returned prove_run args to attempt public Proven; use record_run only for static diagnostics.
+5. After a pass, call `orangepro_prove` with the returned `prove_run` args to attempt Dynamically Proven; use `record_run` only for static diagnostics.
 
 Do not treat drafts as runnable tests. Drafts are context.
 Do not claim coverage changed unless OrangePro reports Proven, Reproven, Runtime-covered, Associated signal, or No integration signal changed.
@@ -148,7 +120,7 @@ For repos that use an `AGENTS.md`, keep the OrangePro instruction short:
 - For baseline gaps, run `opro gaps --limit 10`, pick one target, then run
   `opro generate --target <target-id> --single --limit 1`.
 - Write only tests that include `run_hints`; drafts are context, not runnable claims.
-- Write each generated body to `suggested_path`, run `run_command`, call the returned `prove_run` args after a pass to attempt public Proven. Use `record_run` only for static diagnostics.
+- Write each generated body to `suggested_path`, run `run_command`, call `orangepro_prove` with the returned `prove_run` args after a pass to attempt Dynamically Proven. Use `record_run` only for static diagnostics.
 - Report coverage status as Proven / Reproven / Runtime-covered / Associated signal / No integration signal. Do not promote Associated signal or AI links to Proven.
 ```
 

package/docs/agents/claude-code.md

@@ -12,15 +12,9 @@ opro
 
 ## Claude Plugin
 
-Install the bundled plugin from this repo marketplace:
+The public, supported path today is MCP setup through `opro agent --client claude-code` below. The bundled plugin metadata is for marketplace submission and maintainer validation; use marketplace install commands only after OrangePro is listed in your Claude Code plugin marketplace.
 
-```text
-/plugin marketplace add OrangeproAI/orangepro-mcp
-/plugin install orangepro@orangepro
-/reload-plugins
-```
-
-The plugin starts the `orangepro-local` MCP server automatically and exposes the `/orangepro:opro` skill. It does not pin a model; OrangePro uses provider/model values from the environment, `.env.provider.local`, `.env.local`, `.env`, or `opro setup`.
+When installed through a marketplace, the plugin starts the same `orangepro-local` MCP server and exposes the `/orangepro:opro` skill. It does not pin a model; OrangePro uses provider/model values from the environment, `.env.provider.local`, `.env.local`, `.env`, or `opro setup`.
 
 ## MCP Setup
 
@@ -39,5 +33,5 @@ If your Claude Code setup supports custom slash commands, map `/opro` to: call `
 ## Agent Prompt
 
 ```text
-Use OrangePro first. Call orangepro_start, then use orangepro_generate_tests for the returned PR or gap target. Write each runnable test to suggested_path, run run_command, and call prove_run with the result for public Proven. Use record_run only for static diagnostics. Do not treat drafts as runnable tests.
+Use OrangePro first. Call orangepro_start, then use orangepro_generate_tests for the returned PR or gap target. Write each runnable test to suggested_path, run run_command, and call `orangepro_prove` with the returned `prove_run` args for Dynamically Proven. Use record_run only for static diagnostics. Do not treat drafts as runnable tests.
 ```

package/docs/agents/codex.md

@@ -12,26 +12,9 @@ opro
 
 ## Codex Plugin
 
-When OrangePro is available in your configured Codex marketplace, install it like any other plugin:
+The public, supported path today is MCP setup through `opro agent --client codex` below. `codex plugin add orangepro` is only valid after OrangePro is listed in a Codex marketplace configured for your Codex install.
 
-```bash
-codex plugin add orangepro
-```
-
-Until OrangePro is accepted into a default marketplace, add this repo as a Codex marketplace and install from it:
-
-```bash
-codex plugin marketplace add OrangeproAI/orangepro-mcp --sparse .agents/plugins --sparse plugins/orangepro
-codex plugin add orangepro@orangepro
-```
-
-For maintainer-local development before npm publishing, install the personal marketplace plugin:
-
-```bash
-codex plugin add orangepro@personal
-```
-
-The plugin starts the `orangepro-local` MCP server. It does not pin an LLM model; OrangePro uses the provider/model configured in your environment, `.env.provider.local`, `.env.local`, `.env`, or `opro setup`.
+The bundled plugin metadata in this repo is for marketplace submission and maintainer validation. It starts the same `orangepro-local` MCP server and does not pin an LLM model; OrangePro uses the provider/model configured in your environment, `.env.provider.local`, `.env.local`, `.env`, or `opro setup`.
 
 ## MCP Setup
 
@@ -48,5 +31,5 @@ If your Codex build supports plugin/shortcut commands, map `$opro` (or `/opro`)
 ## Agent Prompt
 
 ```text
-Use OrangePro first. Call orangepro_start for this checkout, inspect the returned next_actions, then generate tests only through orangepro_generate_tests. Write only runnable tests with run_hints. After running them, call prove_run with the provided args for public Proven. Use record_run only for static diagnostics.
+Use OrangePro first. Call orangepro_start for this checkout, inspect the returned next_actions, then generate tests only through orangepro_generate_tests. Write only runnable tests with run_hints. After running them, call `orangepro_prove` with the returned `prove_run` args for Dynamically Proven. Use record_run only for static diagnostics.
 ```

package/docs/agents/cursor.md

@@ -35,5 +35,5 @@ If your Cursor setup supports custom commands, map `/opro` to: call `orangepro_s
 ## Agent Prompt
 
 ```text
-Use OrangePro first. Call orangepro_start in this repo, then follow its next_actions. Generate tests with orangepro_generate_tests, write only runnable outputs with run_hints, run the suggested command, and call prove_run after a passing run for public Proven. Use record_run only for static diagnostics.
+Use OrangePro first. Call orangepro_start in this repo, then follow its next_actions. Generate tests with orangepro_generate_tests, write only runnable outputs with run_hints, run the suggested command, and call `orangepro_prove` with the returned `prove_run` args after a passing run for Dynamically Proven. Use record_run only for static diagnostics.
 ```

package/docs/agents/opencode.md

@@ -39,5 +39,5 @@ If your OpenCode setup supports slash or dollar commands, map `/opro` or `$opro`
 ## Agent Prompt
 
 ```text
-Use OrangePro first. Call orangepro_start, generate tests only through orangepro_generate_tests, write runnable tests with run_hints, run the command, and call prove_run after a pass for public Proven. Use record_run only for static diagnostics. Report setup failures plainly.
+Use OrangePro first. Call orangepro_start, generate tests only through orangepro_generate_tests, write runnable tests with run_hints, run the command, and call `orangepro_prove` with the returned `prove_run` args after a pass for Dynamically Proven. Use record_run only for static diagnostics. Report setup failures plainly.
 ```

package/docs/agents/vscode.md

@@ -30,5 +30,5 @@ Do not hardcode provider keys in a committed workspace config. Prefer your shell
 ## Agent Prompt
 
 ```text
-Use OrangePro first. Call orangepro_start for this repo, then follow next_actions. Generate tests with orangepro_generate_tests, write only runnable outputs with run_hints, run the suggested command, and call prove_run after a pass for public Proven. Use record_run only for static diagnostics.
+Use OrangePro first. Call orangepro_start for this repo, then follow next_actions. Generate tests with orangepro_generate_tests, write only runnable outputs with run_hints, run the suggested command, and call `orangepro_prove` with the returned `prove_run` args after a pass for Dynamically Proven. Use record_run only for static diagnostics.
 ```

package/docs/local-proof-kit.md

@@ -47,7 +47,7 @@ source checkout. npm users can run the CLI commands below directly.
 ```bash
 opro                            # one-command start: analyze, optional AI weak links, graph, RTM, next actions
 opro init                       # create the .orangepro/ workspace
-opro analyze .                  # build the local evidence graph + write .orangepro/graph.html (scan-all by default)
+opro analyze .                  # build the local evidence graph + write .orangepro/behavior-coverage.html (scan-all by default)
 opro status                     # fresh / stale / missing + score + privacy
 opro doctor                     # smallest next source that improves test quality
 opro score                      # readiness score + breakdown + "why not higher"
@@ -62,7 +62,7 @@ opro explain <generated_test_id># which evidence anchors grounded a test
 opro update                     # incremental, non-destructive refresh
 opro changed --base main        # changed files + affected behaviors/tests
 opro export --out orangepro-evidence-pack.json
-opro analyze . --no-graph-html  # skip the explorer (it is written by default)
+opro analyze . --no-coverage-html # skip the behavior report HTML (it is written by default)
 opro export --format graph-html # write just the explorer (orangepro-graph.html)
 opro mcp                        # run the MCP server (stdio)
 ```
@@ -82,9 +82,11 @@ huge run), and it prints `files scanned: N` plus any cap that was hit.
 
 ### Evidence graph explorer
 
-`analyze` writes a **self-contained, offline** HTML explorer to `.orangepro/graph.html`
-**by default** (`--no-graph-html` to skip; or `export --format graph-html` for a
-standalone copy) — no CDN, no network, metadata-only (never source, bodies, or prompts).
+`analyze` writes a **self-contained, offline** behavior report to
+`.orangepro/behavior-coverage.html` **by default** (`--no-coverage-html` to skip). The
+graph explorer described below is written by `opro export --format graph-html`
+(standalone `orangepro-graph.html`) — no CDN, no network, metadata-only (never source,
+bodies, or prompts).
 It opens
 score-first, shows a *summarized* evidence layer (not a 3k-node hairball), and lets you
 search a symbol (e.g. `useScaledAmount`), click it, and see the connected files, tests,
@@ -112,6 +114,34 @@ offline, opt in explicitly with `--provider deterministic` (CLI) or
 `ORANGEPRO_ALLOW_DETERMINISTIC=1`, which uses a clearly-labeled deterministic stand-in.
 Static analysis, scoring, gaps, and pack export never need a model.
 
+### v5 batched generation (opt-in)
+
+The auto-prove generation lane (`opro start`, the `orangepro_start` MCP tool, and the PR
+diff path) defaults to the **v2** prompt strategy. Opt into the **v5** batched two-phase
+strategy (plan scenarios → batch-generate) with `--prompt-version v5` (CLI) or
+`prompt_version: "v5"` (MCP). The flag only changes **which** tests are drafted — a
+generated test is still marked Proven only when it genuinely kills the null-sentinel mutant
+via the **unchanged** dynamic-proof oracle. The default path is unchanged (no key required
+for v2/deterministic; existing behavior and CI are untouched).
+
+Exercise the live v5 loop against a tiny fixture with a keyed smoke:
+
+```bash
+# LIVE (requires a BYOK key — fails clearly, exit 2, if none is set):
+OPENAI_API_KEY=sk-... npm run smoke:generate-prove-v5
+# or ANTHROPIC_API_KEY=... / OLLAMA_BASE_URL=...
+
+# Offline plumbing check (flag accepted + start completes; generation lane is key-gated):
+node scripts/smoke-generate-prove-v5.mjs --fake
+```
+
+**CI note:** `smoke:generate-prove-v5` (LIVE) needs a real provider key and is intentionally
+NOT wired into the default CI. To add a keyed job, expose one of `OPENAI_API_KEY` /
+`ANTHROPIC_API_KEY` / `OLLAMA_BASE_URL` as a CI secret and run `npm run smoke:generate-prove-v5`.
+The end-to-end v5→Proven wiring is covered offline (no key) by
+`tests/local/autoProve.test.ts` ("v5 track wiring"), which drives the real v5 branch with a
+fake provider.
+
 ## Scenario buckets (generation diversity)
 
 `generate` is **target-focused**: it picks the top-gap behavior (or your `--target`)
@@ -152,7 +182,7 @@ config plus the write/run/report loop. The shipped guide is
 
 First-slice MCP tools (same behavior as the CLI, same core): `orangepro_start`, `orangepro_analyze_sources`,
 `orangepro_graph_score`, `orangepro_status`, `orangepro_doctor`, `orangepro_find_test_gaps`,
-`orangepro_record_run`, `orangepro_prove`, `orangepro_stats`, `orangepro_rtm`, `orangepro_update_graph`,
+`orangepro_record_run`, `orangepro_prove`, `orangepro_prove_loop`, `orangepro_stats`, `orangepro_rtm`, `orangepro_update_graph`,
 `orangepro_changed_impact`, `orangepro_ai_links`, `orangepro_ai_flows`, `orangepro_generate_tests`,
 `orangepro_explain_test`, `orangepro_export_evidence_pack`. **No upload or repo-write tools.**
 
@@ -164,7 +194,7 @@ Two explicit classes, so an agent never fabricates PR analysis when there is no
   current local graph/checkout and need **no diff or PR**: `orangepro_start`,
   `orangepro_analyze_sources`, `orangepro_status`, `orangepro_graph_score`,
   `orangepro_doctor`, `orangepro_find_test_gaps`, `orangepro_rtm`,
-  `orangepro_generate_tests`, `orangepro_record_run`, `orangepro_prove`, `orangepro_stats`,
+  `orangepro_generate_tests`, `orangepro_record_run`, `orangepro_prove`, `orangepro_prove_loop`, `orangepro_stats`,
   `orangepro_explain_test`, `orangepro_export_evidence_pack`.
 - **Diff/PR tools** — only for **real code-review situations**. They require a git repo
   and a real diff vs a base ref (default `main`). Today: `orangepro_changed_impact`
@@ -207,20 +237,23 @@ presentation labels over the same statuses above; they change no classification,
 LLM, similarity inference, and static hard TESTED_BY/COVERS edges are candidate or
 associated signals until a dynamic targeted proof closes.
 
-### Dynamic proof is TS/JS-only today (language-profiled)
+### Dynamic proof language profiles
+
+Dynamic targeted proof ships as per-ecosystem **profiles**, all passing the same trust
+gate (baseline green → targeted mutation → the same test fails at an assertion → target
+not mocked):
 
-Dynamic targeted proof currently runs for **TypeScript/JavaScript only** — the oracle drives
-`vitest`/`jest`, and only TS/JS files are eligible for a proof target. The static map is
-multi-language: **Java, Go, Rust, and Python monorepos still get the full static picture today**
-(behaviors, flows, Statically Linked, Reachable Untested, and any ingested runtime coverage).
+- **TypeScript/JavaScript** — vitest / jest / mocha, monorepo-aware (`tsconfig`
+  `extends`/`paths` workspaces).
+- **Go** — `go test`, scoped to the target's package.
+- **Java** — Maven / JUnit.
+- **Python** — pytest.
 
-Monorepo-aware dynamic proof is delivered as per-ecosystem **profiles**. The **`ts_js` profile**
-(handling `tsconfig` `extends`/`paths` monorepos) is the first and currently the only implemented
-profile — the M-1/M-2 sandboxing work improves TS/JS monorepo proof only. Dynamic proof for
-Java/Go/Rust/Python is future work: each needs its own test runner plus a workspace-config profile.
-Until a language's profile exists, dynamic proof does **not** pretend the TS/JS fixes apply — it
-reports "not supported for this language/ecosystem yet" or a precise `<lang>_workspace_config_missing`
-reason, and those behaviors simply stay in their static tiers.
+The static map is broader than the dynamic pass: languages without a proof profile yet
+(Kotlin, Rust, ...) still get the full static picture (behaviors, flows, Statically
+Linked, Reachable Untested, and any ingested runtime coverage). Where a language's
+profile cannot run, dynamic proof does not pretend — it reports a precise "not supported
+/ workspace config missing" reason and those behaviors stay in their static tiers.
 
 The local ledger is a trusted local artifact, not a cryptographic attestation. A
 hosted/product proof path must bind each dynamic certificate to witnessed run artifacts

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@orangepro/orangepro-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "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; no repo writes.",
+  "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",
-  "author": "OrangePro (OrangeproAI)",
+  "author": "OrangePro",
   "homepage": "https://github.com/OrangeproAI/orangepro-mcp#readme",
   "repository": {
     "type": "git",
@@ -30,6 +30,12 @@
     "scripts/spikes/dynamic-proof-vitest-reporter.mjs",
     "scripts/spikes/dynamic-proof-jest-reporter.cjs",
     "scripts/spikes/dynamic-proof-mocha-reporter.cjs",
+    "scripts/spikes/go-dynamic-proof-spike.mjs",
+    "scripts/spikes/go-mutate.go",
+    "scripts/spikes/java-dynamic-proof-spike.mjs",
+    "scripts/spikes/java-mutate.mjs",
+    "scripts/spikes/python-dynamic-proof-spike.mjs",
+    "scripts/spikes/python-mutate.py",
     "README.md",
     "LICENSE",
     "docs/agents",
@@ -48,15 +54,42 @@
     "dev": "tsx src/index.ts",
     "local": "tsx src/local/cli.ts",
     "start": "node dist/index.js",
-    "test": "npm run test:rest && npm run test:spike:core && npm run test:spike:mono",
-    "test:rest": "vitest run --exclude '**/dynamicProofSpike.test.ts'",
+    "test": "npm run test:rest && npm run test:spike:core && npm run test:spike:mono && npm run test:spike:go && npm run test:spike:java && npm run test:spike:python && npm run test:integration",
+    "test:rest": "vitest run --exclude '**/dynamicProofSpike.test.ts' --exclude '**/goDynamicProofSpike.test.ts' --exclude '**/javaDynamicProofSpike.test.ts' --exclude '**/pythonDynamicProofSpike.test.ts' --exclude '**/goProveIntegration.test.ts' --exclude '**/javaProveIntegration.test.ts' --exclude '**/autoProveGo.test.ts' --exclude '**/autoProveJava.test.ts'",
     "test:spike:core": "npm run test:spike:core:main && npm run test:spike:core:runner",
     "test:spike:core:main": "vitest run tests/local/dynamicProofSpike.test.ts -t \"^(?!.*(M-[123]|Mocha|free-function mutator)).*\" --pool=forks --poolOptions.forks.maxForks=1",
     "test:spike:core:runner": "vitest run tests/local/dynamicProofSpike.test.ts -t \"Mocha|free-function mutator\" --pool=forks --poolOptions.forks.maxForks=1",
-    "test:spike:mono": "vitest run tests/local/dynamicProofSpike.test.ts -t \"M-[123]\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:mono": "npm run test:spike:mono:base && npm run test:spike:mono:aspect",
+    "test:spike:mono:base": "vitest run tests/local/dynamicProofSpike.test.ts -t \"^(?!.*aspect).*M-[123]\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:mono:aspect": "vitest run tests/local/dynamicProofSpike.test.ts -t \"M-3 aspect\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:go": "npm run test:spike:go:1 && npm run test:spike:go:2 && npm run test:spike:go:3 && npm run test:spike:go:4",
+    "test:spike:go:1": "vitest run tests/local/goDynamicProofSpike.test.ts -t \"FIX 1|FIX 2\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:go:2": "vitest run tests/local/goDynamicProofSpike.test.ts -t \"^(?!.*Slice 2).*(does not|equivalent|ambiguous)\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:go:3": "vitest run tests/local/goDynamicProofSpike.test.ts -t \"^(?!.*(FIX 1|FIX 2|does not|equivalent|ambiguous|Slice 2))\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:go:4": "vitest run tests/local/goDynamicProofSpike.test.ts -t \"Slice 2\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:java": "npm run test:spike:java:proof && npm run test:spike:java:reject:compile && npm run test:spike:java:reject:runtime && npm run test:spike:java:reject:baseline && npm run test:spike:java:reject:shape",
+    "test:spike:java:proof": "vitest run tests/local/javaDynamicProofSpike.test.ts -t \"^(?!.*rejects).*\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:java:reject:compile": "vitest run tests/local/javaDynamicProofSpike.test.ts -t \"mutant compile failure\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:java:reject:runtime": "vitest run tests/local/javaDynamicProofSpike.test.ts -t \"runtime exception\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:java:reject:baseline": "vitest run tests/local/javaDynamicProofSpike.test.ts -t \"setup precondition|red baseline|manually-thrown\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:java:reject:shape": "vitest run tests/local/javaDynamicProofSpike.test.ts -t \"nested/multiple-return|type-variable\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:spike:python": "vitest run tests/local/pythonDynamicProofSpike.test.ts --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration": "npm run test:integration:go && npm run test:integration:java:1 && npm run test:integration:java:2 && npm run test:integration:java:3",
+    "test:integration:go": "npm run test:integration:go:mint && npm run test:integration:go:auto",
+    "test:integration:go:mint": "npm run test:integration:go:mint:fast && npm run test:integration:go:mint:positive && npm run test:integration:go:mint:survives && npm run test:integration:go:mint:loop",
+    "test:integration:go:mint:fast": "vitest run tests/local/goProveIntegration.test.ts -t \"^(?!.*(positive: a free-function|no-false-Proven|mints the same Proven)).*\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:go:mint:positive": "vitest run tests/local/goProveIntegration.test.ts -t \"positive: a free-function\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:go:mint:survives": "vitest run tests/local/goProveIntegration.test.ts -t \"no-false-Proven\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:go:mint:loop": "vitest run tests/local/goProveIntegration.test.ts -t \"mints the same Proven\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:go:auto": "vitest run tests/local/autoProveGo.test.ts --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:go:auto:slow": "OPRO_SLOW_GO_AUTO=1 vitest run tests/local/autoProveGo.test.ts --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:java:1": "vitest run tests/local/javaProveIntegration.test.ts -t \"^(?!.*(no-false-Proven|mints the same Proven)).*\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:java:2": "vitest run tests/local/javaProveIntegration.test.ts -t \"no-false-Proven|mints the same Proven\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:java:3": "vitest run tests/local/autoProveJava.test.ts --pool=forks --poolOptions.forks.maxForks=1",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "smoke:gap-fill": "npm run build && node scripts/smoke-gap-fill-loop.mjs",
     "smoke:generate-prove": "npm run build && node scripts/smoke-generate-prove-e2e.mjs",
+    "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",
     "prepublishOnly": "npm run build && npm test"
   },