gentle-pi 2.4.0 → 2.6.0

package/tests/gentle-ai.test.ts

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
@@ -12,10 +13,14 @@ import type {
 	Theme,
 	ToolCallEventResult,
 } from "@earendil-works/pi-coding-agent";
-import { __testing, createGentleAiExtension } from "../extensions/gentle-ai.ts";
-import type { NativeReviewCli } from "../lib/native-review-cli.ts";
+import { __testing, applyModelConfig, applyModelConfigAsync, createGentleAiExtension } from "../extensions/gentle-ai.ts";
+import { PROFILES_KIND, PROFILES_VERSION } from "../lib/agent-profiles.ts";
+import { NATIVE_REVIEW_ERROR_CODE, NativeReviewCliError, type NativeReviewCli } from "../lib/native-review-cli.ts";
+import { CandidateViewError, type CandidateViewRegistry } from "../lib/review-candidate-view.ts";
+import { installPackageAssets } from "../lib/sdd-preflight.ts";
 import type { ReviewCollectInputV3, ReviewStatusV3 } from "../lib/review-integration-v2.ts";
 import { stripAnsi } from "../lib/terminal-theme.ts";
+import { cardBody, cardHint, cardTitle, cardTone } from "./gentle-card-text.ts";
 
 initTheme("dark");
 
@@ -60,6 +65,146 @@ function lifecycleContext(overrides: Record<string, unknown> = {}): Record<strin
 	};
 }
 
+// gentle-pi#874: the provider's fresh_target_ready offer. The argument order
+// mirrors the live selectorless STATUS a clean, fully committed worktree
+// receives: it names the merge-base it wants so a plain START can adopt it.
+function offeredCommittedRangeStatus(baseRef: string, baseTree: string, candidateTree: string, paths: readonly string[] = ["app.ts"]): ReviewStatusV3 {
+	const targetIdentity = `sha256:${"a".repeat(64)}`;
+	return {
+		contract: "gentle-ai.review-integration/v2",
+		applicability: "unrelated",
+		action: "start",
+		replayability: "not_replayable",
+		targetIdentity,
+		projection: {
+			schema: "gentle-ai.review-candidate-projection/v1",
+			kind: "base-diff",
+			projection: "workspace",
+			baseTree,
+			initialReviewTree: candidateTree,
+			currentCandidateTree: candidateTree,
+			pathsDigest: `sha256:${"b".repeat(64)}`,
+			paths: [...paths],
+			intendedUntracked: [],
+			intendedUntrackedProof: `sha256:${"c".repeat(64)}`,
+			initialSnapshotIdentity: `sha256:${"d".repeat(64)}`,
+			currentSnapshotIdentity: `sha256:${"d".repeat(64)}`,
+		},
+		candidates: [],
+		nextTransition: {
+			kind: "execute",
+			reasonCode: "fresh_target_ready",
+			execute: {
+				operation: "review.start",
+				arguments: [
+					{ name: "target", value: targetIdentity, token: `--target=${targetIdentity}` },
+					{ name: "target-evidence", value: `v1:base-diff:workspace:${baseTree}:${candidateTree}:sha256:${"e".repeat(64)}`, token: `--target-evidence=v1:base-diff:workspace:${baseTree}:${candidateTree}:sha256:${"e".repeat(64)}` },
+					{ name: "projection", value: "workspace", token: "--projection=workspace" },
+					{ name: "base-ref", value: baseRef, token: `--base-ref=${baseRef}` },
+					{ name: "committed-only", value: "true", token: "--committed-only=true" },
+					{ name: "lineage", value: "review-offered", token: "--lineage=review-offered" },
+					{ name: "agent", value: "pi", token: "--agent=pi" },
+					{ name: "consent", value: "relay", token: "--consent=relay" },
+				],
+				preconditions: [],
+				binding: { targetIdentity },
+			},
+		},
+		raw: { schema: "gentle-ai.review-integration.status/v5" },
+	} as unknown as ReviewStatusV3;
+}
+
+// The clean, fully committed worktree STATUS with no committed-range offer:
+// the current-changes candidate view a plain START builds today.
+function cleanWorkspaceStatus(headTree: string, nextTransition?: ReviewStatusV3["nextTransition"]): ReviewStatusV3 {
+	const targetIdentity = `sha256:${"a".repeat(64)}`;
+	return {
+		contract: "gentle-ai.review-integration/v2",
+		applicability: "unrelated",
+		action: "start",
+		replayability: "not_replayable",
+		targetIdentity,
+		projection: {
+			schema: "gentle-ai.review-candidate-projection/v1",
+			kind: "current-changes",
+			projection: "workspace",
+			baseTree: headTree,
+			initialReviewTree: headTree,
+			currentCandidateTree: headTree,
+			pathsDigest: `sha256:${"b".repeat(64)}`,
+			paths: [],
+			intendedUntracked: [],
+			intendedUntrackedProof: `sha256:${"c".repeat(64)}`,
+			initialSnapshotIdentity: `sha256:${"d".repeat(64)}`,
+			currentSnapshotIdentity: `sha256:${"d".repeat(64)}`,
+		},
+		candidates: [],
+		...(nextTransition === undefined ? {} : { nextTransition }),
+		raw: { schema: "gentle-ai.review-integration.status/v5" },
+	} as unknown as ReviewStatusV3;
+}
+
+function startedReviewResult(): Record<string, unknown> {
+	return { lineageId: "adopted-range", state: "reviewing", riskLevel: "low", selectedLenses: [], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: false, riskReasons: [], raw: {} };
+}
+
+interface ReviewStartRepository {
+	cwd: string;
+	baseCommit: string;
+	baseTree: string;
+	headTree: string;
+}
+
+// A hermetic two-commit repository whose candidate range is a real committed
+// change, so both the adopted and explicit base-ref paths resolve through the
+// real candidate-view guard.
+function reviewRepository(t: test.TestContext): ReviewStartRepository {
+	const cwd = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-review-start-")));
+	t.after(() => {
+		try { execFileSync("chmod", ["-R", "u+w", cwd], { stdio: "ignore" }); } catch { /* best effort */ }
+		rmSync(cwd, { recursive: true, force: true });
+	});
+	execFileSync("git", ["init", "-b", "main"], { cwd, stdio: "ignore" });
+	writeFileSync(join(cwd, "app.ts"), "export const value = 1;\n");
+	execFileSync("git", ["add", "app.ts"], { cwd, stdio: "ignore" });
+	execFileSync("git", ["-c", "user.name=Review Test", "-c", "user.email=review@example.invalid", "commit", "-m", "base"], { cwd, stdio: "ignore" });
+	const baseCommit = execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" }).trim();
+	writeFileSync(join(cwd, "app.ts"), "export const value = 2;\n");
+	execFileSync("git", ["add", "app.ts"], { cwd, stdio: "ignore" });
+	execFileSync("git", ["-c", "user.name=Review Test", "-c", "user.email=review@example.invalid", "commit", "-m", "candidate"], { cwd, stdio: "ignore" });
+	return {
+		cwd,
+		baseCommit,
+		baseTree: execFileSync("git", ["rev-parse", `${baseCommit}^{tree}`], { cwd, encoding: "utf8" }).trim(),
+		headTree: execFileSync("git", ["rev-parse", "HEAD^{tree}"], { cwd, encoding: "utf8" }).trim(),
+	};
+}
+
+test("missing package-local binaries give a direct recovery without attributing the cause to lifecycle scripts", async () => {
+	const result = await __testing.executeReviewControllerOperation(
+		{ operation: "inspect" },
+		process.cwd(),
+		{
+			targetStatus: async () => {
+				throw new NativeReviewCliError(
+					NATIVE_REVIEW_ERROR_CODE.PACKAGE_BINARY_MISSING,
+					"review/status",
+					false,
+					false,
+					"package binary missing",
+				);
+			},
+		} as unknown as NativeReviewCli,
+	);
+
+	assert.equal(result.outcome, "native-status-package-binary-missing");
+	assert.equal(result.recovery_command, "node scripts/install-gentle-ai.mjs");
+	assert.match(String(result.next_action), /installed gentle-pi package directory/);
+	assert.match(String(result.next_action), /GENTLE_PI_SKIP_GENTLE_AI_INSTALL/);
+	assert.match(String(result.next_action), /remove or unset it before/);
+	assert.match(String(result.reason), /does not prove install lifecycle scripts were disabled/);
+});
+
 test("registered Gentle Review tools render reusable rose lifecycle call rows", () => {
 	const tools = registeredGentleTools();
 	const cases = [
@@ -112,10 +257,10 @@ test("registered Gentle Review tools render reusable rose lifecycle call rows",
 		assert.strictEqual(initial, running);
 		assert.strictEqual(running, completed);
 		assert.strictEqual(completed, failed);
-		assert.equal(initialText, `<warning>🌹︎ Gentle AI · running · ${operationPath}</warning>`);
-		assert.equal(runningText, `<warning>🌹︎ Gentle AI · running · ${operationPath}</warning>`);
-		assert.equal(completedText, `<success>🌹︎ Gentle AI · completed · ${operationPath}</success>`);
-		assert.equal(failedText, `<error>🌹︎ Gentle AI · failed · ${operationPath}</error>`);
+		assert.equal(cardTitle(initialText), `🌹︎ Gentle AI · running · ${operationPath}`); assert.equal(cardTone(initialText), "warning");
+		assert.equal(cardTitle(runningText), `🌹︎ Gentle AI · running · ${operationPath}`); assert.equal(cardTone(runningText), "warning");
+		assert.equal(cardTitle(completedText), `🌹︎ Gentle AI · completed · ${operationPath}`); assert.equal(cardTone(completedText), "success");
+		assert.equal(cardTitle(failedText), `🌹︎ Gentle AI · failed · ${operationPath}`); assert.equal(cardTone(failedText), "error");
 		assert.doesNotMatch(renderComponent(failed), /future-operation|secret|private/);
 		for (const forbiddenValue of ["lineage-id", "binding-id", "sha256:hash-value", "secret-value", "arbitrary-value"]) {
 			assert.doesNotMatch(failedText, new RegExp(forbiddenValue));
@@ -159,20 +304,317 @@ test("registered Gentle Review tools preserve result envelopes and redact collap
 			{ expanded: false, isPartial: false, isError: true },
 		]) {
 			const collapsed = renderComponent(tool.renderResult({ content: [{ type: "text", text: resultText }] }, options, lifecycleTheme, {}));
-			assert.equal(collapsed, expandHint, `${name} collapsed output must contain one expand hint`);
-			assert.equal(collapsed.split("\n")[0], expandHint, `${name} collapsed output must start with the hint`);
+			assert.match(cardBody(collapsed), /\d+ lines?\b/, `${name} collapsed output must contain one expand hint`);
+			assert.match(cardBody(collapsed), /\d+ lines?\b/, `${name} collapsed output must start with the hint`);
 			assert.doesNotMatch(collapsed, /safe result|lineage=secret|private/);
 		}
 		const expanded = renderComponent(tool.renderResult({ content: [{ type: "text", text: resultText }] }, { expanded: true, isPartial: false, isError: true }, lifecycleTheme, {}));
-		assert.equal(expanded.split("\n")[0], "safe result");
+		assert.equal(cardBody(expanded).split("\n")[0], "safe result");
 		assert.match(expanded, /safe result/);
 		assert.match(expanded, /lineage=secret body=private/);
 		assert.doesNotMatch(expanded, /to expand/);
-		assert.doesNotMatch(expanded, /\x1b\[/);
+		assert.doesNotMatch(cardBody(expanded), /\x1b\[/);
 		const nonText = renderComponent(tool.renderResult({ content: [{ type: "image", data: "opaque", mimeType: "image/png" }] }, { expanded: true, isPartial: false }, lifecycleTheme, {}));
-		assert.equal(nonText, "");
+		assert.equal(cardBody(nonText), "");
 		const empty = renderComponent(tool.renderResult({ content: [{ type: "text", text: "" }] }, { expanded: false, isPartial: false }, lifecycleTheme, {}));
-		assert.equal(empty, "");
+		assert.equal(cardBody(empty), "");
+	}
+});
+
+interface RoutingConsumerPanel {
+	render(width: number): string[];
+	handleInput(data: string): void;
+}
+
+function routingConsumerFixture(t: test.TestContext, agents = ["worker"]) {
+	const root = mkdtempSync(join(tmpdir(), "gentle-pi-routing-consumers-"));
+	const configHome = join(root, "global");
+	const agentHome = join(root, "agent-home");
+	const projectPath = join(root, ".pi", "gentle-ai", "models.json");
+	const globalPath = join(configHome, "models.json");
+	const exportPath = join(configHome, "models.export.json");
+	for (const dir of [dirname(projectPath), join(root, "agents"), join(agentHome, "agents"), join(agentHome, "subagents")]) {
+		mkdirSync(dir, { recursive: true });
+	}
+	for (const name of agents) {
+		writeMarkdown(join(root, ".pi", "agents", `${name}.md`), `---\nname: ${name}\ndescription: Worker\n---\nbody\n`);
+	}
+	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 });
+	// Isolate homedir-based discovery on POSIX and Windows.
+	// Package-sibling legacy agents remain subject to discovery assertions.
+	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 });
+	});
+	const commands = new Map<string, Parameters<ExtensionAPI["registerCommand"]>[1]>();
+	createGentleAiExtension({ nativeReviewCli: null })({
+		on() {},
+		registerTool() {},
+		registerCommand(name, command) { commands.set(name, command); },
+	} as ExtensionAPI);
+	const notifications: Array<{ message: string; severity: string }> = [];
+	// The profiles panel reads the terminal rows to size its full-screen frame, so
+	// the fake UI hands every factory a TUI-shaped stand-in with a mutable height.
+	const fixtureTui = { terminal: { rows: 24 }, requestRender() {} };
+	let panelVisits = 0;
+	const panels: string[] = [];
+	let onPanel = () => ({ type: "cancel", config: {} });
+	let onInput: ((panel: RoutingConsumerPanel) => void) | undefined;
+	const ctx = {
+		cwd: root,
+		hasUI: true,
+		modelRegistry: { getAvailable: async () => [
+			{ provider: "openai", id: "alpha" },
+			{ provider: "openai", id: "beta" },
+		] },
+		ui: {
+			notify(message: string, severity: string) { notifications.push({ message, severity }); },
+			custom: async (factory: (tui: unknown, theme: Theme, keybindings: unknown, done: (result: unknown) => void) => RoutingConsumerPanel) => {
+				let result: unknown;
+				const panel = factory(fixtureTui, { fg: (_color: string, text: string) => text } as unknown as Theme, undefined, (value) => { result = value; });
+				panels.push(stripAnsi(renderComponent(panel)));
+				panelVisits += 1;
+				if (onInput) {
+					onInput(panel);
+					assert.notEqual(result, undefined, "panel input must finish the interaction");
+					return result;
+				}
+				return onPanel();
+			},
+		},
+	} as unknown as Parameters<Parameters<ExtensionAPI["registerCommand"]>[1]["handler"]>[1];
+	return {
+		root, agentHome, configHome, projectPath, globalPath, exportPath, notifications, panels,
+		tui: fixtureTui as { terminal: { rows: number } },
+		panelVisits: () => panelVisits,
+		onPanel(action: typeof onPanel) { onPanel = action; },
+		onInput(action: (panel: RoutingConsumerPanel) => void) { onInput = action; },
+		run: (name: string) => commands.get(name)!.handler("", ctx),
+	};
+}
+
+test("models saves and clears independent provider review roles without local artifacts", async (t) => {
+	const fixture = routingConsumerFixture(t, []);
+	const roles = ["review-refuter", "review-validator"];
+	assert.deepEqual(
+		__testing.listDiscoverableAgents(fixture.root).map((agent) => agent.name),
+		[],
+		"requires zero discovered agents; check package-sibling legacy agent directories",
+	);
+
+	const assertNoLocalArtifacts = () => {
+		for (const base of [join(fixture.root, ".pi"), fixture.agentHome]) {
+			assert.equal(existsSync(join(base, "subagents.json")), false);
+			for (const dir of ["agents", "subagents"]) {
+				for (const role of roles) {
+					assert.equal(existsSync(join(base, dir, `${role}.md`)), false);
+				}
+			}
+		}
+	};
+	fixture.onInput((panel) => {
+		const initial = renderComponent(panel);
+		for (const role of roles) {
+			assert.equal(initial.split(role).length - 1, 1);
+		}
+		assert.match(initial, /Pi persisted default model/);
+		assert.match(initial, /Pi persisted default effort/);
+		for (const [index, model] of ["alpha", "beta"].entries()) {
+			panel.handleInput("j");
+			panel.handleInput("\r");
+			assert.match(renderComponent(panel), /Pi persisted default model/);
+			assert.doesNotMatch(renderComponent(panel), /Inherit active\/default model/);
+			for (const character of model) panel.handleInput(character);
+			panel.handleInput("\r");
+			panel.handleInput("e");
+			assert.match(renderComponent(panel), /Pi persisted default effort/);
+			assert.doesNotMatch(renderComponent(panel), /Inherit effort/);
+			for (let step = 0; step <= index; step++) panel.handleInput("j");
+			panel.handleInput("\r");
+		}
+		panel.handleInput("\x13");
+	});
+	await fixture.run("gentle:models");
+	assert.deepEqual(JSON.parse(readFileSync(fixture.globalPath, "utf8")), {
+		"review-refuter": { model: "openai/alpha", thinking: "off" },
+		"review-validator": { model: "openai/beta", thinking: "minimal" },
+	});
+	assertNoLocalArtifacts();
+
+	fixture.onInput((panel) => {
+		panel.handleInput("j");
+		panel.handleInput("i");
+		panel.handleInput("\x13");
+	});
+	await fixture.run("gentle:models");
+	assert.deepEqual(JSON.parse(readFileSync(fixture.globalPath, "utf8")), {
+		"review-refuter": {},
+		"review-validator": { model: "openai/beta", thinking: "minimal" },
+	});
+	assertNoLocalArtifacts();
+
+	fixture.onInput((panel) => {
+		panel.handleInput("j");
+		panel.handleInput("j");
+		panel.handleInput("i");
+		panel.handleInput("\x13");
+	});
+	await fixture.run("gentle:models");
+	assert.deepEqual(JSON.parse(readFileSync(fixture.globalPath, "utf8")), {
+		"review-refuter": {},
+		"review-validator": {},
+	});
+	assertNoLocalArtifacts();
+});
+
+test("provider review roles skip migration and both projection paths even when discoverable", async (t) => {
+	const roles = ["review-refuter", "review-validator"];
+	const fixture = routingConsumerFixture(t, [...roles, "worker"]);
+	assert.deepEqual(
+		__testing.listDiscoverableAgents(fixture.root).map((agent) => agent.name).sort(),
+		[...roles, "worker"].sort(),
+		"requires only seeded agents; check package-sibling legacy agent directories",
+	);
+
+	const rolePaths = roles.map((role) => join(fixture.root, ".pi", "agents", `${role}.md`));
+	const originals = rolePaths.map((path) => readFileSync(path, "utf8"));
+	const profilePaths = [
+		join(fixture.root, ".pi", "subagents.json"),
+		join(fixture.agentHome, "subagents.json"),
+	];
+	const profile = `${JSON.stringify({ model_profiles: {
+		"review-refuter": "existing-refuter",
+		"review-validator": "existing-validator",
+	} }, null, 2)}\n`;
+	for (const path of profilePaths) writeMarkdown(path, profile);
+	const assignments = {
+		"review-refuter": { model: "openai/alpha", thinking: "off" as const },
+		"review-validator": { model: "openai/beta", thinking: "minimal" as const },
+	};
+	writeMarkdown(join(fixture.root, ".pi", "settings.json"), JSON.stringify({
+		subagents: { agentOverrides: assignments },
+	}));
+	const assertReservedUnchanged = () => {
+		rolePaths.forEach((path, index) => assert.equal(readFileSync(path, "utf8"), originals[index]));
+		for (const path of profilePaths) assert.equal(readFileSync(path, "utf8"), profile);
+	};
+	await fixture.run("gentle:models");
+	assertReservedUnchanged();
+	for (const role of roles) assert.equal(fixture.panels[0].split(role).length - 1, 1);
+	assert.match(fixture.panels[0], /worker\s+model=inherit, effort=inherit/);
+	for (const apply of [applyModelConfig, applyModelConfigAsync]) {
+		await apply(fixture.root, assignments);
+		assertReservedUnchanged();
+		await apply(fixture.root, { "review-refuter": {}, "review-validator": {} });
+		assertReservedUnchanged();
+	}
+	await applyModelConfigAsync(fixture.root, { worker: { model: "openai/alpha" } });
+	assert.match(readFileSync(join(fixture.root, ".pi", "agents", "worker.md"), "utf8"), /model: openai\/alpha/);
+	assert.ok(JSON.parse(readFileSync(profilePaths[0], "utf8")).model_profiles.worker);
+});
+
+test("models rejects invalid project routing with its selected source path", async (t) => {
+	const fixture = routingConsumerFixture(t);
+	writeFileSync(fixture.projectPath, "[]");
+	await fixture.run("gentle:models");
+	assert.equal(fixture.notifications[0]?.severity, "warning");
+	assert.ok(fixture.notifications[0]?.message.includes(fixture.projectPath));
+	assert.equal(fixture.panelVisits(), 0);
+});
+
+test("export re-reads saved routing and rejects invalid project before creating its destination parent", async (t) => {
+	const fixture = routingConsumerFixture(t);
+	writeFileSync(fixture.projectPath, '{"worker":"openai/gpt-5"}');
+	fixture.onPanel(() => {
+		if (fixture.panelVisits() > 1) return { type: "cancel", config: {} };
+		writeFileSync(fixture.projectPath, "[]");
+		return { type: "export", config: {} };
+	});
+	await fixture.run("gentle:models");
+	assert.equal(fixture.notifications[0]?.severity, "warning");
+	assert.ok(fixture.notifications[0]?.message.includes(`Invalid model config: ${fixture.projectPath}`));
+	assert.equal(existsSync(fixture.exportPath), false);
+	assert.equal(existsSync(fixture.configHome), false);
+});
+
+test("status reports invalid saved routing path instead of default agent routing", async (t) => {
+	const fixture = routingConsumerFixture(t);
+	writeFileSync(fixture.projectPath, "[]");
+	await fixture.run("gentle:status");
+	const report = fixture.notifications.at(-1)!;
+	assert.match(report.message, /Saved model routing: invalid/);
+	assert.ok(report.message.includes(fixture.projectPath));
+	assert.equal(report.severity, "warning");
+	assert.doesNotMatch(report.message, /worker: model=/);
+});
+
+test("models exports missing, normalized project, and global-precedence saved routing", async (t) => {
+	for (const source of ["missing", "project", "global"] as const) {
+		await t.test(source, async (t) => {
+			const fixture = routingConsumerFixture(t);
+			if (source !== "missing") writeFileSync(fixture.projectPath, '{"worker":" openai/gpt-5 ","ignored":null}');
+			if (source === "global") writeMarkdown(fixture.globalPath, '{"worker":{"model":" anthropic/opus ","thinking":"high"}}');
+			fixture.onPanel(() => ({ type: fixture.panelVisits() === 1 ? "export" : "cancel", config: {} }));
+			await fixture.run("gentle:models");
+			const agents = source === "missing" ? {} : source === "project"
+				? { worker: { model: "openai/gpt-5" } }
+				: { worker: { model: "anthropic/opus", thinking: "high" } };
+			assert.deepEqual(JSON.parse(readFileSync(fixture.exportPath, "utf8")).agents, agents);
+			assert.equal(fixture.notifications[0]?.severity, "info");
+			assert.match(fixture.notifications[0]!.message, /exported/);
+			assert.equal(fixture.panelVisits(), 2);
+			await fixture.run("gentle:status");
+			const report = fixture.notifications.at(-1)!.message;
+			assert.ok(report.includes(`Saved model routing: ${source === "missing" ? "missing" : "valid"}`));
+			assert.ok(report.includes(`Global model config: ${source === "global" ? "present" : "missing"}`));
+			const expectedRouting = source === "missing" ? "inherit, effort=inherit"
+				: source === "project" ? "openai/gpt-5, effort=inherit" : "anthropic/opus, effort=high";
+			assert.ok(report.includes(`worker: model=${expectedRouting}`), report);
+			assert.ok(fixture.panels[0].includes(`model=${expectedRouting}`), fixture.panels[0]);
+		});
+	}
+});
+
+test("invalid global routing overrides valid project in models, status, and export re-read", async (t) => {
+	for (const atExport of [false, true]) {
+		await t.test(atExport ? "invalidated during panel" : "invalid before panel", async (t) => {
+			const fixture = routingConsumerFixture(t);
+			writeFileSync(fixture.projectPath, '{"worker":"openai/gpt-5"}');
+			if (!atExport) writeMarkdown(fixture.globalPath, "[]");
+			fixture.onPanel(() => {
+				if (fixture.panelVisits() > 1) return { type: "cancel", config: {} };
+				writeMarkdown(fixture.globalPath, "[]");
+				return { type: "export", config: {} };
+			});
+			await fixture.run("gentle:models");
+			assert.equal(fixture.notifications[0]?.severity, "warning");
+			assert.ok(fixture.notifications[0]?.message.includes(fixture.globalPath));
+			assert.match(fixture.notifications[0]!.message, atExport ? /export failed/ : /cannot open model config/);
+			assert.equal(fixture.panelVisits(), atExport ? 2 : 0);
+			assert.equal(existsSync(fixture.exportPath), false);
+			await fixture.run("gentle:status");
+			const report = fixture.notifications.at(-1)!;
+			assert.match(report.message, /Global model config: present\nSaved model routing: invalid/);
+			assert.ok(report.message.includes(fixture.globalPath));
+			assert.doesNotMatch(report.message, /worker: model=/);
+			assert.equal(report.severity, "warning");
+		});
 	}
 });
 
@@ -240,6 +682,21 @@ test("session startup reports invalid project routing without mutating the profi
 	assert.equal(warning!.severity, "warning");
 	assert.match(warning!.message, /skipped model config/);
 	assert.equal(readFileSync(profilePath, "utf8"), before);
+
+	writeFileSync(join(projectConfigDir, "models.json"), '{"worker":"openai/gpt-5"}');
+	const globalPath = join(configHome, "models.json");
+	writeFileSync(globalPath, "[]");
+	notifications.length = 0;
+	await sessionStart!({}, {
+		cwd: root,
+		hasUI: true,
+		ui: { notify(message: string, severity: string) { notifications.push({ message, severity }); } },
+	} as unknown as ExtensionContext);
+	const globalWarning = notifications.find((entry) => entry.message.includes(globalPath));
+	assert.ok(globalWarning, JSON.stringify(notifications));
+	assert.equal(globalWarning.severity, "warning");
+	assert.match(globalWarning.message, /skipped model config/);
+	assert.equal(readFileSync(profilePath, "utf8"), before);
 });
 
 test("agent discovery skips skills directories", async (t) => {
@@ -267,6 +724,82 @@ test("agent discovery skips skills directories", async (t) => {
 	);
 });
 
+test("managed routing timeout leaves its profile, agent, and manifest unchanged", (t) => {
+	const root = mkdtempSync(join(tmpdir(), "gentle-pi-managed-routing-timeout-"));
+	const agentHome = join(root, "agent-home");
+	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
+	t.after(() => {
+		if (previousAgentHome === undefined) delete process.env.GENTLE_PI_AGENT_HOME;
+		else process.env.GENTLE_PI_AGENT_HOME = previousAgentHome;
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	process.env.GENTLE_PI_AGENT_HOME = agentHome;
+	installPackageAssets(root, false, ["sdd"]);
+	const agentPath = join(agentHome, "agents", "sdd-apply.md");
+	const manifestPath = join(agentHome, "gentle-ai", "managed-assets.json");
+	const profilePath = join(agentHome, "subagents.json");
+	const profileBefore = "{\n  \"unrelated\": true\n}\n";
+	writeFileSync(profilePath, profileBefore);
+	const agentBefore = readFileSync(agentPath, "utf8");
+	const manifestBefore = readFileSync(manifestPath, "utf8");
+	writeFileSync(
+		join(agentHome, "gentle-ai", "managed-assets.lock"),
+		JSON.stringify({ schemaVersion: 1, token: "foreign", pid: process.pid, createdAtMs: Date.now() }),
+	);
+
+	assert.throws(
+		() => applyModelConfig(root, { "sdd-apply": { model: "test/managed", thinking: "high" } }),
+		/Timed out acquiring managed-assets lock file/i,
+	);
+	assert.equal(readFileSync(profilePath, "utf8"), profileBefore);
+	assert.equal(readFileSync(agentPath, "utf8"), agentBefore);
+	assert.equal(readFileSync(manifestPath, "utf8"), manifestBefore);
+});
+
+test("a later alias keeps managed-root precedence and manifest ownership", (t) => {
+	const root = mkdtempSync(join(tmpdir(), "gentle-pi-agent-root-alias-"));
+	const agentHome = join(root, "agent-home");
+	const home = join(root, "home");
+	const cwd = join(root, "project");
+	const managed = join(agentHome, "agents");
+	const intervening = join(agentHome, "subagents");
+	const alias = join(home, ".agents");
+	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
+	const previousHome = process.env.HOME;
+	const previousUserProfile = process.env.USERPROFILE;
+	t.after(() => {
+		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 });
+	});
+
+	process.env.GENTLE_PI_AGENT_HOME = agentHome;
+	process.env.HOME = home;
+	process.env.USERPROFILE = home;
+	installPackageAssets(cwd, false, ["sdd"]);
+	writeMarkdown(join(intervening, "sdd-apply.md"), "---\nname: sdd-apply\n---\nintervening override\n");
+	mkdirSync(home, { recursive: true });
+	try {
+		symlinkSync(managed, alias, process.platform === "win32" ? "junction" : "dir");
+	} catch (error) {
+		t.skip(`directory aliases unavailable: ${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+
+	const selected = __testing.listDiscoverableAgents(cwd).find((agent) => agent.name === "sdd-apply");
+	assert.equal(selected?.filePath, join(managed, "sdd-apply.md"));
+	applyModelConfig(cwd, { "sdd-apply": { model: "test/managed", thinking: "high" } });
+	const manifest = JSON.parse(readFileSync(join(agentHome, "gentle-ai", "managed-assets.json"), "utf8")) as { assets: Record<string, string> };
+	const routed = readFileSync(join(managed, "sdd-apply.md"), "utf8");
+	assert.match(routed, /^model: test\/managed$/m);
+	assert.equal(manifest.assets["agents/sdd-apply.md"], createHash("sha256").update(routed).digest("hex"));
+});
+
 test("runtime guidance keeps review policy out of the static orchestrator", () => {
 	const staticReferences = ["README.md", "skills/gentle-ai/SKILL.md"];
 	const forbiddenGenericRoutes = [
@@ -376,6 +909,151 @@ test("ordinary native capture exposes a registered schema and STATUS binding cop
 	assert.equal(launches, 1);
 });
 
+test("ordinary START adopts the committed-range selectors the provider just offered", async (t) => {
+	const { cwd, baseCommit, baseTree, headTree: candidateTree } = reviewRepository(t);
+	const starts: Array<Record<string, unknown>> = [];
+	const native = {
+		targetStatus: async () => offeredCommittedRangeStatus(baseCommit, baseTree, candidateTree),
+		start: async (request: Record<string, unknown>) => { starts.push(request); return startedReviewResult(); },
+	} as unknown as NativeReviewCli;
+	const result = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, cwd, native);
+	assert.equal(result.operation, "start");
+	assert.equal(starts.length, 1);
+	assert.equal(starts[0]?.baseRef, baseCommit);
+	assert.equal(starts[0]?.committedOnly, true);
+});
+
+test("ordinary START keeps an explicit caller baseRef and ignores the offered selector", async (t) => {
+	const { cwd, baseCommit, baseTree, headTree: candidateTree } = reviewRepository(t);
+	const starts: Array<Record<string, unknown>> = [];
+	const native = {
+		// A shape-valid but never-invoked offer: the explicit caller value must win
+		// before this is ever considered.
+		targetStatus: async () => offeredCommittedRangeStatus("f".repeat(40), baseTree, candidateTree),
+		start: async (request: Record<string, unknown>) => { starts.push(request); return startedReviewResult(); },
+	} as unknown as NativeReviewCli;
+	const result = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary", baseRef: baseCommit, committedOnly: true }) }, cwd, native);
+	assert.equal(result.operation, "start");
+	assert.equal(starts.length, 1);
+	assert.equal(starts[0]?.baseRef, baseCommit);
+	assert.equal(starts[0]?.committedOnly, true);
+});
+
+test("ordinary START keeps today's invocation when STATUS offers no committed-range selector", async (t) => {
+	const { cwd, headTree } = reviewRepository(t);
+	const offeredWithoutBaseRef = cleanWorkspaceStatus(headTree, {
+		kind: "execute",
+		reasonCode: "fresh_target_ready",
+		execute: { operation: "review.start", arguments: [{ name: "projection", value: "workspace", token: "--projection=workspace" }], preconditions: [], binding: { targetIdentity: `sha256:${"a".repeat(64)}` } },
+	});
+	for (const [label, target] of [["no execute transition", cleanWorkspaceStatus(headTree)], ["no base-ref", offeredWithoutBaseRef]] as const) {
+		const starts: Array<Record<string, unknown>> = [];
+		const native = {
+			targetStatus: async () => target,
+			start: async (request: Record<string, unknown>) => { starts.push(request); return startedReviewResult(); },
+		} as unknown as NativeReviewCli;
+		const result = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, cwd, native);
+		assert.equal(result.operation, "start", label);
+		assert.equal(starts.length, 1, label);
+		assert.equal(starts[0]?.baseRef, undefined, label);
+		assert.equal("committedOnly" in starts[0]!, false, label);
+	}
+});
+
+test("ordinary START reports candidate-owner preparation failure as pre-native no mutation", async () => {
+	let nativeStarts = 0;
+	const target = {
+		contract: "gentle-ai.review-integration/v2",
+		applicability: "unrelated",
+		action: "start",
+		replayability: "not_replayable",
+		targetIdentity: "a".repeat(64),
+		projection: {
+			schema: "gentle-ai.review-candidate-projection/v1",
+			kind: "current-changes",
+			projection: "workspace",
+			baseTree: "b".repeat(40),
+			initialReviewTree: "b".repeat(40),
+			currentCandidateTree: "b".repeat(40),
+			pathsDigest: "a".repeat(64),
+			paths: [],
+			intendedUntracked: [],
+			intendedUntrackedProof: "a".repeat(64),
+			initialSnapshotIdentity: "a".repeat(64),
+			currentSnapshotIdentity: "a".repeat(64),
+		},
+		candidates: [],
+		raw: { schema: "gentle-ai.review-integration.status/v5" },
+	} as unknown as ReviewStatusV3;
+	const native = {
+		targetStatus: async () => target,
+		start: async () => { nativeStarts += 1; throw new Error("native START must not run"); },
+	} as unknown as NativeReviewCli;
+	const candidateViews = {
+		createOrReuse: () => { throw new CandidateViewError("candidate view owner preparation failed", "candidate-owner-preparation-failed"); },
+	} as unknown as CandidateViewRegistry;
+	const result = await __testing.executeReviewControllerOperation(
+		{ operation: "start", input: JSON.stringify({ mode: "ordinary" }) },
+		process.cwd(),
+		native,
+		undefined,
+		candidateViews,
+	);
+	assert.equal(nativeStarts, 0);
+	assert.equal(result.outcome, "native-operation-failed");
+	assert.equal(result.mutation_outcome, "none");
+	assert.deepEqual(result.diagnostics, {
+		code: "candidate-owner-preparation-failed",
+		message: "candidate view rejected before native START",
+	});
+
+	let materializationStatusCalls = 0;
+	const rawMaterializationFailure = await __testing.executeReviewControllerOperation(
+		{ operation: "start", input: JSON.stringify({ mode: "ordinary" }) },
+		process.cwd(),
+		{
+			targetStatus: async () => { materializationStatusCalls += 1; return target; },
+			start: async () => { nativeStarts += 1; throw new Error("native START must not run"); },
+		} as unknown as NativeReviewCli,
+		undefined,
+		{ createOrReuse: () => { throw new Error("candidate materialization failed"); } } as unknown as CandidateViewRegistry,
+	);
+	assert.equal(nativeStarts, 0);
+	assert.equal(materializationStatusCalls, 1, "a pre-START materialization failure never triggers reconciliation STATUS");
+	assert.equal(rawMaterializationFailure.outcome, "native-operation-failed");
+	assert.equal(rawMaterializationFailure.mutation_outcome, "none");
+	assert.equal(rawMaterializationFailure.next_action, "resolve-native-operation-failure");
+
+	let statusCalls = 0;
+	const afterNative = await __testing.executeReviewControllerOperation(
+		{ operation: "start", input: JSON.stringify({ mode: "ordinary" }) },
+		process.cwd(),
+		{
+			targetStatus: async () => { statusCalls += 1; return target; },
+			start: async () => {
+				nativeStarts += 1;
+				throw new CandidateViewError("post-native candidate verification failed", "candidate-view-timeout", {
+					phase: "candidate-view",
+					category: "timeout",
+					git_subcommand: "worktree",
+					timeout_ms: 10_000,
+					max_buffer_bytes: 64 * 1024 * 1024,
+					message: "candidate-view Git command worktree timed out after 10000ms; inspect the candidate state before any new START",
+				});
+			},
+		} as unknown as NativeReviewCli,
+		undefined,
+		null,
+	);
+	assert.equal(nativeStarts, 1);
+	assert.equal(statusCalls, 2, "a post-native diagnostic must reconcile STATUS");
+	assert.equal(afterNative.mutation_outcome, "unknown");
+	assert.deepEqual(afterNative.diagnostics, {
+		code: "candidate-view-timeout",
+		message: "post-native candidate verification failed",
+	});
+});
+
 test("agent model discovery prioritizes SDD and Judgment Day agents", (t) => {
 	const root = mkdtempSync(join(tmpdir(), "gentle-pi-model-agents-"));
 	t.after(() => rmSync(root, { recursive: true, force: true }));
@@ -435,8 +1113,8 @@ test("model panel render does not auto-apply the Gentle theme and sanitizes agen
 	const rendered = lines.join("\n");
 	const plain = stripAnsi(rendered);
 
-	assert.doesNotMatch(rendered, /\x1b\[38;2;71;85;105m/);
-	assert.doesNotMatch(rendered, /\x1b\[38;2;125;211;252m/);
+	assert.doesNotMatch(cardBody(rendered), /\x1b\[38;2;71;85;105m/);
+	assert.doesNotMatch(cardBody(rendered), /\x1b\[38;2;125;211;252m/);
 	assert.match(plain, /Assign Models and Effort to Agents/);
 	assert.match(plain, /safe-agent\s+model=inherit, effort=inherit/);
 	assert.doesNotMatch(plain, /\[31m/);
@@ -990,3 +1668,281 @@ test("permission lifecycle is inactive for unguarded and headless commands", asy
 		rmSync(cwd, { recursive: true, force: true });
 	}
 });
+test("registered Gentle Review capture tools name the lens they run", () => {
+	const tools = registeredGentleTools();
+	const binding = (lens: string) => JSON.stringify({ name: "reviewer_result", captureOperation: "review.capture-result", arguments: [], artifactSubject: { lens } });
+	const single = tools.get("gentle_review_capture")!.renderCall({ lineageId: "l", collectBinding: binding("review-risk") }, lifecycleTheme, lifecycleContext({ executionStarted: true }));
+	assert.equal(cardTitle(renderComponent(single)), "🌹︎ Gentle AI · running · review capture · risk");
+	const bare = tools.get("gentle_review_capture")!.renderCall({ lineageId: "l", collectBinding: "{not json" }, lifecycleTheme, lifecycleContext({ executionStarted: true }));
+	assert.equal(cardTitle(renderComponent(bare)), "🌹︎ Gentle AI · running · review capture");
+	const group = tools.get("gentle_review_capture_group")!.renderCall(
+		{ lineageId: "l", collectBindings: [binding("review-risk"), binding("review-resilience"), binding("review-readability"), binding("review-reliability")] },
+		lifecycleTheme,
+		lifecycleContext({ executionStarted: true }),
+	);
+	assert.equal(cardTitle(renderComponent(group)), "🌹︎ Gentle AI · running · review capture group · risk · resilience · readability · reliability");
+});
+
+test("bash tool_call confirms a late guarded npm publish and denies on non-approval", async () => {
+	type ToolCallHandler = (
+		event: { toolName: string; input: unknown },
+		ctx: ExtensionContext,
+	) => Promise<ToolCallEventResult | undefined>;
+
+	const confirmArgs: Array<[string, string]> = [];
+	const handlers = new Map<string, ToolCallHandler>();
+	const pi = {
+		on(name: string, handler: ToolCallHandler) {
+			handlers.set(name, handler);
+		},
+		events: { emit() {} },
+		registerCommand() {},
+		registerTool() {},
+	} as unknown as ExtensionAPI;
+	createGentleAiExtension({ nativeReviewCli: null })(pi);
+	const toolCall = handlers.get("tool_call");
+	assert.equal(typeof toolCall, "function");
+
+	const configHome = mkdtempSync(join(tmpdir(), "gentle-pi-guard-confirm-"));
+	const ctx = {
+		cwd: process.cwd(),
+		hasUI: true,
+		ui: {
+			confirm: async (title: string, message: string) => {
+				confirmArgs.push([title, message]);
+				return false;
+			},
+		},
+	} as ExtensionContext;
+
+	const prefix = "noise ".repeat(80);
+	const command = `${prefix}npm publish --tag beta`;
+	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
+	process.env.GENTLE_PI_CONFIG_HOME = configHome;
+	try {
+		const result = await toolCall!({ toolName: "bash", input: { command } }, ctx);
+		assert.deepEqual(result, {
+			block: true,
+			reason:
+				"Gentle AI safety policy blocked the command because it was not confirmed.",
+		});
+	} finally {
+		if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
+		else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
+		rmSync(configHome, { recursive: true, force: true });
+	}
+
+	assert.equal(confirmArgs.length, 1, "guard asks exactly one confirmation before denying");
+	const [title, preview] = confirmArgs[0];
+	assert.equal(title, "Allow guarded npm publish?");
+	assert.match(preview, /npm publish --tag beta/);
+	assert.ok(preview.startsWith("…"), "preview elides leading context near a late match");
+});
+
+test("bash tool_call confirms every compound action and centers a long git -C push", async () => {
+	type ToolCallHandler = (
+		event: { toolName: string; input: unknown },
+		ctx: ExtensionContext,
+	) => Promise<ToolCallEventResult | undefined>;
+	const confirmArgs: Array<[string, string]> = [];
+	const handlers = new Map<string, ToolCallHandler>();
+	const pi = {
+		on(name: string, handler: ToolCallHandler) { handlers.set(name, handler); },
+		events: { emit() {} },
+		registerCommand() {},
+		registerTool() {},
+	} as unknown as ExtensionAPI;
+	createGentleAiExtension({ nativeReviewCli: null })(pi);
+	const toolCall = handlers.get("tool_call");
+	assert.equal(typeof toolCall, "function");
+
+	const configHome = mkdtempSync(join(tmpdir(), "gentle-pi-guard-compound-"));
+	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
+	process.env.GENTLE_PI_CONFIG_HOME = configHome;
+	try {
+		const command = `git -C /${"very-long-path/".repeat(30)} push origin main && npm publish --tag beta`;
+		const result = await toolCall!({ toolName: "bash", input: { command } }, {
+			cwd: process.cwd(),
+			hasUI: true,
+			ui: { confirm: async (title: string, message: string) => (confirmArgs.push([title, message]), false) },
+		} as ExtensionContext);
+		assert.deepEqual(result, {
+			block: true,
+			reason: "Gentle AI safety policy blocked the command because it was not confirmed.",
+		});
+	} finally {
+		if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
+		else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
+		rmSync(configHome, { recursive: true, force: true });
+	}
+
+	assert.equal(confirmArgs.length, 1);
+	const [title, preview] = confirmArgs[0];
+	assert.equal(title, "Allow guarded actions: git push; npm publish?");
+	assert.match(preview, /push origin main && npm publish --tag beta/);
+	assert.ok(preview.startsWith("…"));
+});
+// /gentle:profiles reopens its panel after every action, so a test that applies
+// once must confirm on the first visit and close on the next, or the panel and
+// the action loop feed each other forever.
+function applyOnce(
+	fixture: { onInput(action: (panel: { handleInput(data: string): void }) => void): void },
+): void {
+	let visits = 0;
+	fixture.onInput((panel) => {
+		visits += 1;
+		panel.handleInput(visits === 1 ? "\r" : "\x1b");
+	});
+}
+
+function profilesStoreFixture(t: test.TestContext) {
+	const fixture = routingConsumerFixture(t, ["worker"]);
+	const storePath = join(fixture.configHome, "profiles.json");
+	const settingsPath = join(fixture.agentHome, "settings.json");
+	const writeStore = (profiles: Record<string, unknown>, active?: string) => {
+		mkdirSync(fixture.configHome, { recursive: true });
+		const store: Record<string, unknown> = { kind: PROFILES_KIND, version: PROFILES_VERSION, profiles };
+		if (active !== undefined) store.active = active;
+		writeFileSync(storePath, `${JSON.stringify(store, null, 2)}\n`);
+	};
+	const writeSettings = (extra: Record<string, unknown> = {}) => {
+		const settings = {
+			packages: ["npm:pi-mcp-adapter"],
+			theme: "Gentleman-Cute",
+			defaultProvider: "nan",
+			defaultModel: "deepseek-v4-flash",
+			defaultThinkingLevel: "high",
+			...extra,
+		};
+		writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+		return settings;
+	};
+	return { fixture, storePath, settingsPath, writeStore, writeSettings };
+}
+
+test("applying a profile persists its orchestrator and never leaks the key into agent routing", async (t) => {
+	const { fixture, settingsPath, writeStore, writeSettings } = profilesStoreFixture(t);
+	const before = writeSettings();
+	writeStore({
+		team: {
+			orchestrator: { model: "nan/glm5.3", thinking: "max" },
+			worker: { model: "openai/alpha" },
+		},
+	});
+	applyOnce(fixture);
+	await fixture.run("gentle:profiles");
+
+	const after = JSON.parse(readFileSync(settingsPath, "utf8"));
+	assert.equal(after.defaultProvider, "nan");
+	assert.equal(after.defaultModel, "glm5.3");
+	assert.equal(after.defaultThinkingLevel, "max");
+	assert.deepEqual(after.packages, before.packages, "unrelated settings keys survive");
+	assert.equal(after.theme, before.theme, "unrelated settings keys survive");
+
+	// The reserved key is routing, not an agent: it must never reach the
+	// subagent profile store or the agent frontmatter.
+	const projectProfiles = JSON.parse(readFileSync(join(fixture.root, ".pi", "subagents.json"), "utf8"));
+	assert.equal("orchestrator" in projectProfiles.model_profiles, false);
+	assert.equal(readFileSync(join(fixture.root, ".pi", "agents", "worker.md"), "utf8"), readFileSync(join(fixture.root, ".pi", "agents", "worker.md"), "utf8"));
+	assert.match(readFileSync(join(fixture.root, ".pi", "agents", "worker.md"), "utf8"), /model: openai\/alpha/);
+	const applied = fixture.notifications.at(-1)?.message ?? "";
+	assert.match(applied, /Orchestrator set to nan\/glm5\.3 · max/);
+});
+
+test("applying a profile without an orchestrator entry leaves settings.json untouched", async (t) => {
+	const { fixture, settingsPath, writeStore, writeSettings } = profilesStoreFixture(t);
+	writeSettings();
+	writeStore({ team: { worker: { model: "openai/alpha" } } });
+	applyOnce(fixture);
+	await fixture.run("gentle:profiles");
+
+	const after = JSON.parse(readFileSync(settingsPath, "utf8"));
+	assert.equal(after.defaultProvider, "nan");
+	assert.equal(after.defaultModel, "deepseek-v4-flash");
+	assert.equal(after.defaultThinkingLevel, "high");
+	const applied = fixture.notifications.at(-1)?.message ?? "";
+	assert.doesNotMatch(applied, /Orchestrator set to/);
+});
+
+test("a profile store entry with only the orchestrator key counts zero roles", async (t) => {
+	const { fixture, writeStore } = profilesStoreFixture(t);
+	writeStore({ team: { orchestrator: { model: "nan/glm5.3", thinking: "high" } } }, "team");
+	applyOnce(fixture);
+	await fixture.run("gentle:profiles");
+	const applied = fixture.notifications.at(-1)?.message ?? "";
+	assert.match(applied, /0 agents updated/);
+	assert.match(applied, /Orchestrator set to nan\/glm5\.3 · high/);
+});
+
+test("the profiles panel fills the terminal, lists routing per agent, and scrolls", async (t) => {
+	const { fixture, writeStore } = profilesStoreFixture(t);
+	writeStore({
+		team: {
+			orchestrator: { model: "nan/glm5.3", thinking: "high" },
+			worker: { model: "openai/alpha", thinking: "high" },
+			"sdd-design": { model: "nan/glm5.3", thinking: "high" },
+		},
+	}, "team");
+	let rendered: string | undefined;
+	let panel: { render(width: number): string[] } | undefined;
+	fixture.onInput((visited) => {
+		panel = visited;
+		rendered = renderComponent(visited);
+		visited.handleInput("\x1b");
+	});
+	await fixture.run("gentle:profiles");
+
+	assert.ok(rendered);
+	const lines = rendered.split("\n");
+	// The frame spans the terminal height the fake TUI reports.
+	assert.equal(lines.length, 24, `expected 24 rows, got ${lines.length}`);
+	assert.match(lines[0], /^╭/);
+	assert.match(lines.at(-1)!, /^╰/);
+	const text = rendered;
+	// Routing is listed one agent per line, aligned in columns, never collapsed
+	// into "N agents → model: a, b, …" summaries.
+	assert.match(text, /Profile routing/);
+	assert.match(text, /Current routing \(models\.json\)/);
+	assert.match(text, /orchestrator\s+nan\/glm5\.3 · high/);
+	assert.match(text, /worker\s+openai\/alpha\s+high/);
+	assert.match(text, /sdd-design\s+nan\/glm5\.3\s+high/);
+	assert.doesNotMatch(text, /agents? → /);
+
+	// A taller terminal renders a taller frame with the same content.
+	fixture.tui.terminal.rows = 40;
+	const taller = renderComponent(panel);
+	assert.equal(taller.split("\n").length, 40);
+
+	// A short terminal clamps instead of crashing, and keeps both borders.
+	fixture.tui.terminal.rows = 9;
+	const short = stripAnsi(panel.render(120).map((line) => line.replace(/[ \t]+$/g, "")).join("\n"));
+	const shortLines = short.split("\n");
+	assert.equal(shortLines.length, 9);
+	assert.match(shortLines[0], /^╭/);
+	assert.match(shortLines.at(-1)!, /^╰/);
+});
+
+test("j and k scroll the detail pane one line at a time, like the agents view", async (t) => {
+	const { fixture, writeStore } = profilesStoreFixture(t);
+	const routing: Record<string, { model: string; thinking: string }> = {};
+	for (let index = 1; index <= 25; index += 1) {
+		routing[`agent-${String(index).padStart(2, "0")}`] = { model: "openai/alpha", thinking: "high" };
+	}
+	writeStore({ team: routing }, "team");
+	let panel: { handleInput(data: string): void; render(width: number): string[] } | undefined;
+	fixture.onInput((visited) => {
+		panel = visited;
+		visited.handleInput("\x1b");
+	});
+	await fixture.run("gentle:profiles");
+	assert.ok(panel, "the panel must open");
+	const body = () => panel!.render(120).slice(1, -2).map((line) => line.replace(/[ \t]+$/, "")).join("\n");
+	const firstAgentRow = (text: string) => text.split("\n").findIndex((line) => line.includes("agent-01"));
+	const before = body();
+	assert.ok(firstAgentRow(before) >= 0, "the first routing row must be visible before scrolling");
+	panel!.handleInput("j");
+	const afterJ = body();
+	assert.notEqual(firstAgentRow(afterJ), firstAgentRow(before), "j must scroll the detail down by one line");
+	panel!.handleInput("k");
+	assert.equal(firstAgentRow(body()), firstAgentRow(before), "k must scroll the detail back up");
+});