gentle-pi 4.0.0 → 4.2.0

package/tests/model-profiles-preservation.test.ts

@@ -0,0 +1,153 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { applyModelConfig, applyModelConfigAsync, applySavedModelConfig } from "../extensions/gentle-ai.ts";
+
+// gentle-ai#4946: the activation sweep re-applies saved routing without user
+// consent. Persisted clear entries (an "inherit" saved from /gentle:models is
+// `{}`) must not delete `model_profiles` entries the user authored in the
+// agent-home `subagents.json`. Clearing stays owned by the consented flows
+// that issue it: the panel save and a confirmed profile apply.
+function preservedProfilesFixture(t: test.TestContext) {
+	const root = mkdtempSync(join(tmpdir(), "gentle-pi-model-profiles-"));
+	const configHome = join(root, "global");
+	const agentHome = join(root, "agent-home");
+	for (const dir of [configHome, join(agentHome, "agents")]) {
+		mkdirSync(dir, { recursive: true });
+	}
+	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
+	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
+	const previousHome = process.env.HOME;
+	const previousUserProfile = process.env.USERPROFILE;
+	const isolatedHome = join(root, "home");
+	mkdirSync(isolatedHome, { recursive: true });
+	process.env.HOME = isolatedHome;
+	process.env.USERPROFILE = isolatedHome;
+	process.env.GENTLE_PI_CONFIG_HOME = configHome;
+	process.env.GENTLE_PI_AGENT_HOME = agentHome;
+	t.after(() => {
+		if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
+		else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
+		if (previousAgentHome === undefined) delete process.env.GENTLE_PI_AGENT_HOME;
+		else process.env.GENTLE_PI_AGENT_HOME = previousAgentHome;
+		if (previousHome === undefined) delete process.env.HOME;
+		else process.env.HOME = previousHome;
+		if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = previousUserProfile;
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	// A discoverable user-source agent definition, as gentle-pi installs them.
+	writeFileSync(
+		join(agentHome, "agents", "worker.md"),
+		"---\nname: worker\ndescription: Worker\n---\nbody\n",
+	);
+	const subagentsPath = join(agentHome, "subagents.json");
+	const writeUserRouting = () => {
+		writeFileSync(
+			subagentsPath,
+			JSON.stringify({
+				max_concurrency: 3,
+				model_profiles: {
+					worker: { model: "openai/gpt-4o", effort: "high" },
+					"my-custom-agent": { model: "anthropic/opus" },
+				},
+			}),
+		);
+	};
+	writeUserRouting();
+	const globalModelsPath = join(configHome, "models.json");
+	const context = { cwd: root } as Parameters<typeof applySavedModelConfig>[0];
+	return { root, configHome, agentHome, subagentsPath, globalModelsPath, context, writeUserRouting };
+}
+
+test("startup sweep keeps user model_profiles entries for persisted clears", async (t) => {
+	const fixture = preservedProfilesFixture(t);
+	// Saved routing as /gentle:models leaves it after pressing "inherit" on
+	// worker: a persisted clear entry. The sweep must not delete the entries.
+	writeFileSync(fixture.globalModelsPath, JSON.stringify({ worker: {} }));
+	const result = await applySavedModelConfig(fixture.context);
+	assert.equal(result.invalidPath, undefined);
+	assert.ok(existsSync(fixture.subagentsPath));
+	const stored = JSON.parse(readFileSync(fixture.subagentsPath, "utf8"));
+	assert.equal(stored.max_concurrency, 3, "unrelated user keys survive");
+	assert.equal(
+		stored.model_profiles?.worker?.model,
+		"openai/gpt-4o",
+		"user-authored worker profile must survive a persisted clear entry",
+	);
+	assert.equal(
+		stored.model_profiles?.["my-custom-agent"]?.model,
+		"anthropic/opus",
+		"user-authored profile for an agent absent from the store must survive",
+	);
+});
+
+test("activation never deletes empty saved routes, including previously materialized and missing agents", async (t) => {
+	for (const scenario of ["user-authored", "previously-materialized", "missing-definition"]) {
+		await t.test(scenario, async (t) => {
+			const fixture = preservedProfilesFixture(t);
+			if (scenario === "previously-materialized") await applyModelConfigAsync(fixture.root, { worker: { model: "openai/alpha", thinking: "high" } });
+			const target = scenario === "missing-definition" ? "my-custom-agent" : "worker";
+			writeFileSync(fixture.globalModelsPath, `${JSON.stringify({ [target]: {} })}\n`);
+			const files = [fixture.subagentsPath, join(fixture.agentHome, "agents", "worker.md"), fixture.globalModelsPath];
+			const before = files.map((path) => readFileSync(path, "utf8"));
+			for (const phase of ["startup", "reload"]) {
+				const result = await applySavedModelConfig(fixture.context);
+				assert.equal(result.invalidPath, undefined);
+				assert.equal(result.updated, 0, `${phase} must not delete or rewrite routing`);
+				assert.deepEqual(files.map((path) => readFileSync(path, "utf8")), before, `${phase} preserves routing, frontmatter, instructions and unrelated keys byte-identically`);
+			}
+		});
+	}
+});
+
+test("startup sweep still materializes saved non-clear routing", async (t) => {
+	const fixture = preservedProfilesFixture(t);
+	writeFileSync(
+		fixture.globalModelsPath,
+		JSON.stringify({ worker: { model: "openai/alpha", thinking: "high" } }),
+	);
+	const result = await applySavedModelConfig(fixture.context);
+	assert.equal(result.invalidPath, undefined);
+	const stored = JSON.parse(readFileSync(fixture.subagentsPath, "utf8"));
+	assert.deepEqual(
+		stored.model_profiles?.worker,
+		{ model: "openai/alpha", effort: "high" },
+		"saved routing still materializes",
+	);
+	assert.equal(
+		stored.model_profiles?.["my-custom-agent"]?.model,
+		"anthropic/opus",
+		"materializing one agent leaves other user entries alone",
+	);
+	assert.equal(stored.max_concurrency, 3);
+});
+
+test("explicit clears and equal-value writes retain sync and async behavior", async (t) => {
+	for (const [name, apply] of [["sync", applyModelConfig], ["async", applyModelConfigAsync]] as const) {
+		await t.test(name, async (t) => {
+			const fixture = preservedProfilesFixture(t);
+			const agentPath = join(fixture.agentHome, "agents", "worker.md");
+			writeFileSync(agentPath, "---\nname: worker\ndescription: Worker\nmodel: openai/gpt-4o\nthinking: high\n---\nUser instructions.\n");
+			const original = readFileSync(fixture.subagentsPath, "utf8");
+			const markdown = readFileSync(agentPath, "utf8");
+			const unchanged = await apply(fixture.root, { worker: { model: "openai/gpt-4o", thinking: "high" } });
+			assert.equal(unchanged.updated, 0);
+			assert.equal(readFileSync(fixture.subagentsPath, "utf8"), original);
+			assert.equal(readFileSync(agentPath, "utf8"), markdown);
+			const cleared = await apply(fixture.root, { worker: {} });
+			assert.equal(cleared.updated, 2, "explicit clear updates both routing surfaces");
+			assert.deepEqual(JSON.parse(readFileSync(fixture.subagentsPath, "utf8")), {
+				max_concurrency: 3, model_profiles: { "my-custom-agent": { model: "anthropic/opus" } },
+			});
+			const stored = readFileSync(agentPath, "utf8");
+			assert.doesNotMatch(stored, /^model:/m);
+			assert.doesNotMatch(stored, /^thinking:/m);
+			assert.ok(stored.endsWith("User instructions.\n"));
+		});
+	}
+});

package/tests/model-routing-package.test.ts

@@ -0,0 +1,10 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+// This manifest is the public dependency contract consumed by package managers.
+test("routing activation requires no native ownership dependency", () => {
+	const manifest = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+	assert.equal(manifest.dependencies["fs-native-extensions"], undefined);
+	assert.equal(manifest.dependencies["@heyhuynhgiabuu/pi-pretty"], "0.6.27", "unrelated dependency remains pinned");
+});

package/tests/nan-provider-runtime.test.ts

@@ -0,0 +1,156 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+
+const dependencyEntry = import.meta.resolve("@earendil-works/pi-coding-agent");
+const bundledEntry = new URL("./bundle/index.js", dependencyEntry);
+// An explicit override must load successfully; never skip a missing/broken SDK.
+const override = process.env.NAN_RUNTIME_SDK_ENTRY;
+const sdkEntry = override ? pathToFileURL(override).href
+	: existsSync(bundledEntry) ? bundledEntry.href : dependencyEntry;
+const sdkLayout = sdkEntry.includes("/bundle/") ? "bundled" : "unbundled";
+const extensionPath = fileURLToPath(new URL("../extensions/nan-provider.ts", import.meta.url));
+const run = promisify(execFile);
+
+// Fresh process per case: the real loader owns jiti and its pi-ai module mapping.
+// No direct extension import, agent session, credential store, or provider network.
+const probe = String.raw`
+import assert from "node:assert/strict";
+import { join } from "node:path";
+const [sdkEntry, extensionPath, workspace, scenario] = process.argv.slice(1);
+const originalFetch = globalThis.fetch;
+let requests = 0;
+let unexpectedRequests = 0;
+globalThis.fetch = async () => {
+	unexpectedRequests++;
+	throw new Error("Automatic/global network is forbidden in this test");
+};
+try {
+	const { DefaultResourceLoader, SettingsManager, VERSION } = await import(sdkEntry);
+	const loader = new DefaultResourceLoader({
+		cwd: workspace, agentDir: join(workspace, "agent"),
+		settingsManager: SettingsManager.inMemory({ packages: [], retry: { enabled: false } }),
+		noExtensions: true, additionalExtensionPaths: [extensionPath],
+		noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true,
+	});
+	await loader.reload();
+	const loaded = loader.getExtensions();
+	assert.deepEqual(loaded.errors, []);
+	assert.equal(loaded.extensions.length, 1);
+	assert.deepEqual(loader.getAgentsFiles().agentsFiles, []);
+	const registrations = loaded.runtime.pendingNativeProviderRegistrations;
+	assert.equal(registrations.length, 1);
+	const { provider } = registrations[0];
+	assert.equal(provider.id, "nan");
+	const model = provider.getModels().find(m => m.id === "deepseek-v4-flash");
+	assert.ok(model);
+	const fakeFetch = async (input, init) => {
+		requests++;
+		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+		assert.equal(url, "https://api.nan.builders/v1/chat/completions");
+		assert.equal(init.method, "POST");
+		const body = JSON.parse(init.body);
+		assert.equal(body.model, "deepseek-v4-flash");
+		assert.equal(body.stream, true);
+		if (scenario === "http-error") {
+			return new Response(JSON.stringify({ error: { message: "synthetic unavailable" } }), {
+				status: 503, headers: { "content-type": "application/json" },
+			});
+		}
+		const delta = scenario === "tool" ? {
+			role: "assistant", tool_calls: [{ index: 0, id: "call_synthetic", type: "function",
+				function: { name: "lookup", arguments: '{"city":' } }],
+		} : { role: "assistant", content: "NAN_" };
+		if (scenario === "tool") {
+			assert.equal(body.tools[0].function.name, "lookup");
+			assert.equal(body.tools[0].function.parameters.properties.city.type, "string");
+		}
+		const nextDelta = scenario === "tool"
+			? { tool_calls: [{ index: 0, function: { arguments: '"Paris"}' } }] }
+			: { content: "OK" };
+		const chunk = (delta, finish_reason = null, usage) => ({
+			id: "synthetic", object: "chat.completion.chunk", created: 1, model: body.model,
+			choices: [{ index: 0, delta, finish_reason }], ...(usage ? { usage } : {}),
+		});
+		const chunks = [chunk(delta), chunk(nextDelta), chunk({}, scenario === "tool" ? "tool_calls" : "stop",
+			{ prompt_tokens: 3, completion_tokens: 2, total_tokens: 5 })];
+		return new Response(chunks.map(c => "data: " + JSON.stringify(c) + "\n\n").join("")
+			+ "data: [DONE]\n\n", { headers: { "content-type": "text/event-stream" } });
+	};
+	const messages = [{ role: "user", content: [{ type: "text", text: "Synthetic request" }], timestamp: 1 }];
+	if (scenario === "tool") messages.unshift({ role: "system", content: "Use lookup", timestamp: 1,
+		toolsAdded: [{ name: "lookup", description: "Synthetic lookup", parameters: {
+			type: "object", properties: { city: { type: "string" } }, required: ["city"],
+		} }] });
+	const stream = provider.streamSimple(model, { messages }, {
+		apiKey: "synthetic-key", fetch: fakeFetch, maxRetries: 0, maxTokens: 16, timeoutMs: 5000,
+	});
+	const events = [];
+	for await (const event of stream) events.push(event);
+	const result = await stream.result();
+	const types = events.map(event => event.type);
+	assert.equal(requests, 1, "including HTTP failures: retries must remain disabled");
+	assert.equal(unexpectedRequests, 0);
+	assert.equal(types.filter(type => type === "done" || type === "error").length, 1);
+	if (scenario === "http-error") {
+		assert.equal(types.at(-1), "error");
+		assert.equal(result.stopReason, "error");
+		assert.match(result.errorMessage, /synthetic unavailable/);
+		assert.equal(events.at(-1).error, result);
+	} else {
+		assert.equal(types[0], "start", result.errorMessage);
+		assert.equal(types.at(-1), "done");
+		assert.equal(events.at(-1).message, result);
+		assert.equal(result.usage.input, 3);
+		assert.equal(result.usage.output, 2);
+		assert.equal(result.usage.totalTokens, 5);
+		if (scenario === "tool") {
+			assert.equal(result.stopReason, "toolUse");
+			for (const type of ["toolcall_start", "toolcall_delta", "toolcall_end"]) assert.ok(types.includes(type));
+			const toolCall = result.content.find(block => block.type === "toolCall");
+			assert.equal(toolCall.name, "lookup");
+			assert.deepEqual(toolCall.arguments, { city: "Paris" });
+			assert.deepEqual(events.find(event => event.type === "toolcall_end").toolCall.arguments, { city: "Paris" });
+		} else {
+			assert.equal(result.stopReason, "stop");
+			assert.equal(result.content.filter(block => block.type === "text").map(block => block.text).join(""), "NAN_OK");
+			assert.equal(events.filter(event => event.type === "text_delta").map(event => event.delta).join(""), "NAN_OK");
+			assert.equal(types.filter(type => type === "text_start").length, 1);
+			assert.equal(types.filter(type => type === "text_end").length, 1);
+		}
+	}
+	console.log(JSON.stringify({ sdkVersion: VERSION, requests, types, stopReason: result.stopReason }));
+} finally {
+	globalThis.fetch = originalFetch;
+}
+`;
+
+for (const cache of ["default filesystem-cache env", "JITI_FS_CACHE=false"] as const) {
+	for (const scenario of ["text", "http-error", "tool"] as const) {
+		test(`NaN real loader → ${scenario} stream (${sdkLayout} SDK, cache ${cache})`, { timeout: 30_000 }, async (t) => {
+			const workspace = await mkdtemp(join(tmpdir(), "nan-runtime-test-"));
+			try {
+				const { stdout } = await run(process.execPath, ["--input-type=module", "--eval", probe,
+					sdkEntry, extensionPath, workspace, scenario], {
+					timeout: 25_000,
+					// Do not inherit provider keys or the user's settings/resource locations.
+					env: { HOME: workspace, PI_CODING_AGENT_DIR: join(workspace, "agent"), PI_OFFLINE: "1",
+						// Confine os.tmpdir fallback only; SDK-local default cache may still be used.
+						TMPDIR: workspace, TMP: workspace, TEMP: workspace,
+						...(cache === "JITI_FS_CACHE=false" ? { JITI_FS_CACHE: "false" } : {}) },
+				});
+				const evidence = JSON.parse(stdout.trim());
+				assert.equal(evidence.requests, 1);
+				t.diagnostic(`SDK ${evidence.sdkVersion} ${sdkLayout}: ${sdkEntry}`);
+			} finally {
+				await rm(workspace, { recursive: true, force: true });
+			}
+		});
+	}
+}

package/tests/nan-provider.test.ts

@@ -4,7 +4,7 @@ import type { RefreshModelsContext } from "@earendil-works/pi-ai";
 import { clampThinkingLevel, createModels, getSupportedThinkingLevels, InMemoryCredentialStore } from "@earendil-works/pi-ai";
 import type { Provider } from "@earendil-works/pi-ai";
 import nanProviderExtension from "../extensions/nan-provider.ts";
-import { createNanProviderConfig as createNativeProvider, NAN_PROVIDER_BASE_URL, NAN_PROVIDER_ID } from "../lib/nan-provider.ts";
+import { createNanProviderConfig as createNativeProvider, isNanAdaptiveReasoningModel, NAN_PROVIDER_BASE_URL, NAN_PROVIDER_ID } from "../lib/nan-provider.ts";
 
 // Keep catalog assertions independent of the native refresh's void return contract.
 function createNanProviderConfig(options: Parameters<typeof createNativeProvider>[0] = {}) {
@@ -195,37 +195,47 @@ test("initial catalog contains all seven documented chat models with configured
 	assert.deepEqual(model?.cost, { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
 });
 
-test("adjustable models map Pi thinking levels to accepted NaN efforts", () => {
+test("GLM models expose exactly NaN's four efforts and no off", () => {
 	const models = createNativeProvider().getModels();
 	for (const id of ["glm5.3", "glm5.3-flash"]) {
 		const model = models.find((model) => model.id === id);
 		assert.ok(model);
-		assert.deepEqual(model.thinkingLevelMap, { off: null, minimal: "low", xhigh: "max", max: "max" });
-		assert.deepEqual(getSupportedThinkingLevels(model), ["minimal", "low", "medium", "high", "xhigh", "max"]);
-		assert.equal(clampThinkingLevel(model, "off"), "minimal");
+		assert.deepEqual(model.thinkingLevelMap, { off: null, minimal: null, xhigh: null, max: "max" });
+		assert.deepEqual(getSupportedThinkingLevels(model), ["low", "medium", "high", "max"]);
+		// Pi levels NaN does not declare clamp onto the nearest declared effort.
+		assert.equal(clampThinkingLevel(model, "off"), "low");
+		assert.equal(clampThinkingLevel(model, "minimal"), "low");
+		assert.equal(clampThinkingLevel(model, "xhigh"), "max");
 	}
-	for (const id of ["qwen3.6", "gemma4"]) {
+});
+
+test("models with none and minimal expose exactly NaN's six efforts", () => {
+	const models = createNativeProvider().getModels();
+	// Qwen 3.6 and Gemma 4 honor these values as depth controls; DeepSeek V4 Flash,
+	// Qwen 3.8 Flash, and MiMo accept them while NaN manages depth itself.
+	for (const id of ["qwen3.6", "gemma4", "deepseek-v4-flash", "qwen3.8-flash", "mimo-v2.6-flash"]) {
 		const model = models.find((model) => model.id === id);
 		assert.ok(model);
-		assert.deepEqual(model.thinkingLevelMap, { off: "none", xhigh: "max", max: "max" });
-		assert.deepEqual(getSupportedThinkingLevels(model), ["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-		assert.equal(clampThinkingLevel(model, "off"), "off");
+		assert.deepEqual(model.thinkingLevelMap, { off: "none", xhigh: null, max: "max" });
+		assert.deepEqual(getSupportedThinkingLevels(model), ["off", "minimal", "low", "medium", "high", "max"]);
+		assert.equal(clampThinkingLevel(model, "xhigh"), "max");
 	}
 });
 
-test("fixed-depth models expose only medium and clamp unsupported thinking levels", () => {
+test("only the self-managing models carry the adaptive reasoning marker", () => {
 	const models = createNativeProvider().getModels();
-	for (const id of ["deepseek-v4-flash", "qwen3.8-flash", "mimo-v2.6-flash"]) {
+	assert.deepEqual(
+		models.filter((model) => isNanAdaptiveReasoningModel(model)).map((model) => model.id),
+		["deepseek-v4-flash", "qwen3.8-flash", "mimo-v2.6-flash"],
+	);
+	// Qwen 3.6 and Gemma 4 share the same map but honor the level as a depth budget.
+	for (const id of ["qwen3.6", "gemma4", "glm5.3", "glm5.3-flash"]) {
 		const model = models.find((model) => model.id === id);
 		assert.ok(model);
-		assert.deepEqual(model.thinkingLevelMap, {
-			off: null, minimal: null, low: null, high: null, xhigh: null, max: null,
-		});
-		assert.deepEqual(getSupportedThinkingLevels(model), ["medium"]);
-		for (const level of ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const) {
-			assert.equal(clampThinkingLevel(model, level), "medium");
-		}
+		assert.equal(isNanAdaptiveReasoningModel(model), false);
 	}
+	assert.equal(isNanAdaptiveReasoningModel(undefined), false);
+	assert.equal(isNanAdaptiveReasoningModel({ provider: "openai", id: "deepseek-v4-flash" }), false);
 });
 
 test("thinking maps are isolated across snapshots, providers, and live catalog refreshes", async () => {

package/tests/native-binary-gate.test.ts

@@ -53,6 +53,7 @@ test("without the env var unpinned digests yield a skip with a distinct reason",
 	const unpinned = requireNativeBinary({ ...PINNED, digestsPinned: false, env: {} });
 
 	assert.equal(unpinned.run, false);
+	assert.ok("reason" in unresolved);
 	assert.match(unpinned.reason as string, /digest/i);
 	assert.notEqual(unpinned.reason, unresolved.reason, "the two causes must be distinguishable in output");
 });
@@ -110,6 +111,7 @@ test("without the env var a set but non-existent dev binary path yields a distin
 	const missingVar = requireDevBinary({ devBinaryPath: undefined, exists: false, env: {} });
 	const badPath = requireDevBinary({ devBinaryPath: "/no/such/gentle-ai", exists: false, env: {} });
 	assert.equal(badPath.run, false);
+	assert.ok("reason" in missingVar);
 	assert.match(badPath.reason as string, /\/no\/such\/gentle-ai/);
 	assert.notEqual(badPath.reason, missingVar.reason, "the two causes must be distinguishable in output");
 });

package/tests/native-review-capability-contract.test.ts

@@ -373,11 +373,17 @@ test("4.0.0 explicitly repeats 3.7.0 because provider contract 1.2.0 and capabil
 	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["3.7.0"] as Record<string, boolean>);
 });
 
+test("4.1.1 explicitly repeats 4.0.0 because capabilities/v2.6 is unchanged despite provider contract 1.3.0", () => {
+	const contract = NATIVE_CLI_CONTRACTS["4.1.1"] as Record<string, boolean>;
+	assert.ok(contract);
+	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["4.0.0"] as Record<string, boolean>);
+});
+
 test("no shipped version key was added beyond the pin bump", () => {
 	// Rows are promises to consumers, so a new key only ever appears in a
 	// dedicated commit alongside a pin bump, never as a side effect. v2.2.4 and
 	// v2.3.0 shipped upstream while Pi stayed on 2.2.3 and were never pinned,
 	// so they get no row: a row asserts ground truth measured against a binary
 	// Pi actually ran, and the table only has to be ascending, not gapless.
-	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2", "2.2.3", "2.4.0", "2.5.0-rc.3", "2.5.0", "2.6.0", "2.7.0", "2.8.0", "2.8.1", "2.8.2", "2.9.0", "2.9.1", "3.0.0", "3.0.1", "3.1.0", "3.2.1", "3.4.0", "3.5.0", "3.6.0", "3.6.1", "3.7.0", "4.0.0"]);
+	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2", "2.2.3", "2.4.0", "2.5.0-rc.3", "2.5.0", "2.6.0", "2.7.0", "2.8.0", "2.8.1", "2.8.2", "2.9.0", "2.9.1", "3.0.0", "3.0.1", "3.1.0", "3.2.1", "3.4.0", "3.5.0", "3.6.0", "3.6.1", "3.7.0", "4.0.0", "4.1.1"]);
 });