gentle-pi 2.1.2 → 2.3.0

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

@@ -0,0 +1,257 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { applySavedModelConfig, readModelConfig, readModelConfigAsync } from "../extensions/gentle-ai.ts";
+
+test("model routing authority normalizes and preserves sync/async source status", async (t) => {
+	const loaded = await import("../lib/model-routing-authority.ts").then(
+		(module) => ({ module, error: undefined }),
+		(error) => ({ module: undefined, error }),
+	);
+	assert.ok(
+		loaded.module,
+		`shared model routing authority must load: ${String(loaded.error)}`,
+	);
+	const authority = loaded.module;
+	const root = mkdtempSync(join(tmpdir(), "gentle-pi-model-routing-authority-"));
+	const globalDir = join(root, "global");
+	const projectDir = join(root, "project");
+	const projectConfigDir = join(projectDir, ".pi", "gentle-ai");
+	const agentsDir = join(root, "agents");
+	mkdirSync(globalDir, { recursive: true });
+	mkdirSync(projectConfigDir, { recursive: true });
+	mkdirSync(agentsDir, { recursive: true });
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+
+	assert.equal(authority.normalizeModelId(" openai/gpt-5 "), "openai/gpt-5");
+	assert.equal(authority.normalizeModelId("bad model"), undefined);
+	assert.deepEqual(authority.normalizeRoutingEntry(" inherit "), { model: "inherit" });
+	assert.deepEqual(
+		authority.normalizeRoutingEntry({ model: " anthropic/opus ", thinking: "high" }),
+		{ model: "anthropic/opus", thinking: "high" },
+	);
+	assert.deepEqual(authority.normalizeRoutingEntry(null), undefined);
+	assert.deepEqual(
+		authority.normalizeModelConfig({
+			worker: " openai/gpt-5 ",
+			clear: {},
+			"not valid": "ignored",
+			nullValue: null,
+		}),
+		{ worker: { model: "openai/gpt-5" }, clear: {} },
+	);
+
+	const missingPath = join(globalDir, "missing.json");
+	assert.deepEqual(authority.readModelConfigFile(missingPath), { status: "missing" });
+	assert.deepEqual(await authority.readModelConfigFileAsync(missingPath), { status: "missing" });
+
+	const validGlobalPath = join(globalDir, "valid.json");
+	writeFileSync(
+		validGlobalPath,
+		JSON.stringify({ worker: "openai/gpt-5", reviewer: { thinking: "medium" }, "not valid": "openai/gpt-4" }),
+	);
+	const validSync = authority.readModelConfigFile(validGlobalPath);
+	const validAsync = await authority.readModelConfigFileAsync(validGlobalPath);
+	assert.deepEqual(validSync, {
+		status: "valid",
+		config: {
+			worker: { model: "openai/gpt-5" },
+			reviewer: { model: undefined, thinking: "medium" },
+			"not valid": { model: "openai/gpt-4" },
+		},
+	});
+	assert.deepEqual(validAsync, validSync);
+
+	const invalidGlobalPath = join(globalDir, "invalid.json");
+	writeFileSync(invalidGlobalPath, "[]");
+	assert.deepEqual(authority.readModelConfigFile(invalidGlobalPath), {
+		status: "invalid",
+		path: invalidGlobalPath,
+	});
+	assert.deepEqual(await authority.readModelConfigFileAsync(invalidGlobalPath), {
+		status: "invalid",
+		path: invalidGlobalPath,
+	});
+
+	const projectPath = join(projectConfigDir, "models.json");
+	writeFileSync(projectPath, JSON.stringify({ project: "google/gemini" }));
+	assert.deepEqual(
+		authority.readSavedModelConfig(missingPath, projectPath),
+		{ status: "valid", config: { project: { model: "google/gemini" } } },
+	);
+	assert.deepEqual(
+		await authority.readSavedModelConfigAsync(missingPath, projectPath),
+		await authority.readSavedModelConfig(missingPath, projectPath),
+	);
+	assert.deepEqual(authority.readSavedModelConfig(invalidGlobalPath, projectPath), {
+		status: "invalid",
+		path: invalidGlobalPath,
+	});
+	assert.deepEqual(await authority.readSavedModelConfigAsync(invalidGlobalPath, projectPath), {
+		status: "invalid",
+		path: invalidGlobalPath,
+	});
+
+	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
+	process.env.GENTLE_PI_CONFIG_HOME = globalDir;
+	t.after(() => {
+		if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
+		else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
+	});
+	writeFileSync(projectPath, JSON.stringify({ project: "google/gemini" }));
+	assert.deepEqual(readModelConfig(projectDir), { project: { model: "google/gemini" } });
+	assert.deepEqual(await readModelConfigAsync(projectDir), readModelConfig(projectDir));
+
+	writeFileSync(projectPath, "[]");
+	assert.deepEqual(authority.readModelConfigFile(projectPath), { status: "invalid", path: projectPath });
+	assert.deepEqual(await authority.readModelConfigFileAsync(projectPath), { status: "invalid", path: projectPath });
+	assert.deepEqual(readModelConfig(projectDir), {});
+	assert.deepEqual(await readModelConfigAsync(projectDir), {});
+
+	writeFileSync(join(globalDir, "models.json"), JSON.stringify({ global: "openai/gpt-5" }));
+	assert.deepEqual(readModelConfig(projectDir), { global: { model: "openai/gpt-5" } });
+	assert.deepEqual(await readModelConfigAsync(projectDir), readModelConfig(projectDir));
+
+	writeFileSync(join(globalDir, "models.json"), "[]");
+	assert.deepEqual(readModelConfig(projectDir), {});
+	assert.deepEqual(await readModelConfigAsync(projectDir), {});
+});
+
+test("saved-routing apply fails closed for invalid project and global sources", async (t) => {
+	const root = mkdtempSync(join(tmpdir(), "gentle-pi-model-routing-apply-"));
+	const configHome = join(root, "global");
+	const projectConfigDir = join(root, ".pi", "gentle-ai");
+	const projectAgentsDir = join(root, ".pi", "agents");
+	const projectProfileDir = join(root, ".pi");
+	const agentHome = join(root, "agent-home");
+	const agentHomeAgentsDir = join(agentHome, "agents");
+	const agentHomeSubagentsDir = join(agentHome, "subagents");
+	mkdirSync(configHome, { recursive: true });
+	mkdirSync(projectConfigDir, { recursive: true });
+	mkdirSync(projectAgentsDir, { recursive: true });
+	mkdirSync(projectProfileDir, { recursive: true });
+	mkdirSync(agentHomeAgentsDir, { recursive: true });
+	mkdirSync(agentHomeSubagentsDir, { recursive: true });
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+
+	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
+	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
+	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;
+	});
+
+	const agentPath = join(projectAgentsDir, "worker.md");
+	writeFileSync(agentPath, "---\nname: worker\ndescription: Worker\n---\nbody\n");
+	const profilePath = join(projectProfileDir, "subagents.json");
+	const profileBytes = JSON.stringify({
+		unrelated: { keep: true },
+		model_profiles: { worker: { model: "existing/model", effort: "low" } },
+	}, null, 2) + "\n";
+	writeFileSync(profilePath, profileBytes);
+	const context = { cwd: root } as Parameters<typeof applySavedModelConfig>[0];
+	const projectPath = join(projectConfigDir, "models.json");
+	const globalPath = join(configHome, "models.json");
+	let mutatorCalls = 0;
+	const applyConfig = async () => {
+		mutatorCalls += 1;
+		return { updated: 0, skipped: 0 };
+	};
+
+	for (const projectValue of ["{", "[]", "null"] as const) {
+		writeFileSync(projectPath, projectValue);
+		const before = statSync(profilePath);
+		const result = await applySavedModelConfig(context, applyConfig);
+		assert.deepEqual(result, { updated: 0, skipped: 0, invalidPath: projectPath });
+		assert.equal(mutatorCalls, 0);
+		assert.equal(readFileSync(profilePath, "utf8"), profileBytes);
+		assert.equal(statSync(profilePath).mtimeMs, before.mtimeMs);
+	}
+
+	writeFileSync(globalPath, "[]");
+	writeFileSync(projectPath, JSON.stringify({ worker: "new/model" }));
+	const before = statSync(profilePath);
+	const result = await applySavedModelConfig(context, applyConfig);
+	assert.deepEqual(result, { updated: 0, skipped: 0, invalidPath: globalPath });
+	assert.equal(mutatorCalls, 0);
+	assert.equal(readFileSync(profilePath, "utf8"), profileBytes);
+	assert.equal(statSync(profilePath).mtimeMs, before.mtimeMs);
+});
+
+test("saved-routing apply preserves missing, valid, null, inherit, and omission behavior", async (t) => {
+	const root = mkdtempSync(join(tmpdir(), "gentle-pi-model-routing-apply-valid-"));
+	const configHome = join(root, "global");
+	const projectConfigDir = join(root, ".pi", "gentle-ai");
+	const projectAgentsDir = join(root, ".pi", "agents");
+	const projectProfileDir = join(root, ".pi");
+	const agentHome = join(root, "agent-home");
+	const agentHomeAgentsDir = join(agentHome, "agents");
+	const agentHomeSubagentsDir = join(agentHome, "subagents");
+	mkdirSync(configHome, { recursive: true });
+	mkdirSync(projectConfigDir, { recursive: true });
+	mkdirSync(projectAgentsDir, { recursive: true });
+	mkdirSync(projectProfileDir, { recursive: true });
+	mkdirSync(agentHomeAgentsDir, { recursive: true });
+	mkdirSync(agentHomeSubagentsDir, { recursive: true });
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+
+	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
+	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
+	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;
+	});
+
+	const agentPath = join(projectAgentsDir, "worker.md");
+	writeFileSync(agentPath, "---\nname: worker\ndescription: Worker\n---\nbody\n");
+	const profilePath = join(projectProfileDir, "subagents.json");
+	const initialProfile = {
+		unrelated: { keep: true },
+		model_profiles: { worker: { model: "existing/model", effort: "low" } },
+	};
+	writeFileSync(profilePath, `${JSON.stringify(initialProfile, null, 2)}\n`);
+	const context = { cwd: root } as Parameters<typeof applySavedModelConfig>[0];
+	const projectPath = join(projectConfigDir, "models.json");
+
+	const missing = await applySavedModelConfig(context);
+	assert.equal(missing.invalidPath, undefined);
+	assert.deepEqual(JSON.parse(readFileSync(profilePath, "utf8")), initialProfile);
+
+	writeFileSync(projectPath, JSON.stringify({ worker: "inherit" }));
+	const valid = await applySavedModelConfig(context);
+	assert.equal(valid.invalidPath, undefined);
+	const validProfile = JSON.parse(readFileSync(profilePath, "utf8")) as Record<string, any>;
+	assert.deepEqual(validProfile.unrelated, initialProfile.unrelated);
+	assert.deepEqual(validProfile.model_profiles.worker, { model: "inherit" });
+	assert.match(readFileSync(agentPath, "utf8"), /model: inherit\n/);
+	assert.doesNotMatch(readFileSync(agentPath, "utf8"), /thinking:/);
+
+	const afterValidBytes = readFileSync(profilePath, "utf8");
+	const afterValid = statSync(profilePath);
+	writeFileSync(projectPath, JSON.stringify({ worker: null }));
+	const nullEntry = await applySavedModelConfig(context);
+	assert.equal(nullEntry.invalidPath, undefined);
+	assert.equal(readFileSync(profilePath, "utf8"), afterValidBytes);
+	assert.equal(statSync(profilePath).mtimeMs, afterValid.mtimeMs);
+	assert.doesNotMatch(readFileSync(agentPath, "utf8"), /model: null/);
+
+	let mutatorCalls = 0;
+	const applyConfig = async () => {
+		mutatorCalls += 1;
+		return { updated: 0, skipped: 0 };
+	};
+	writeFileSync(projectPath, JSON.stringify({ worker: "new/model" }));
+	const injected = await applySavedModelConfig(context, applyConfig);
+	assert.equal(injected.invalidPath, undefined);
+	assert.equal(mutatorCalls, 1);
+});

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

@@ -80,8 +80,81 @@ test("2.2.2 repeats 2.2.1 because the lane Pi speaks still did not move", () =>
 	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.2.1"] as Record<string, boolean>);
 });
 
+test("2.2.3 repeats 2.2.2 because Pi's consumed capability columns did not move", () => {
+	// Ground-truthed against the released v2.2.3 binary: the v2 lane reports
+	// protocol 2.0, the same eight negotiated operations, and the same START
+	// fields represented by this table.
+	const contract = NATIVE_CLI_CONTRACTS["2.2.3"] as Record<string, boolean>;
+	assert.equal(contract.mode, true);
+	assert.equal(contract.delivery, true);
+	assert.equal(contract.riskEvidence, false);
+	assert.equal(contract.hint, false);
+	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.2.2"] as Record<string, boolean>);
+});
+
+test("2.4.0 repeats 2.2.3 because the START envelope Pi consumes still omits risk_evidence and hint", () => {
+	// Ground-truthed against the published v2.4.0 linux_amd64 release binary
+	// (sha256:0be4467... , captured 2026-08-17), not against a main build:
+	//
+	//   mode      `gentle-ai review mode status --json` still answers
+	//             `gentle-ai.rdd-mode-status/v1`. The RESOLVED value moved --
+	//             an unconfigured install now reports effective "off" with
+	//             source "default" instead of "on" -- but that is a decision
+	//             the envelope carries, not a capability it lost.
+	//   delivery  `review validate --gate pre-commit` still answers
+	//             `gentle-ai.review-gate-result/v1` with
+	//             `delivery: "disabled/unmanaged"` at exit 0. Under opt-in RDD
+	//             this is now the DEFAULT delivery answer for an install that
+	//             never enabled review, so the column matters more, not less.
+	//
+	// riskEvidence and hint stay dark for exactly the reason the 2.2.0 comment
+	// gives, re-proven rather than inherited: the negotiated
+	// `gentle-ai.review-integration.start/v3` envelope captured from this
+	// binary carries `risk_reasons: [{ code: "non_executable_only" }]` and no
+	// `risk_evidence` and no `hint`. `risk_evidence` does appear in v2.4.0, but
+	// only on the `gentle-ai.review-integration.consent/v3` blocking envelope,
+	// which is a different envelope on a different branch of START and is not
+	// what these columns describe.
+	const contract = NATIVE_CLI_CONTRACTS["2.4.0"] as Record<string, boolean>;
+	assert.equal(contract.mode, true);
+	assert.equal(contract.delivery, true);
+	assert.equal(contract.riskEvidence, false);
+	assert.equal(contract.hint, false);
+	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.2.3"] as Record<string, boolean>);
+});
+
+test("2.5.0-rc.3 repeats 2.4.0 because the negotiated lane Pi consumes is unchanged", () => {
+	// Ground-truthed by driving the exact v2.5.0-rc.3 tagged build through the
+	// gentle-ai-bench driven journey corpus (exit 0), which exercises the
+	// start/status/capture/validate/mode/delivery lifecycles Pi consumes. The
+	// lane now advertises capabilities/v2.3 and the reviewing START is the
+	// `start/v4` continuation envelope that #499 already decodes; the closed
+	// fields Pi reads did not change. riskEvidence and hint stay dark: still
+	// not proven to reach the negotiated START path Pi consumes.
+	const contract = NATIVE_CLI_CONTRACTS["2.5.0-rc.3"] as Record<string, boolean>;
+	assert.equal(contract.riskEvidence, false);
+	assert.equal(contract.hint, false);
+	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.4.0"] as Record<string, boolean>);
+});
+
+test("2.5.0 repeats 2.5.0-rc.3 because the stable lane Pi consumes is unchanged", () => {
+	// Ground-truthed against the published v2.5.0 binary installed from its
+	// signed archive: the v2 lane advertises capabilities/v2.4 and answers
+	// status/v6, consent/v3, and the `start/v4` continuation, all already
+	// decoded. The closed fields Pi reads did not change between rc.3 and
+	// stable. riskEvidence and hint stay dark: still not proven to reach the
+	// negotiated START path Pi consumes.
+	const contract = NATIVE_CLI_CONTRACTS["2.5.0"] as Record<string, boolean>;
+	assert.equal(contract.riskEvidence, false);
+	assert.equal(contract.hint, false);
+	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.5.0-rc.3"] 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.
-	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2"]);
+	// 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"]);
 });