riciplay 1.9.1 → 1.9.3

package/README.md

@@ -18,7 +18,7 @@ npm install -g riciplay
 pip install riciplay-cli
 ```
 
-Requires Python 3.10+ (installed automatically when possible). Chrome and mitmproxy integrations are pulled in as Python dependencies.
+Requires Node.js 18+ and an existing Python 3.12+ installation; this wrapper does not install Python itself. Chrome and proxy integrations are pulled in as Python dependencies. The 1.9.3 candidate uses `riciplay-mitmproxy==12.3.1.1` and MiniProxy 0.9.7+. It rejects coexistence with upstream `mitmproxy`, refuses automatic shared-package removal, and requires a fresh venv for migration. Publication remains held until the complete fork chain and public installation/audit gates pass.
 
 ## Usage
 
@@ -29,15 +29,32 @@ riciplay chat         # start an agent session
 
 ## The npm wrapper
 
-`bin/riciplay` resolves the pip-installed console script via `PATH` and falls back to invoking `riciplay_cli.main:app` through `python3`. It explicitly excludes its own path as a candidate, so an npm global install (which symlinks this wrapper onto `PATH`) can never re-exec itself.
+`bin/riciplay` resolves the pip-installed console script via `PATH` and falls back to invoking `riciplay_cli.main:app` through a detected Python 3.12+ interpreter. It explicitly excludes its own path as a candidate, so an npm global install (which symlinks this wrapper onto `PATH`) can never re-exec itself.
 
-`scripts/postinstall.js` pip-installs `riciplay-cli` **pinned to this launcher's exact version** (`riciplay-cli==<package.json version>`), and compares the *installed* version rather than merely checking that the module imports — so an out-of-date install is upgraded instead of being silently kept. It degrades to a printed manual command when it can't (no network, `--ignore-scripts`, managed Python).
+`scripts/postinstall.js` selects Python 3.12+ and runs that interpreter's `-m pip` to install `riciplay-cli` **pinned to this launcher's exact version** (`riciplay-cli==<package.json version>`). It checks the installed version both before and after installation, so an out-of-date install is upgraded instead of being silently kept. It degrades to a printed manual command when it can't (no network, `--ignore-scripts`, managed Python).
+
+Before dispatching user commands, both PATH-console and module-fallback routes
+require the exact CLI version, Python 3.12+, Tornado 6.6+, and
+`riciplay-mitmproxy==12.3.1.1` via a local metadata-only check. A stale PATH entry fails closed;
+it is not silently run after a failed installation. This is a version guard,
+not a substitute for the release dependency audit or a guarantee against a
+malicious executable placed on your PATH.
 
 ### The two versions are locked together
 
 The launcher and the Python package must be released at the same version, because postinstall pins the pair. That used to be an unenforced convention and it drifted (npm `1.8.95` against PyPI `1.8.96`). Three things now enforce it:
 
 - `npm test` / `npm publish` run `scripts/check-version-sync.js` — `prepublishOnly` **refuses to publish** a mismatched pair
+- `npm test`, CI, and `npm publish` execute the real launcher regression. Publish
+  also enforces the version-bound `release-readiness.json` hold and independently
+  fetches exact non-yanked PyPI metadata, resolves `riciplay-cli==<version>` in a
+  fresh Python 3.12 venv, rejects upstream/fork overlap, runs `pip check`, and
+  requires a strict zero-finding `pip-audit`. A mutable readiness file alone is
+  never release authorization. Release automation also supplies a new absolute
+  `RICIPLAY_PUBLIC_GATE_EVIDENCE` path; prepublish records public artifact hashes
+  there with create-only private permissions after all checks succeed. It also
+  requires `RICIPLAY_RELEASE_PYTHON` to be the absolute validated Python 3.12
+  interpreter, avoiding PATH-dependent release resolution.
 - `pytest tests/test_version_sync.py` fails the suite on drift, catching it at PR time
 - `python scripts/bump_version.py <version>` moves both files together, so the correct action is also the easy one (`--check` to verify, `--show` to inspect)
 

package/bin/riciplay

@@ -18,6 +18,9 @@ const { spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const { EOL } = require('os');
+const { minimumPython, resolvePython } = require('../scripts/python');
+const { checkRuntime } = require('../scripts/runtime');
+const npmVersion = require('../package.json').version;
 
 function realpathSafe(p) {
   try {
@@ -93,7 +96,7 @@ function fail(msg) {
 function run(cmd, argv) {
   const proc = spawn(cmd, argv, { stdio: 'inherit' });
   proc.on('error', (err) => fail(err.code === 'ENOENT'
-    ? 'python3 not found. Riciplay is a Python tool — install Python 3.10+ first.'
+    ? `Selected executable not found. Install Python ${minimumPython}+ and the matching riciplay-cli package.`
     : err.message));
   proc.on('close', (code) => process.exit(code ?? 1));
 }
@@ -102,17 +105,30 @@ function main(argv = process.argv.slice(2)) {
   // Prefer an installed console script (same PATH resolution the OS used).
   const candidate = resolveConsoleScript();
   if (candidate) {
+    if (!checkRuntime(candidate, [], npmVersion)) {
+      fail(`PATH riciplay is incompatible. Require riciplay-cli ${npmVersion}, Python ${minimumPython}+, Tornado 6.6+, and riciplay-mitmproxy 12.3.1.1 without upstream mitmproxy. Migrate to a fresh venv or remove the stale PATH entry.`);
+      return;
+    }
     run(candidate, argv);
     return;
   }
 
   // Module fallback — app() reads sys.argv; normalize argv[0] so usage
   // strings and version output match the real console script.
-  run('python3', [
+  const python = resolvePython();
+  if (!python) {
+    fail(`No supported Python found. Riciplay requires Python ${minimumPython}+.`);
+    return;
+  }
+  const prefix = [
     '-c',
     "import sys; sys.argv[0] = 'riciplay'; from riciplay_cli.main import app; app()",
-    ...argv,
-  ]);
+  ];
+  if (!checkRuntime(python, prefix, npmVersion)) {
+    fail(`Install matching riciplay-cli ${npmVersion} with its supported dependencies in the selected Python ${minimumPython}+ environment.`);
+    return;
+  }
+  run(python, [...prefix, ...argv]);
 }
 
 if (require.main === module) {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "riciplay",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "AI-powered bug bounty reconnaissance and penetration testing agent \u2014 browser, proxy interception, recon, and exploit workflows",
   "main": "index.js",
   "bin": {
     "riciplay": "./bin/riciplay"
   },
   "scripts": {
-    "test": "node scripts/check-version-sync.js",
-    "prepublishOnly": "node scripts/check-version-sync.js || (echo 'Refusing to publish: npm and PyPI versions disagree.' && exit 1)",
+    "test": "node scripts/check-version-sync.js && node tests/npm_launcher_test.js",
+    "prepublishOnly": "npm test && node scripts/check-publish-ready.js",
     "postinstall": "node scripts/postinstall.js"
   },
   "repository": {
@@ -33,7 +33,7 @@
   },
   "homepage": "https://github.com/Zaidux/Riciplay#readme",
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   },
   "os": [
     "darwin",
@@ -42,6 +42,13 @@
   "files": [
     "bin/",
     "scripts/postinstall.js",
+    "scripts/python.js",
+    "scripts/runtime.js",
+    "scripts/public-release-gate.js",
+    "tests/npm_launcher_test.js",
+    "scripts/check-publish-ready.js",
+    "scripts/check-version-sync.js",
+    "release-readiness.json",
     "README.md"
   ],
   "dependencies": {},

package/release-readiness.json

@@ -0,0 +1,5 @@
+{
+  "version": "1.9.3",
+  "blocked": false,
+  "reason": "Complete CLI/MiniProxy regressions, validated artifacts and installed smokes; exact public PyPI versions/hashes, fresh resolution and strict complete audit verified before npm publication."
+}

package/scripts/check-publish-ready.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// An explicit, version-bound release hold; builds/local packs remain allowed.
+const fs = require('fs');
+const path = require('path');
+const version = require('../package.json').version;
+const { verifyPublicRelease } = require('./public-release-gate');
+const readinessFile = path.resolve(__dirname, '..', 'release-readiness.json');
+
+function checkReadiness(file = readinessFile, target = version) {
+  try {
+    const state = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (state.version !== target || typeof state.blocked !== 'boolean' ||
+        typeof state.reason !== 'string' || !state.reason.trim()) {
+      return { ready: false, reason: 'Missing or mismatched release-readiness evidence.' };
+    }
+    return { ready: state.blocked === false, reason: state.reason };
+  } catch {
+    return { ready: false, reason: 'Missing or invalid release-readiness file.' };
+  }
+}
+
+async function main() {
+  const state = checkReadiness();
+  if (!state.ready) {
+    throw new Error(state.reason);
+  }
+  const evidenceFile = process.env.RICIPLAY_PUBLIC_GATE_EVIDENCE;
+  if (!evidenceFile || !path.isAbsolute(evidenceFile)) {
+    throw new Error('RICIPLAY_PUBLIC_GATE_EVIDENCE must name a new absolute private evidence file');
+  }
+  const verified = await verifyPublicRelease();
+  const { writeEvidence } = require('./public-release-gate');
+  await writeEvidence(evidenceFile, verified.metadata);
+  return true;
+}
+
+if (require.main === module) main().catch(error => {
+  console.error(`Refusing to publish riciplay ${version}: ${error.message}`);
+  process.exitCode = 1;
+});
+module.exports = { checkReadiness, main };

package/scripts/check-version-sync.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+// Release guard: refuse to publish when the npm launcher and the Python
+// package disagree on version.
+//
+// The npm package pins `riciplay-cli==<its own version>` in postinstall, so a
+// published pair with different versions either installs the wrong
+// implementation or fails outright. This ran as an unenforced convention once
+// already, and drifted (npm 1.8.95 vs PyPI 1.8.96).
+//
+// Run by `prepublishOnly` (so `npm publish` fails closed) and by the test
+// suite. Deliberately reads both files directly rather than importing the
+// Python helper: this must work with only node available.
+
+const fs = require('fs');
+const path = require('path');
+
+const NPM_DIR = path.resolve(__dirname, '..');
+const CLI_DIR = path.resolve(NPM_DIR, '..');
+const PYPROJECT = path.join(CLI_DIR, 'pyproject.toml');
+const NPM_PACKAGE = path.join(NPM_DIR, 'package.json');
+
+/**
+ * First bare `version = "x.y.z"` in pyproject.toml — the [project] version.
+ * Dependency pins never start a line, so the first match is the package's.
+ */
+function readPyprojectVersion(file = PYPROJECT) {
+  const text = fs.readFileSync(file, 'utf8');
+  const m = text.match(/^version\s*=\s*"([^"]+)"/m);
+  if (!m) throw new Error(`no version found in ${file}`);
+  return m[1];
+}
+
+function readNpmVersion(file = NPM_PACKAGE) {
+  return JSON.parse(fs.readFileSync(file, 'utf8')).version;
+}
+
+function compareVersions(pythonFile = process.env.RICIPLAY_RELEASE_PYPROJECT || PYPROJECT,
+                         npmFile = NPM_PACKAGE) {
+  const py = readPyprojectVersion(pythonFile);
+  const npm = readNpmVersion(npmFile);
+  return { py, npm, match: py === npm };
+}
+
+function main() {
+  const { py, npm, match } = compareVersions();
+  if (match) {
+    console.log(`✓ version sync OK: riciplay-cli ${py} == npm riciplay ${npm}`);
+    return 0;
+  }
+  console.error(
+    `error: version mismatch — pyproject.toml=${py} npm/package.json=${npm}\n` +
+    '       The npm launcher pins riciplay-cli==<its own version>, so these\n' +
+    '       must match. Fix with: python scripts/bump_version.py <version>'
+  );
+  return 1;
+}
+
+if (require.main === module) {
+  process.exit(main());
+}
+
+module.exports = { readPyprojectVersion, readNpmVersion, compareVersions, main };

package/scripts/postinstall.js

@@ -18,15 +18,16 @@
 // --ignore-scripts, without network, or managing Python manually — print the
 // manual command instead of failing the install.
 
-const { execSync, spawnSync } = require('child_process');
+const { spawnSync } = require('child_process');
 const os = require('os');
 const path = require('path');
+const { minimumPython, resolvePython } = require('./python');
+const { upstreamAbsent, checkRuntime } = require('./runtime');
 
 const npmVersion = require(path.join(__dirname, '..', 'package.json')).version;
 
 const isWin = os.platform() === 'win32';
 const python = isWin ? 'python' : 'python3';
-const pip = isWin ? 'pip' : 'pip3';
 
 /**
  * The version of `riciplay_cli` importable right now, or null if it is not
@@ -55,17 +56,38 @@ function pipSpec(target = npmVersion) {
   return `riciplay-cli==${target}`;
 }
 
-function main() {
+function quotePython(command, platform = process.platform) {
+  return platform === 'win32'
+    ? `"${command.replace(/"/g, '""')}"`
+    : `'${command.replace(/'/g, "'\\''")}'`;
+}
+
+function main({ run = spawnSync } = {}) {
   console.log('\n🕷️  Installing Riciplay (bug bounty AI agent)...\n');
 
+  const selectedPython = resolvePython({ run });
+  if (!selectedPython) {
+    console.warn(
+      `⚠ Riciplay needs Python ${minimumPython}+. Install it first, then run:\n` +
+      `    python3.12 -m pip install ${pipSpec()}\n`
+    );
+    return;
+  }
+
   let current = null;
   try {
-    current = installedVersion();
+    current = installedVersion(selectedPython, run);
   } catch {
     current = null; // treated as "not installed" below
   }
 
-  if (!needsInstall(current)) {
+  // Shared files cannot be safely repaired by uninstalling one distribution.
+  // Refuse mutation and leave captures/credentials/old environments untouched.
+  if (!upstreamAbsent(selectedPython, run)) {
+    console.warn('⚠ Upstream mitmproxy is installed or could not be checked. Riciplay 1.9.3 requires a fresh Python 3.12+ venv without upstream mitmproxy. No packages were removed. See cli/README.md.');
+    return;
+  }
+  if (!needsInstall(current) && checkRuntime(selectedPython, ['-m', 'riciplay_cli.main'], npmVersion, run)) {
     console.log(`✓ riciplay-cli ${npmVersion} already installed.`);
   } else {
     if (current) {
@@ -80,13 +102,24 @@ function main() {
       );
     }
     try {
-      execSync(`${pip} install --upgrade ${pipSpec()}`, { stdio: 'inherit' });
+      const result = run(selectedPython, ['-m', 'pip', 'install', '--upgrade', pipSpec()], {
+        stdio: 'inherit',
+      });
+      if (result.error || result.status !== 0) {
+        throw new Error('pip installation failed');
+      }
+      if (needsInstall(installedVersion(selectedPython, run))) {
+        throw new Error('the matching CLI version is still not importable');
+      }
+      if (!checkRuntime(selectedPython, ['-m', 'riciplay_cli.main'], npmVersion, run)) {
+        throw new Error('proxy distribution/version/overlap verification failed');
+      }
       console.log(`✓ Installed riciplay-cli ${npmVersion}.`);
     } catch (err) {
       console.warn(
         `\n⚠ Could not install the Python package automatically (${err.message}).\n` +
-        '  Riciplay needs Python 3.10+. Install the matching version manually with:\n' +
-        `    pip install ${pipSpec()}\n`
+        `  Riciplay needs Python ${minimumPython}+. Install the matching version manually with:\n` +
+        `    ${quotePython(selectedPython)} -m pip install ${pipSpec()}\n`
       );
     }
   }
@@ -98,4 +131,4 @@ if (require.main === module) {
   main();
 }
 
-module.exports = { npmVersion, installedVersion, needsInstall, pipSpec, main };
+module.exports = { npmVersion, installedVersion, needsInstall, pipSpec, quotePython, main };

package/scripts/public-release-gate.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+/* Fail-closed public dependency metadata, resolution and vulnerability audit. */
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const required = Object.freeze({
+  'riciplay-cli': require('../package.json').version,
+  'riciplay-miniproxy': '0.9.7',
+  'riciplay-mitmproxy': '12.3.1.1',
+});
+
+async function publicMetadata(name, version, fetcher = fetch) {
+  const response = await fetcher(`https://pypi.org/pypi/${name}/${version}/json`, {
+    headers: { accept: 'application/json' }, signal: AbortSignal.timeout(20000),
+  });
+  if (!response.ok) throw new Error(`${name} ${version} is not publicly available (HTTP ${response.status})`);
+  const data = await response.json();
+  if (data.info.version !== version || !Array.isArray(data.urls) || !data.urls.some(item => item.yanked === false)) {
+    throw new Error(`${name} ${version} has no public non-yanked artifact`);
+  }
+  return data;
+}
+
+async function releaseHashes(name, version, fetcher = fetch) {
+  const metadata = await publicMetadata(name, version, fetcher);
+  const artifacts = metadata.urls.map(item => ({ filename: item.filename, sha256: item.digests && item.digests.sha256 }))
+    .filter(item => item.filename && /^[a-f0-9]{64}$/.test(item.sha256 || ''));
+  if (!artifacts.length) throw new Error(`${name} ${version} has no public SHA-256 artifact hashes`);
+  return artifacts;
+}
+
+function exactRequirement(requirements, name, version) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return requirements.some(value => new RegExp(`^${escaped}\\s*==\\s*${version}(?:\\s*;.*)?$`, 'i').test(value));
+}
+
+function hasRangeRequirement(requirements, name, minimum, maximum) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return requirements.some(value => {
+    const match = String(value).match(new RegExp(`^${escaped}\\s*(?:\\(([^)]*)\\)|([^;]*))(?:;.*)?$`, 'i'));
+    const spec = match && (match[1] || match[2] || '');
+    return Boolean(spec && new RegExp(`(?:^|,)\\s*>=\\s*${minimum}(?:\\s*,|$)`).test(spec) &&
+      new RegExp(`(?:^|,)\\s*<\\s*${maximum}(?:\\s*,|$)`).test(spec));
+  });
+}
+
+function hasCompatibleTornado(requirements) {
+  return requirements.some(value => {
+    const match = String(value).match(/^tornado\s*(?:\(([^)]*)\)|([^;]*))(?:;.*)?$/i);
+    const spec = match && (match[1] || match[2] || '');
+    return Boolean(spec && /(?:^|,)\s*>=\s*6\.6(?:\s*,|$)/.test(spec) &&
+      (/(?:^|,)\s*<\s*7(?:\.0*)?(?:\s*,|$)/.test(spec) ||
+       /(?:^|,)\s*<=\s*6\.6(?:\.0*)?(?:\s*,|$)/.test(spec) ||
+       /(?:^|,)\s*==\s*6\.6(?:\.0*)?(?:\s*,|$)/.test(spec)));
+  });
+}
+
+function runChecked(run, command, args, options) {
+  const result = run(command, args, options);
+  if (result.error || result.status !== 0) throw new Error(`${command} ${args.join(' ')} failed`);
+}
+
+async function verifyPublicRelease({ fetcher = fetch, run = spawnSync, tempRoot = os.tmpdir(), metadata = null } = {}) {
+  const [cli, mini, fork] = metadata || await Promise.all(Object.entries(required).map(([name, version]) => publicMetadata(name, version, fetcher)));
+  const cliReq = cli.info.requires_dist || [];
+  const miniReq = mini.info.requires_dist || [];
+  if (!exactRequirement(cliReq, 'riciplay-mitmproxy', required['riciplay-mitmproxy']) ||
+      !hasRangeRequirement(cliReq, 'riciplay-miniproxy', '0\\.9\\.7', '2')) {
+    throw new Error('Public CLI metadata does not require the validated dependency releases');
+  }
+  if (!exactRequirement(miniReq, 'riciplay-mitmproxy', required['riciplay-mitmproxy'])) {
+    throw new Error('Public MiniProxy metadata does not require the validated fork');
+  }
+  if ((fork.info.requires_dist || []).some(value => /^mitmproxy\b/i.test(value))) {
+    throw new Error('Fork metadata overlaps the upstream mitmproxy distribution');
+  }
+  if (!hasCompatibleTornado(fork.info.requires_dist || [])) {
+    throw new Error('Public fork metadata does not enforce Tornado 6.6 compatibility');
+  }
+
+  const directory = fs.mkdtempSync(path.join(tempRoot, 'riciplay-public-gate-'));
+  try {
+    const python = process.env.RICIPLAY_RELEASE_PYTHON;
+    if (!python || !path.isAbsolute(python)) {
+      throw new Error('RICIPLAY_RELEASE_PYTHON must be the absolute validated Python 3.12 interpreter');
+    }
+    const venv = path.join(directory, 'venv');
+    runChecked(run, python, ['-m', 'venv', venv], { stdio: 'inherit', timeout: 120000 });
+    const py = path.join(venv, process.platform === 'win32' ? 'Scripts/python.exe' : 'bin/python');
+    runChecked(run, py, ['-m', 'pip', 'install', '--upgrade', 'pip', 'pip-audit'], { stdio: 'inherit', timeout: 300000 });
+    runChecked(run, py, ['-m', 'pip', 'install', '--only-binary=:all:', '--no-cache-dir', '--force-reinstall',
+      `riciplay-cli==${required['riciplay-cli']}`], { stdio: 'inherit', timeout: 600000 });
+    runChecked(run, py, ['-m', 'pip', 'check'], { stdio: 'inherit', timeout: 120000 });
+    runChecked(run, py, ['-c', [
+      'from importlib import metadata',
+      `expected=${JSON.stringify(required)}`,
+      'assert all(metadata.version(name)==version for name,version in expected.items())',
+      'try:',
+      '    metadata.version("mitmproxy")',
+      'except metadata.PackageNotFoundError:',
+      '    pass',
+      'else:',
+      '    raise SystemExit("upstream mitmproxy overlap")',
+    ].join('\n')], { stdio: 'inherit', timeout: 120000 });
+    runChecked(run, py, ['-m', 'pip_audit', '--strict', '--progress-spinner', 'off'], { stdio: 'inherit', timeout: 300000 });
+  } finally {
+    fs.rmSync(directory, { recursive: true, force: true });
+  }
+  return { metadata: [cli, mini, fork] };
+}
+
+async function writeEvidence(file, metadata) {
+  const releases = {};
+  let index = 0;
+  for (const [name, version] of Object.entries(required)) {
+    const artifacts = metadata[index++].urls.map(item => ({ filename: item.filename, sha256: item.digests && item.digests.sha256 }))
+      .filter(item => item.filename && /^[a-f0-9]{64}$/.test(item.sha256 || ''));
+    if (!artifacts.length) throw new Error(`${name} ${version} has no public SHA-256 artifact hashes`);
+    releases[name] = { version, artifacts };
+  }
+  const evidence = { schema: 1, created_at: new Date().toISOString(), releases };
+  fs.writeFileSync(file, JSON.stringify(evidence, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+  return evidence;
+}
+
+if (require.main === module) verifyPublicRelease().catch(error => {
+  console.error(`Public release gate failed: ${error.message}`);
+  process.exitCode = 1;
+});
+module.exports = { required, publicMetadata, releaseHashes, writeEvidence, exactRequirement,
+  hasRangeRequirement, hasCompatibleTornado, verifyPublicRelease };

package/scripts/python.js

@@ -0,0 +1,27 @@
+// Share interpreter selection between postinstall and the module fallback.
+// Prefer the active venv's generic command; skip Python <3.12 rather than
+// installing into an unrelated pip or running an unsupported interpreter.
+const { spawnSync } = require('child_process');
+
+const minimumPython = '3.12';
+const probe =
+  "import sys; sys.exit(1) if sys.version_info < (3, 12) or sys.version_info.major != 3 else None; print(sys.executable)";
+
+function resolvePython({ platform = process.platform, run = spawnSync } = {}) {
+  const candidates = platform === 'win32'
+    ? ['python', 'python3', 'python3.12', 'python3.13', 'python3.14', 'python3.15']
+    : ['python3', 'python3.12', 'python3.13', 'python3.14', 'python3.15', 'python'];
+  for (const command of candidates) {
+    try {
+      const result = run(command, ['-c', probe], { encoding: 'utf8', timeout: 10000 });
+      if (result.status === 0 && result.stdout && String(result.stdout).trim()) {
+        return String(result.stdout).trim();
+      }
+    } catch {
+      // Missing/broken interpreter: try the next candidate.
+    }
+  }
+  return null;
+}
+
+module.exports = { minimumPython, resolvePython };

package/scripts/runtime.js

@@ -0,0 +1,39 @@
+const { spawnSync } = require('child_process');
+
+function runtimeReady(info, target) {
+  if (!info || info.cli_version !== target) return false;
+  const python = info.python_version;
+  if (!Array.isArray(python) || python.length !== 3 ||
+      !python.every(n => Number.isSafeInteger(n) && n >= 0) ||
+      python[0] !== 3 || python[1] < 12) return false;
+  // The same Python process evaluates the declared floors with packaging's
+  // PEP 440 semantics. Do not substitute a JavaScript semver parser: valid
+  // post/local releases are not npm semver, and prereleases must stay rejected.
+  return typeof info.tornado_version === 'string' &&
+    typeof info.mitmproxy_version === 'string' &&
+    info.proxy_distribution === 'riciplay-mitmproxy' &&
+    info.upstream_mitmproxy_version === null &&
+    info.proxy_dependencies_supported === true;
+}
+
+function upstreamAbsent(python, run = spawnSync) {
+  try {
+    const result = run(python, ['-c',
+      'from importlib.metadata import version,PackageNotFoundError\ntry: version("mitmproxy")\nexcept PackageNotFoundError: raise SystemExit(0)\nraise SystemExit(1)'],
+      { encoding: 'utf8', timeout: 10000, maxBuffer: 65536 });
+    return result.status === 0;
+  } catch { return false; }
+}
+
+function checkRuntime(command, prefix, target, run = spawnSync) {
+  try {
+    const result = run(command, [...prefix, 'launcher-info'], {
+      encoding: 'utf8', timeout: 20000, maxBuffer: 65536,
+    });
+    return result.status === 0 && runtimeReady(JSON.parse(result.stdout), target);
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { runtimeReady, checkRuntime, upstreamAbsent };

package/tests/npm_launcher_test.js

@@ -0,0 +1,462 @@
+#!/usr/bin/env node
+// Regression test for npm/bin/riciplay launcher path resolution.
+//
+// Fails on the pre-fix launcher (a hardcoded /usr/local/bin, /usr/bin,
+// ~/.local/bin scan that matched the npm wrapper's own symlink → infinite
+// recursion, and that ignored a venv/pipx console script → wrong interpreter)
+// and passes once resolution goes through PATH while explicitly skipping the
+// wrapper's own file.
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const REPO_CLI = path.resolve(__dirname, '..', '..');
+const WRAPPER = path.join(REPO_CLI, 'npm', 'bin', 'riciplay');
+
+let failures = 0;
+function test(name, fn) {
+  try {
+    const result = fn();
+    if (result && typeof result.then === 'function') {
+      throw new Error('async tests must use testAsync');
+    }
+    console.log(`ok   - ${name}`);
+  } catch (err) {
+    failures += 1;
+    console.error(`FAIL - ${name}`);
+    console.error(`       ${err && err.message}`);
+  }
+}
+
+const pending = [];
+function testAsync(name, fn) {
+  pending.push(Promise.resolve().then(fn).then(
+    () => console.log(`ok   - ${name}`),
+    err => { failures += 1; console.error(`FAIL - ${name}`); console.error(`       ${err && err.message}`); },
+  ));
+}
+
+function tmpdir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'riciplay-launcher-'));
+}
+
+function writeFakeConsoleScript(dir) {
+  const target = path.join(dir, 'riciplay');
+  const info = JSON.stringify(safeRuntime());
+  fs.writeFileSync(target, `#!/bin/sh\nif [ "$1" = "launcher-info" ]; then\n  echo '${info}'\nelse\n  echo RICIPLAY_FAKE_CONSOLE_SCRIPT "$@"\nfi\n`);
+  fs.chmodSync(target, 0o755);
+  return target;
+}
+
+const launcher = require(WRAPPER);
+const { resolvePython, minimumPython } = require('../scripts/python');
+const postinstall = require('../scripts/postinstall');
+const { runtimeReady, checkRuntime } = require('../scripts/runtime');
+const { checkReadiness } = require('../scripts/check-publish-ready');
+const publicGate = require('../scripts/public-release-gate');
+assert.strictEqual(typeof launcher.resolveConsoleScript, 'function');
+
+function safeRuntime(overrides = {}) {
+  return {
+    cli_version: postinstall.npmVersion, python_version: [3, 12, 3],
+    tornado_version: '6.6', mitmproxy_version: '12.3.1.1',
+    proxy_distribution: 'riciplay-mitmproxy', upstream_mitmproxy_version: null,
+    proxy_dependencies_supported: true, ...overrides,
+  };
+}
+
+test('runtime gate requires exact CLI, supported Python and both dependency floors', () => {
+  assert.strictEqual(runtimeReady(safeRuntime(), postinstall.npmVersion), true);
+  for (const info of [
+    null, {}, safeRuntime({ cli_version: '1.9.2' }),
+    safeRuntime({ python_version: [3, 11, 9] }), safeRuntime({ python_version: [4, 0, 0] }),
+    safeRuntime({ python_version: ['3', 12, 3] }),
+    safeRuntime({ proxy_dependencies_supported: false }),
+    safeRuntime({ proxy_dependencies_supported: undefined }),
+    safeRuntime({ proxy_dependencies_supported: 'true' }),
+    safeRuntime({ tornado_version: null }), safeRuntime({ mitmproxy_version: null }),
+    safeRuntime({ proxy_distribution: 'mitmproxy' }), safeRuntime({ upstream_mitmproxy_version: '12.3.1' }),
+  ]) assert.strictEqual(runtimeReady(info, postinstall.npmVersion), false, JSON.stringify(info));
+  assert.strictEqual(runtimeReady(safeRuntime({
+    tornado_version: '6.6.post1', mitmproxy_version: '12.3.1.1+local',
+  }), postinstall.npmVersion), true);
+});
+
+test('runtime probe fails closed on old commands, malformed output and timeouts', () => {
+  for (const run of [
+    () => ({ status: 1, stdout: JSON.stringify(safeRuntime()) }),
+    () => ({ status: 0, stdout: 'riciplay-cli 1.9.2' }),
+    () => { throw new Error('timed out'); },
+  ]) assert.strictEqual(checkRuntime('/candidate', [], postinstall.npmVersion, run), false);
+  assert.strictEqual(checkRuntime('/candidate', [], postinstall.npmVersion, (cmd, argv, options) => {
+    assert.deepStrictEqual(argv, ['launcher-info']);
+    assert.strictEqual(options.timeout, 20000);
+    return { status: 0, stdout: JSON.stringify(safeRuntime()) };
+  }), true);
+});
+
+test('recovery command safely quotes the selected POSIX interpreter', () => {
+  const python = "/venv with 'quotes' and $(false)/python";
+  const result = spawnSync('/bin/sh', ['-c', `printf '%s' ${postinstall.quotePython(python, 'linux')}`], {
+    encoding: 'utf8', timeout: 10000,
+  });
+  assert.strictEqual(result.status, 0, result.stderr);
+  assert.strictEqual(result.stdout, python);
+});
+
+test('publish hold rejects missing, malformed, mismatched, and blocked states', () => {
+  const root = tmpdir();
+  const file = path.join(root, 'readiness.json');
+  assert.strictEqual(checkReadiness(file).ready, false);
+  fs.writeFileSync(file, '{');
+  assert.strictEqual(checkReadiness(file).ready, false);
+  for (const state of [
+    { version: '0.0.1', blocked: false, reason: 'verified' },
+    { version: postinstall.npmVersion, blocked: true, reason: 'dependency hold' },
+    { version: postinstall.npmVersion, blocked: 'false', reason: 'invalid' },
+    { version: postinstall.npmVersion, blocked: false },
+  ]) {
+    fs.writeFileSync(file, JSON.stringify(state));
+    assert.strictEqual(checkReadiness(file).ready, false);
+  }
+  fs.writeFileSync(file, JSON.stringify({ version: postinstall.npmVersion, blocked: false, reason: 'verified gates' }));
+  assert.strictEqual(checkReadiness(file).ready, true);
+});
+
+testAsync('public release gate requires exact non-yanked dependency metadata', async () => {
+  const records = {
+    'riciplay-cli': { requires_dist: ['riciplay-miniproxy>=0.9.7,<2', 'riciplay-mitmproxy==12.3.1.1'] },
+    'riciplay-miniproxy': { requires_dist: ['riciplay-mitmproxy==12.3.1.1'] },
+    'riciplay-mitmproxy': { requires_dist: ['tornado>=6.6,<7'] },
+  };
+  for (const [name, version] of Object.entries(publicGate.required)) {
+    const data = await publicGate.publicMetadata(name, version, async url => ({
+      ok: true, status: 200, json: async () => ({ info: { version, ...records[name] },
+        urls: [{ yanked: false, filename: `${name}.whl`, digests: { sha256: 'a'.repeat(64) } }] }),
+    }));
+    assert.strictEqual(data.info.version, version);
+  }
+  assert.strictEqual(publicGate.exactRequirement(records['riciplay-cli'].requires_dist, 'riciplay-mitmproxy', '12.3.1.1'), true);
+  assert.strictEqual((await publicGate.releaseHashes('riciplay-cli', '1.9.3', async () => ({
+    ok: true, status: 200, json: async () => ({ info: { version: '1.9.3' },
+      urls: [{ yanked: false, filename: 'cli.whl', digests: { sha256: 'b'.repeat(64) } }] }),
+  })))[0].sha256, 'b'.repeat(64));
+  assert.strictEqual(publicGate.hasRangeRequirement(records['riciplay-cli'].requires_dist, 'riciplay-miniproxy', '0\\.9\\.7', '2'), true);
+  assert.strictEqual(publicGate.hasCompatibleTornado(['tornado<=6.6,>=6.6']), true);
+  assert.strictEqual(publicGate.hasCompatibleTornado(['tornado>=6.5,<7']), false);
+  assert.strictEqual(publicGate.exactRequirement(['riciplay-mitmproxy>=12.3.1'], 'riciplay-mitmproxy', '12.3.1.1'), false);
+  await assert.rejects(() => publicGate.publicMetadata('riciplay-cli', '1.9.3', async () => ({
+    ok: true, status: 200, json: async () => ({ info: { version: '1.9.3' }, urls: [{ yanked: true }] }),
+  })), /non-yanked/);
+});
+
+testAsync('public gate force-reinstalls exact public CLI and audits the resolved environment', async () => {
+  const metadata = Object.entries(publicGate.required).map(([name, version]) => ({
+    info: { version, requires_dist: name === 'riciplay-cli'
+      ? ['riciplay-miniproxy>=0.9.7,<2', 'riciplay-mitmproxy==12.3.1.1']
+      : name === 'riciplay-miniproxy' ? ['riciplay-mitmproxy==12.3.1.1'] : ['tornado>=6.6,<7'] },
+    urls: [{ yanked: false, filename: `${name}.whl`, digests: { sha256: 'c'.repeat(64) } }],
+  }));
+  const calls = [];
+  const run = (command, args) => {
+    calls.push([command, args]);
+    if (args[1] === 'venv') {
+      const py = path.join(args[2], process.platform === 'win32' ? 'Scripts/python.exe' : 'bin/python');
+      fs.mkdirSync(path.dirname(py), { recursive: true });
+      fs.writeFileSync(py, '');
+    }
+    return { status: 0 };
+  };
+  const previousPython = process.env.RICIPLAY_RELEASE_PYTHON;
+  process.env.RICIPLAY_RELEASE_PYTHON = process.platform === 'win32'
+    ? 'C:\\Python312\\python.exe' : '/usr/bin/python3.12';
+  try {
+    await publicGate.verifyPublicRelease({ metadata, run, tempRoot: tmpdir() });
+  } finally {
+    if (previousPython === undefined) delete process.env.RICIPLAY_RELEASE_PYTHON;
+    else process.env.RICIPLAY_RELEASE_PYTHON = previousPython;
+  }
+  const install = calls.find(([, args]) => args.includes('riciplay-cli==1.9.3'))[1];
+  assert(install.includes('--only-binary=:all:') && install.includes('--force-reinstall'));
+  assert(calls.some(([, args]) => args.includes('check')));
+  assert(calls.some(([, args]) => args.includes('pip_audit') && args.includes('--strict')));
+});
+
+testAsync('public gate rejects PATH-relative release interpreters before running commands', async () => {
+  const previous = process.env.RICIPLAY_RELEASE_PYTHON;
+  process.env.RICIPLAY_RELEASE_PYTHON = 'python3.12';
+  const metadata = [
+    { info: { requires_dist: ['riciplay-miniproxy>=0.9.7,<2', 'riciplay-mitmproxy==12.3.1.1'] }, urls: [] },
+    { info: { requires_dist: ['riciplay-mitmproxy==12.3.1.1'] }, urls: [] },
+    { info: { requires_dist: ['tornado>=6.6,<7'] }, urls: [] },
+  ];
+  try {
+    await assert.rejects(() => publicGate.verifyPublicRelease({ metadata,
+      run: () => { throw new Error('must not run'); } }),
+      /absolute validated Python/);
+  } finally {
+    if (previous === undefined) delete process.env.RICIPLAY_RELEASE_PYTHON;
+    else process.env.RICIPLAY_RELEASE_PYTHON = previous;
+  }
+});
+
+test('Python selection preserves a supported active venv', () => {
+  const calls = [];
+  const python = resolvePython({ platform: 'linux', run: (cmd, argv, options) => {
+    calls.push(cmd);
+    assert.match(argv[1], /sys.version_info < \(3, 12\)/);
+    assert.match(argv[1], /sys.version_info.major != 3/);
+    assert.strictEqual(options.timeout, 10000);
+    return { status: 0, stdout: '/active venv/bin/python\n' };
+  } });
+  assert.strictEqual(python, '/active venv/bin/python');
+  assert.deepStrictEqual(calls, ['python3']);
+  assert.strictEqual(minimumPython, '3.12');
+});
+
+test('Python selection skips an unsupported generic Python', () => {
+  const calls = [];
+  const python = resolvePython({ platform: 'linux', run: (cmd) => {
+    calls.push(cmd);
+    return cmd === 'python3.12'
+      ? { status: 0, stdout: '/python312/bin/python\n' }
+      : { status: 1, stdout: '' };
+  } });
+  assert.strictEqual(python, '/python312/bin/python');
+  assert.deepStrictEqual(calls, ['python3', 'python3.12']);
+});
+
+test('Python selection fails closed for missing, broken, or empty probes', () => {
+  assert.strictEqual(resolvePython({ run: () => ({ status: 1 }) }), null);
+  assert.strictEqual(resolvePython({ run: () => ({ status: 0, stdout: '  \n' }) }), null);
+  assert.strictEqual(resolvePython({ run: () => { throw new Error('not found'); } }), null);
+});
+
+test('Windows Python selection probes python first', () => {
+  const calls = [];
+  assert.strictEqual(resolvePython({ platform: 'win32', run: (cmd) => {
+    calls.push(cmd);
+    return { status: 0, stdout: 'C:\\Python312\\python.exe\n' };
+  } }), 'C:\\Python312\\python.exe');
+  assert.deepStrictEqual(calls, ['python']);
+});
+
+function capturePostinstall(run) {
+  const logs = [], warnings = [];
+  const log = console.log, warn = console.warn;
+  try {
+    console.log = (...args) => logs.push(args.join(' '));
+    console.warn = (...args) => warnings.push(args.join(' '));
+    postinstall.main({ run });
+  } finally {
+    console.log = log;
+    console.warn = warn;
+  }
+  return { logs: logs.join('\n'), warnings: warnings.join('\n') };
+}
+
+test('postinstall uses the selected interpreter pip and verifies the exact version', () => {
+  const calls = [];
+  let installed = false;
+  const output = capturePostinstall((cmd, argv) => {
+    calls.push([cmd, argv]);
+    if (argv[0] === '-c' && argv[1].includes('sys.version_info')) {
+      return { status: 0, stdout: '/venv with spaces/bin/python\n' };
+    }
+    assert.strictEqual(cmd, '/venv with spaces/bin/python');
+    if (argv[0] === '-c' && argv[1].includes('PackageNotFoundError')) return { status: 0 };
+    if (argv[0] === '-m') {
+      if (argv[1] === 'riciplay_cli.main') return { status: 0, stdout: JSON.stringify(safeRuntime()) };
+      assert.deepStrictEqual(argv, ['-m', 'pip', 'install', '--upgrade', postinstall.pipSpec()]);
+      installed = true;
+      return { status: 0 };
+    }
+    return installed
+      ? { status: 0, stdout: `${postinstall.npmVersion}\n` }
+      : { status: 1 };
+  });
+  assert.strictEqual(calls.length, 6); // Python, version, overlap, install, version, runtime
+  assert.match(output.logs, /✓ Installed riciplay-cli/);
+  assert.strictEqual(output.warnings, '');
+});
+
+test('postinstall never invokes pip without a supported Python', () => {
+  const output = capturePostinstall((cmd, argv) => {
+    assert.strictEqual(argv[0], '-c');
+    return { status: 1 };
+  });
+  assert.match(output.warnings, /needs Python 3\.12\+/);
+  assert.doesNotMatch(output.logs, /✓ Installed/);
+});
+
+test('postinstall rejects pip failure and a successful install with stale readback', () => {
+  for (const pipStatus of [0, 1]) {
+    const output = capturePostinstall((cmd, argv) => {
+      if (argv[0] === '-c' && argv[1].includes('sys.version_info')) {
+        return { status: 0, stdout: '/venv/bin/python\n' };
+      }
+      if (argv[0] === '-c' && argv[1].includes('PackageNotFoundError')) return { status: 0 };
+      if (argv[0] === '-m') return { status: pipStatus };
+      return { status: 0, stdout: '0.0.1\n' };
+    });
+    assert.match(output.warnings, /Could not install/);
+    assert.match(output.warnings, /'\/venv\/bin\/python' -m pip install/);
+    assert.doesNotMatch(output.logs, /✓ Installed/);
+  }
+});
+
+test('postinstall keeps the exact already-installed version without invoking pip', () => {
+  const output = capturePostinstall((cmd, argv) => {
+    if (argv[0] === '-m') {
+      assert.strictEqual(argv[1], 'riciplay_cli.main');
+      return { status: 0, stdout: JSON.stringify(safeRuntime()) };
+    }
+    assert.strictEqual(argv[0], '-c');
+    return {
+      status: 0,
+      stdout: argv[1].includes('sys.version_info') ? '/venv/bin/python\n' : `${postinstall.npmVersion}\n`,
+    };
+  });
+  assert.match(output.logs, /already installed/);
+  assert.strictEqual(output.warnings, '');
+});
+
+test('postinstall refuses overlapping upstream installs without mutation', () => {
+  const output = capturePostinstall((cmd, argv) => {
+    assert.strictEqual(argv[0], '-c');
+    if (argv[1].includes('sys.version_info')) return { status: 0, stdout: '/venv/bin/python\n' };
+    if (argv[1].includes('PackageNotFoundError')) return { status: 1 };
+    return { status: 0, stdout: '1.9.2\n' };
+  });
+  assert.match(output.warnings, /fresh Python 3\.12\+ venv/);
+  assert.doesNotMatch(output.logs, /✓ Installed/);
+});
+
+test('resolveConsoleScript skips its own npm symlink and picks the PATH script', () => {
+  const root = tmpdir();
+  const npmbin = path.join(root, 'npmbin');
+  const venvbin = path.join(root, 'venv', 'bin');
+  fs.mkdirSync(npmbin);
+  fs.mkdirSync(venvbin, { recursive: true });
+  const real = writeFakeConsoleScript(venvbin);
+  const selfLink = path.join(npmbin, 'riciplay');
+  fs.symlinkSync(WRAPPER, selfLink);
+
+  const resolved = launcher.resolveConsoleScript({
+    platform: 'linux',
+    env: { PATH: `${npmbin}:${venvbin}` },
+    argv1: selfLink,
+    filename: WRAPPER,
+  });
+  assert.strictEqual(resolved, real, `expected ${real}, got ${resolved}`);
+});
+
+test('venv/pipx console script is found when PATH only contains it (bug 3b)', () => {
+  const root = tmpdir();
+  const venvbin = path.join(root, 'venv', 'bin');
+  fs.mkdirSync(venvbin, { recursive: true });
+  const real = writeFakeConsoleScript(venvbin);
+
+  const resolved = launcher.resolveConsoleScript({
+    platform: 'linux',
+    env: { PATH: venvbin },
+    argv1: path.join(root, 'npmbin', 'riciplay'),
+    filename: WRAPPER,
+  });
+  assert.strictEqual(resolved, real);
+});
+
+test('returns null when the only riciplay on PATH is the wrapper itself', () => {
+  const root = tmpdir();
+  const npmbin = path.join(root, 'npmbin');
+  fs.mkdirSync(npmbin);
+  const selfLink = path.join(npmbin, 'riciplay');
+  fs.symlinkSync(WRAPPER, selfLink);
+
+  const resolved = launcher.resolveConsoleScript({
+    platform: 'linux',
+    env: { PATH: npmbin },
+    argv1: selfLink,
+    filename: WRAPPER,
+  });
+  assert.strictEqual(resolved, null);
+});
+
+test('end-to-end: wrapper invoked via npm symlink runs the real script, no recursion', () => {
+  if (process.platform === 'win32') return; // shebang console scripts are POSIX-only
+  const root = tmpdir();
+  const npmbin = path.join(root, 'npmbin');
+  const venvbin = path.join(root, 'venv', 'bin');
+  fs.mkdirSync(npmbin);
+  fs.mkdirSync(venvbin, { recursive: true });
+  writeFakeConsoleScript(venvbin);
+  const selfLink = path.join(npmbin, 'riciplay');
+  fs.symlinkSync(WRAPPER, selfLink);
+
+  const proc = spawnSync(process.execPath, [selfLink, '--version'], {
+    encoding: 'utf8',
+    timeout: 20000,
+    env: { PATH: `${npmbin}:${venvbin}`, HOME: root },
+  });
+  assert.strictEqual(
+    proc.status, 0,
+    `launcher exited ${proc.status}; stdout=${proc.stdout} stderr=${proc.stderr}`,
+  );
+  assert.match(proc.stdout, /RICIPLAY_FAKE_CONSOLE_SCRIPT/);
+});
+
+test('module fallback skips unsupported python3 and uses python3.12', () => {
+  if (process.platform === 'win32') return;
+  const root = tmpdir();
+  const oldPython = path.join(root, 'python3');
+  const newPython = path.join(root, 'python3.12');
+  fs.writeFileSync(oldPython, '#!/bin/sh\nexit 1\n');
+  fs.writeFileSync(newPython, `#!/bin/sh\ncase "$2" in\n  *sys.version_info*) echo "$0";;\n  *) if [ "$3" = "launcher-info" ]; then echo '${JSON.stringify(safeRuntime())}'; else echo RICIPLAY_PY312 "$@"; fi;;\nesac\n`);
+  fs.chmodSync(oldPython, 0o755);
+  fs.chmodSync(newPython, 0o755);
+  const proc = spawnSync(process.execPath, [WRAPPER, '--version'], {
+    encoding: 'utf8', timeout: 20000, env: { PATH: root, HOME: root },
+  });
+  assert.strictEqual(proc.status, 0, proc.stderr);
+  assert.match(proc.stdout, /RICIPLAY_PY312.*--version/);
+});
+
+test('PATH candidate cannot dispatch user commands with stale versions or unsafe runtimes', () => {
+  if (process.platform === 'win32') return;
+  for (const info of [
+    safeRuntime({ cli_version: '1.9.2' }), safeRuntime({ python_version: [3, 10, 9] }),
+    safeRuntime({ tornado_version: '6.5.10', proxy_dependencies_supported: false }),
+    safeRuntime({ mitmproxy_version: '10.3.0', proxy_dependencies_supported: false }),
+  ]) {
+    const root = tmpdir();
+    const script = path.join(root, 'riciplay');
+    fs.writeFileSync(script, `#!/bin/sh\nif [ "$1" = "launcher-info" ]; then echo '${JSON.stringify(info)}'; else echo UNSAFE_DISPATCH; fi\n`);
+    fs.chmodSync(script, 0o755);
+    const proc = spawnSync(process.execPath, [WRAPPER, 'chat'], {
+      encoding: 'utf8', timeout: 20000, env: { PATH: root, HOME: root },
+    });
+    assert.strictEqual(proc.status, 1, proc.stderr);
+    assert.match(proc.stderr, /PATH riciplay is incompatible/);
+    assert.doesNotMatch(proc.stdout, /UNSAFE_DISPATCH/);
+  }
+});
+
+test('module fallback reports Python 3.12 minimum when no interpreter exists', () => {
+  const root = tmpdir();
+  const proc = spawnSync(process.execPath, [WRAPPER, '--version'], {
+    encoding: 'utf8', timeout: 20000, env: { PATH: root, HOME: root },
+  });
+  assert.strictEqual(proc.status, 1, proc.stderr);
+  assert.match(proc.stderr, /requires Python 3\.12\+/);
+});
+
+Promise.all(pending).then(() => {
+  if (failures > 0) {
+    console.error(`\n${failures} launcher test(s) failed`);
+    process.exit(1);
+  }
+  console.log('\nall launcher tests passed');
+});