gentle-pi 4.4.0 → 4.5.1

package/tests/gentle-music.test.ts

@@ -5,17 +5,27 @@ import { tmpdir } from "node:os";
 import { delimiter, join } from "node:path";
 import test, { type TestContext } from "node:test";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import gentleMusic, {
+import gentleMusicExtension, {
 	findOnPath,
 	formatMusicStatus,
 	GENTLE_STREAM_SPEC,
+	installHint,
 	MUSIC_COMMAND_NAME,
+	MUSIC_INSTALL_OFFER,
+	MUSIC_WINDOWS_UNSUPPORTED,
+	MUSIC_INSTALL_TITLE,
 	musicTuiArgs,
 	parseMusicArgs,
 	resolveGentleStream,
+	type BundledMusicPlayer,
 	type MusicSpawn,
 } from "../extensions/gentle-music.ts";
 
+// The music tests describe a supported (POSIX) host unless they pass `platform`,
+// so they hold on every OS the suite runs on, Windows included.
+const gentleMusic = (pi: Parameters<typeof gentleMusicExtension>[0], deps: Parameters<typeof gentleMusicExtension>[1] = {}) =>
+	gentleMusicExtension(pi, { platform: "linux", ...deps });
+
 // /gentle:music hands the terminal to gentle-stream's own TUI, the way Pi's
 // external editor does, and controls the background player with
 // `gentle-stream ctl …` without taking the terminal.
@@ -333,3 +343,145 @@ test("Windows .cmd and .bat shims are not picked, so resolution falls back to uv
 	const resolved = resolveGentleStream((name) => findOnPath(name, env, "win32"));
 	assert.equal(resolved?.command, join(dir, "uv.EXE"));
 });
+
+// S5: a bundled Gentle Shell offers to install the player inside its own
+// folder; any other install keeps the manual hint.
+const PREVIOUS_HINT = "/gentle:music needs gentle-stream, and neither gentle-stream nor uv is on PATH. Install uv (https://docs.astral.sh/uv/getting-started/installation/) and run /gentle:music again, or install gentle-stream with: uv tool install 'gentle-stream[samples] @ git+https://github.com/Gentleman-Programming/gentle-stream'";
+
+function withConfirm(context: ReturnType<typeof fakeContext>, answer: boolean) {
+	const asked: Array<[string, string]> = [];
+	(context.ctx.ui as unknown as { confirm: (title: string, message: string) => Promise<boolean> }).confirm = async (title, message) => {
+		asked.push([title, message]);
+		return answer;
+	};
+	return asked;
+}
+
+function fakeBundled({ installed = false, fail }: { installed?: boolean; fail?: Error } = {}) {
+	const state = { installed, installs: 0 };
+	const player: BundledMusicPlayer = {
+		gentleStream: "/prefix/music/bin/gentle-stream",
+		installed: () => state.installed,
+		install: async (progress) => {
+			state.installs += 1;
+			progress("Downloading uv 0.13.6…");
+			if (fail) throw fail;
+			state.installed = true;
+			return { gentleStream: "/prefix/music/bin/gentle-stream", samples: true };
+		},
+	};
+	return { state, bundled: async () => player };
+}
+
+test("the manual hint outside a bundled install is unchanged", async () => {
+	assert.equal(installHint(), PREVIOUS_HINT);
+	const { pi, commands } = fakePi();
+	const { spawn, spawned } = fakeSpawn([]);
+	gentleMusic(pi, { which: onPath({}), spawn, bundled: async () => undefined });
+	const context = fakeContext();
+	const asked = withConfirm(context, true);
+	await commands.get(MUSIC_COMMAND_NAME)!.handler("", context.ctx);
+	assert.deepEqual(asked, [], "no offer outside a bundled install");
+	assert.deepEqual(context.notices, [[PREVIOUS_HINT, "warning"]]);
+	assert.equal(spawned.length, 0);
+});
+
+test("a bundled install without the player offers it; declining shows the hint and installs nothing", async () => {
+	const { pi, commands } = fakePi();
+	const { spawn, spawned } = fakeSpawn([]);
+	const { state, bundled } = fakeBundled();
+	gentleMusic(pi, { which: onPath({}), spawn, bundled });
+	const context = fakeContext();
+	const asked = withConfirm(context, false);
+	await commands.get(MUSIC_COMMAND_NAME)!.handler("", context.ctx);
+	assert.deepEqual(asked, [[MUSIC_INSTALL_TITLE, MUSIC_INSTALL_OFFER]]);
+	assert.equal(MUSIC_INSTALL_OFFER, "Install the gentle-stream music player inside Gentle Shell? It downloads uv, Python 3.13 and the player (about 150 MB) into the Gentle Shell folder.");
+	assert.equal(state.installs, 0);
+	assert.deepEqual(context.notices, [[PREVIOUS_HINT, "warning"]]);
+	assert.equal(spawned.length, 0);
+});
+
+test("accepting the offer installs the player with progress, then starts the music from the prefix", async () => {
+	const { pi, commands } = fakePi();
+	const context = fakeContext();
+	const { spawn, spawned } = fakeSpawn([{ code: 0 }], context.calls);
+	const { state, bundled } = fakeBundled();
+	gentleMusic(pi, { which: onPath({}), spawn, bundled, signals: fakeSignals().signals });
+	withConfirm(context, true);
+	await commands.get(MUSIC_COMMAND_NAME)!.handler("calm", context.ctx);
+	assert.equal(state.installs, 1);
+	assert.deepEqual(context.notices.map(([, type]) => type), ["info", "info"]);
+	assert.match(context.notices[0]![0], /Downloading uv/);
+	assert.match(context.notices[1]![0], /installed/i);
+	assert.equal(spawned[0]!.command, "/prefix/music/bin/gentle-stream");
+	assert.deepEqual(spawned[0]!.args, ["--model", "anthropic/claude-sonnet-5-5", "--mood", "calm"]);
+});
+
+test("on Windows /gentle:music explains it is not available yet and never offers, installs or runs anything", async () => {
+	assert.equal(MUSIC_WINDOWS_UNSUPPORTED, "/gentle:music is not available on Windows yet: the gentle-stream player runs on macOS and Linux. It works when Gentle Shell runs inside WSL.");
+	for (const args of ["", "calm", "status", "stop"]) {
+		const { pi, commands } = fakePi();
+		const context = fakeContext();
+		const asked = withConfirm(context, true);
+		const { spawn, spawned } = fakeSpawn([{ code: 0 }], context.calls);
+		const { state, bundled } = fakeBundled({ installed: true });
+		gentleMusic(pi, { which: onPath({ "gentle-stream": "C:\\bin\\gentle-stream.exe", uvx: "C:\\bin\\uvx.exe" }), spawn, bundled, signals: fakeSignals().signals, platform: "win32" });
+		await commands.get(MUSIC_COMMAND_NAME)!.handler(args, context.ctx);
+		assert.deepEqual(context.notices, [[MUSIC_WINDOWS_UNSUPPORTED, "warning"]], args);
+		assert.deepEqual(asked, [], args);
+		assert.equal(state.installs, 0, args);
+		assert.equal(spawned.length, 0, args);
+	}
+});
+
+test("on Windows the not-available notice wins over the interactive-terminal notice", async () => {
+	for (const mode of ["rpc", "json", "print"]) {
+		const { pi, commands } = fakePi();
+		const context = fakeContext(mode);
+		const { spawn, spawned } = fakeSpawn([{ code: 0 }], context.calls);
+		gentleMusic(pi, { which: onPath({ uvx: "C:\\bin\\uvx.exe" }), spawn, platform: "win32" });
+		await commands.get(MUSIC_COMMAND_NAME)!.handler("", context.ctx);
+		assert.deepEqual(context.notices, [[MUSIC_WINDOWS_UNSUPPORTED, "warning"]], mode);
+		assert.equal(spawned.length, 0, mode);
+	}
+});
+
+test("an installed prefix player is used without asking; PATH gentle-stream still comes first", async () => {
+	const { bundled } = fakeBundled({ installed: true });
+	for (const [names, expected] of [[{}, "/prefix/music/bin/gentle-stream"], [{ uvx: "/bin/uvx" }, "/prefix/music/bin/gentle-stream"], [{ "gentle-stream": "/bin/gentle-stream" }, "/bin/gentle-stream"]] as const) {
+		const { pi, commands } = fakePi();
+		const context = fakeContext();
+		const asked = withConfirm(context, false);
+		const { spawn, spawned } = fakeSpawn([{ code: 0 }], context.calls);
+		gentleMusic(pi, { which: onPath(names), spawn, bundled, signals: fakeSignals().signals });
+		await commands.get(MUSIC_COMMAND_NAME)!.handler("", context.ctx);
+		assert.deepEqual(asked, []);
+		assert.equal(spawned[0]!.command, expected);
+		assert.deepEqual(spawned[0]!.args, ["--model", "anthropic/claude-sonnet-5-5"]);
+	}
+	assert.deepEqual(resolveGentleStream(onPath({ uv: "/bin/uv" }), "/prefix/music/bin/gentle-stream"), { command: "/prefix/music/bin/gentle-stream", prefix: [] });
+});
+
+test("a bundled install with uv on PATH keeps the uvx route and does not offer", async () => {
+	const { pi, commands } = fakePi();
+	const context = fakeContext();
+	const asked = withConfirm(context, true);
+	const { spawn, spawned } = fakeSpawn([{ code: 0 }], context.calls);
+	gentleMusic(pi, { which: onPath({ uvx: "/bin/uvx" }), spawn, bundled: fakeBundled().bundled, signals: fakeSignals().signals });
+	await commands.get(MUSIC_COMMAND_NAME)!.handler("", context.ctx);
+	assert.deepEqual(asked, []);
+	assert.equal(spawned[0]!.command, "/bin/uvx");
+});
+
+test("a failed install is reported and nothing starts", async () => {
+	const { pi, commands } = fakePi();
+	const { spawn, spawned } = fakeSpawn([]);
+	gentleMusic(pi, { which: onPath({}), spawn, bundled: fakeBundled({ fail: new Error("Download integrity mismatch") }).bundled });
+	const context = fakeContext();
+	withConfirm(context, true);
+	await commands.get(MUSIC_COMMAND_NAME)!.handler("", context.ctx);
+	assert.equal(spawned.length, 0);
+	const [message, type] = context.notices.at(-1)!;
+	assert.equal(type, "error");
+	assert.match(message, /could not install gentle-stream.*Download integrity mismatch/);
+});

package/tests/gentle-shell-bundled.test.ts

@@ -274,6 +274,18 @@ test("bundledUpdatePlan redirects Pi's own update and keeps the extension update
 	}
 });
 
+test("bundledUpdatePlan marks Pi's own update with --latest and keeps every other --latest form passing through", () => {
+	for (const args of [["update", "--latest"], ["update", "pi", "--latest"], ["update", "--latest", "self"], ["update", "--self", "--latest"]]) {
+		assert.deepEqual(bundledUpdatePlan(args), { self: true, latest: true }, args.join(" "));
+	}
+	assert.deepEqual(bundledUpdatePlan(["update", "--all", "--latest"]), { self: true, latest: true, piArgs: ["update", "--extensions"] });
+	assert.deepEqual(bundledUpdatePlan(["update", "--latest", "--self", "--extensions", "-a"]), { self: true, latest: true, piArgs: ["update", "--extensions", "-a"] });
+	for (const passthrough of [["update", "--extensions", "--latest"], ["update", "npm:x", "--latest"], ["update", "--models", "--latest"], ["update", "--all", "--self", "--latest"],
+		["update", "pi", "npm:x", "--latest"], ["update", "--latest", "--bogus"], ["update", "--help", "--latest"]]) {
+		assert.deepEqual(bundledUpdatePlan(passthrough), { self: false, piArgs: passthrough }, passthrough.join(" "));
+	}
+});
+
 test("bundledUpdateNext still updates extensions when the upgrade did not complete", () => {
 	assert.deepEqual(bundledUpdateNext({ self: false, piArgs: ["update", "npm:x"] }, undefined), { piArgs: ["update", "npm:x"] });
 	assert.deepEqual(bundledUpdateNext({ self: true }, 0), { exitCode: 0 });
@@ -283,6 +295,9 @@ test("bundledUpdateNext still updates extensions when the upgrade did not comple
 	const failed = bundledUpdateNext({ self: true, piArgs: ["update", "--extensions"] }, 1);
 	assert.deepEqual("piArgs" in failed ? failed.piArgs : [], ["update", "--extensions"]);
 	assert.match("note" in failed ? String(failed.note) : "", /upgrade did not complete.*extensions/);
+	const latest = bundledUpdateNext({ self: true, latest: true, piArgs: ["update", "--extensions"] }, 1);
+	assert.match("note" in latest ? String(latest.note) : "", /latest Pi update did not complete.*extensions/);
+	assert.deepEqual(bundledUpdateNext({ self: true, latest: true }, 1), { exitCode: 1 });
 });
 
 test("bundledUpdateNotice explains the pinned Pi and runs or names gentle-shell upgrade", () => {
@@ -290,6 +305,11 @@ test("bundledUpdateNotice explains the pinned Pi and runs or names gentle-shell
 	assert.match(interactive, /Pi ships pinned with Gentle Shell \(Pi 1\.2\.0\)/);
 	assert.match(interactive, /Running 'gentle-shell upgrade'/);
 	assert.match(bundledUpdateNotice({ piVersion: "1.2.0", interactive: false }).join("\n"), /Run 'gentle-shell upgrade'/);
+	for (const interactive of [true, false]) {
+		const lines = bundledUpdateNotice({ piVersion: "1.2.0", interactive });
+		assert.equal(lines[0], "Pi ships pinned with Gentle Shell (Pi 1.2.0): a newer Pi arrives with a Gentle Shell release.");
+		assert.equal(lines.at(-1), "Run 'gentle-shell update --latest' to install the newest published Pi now, without the release's verified lockfile.");
+	}
 });
 
 test("parseBundledUpgradeArgs accepts the release channel and --rollback and refuses the main channel", () => {

package/tests/gentle-shell-launcher.test.ts

@@ -214,6 +214,7 @@ test("help text documents the bundled upgrade, its rollback and the pinned Pi up
 	assert.ok(text.includes("       gentle-shell upgrade --rollback"));
 	assert.match(text, /bundled install.*release channel only.*--rollback switches back to the previous kept version/s);
 	assert.match(text, /In a bundled install Pi ships pinned: 'update' without a package\n\s+runs 'gentle-shell upgrade'/);
+	assert.match(text, /'update --latest' installs the newest published Pi instead,\n\s+without the release's verified lockfile\./);
 });
 
 test("parseLauncherArgs treats home as a plain passthrough token when it is not argv[0]", () => {

package/tests/gentle-shell.test.ts

@@ -24,6 +24,7 @@ import type { ShellBarTheme } from "../lib/shell-bar.ts";
 import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
 import { decodeReviewStatusV3 } from "../lib/review-integration-v2.ts";
 import { REVIEW_SIDEBAR_EVENT } from "../lib/review-sidebar-state.ts";
+import { isJobsSidebarSnapshot } from "../lib/jobs-sidebar-state.ts";
 import type { NativeReviewCli } from "../lib/native-review-cli.ts";
 import { resolveVisualSettings, writeVisualSettings } from "../lib/visual-customization-policy.ts";
 import { resolveAnimationPolicy } from "../lib/animation-policy.ts";
@@ -111,7 +112,7 @@ const renderers = new Map<string, MessageRenderer>();
 const FAKE_SOURCE_INFO: SourceInfo = { path: "extensions/gentle-shell.ts", source: "gentle-shell", scope: "project", origin: "top-level" };
 
 const DEFAULT_COMMANDS: SlashCommandInfo[] = [
-	{ name: "gentle:models", description: "Configure models", source: "extension", sourceInfo: FAKE_SOURCE_INFO },
+	{ name: "gentle:profiles", description: "Configure models", source: "extension", sourceInfo: FAKE_SOURCE_INFO },
 	{ name: "gentle:changes", description: "Browse changes", source: "extension", sourceInfo: FAKE_SOURCE_INFO },
 	{ name: "gentle:status", description: "Show Gentle AI status", source: "extension", sourceInfo: FAKE_SOURCE_INFO },
 	{ name: "skill-registry:refresh", description: "Regenerate the skill registry", source: "extension", sourceInfo: FAKE_SOURCE_INFO },
@@ -503,7 +504,7 @@ test("review sidebar rejects foreign-session events and unsubscribes on shutdown
 	}
 });
 
-test("jobs snapshots populate Status, use one compact fallback, and reject stale sessions", async () => {
+test("jobs snapshots feed their own rail card, keep one compact fallback, and reject stale sessions", async () => {
 	const { pi, handlers } = fakePi();
 	gentleShell(pi, { GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off" });
 	const { ctx, ui } = fakeContext();
@@ -515,35 +516,56 @@ test("jobs snapshots populate Status, use one compact fallback, and reject stale
 	const component = factory(tui, plainTheme, data);
 	const state = sidebarState(tui as unknown as TUI);
 	const rail = state.parts.get("footer")!;
+	const jobs = state.parts.get("jobs")!;
 	const header = state.parts.get("header")!;
 	const publish = (sessionId: string, jobs: unknown) => pi.events.emit("gentle-ai:jobs-sidebar", { sessionId, snapshot: { jobs } });
 	try {
 		publish("shell-session", [{ id: "job-1", label: "CI for PR 1860", startedAt: 1 }]);
-		assert.match(rail.render(46).join("\n"), /Jobs[\s\S]*CI for PR 1860/);
+		assert.doesNotMatch(rail.render(46).join("\n"), /Jobs|CI for PR 1860/, "the Status card never prints jobs; the jobs card owns them");
 		assert.match(rail.render(46).join("\n"), /MCP: 3 servers/);
-		assert.doesNotMatch(rail.render(46).join("\n"), /1 job/, "Jobs replaces the generic integration counter");
+		assert.match(jobs.render(46).join("\n"), /Jobs[\s\S]*CI for PR 1860/);
+		publish("shell-session", [{ id: "job-1", label: "CI for PR 1860", startedAt: 1 }, { id: "job-0", label: "Build runtime", startedAt: 1, status: "exited", endedAt: Date.now(), exitCode: 0 }]);
+		assert.match(jobs.render(60).join("\n"), /1 running · 1 finished/, "finished tails ride the same snapshot");
+		assert.match(jobs.render(60).join("\n"), /✓\s+Build runtime/);
+		// The compact count is running-only: a finished tail still paints the
+		// card, but the header's ⧗ N jobs derives from running entries alone.
+		publish("shell-session", [{ id: "job-2", label: "Fresh tail", startedAt: 1, status: "exited", endedAt: Date.now(), exitCode: 0 }]);
+		tui.terminal.columns = 80;
+		assert.match(jobs.render(46).join("\n"), /Fresh tail/, "the finished tail still paints the card");
+		assert.doesNotMatch(header.render(80).join("\n"), /⧗ 1 job/, "the compact count is running-only");
+		tui.terminal.columns = 160;
+		publish("shell-session", [{ id: "job-0", label: "Stale tail", startedAt: 1, status: "exited", endedAt: 5, exitCode: 0 }]);
+		assert.doesNotMatch(jobs.render(46).join("\n"), /Stale tail/, "a finished job past the TTL paints nothing");
+		assert.doesNotMatch(rail.render(46).join("\n"), /1 job/, "the jobs counter never joins the integration statuses while display data exists");
 		state.active = true;
 		state.ownsHost = () => true;
-		assert.doesNotMatch(header.render(160).join("\n"), /1 job/, "the visible Status card owns jobs details");
+		assert.doesNotMatch(header.render(160).join("\n"), /1 job/, "the visible rail owns job details");
 		state.active = false;
 		tui.terminal.columns = 80;
-		assert.match(header.render(80).join("\n"), /1 job/, "mobile topbar preserves the count");
-		const before = rail.digest?.();
+		publish("shell-session", [{ id: "job-1", label: "CI for PR 1860", startedAt: 1 }]);
+		assert.match(header.render(80).join("\n"), /1 job/, "mobile topbar preserves the count of a running job");
+		const before = jobs.render(46).join("\n");
 		publish("foreign", []);
 		publish("shell-session", [{ label: "invalid" }]);
-		assert.equal(rail.digest?.(), before);
+		assert.equal(jobs.render(46).join("\n"), before);
 		publish("shell-session", []);
-		assert.doesNotMatch(rail.render(46).join("\n"), /Jobs|CI for PR/);
+		assert.doesNotMatch(jobs.render(46).join("\n"), /Jobs|CI for PR/);
 		assert.doesNotMatch(header.render(80).join("\n"), /1 job/);
 		publish("shell-session", [{ id: "job-2", label: "Build runtime", startedAt: 2 }]);
 		await fire(handlers, "session_start", ctx);
-		assert.doesNotMatch(rail.render(46).join("\n"), /Build runtime/);
+		assert.doesNotMatch(state.parts.get("jobs")!.render(46).join("\n"), /Build runtime/);
 		await fire(handlers, "session_shutdown", ctx);
 		publish("shell-session", [{ id: "job-3", label: "late", startedAt: 3 }]);
-		assert.doesNotMatch(rail.render(46).join("\n"), /late/);
+		assert.doesNotMatch(state.parts.get("jobs")!.render(46).join("\n"), /late/);
 	} finally { component.dispose(); }
 });
 
+test("the jobs snapshot validator admits the finished-tail statuses", () => {
+	assert.ok(isJobsSidebarSnapshot({ jobs: [{ id: "job-1", label: "Spawn failed", startedAt: 1, status: "failed", endedAt: 60_000, exitCode: null }] }));
+	assert.ok(isJobsSidebarSnapshot({ jobs: [{ id: "job-2", label: "Stopped", startedAt: 1, status: "stopped", endedAt: 2 }] }));
+	assert.equal(isJobsSidebarSnapshot({ jobs: [{ id: "job-3", label: "Bad", startedAt: 1, status: "exploded" }] }), false);
+});
+
 test("hidden Status leaves only a jobs count in regular bottom and fullscreen header chrome", async (t) => {
 	const home = scopedDoubleEscCancelConfigHome(t);
 	writeVisualSettings({ ...resolveVisualSettings({ gentlePiConfigHome: home }).settings, statusPlacement: "hidden" }, { gentlePiConfigHome: home });
@@ -559,6 +581,9 @@ test("hidden Status leaves only a jobs count in regular bottom and fullscreen he
 		pi.events.emit("gentle-ai:jobs-sidebar", { sessionId: "shell-session", snapshot: { jobs: [{ id: "job-1", label: "CI for PR 1860", startedAt: 1 }] } });
 		assert.equal(component.render(80).join("\n"), "⧗ 1 job");
 		assert.doesNotMatch(component.render(80).join("\n"), /CI for PR|gpt-5/);
+		pi.events.emit("gentle-ai:jobs-sidebar", { sessionId: "shell-session", snapshot: { jobs: [{ id: "job-1", label: "CI for PR 1860", startedAt: 1, status: "exited", endedAt: Date.now(), exitCode: 0 }] } });
+		assert.doesNotMatch(component.render(80).join("\n"), /⧗/, "a finished-only tail never paints a ⧗ 0 jobs row");
+		pi.events.emit("gentle-ai:jobs-sidebar", { sessionId: "shell-session", snapshot: { jobs: [{ id: "job-1", label: "CI for PR 1860", startedAt: 1 }] } });
 		tui.mode = "fullscreen";
 		const header = sidebarState(tui as unknown as TUI).parts.get("header")!;
 		assert.match(header.render(160).join("\n"), /⧗ 1 job/);
@@ -2168,7 +2193,7 @@ test("vim NORMAL slash uses Pi's command and skill completion without displacing
 		fg: (_color, text) => text, bold: (text) => text, requestRender() {}, pending: () => false,
 		now: () => 0, doubleEscCancelEnabled: () => false, dispatchQueuedText() {}, tuiVersion: () => INSTALLED_PI,
 	});
-	const entries = ["gentle:vim", "gentle:models", "skill:example"];
+	const entries = ["gentle:vim", "gentle:profiles", "skill:example"];
 	const requests: string[] = [];
 	editor.setAutocompleteProvider({
 		async getSuggestions(lines: string[], line: number, col: number) {
@@ -5668,11 +5693,11 @@ test("/gentle:commands shows only curated, registered commands, grouped, by thei
 	assert.match(rendered, /Diagnostics/);
 	assert.match(rendered, /Skills/);
 	assert.doesNotMatch(rendered, /\bSDD\b/, "the SDD group has no registered commands and must not appear");
-	assert.match(rendered, /Assign models and effort/);
+	assert.match(rendered, /Models and profiles/);
 	assert.match(rendered, /Browse changes/);
 	assert.match(rendered, /Gentle AI status/);
 	assert.match(rendered, /Refresh skill registry/);
-	assert.doesNotMatch(rendered, /gentle:models|gentle:changes|gentle:status|skill-registry:refresh/, "raw command names must not leak; only labels are shown");
+	assert.doesNotMatch(rendered, /gentle:profiles|gentle:changes|gentle:status|skill-registry:refresh/, "raw command names must not leak; only labels are shown");
 	assert.doesNotMatch(rendered, /gentle:not-in-catalog/);
 	assert.doesNotMatch(rendered, /skill:foo/);
 	const changesLine = lines.find((line) => line.includes("Browse changes"));
@@ -5687,13 +5712,13 @@ test("selecting a command from the palette by its label sends the underlying com
 	const { ctx, ui, overlayReady } = fakeContext();
 	const opened = commands.get("gentle:commands")!.handler("", ctx);
 	await overlayReady;
-	// "mod" only matches the "Assign models and effort" label (it contains
-	// "mod" via "models"); nothing else in the fixture does.
+	// "mod" only matches the "Models and profiles" label (it contains "mod"
+	// via "Models"); nothing else in the fixture does.
 	for (const ch of "mod") ui.overlayView!.handleInput(ch);
-	assert.match(ui.overlayView!.render(100).join("\n"), /Assign models and effort/);
+	assert.match(ui.overlayView!.render(100).join("\n"), /Models and profiles/);
 	ui.overlayView!.handleInput("\r");
 	await opened;
-	assert.deepEqual(sentMessages, [{ content: "/gentle:models", options: { expandPromptTemplates: true } }]);
+	assert.deepEqual(sentMessages, [{ content: "/gentle:profiles", options: { expandPromptTemplates: true } }]);
 });
 
 test("escaping the palette sends no message", async () => {
@@ -5736,7 +5761,7 @@ test("the alt+k shortcut opens the same command palette as the command", async (
 	assert.ok(shortcut, "alt+k not registered");
 	const opened = shortcut.handler(ctx);
 	await overlayReady;
-	assert.match(ui.overlayView!.render(100).join("\n"), /Assign models and effort/);
+	assert.match(ui.overlayView!.render(100).join("\n"), /Models and profiles/);
 	ui.overlayView!.handleInput("\x1b");
 	await opened;
 });

package/tests/installer-downloads.test.ts

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { artifactFor, uvPinVersion } from "../scripts/installer-downloads.mjs";
+
+// The uv the /gentle:music offer installs inside a bundled prefix (S5): the
+// astral-sh/uv release archives, each re-hashed after download before pinning.
+const uvPins = {
+	"darwin-arm64": ["uv-aarch64-apple-darwin.tar.gz", "60fbd5c8a1ed681845eea28d9d622fcde03c51e91a43465b64a1e17db1ed3472", 14235670],
+	"darwin-x64": ["uv-x86_64-apple-darwin.tar.gz", "63ba17fdda55ad1a230d4b37fc6017ffa10c23688c83818bd3bfdf914c652a02", 17004934],
+	"linux-x64": ["uv-x86_64-unknown-linux-gnu.tar.gz", "f29c3e94ffabd7e6f3ba521dba169a9b7ec12100bf3257087f0f24f6123f3645", 16799024],
+	"linux-arm64": ["uv-aarch64-unknown-linux-gnu.tar.gz", "229e194255c7958d86d56e8790d969a6f74736592133f0dfd0076f754c642c1d", 15794886],
+	"win32-x64": ["uv-x86_64-pc-windows-msvc.zip", "a2a8820d5eea32f08ef467ef3b7f66883a9b076d5737a2fc2fbb5f458d1bb50f", 15239500],
+	"win32-arm64": ["uv-aarch64-pc-windows-msvc.zip", "c2426c0c8e28b53d8c440e47a18d96ad4db51e159866c0e81435b196d7f0081c", 15439263],
+} as const;
+
+test("fixed uv descriptors are the astral-sh/uv release archives and checksums, and nothing else", () => {
+	assert.equal(uvPinVersion, "0.13.6");
+	for (const [target, [asset, sha256, size]] of Object.entries(uvPins)) {
+		const [platform, arch] = target.split("-");
+		const artifact = artifactFor("uv", platform, arch);
+		assert.equal(artifact.name, "uv");
+		assert.equal(artifact.version, "0.13.6");
+		assert.equal(artifact.url, `https://github.com/astral-sh/uv/releases/download/0.13.6/${asset}`);
+		assert.equal(artifact.integrity, `sha256-${sha256}`);
+		assert.deepEqual([artifact.size, artifact.maxBytes], [size, size]);
+		assert.deepEqual(artifact.redirectHosts, ["objects.githubusercontent.com", "release-assets.githubusercontent.com"]);
+		assert.ok(Object.isFrozen(artifact));
+	}
+	for (const [platform, arch] of [["linux", "ia32"], ["freebsd", "x64"], ["win32", "ia32"], ["darwin", "ppc64"]]) {
+		assert.throws(() => artifactFor("uv", platform, arch), /Unsupported/);
+	}
+});

package/tests/installer-server.test.ts

@@ -306,8 +306,8 @@ test("/api/plan names the found and required version of an older Gentle Shell an
 		const view = await plan(port, await login());
 		assert.deepEqual(view.blockers.map((blocker: { code: string; tool: string }) => [blocker.code, blocker.tool]), [["incompatible-tool", "shell"]]);
 		assert.equal(view.blockers[0].guidance,
-			"Gentle Shell 3.4.0 is installed globally with pnpm, but this installer needs 4.4.0 or newer. Nothing was replaced. " +
-			"Update it with `pnpm add -g gentle-pi@4.4.0`, or remove it with `pnpm remove -g gentle-pi`, then select Check again.");
+			"Gentle Shell 3.4.0 is installed globally with pnpm, but this installer needs 4.5.1 or newer. Nothing was replaced. " +
+			"Update it with `pnpm add -g gentle-pi@4.5.1`, or remove it with `pnpm remove -g gentle-pi`, then select Check again.");
 		assert.deepEqual(view.actions, []);
 	} finally {
 		await host.close("test");

package/tests/jobs-widget.test.ts

@@ -0,0 +1,138 @@
+import assert from "node:assert/strict";
+import test, { after, before } from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { JOBS_GLYPH, renderJobsCard, widgetJobs } from "../lib/jobs-widget.ts";
+import { CARD_STYLE, cardStyle, setCardStyle } from "../lib/shell-card.ts";
+import { stripAnsi } from "../lib/terminal-theme.ts";
+
+// The Jobs sidebar card replaces the Jobs group the Status card used to print.
+// Rendering is pure, so it verifies without a TUI: newest job first, one row
+// per running job with its elapsed time, collapsible like Agents and Todos.
+
+// Width math counts every painted character, so these assertions use a plain
+// theme; colored roles are covered by the widget's paint calls, not here.
+const plainTheme = {
+	fg(_color: string, text: string) {
+		return text;
+	},
+	bold(text: string) {
+		return text;
+	},
+};
+
+const jobs = [
+	{ id: "job-2", label: "Watcher CI ronda 2", startedAt: 40_000 },
+	{ id: "job-1", label: "Build runtime", startedAt: 10_000 },
+];
+
+// The card style defaults to float; these assertions pin the outlined (neon)
+// panels unless a test switches the style itself.
+const initialCardStyle = cardStyle();
+before(() => setCardStyle(CARD_STYLE.NEON));
+after(() => setCardStyle(initialCardStyle));
+
+test("the jobs card lists running jobs newest first with elapsed time", () => {
+	const lines = renderJobsCard(jobs, plainTheme, 50, 100_000, { collapsed: false, collapseControl: true });
+	const text = lines.join("\n");
+	assert.match(text, new RegExp(`${JOBS_GLYPH} Jobs`));
+	assert.match(text, /2 running/);
+	const watcher = text.indexOf("Watcher CI ronda 2");
+	const build = text.indexOf("Build runtime");
+	assert.ok(watcher >= 0, "the newest job paints");
+	assert.ok(build > watcher, "newest first, matching the /gentle:jobs running group");
+	assert.match(text, /1m 0s/, "the 60s job shows its elapsed time");
+	assert.match(text, /1m 30s/, "the 90s job shows its elapsed time");
+	assert.match(text, /▾ Collapse/);
+	for (const line of lines) assert.ok(visibleWidth(stripAnsi(line)) <= 50, `row fits: ${stripAnsi(line)}`);
+});
+
+test("an empty job list paints nothing", () => {
+	assert.deepEqual(renderJobsCard([], plainTheme, 50, 100_000, { collapsed: false }), []);
+});
+
+test("a collapsed jobs card keeps the newest job and folds the rest", () => {
+	// Wide enough for the header to also fit the "ctrl+shift+j expand" hint.
+	const lines = renderJobsCard(jobs, plainTheme, 64, 100_000, { collapsed: true, collapseKey: "ctrl+shift+j", collapseControl: true });
+	const text = lines.join("\n");
+	assert.match(text, /Watcher CI ronda 2/);
+	assert.doesNotMatch(text, /Build runtime/);
+	assert.match(text, /… 1 more/);
+	assert.match(text, /ctrl\+shift\+j expand/);
+	assert.match(text, /▸ Expand/);
+});
+
+test("the collapse control is opt-in and the sort never mutates the snapshot", () => {
+	const snapshot = [{ id: "job-1", label: "Build runtime", startedAt: 10_000 }];
+	const lines = renderJobsCard(snapshot, plainTheme, 50, 100_000, { collapsed: false });
+	assert.doesNotMatch(lines.join("\n"), /Collapse|Expand/);
+	const sorted = widgetJobs(snapshot, 100_000);
+	assert.deepEqual(snapshot, [{ id: "job-1", label: "Build runtime", startedAt: 10_000 }]);
+	assert.equal(sorted[0]?.id, "job-1");
+});
+
+// Finished tails mirror the Agents card's results: an exit lingers for a
+// minute with the /gentle:jobs outcome glyph, its elapsed frozen at the end.
+
+const exitedJob = { id: "job-1", label: "Build runtime", startedAt: 10_000, status: "exited" as const, endedAt: 70_000, exitCode: 0 as number | null };
+
+function finishedJobs(): Array<typeof exitedJob> {
+	return [1, 2, 3, 4].map((n) => ({ ...exitedJob, id: `job-${n}`, label: `Job ${n}`, startedAt: n * 1_000, endedAt: 100_000 + n * 1_000 }));
+}
+
+test("a finished job lingers with a ✓ row and its elapsed frozen at the end", () => {
+	const lines = renderJobsCard([exitedJob], plainTheme, 50, 100_000, { collapsed: false });
+	const text = lines.join("\n");
+	assert.match(text, /✓\s+Build runtime/);
+	assert.match(text, /1m 0s/, "elapsed freezes at endedAt instead of ticking to 1m 30s");
+	assert.match(text, /1 finished/);
+	for (const line of lines) assert.ok(visibleWidth(stripAnsi(line)) <= 50, `row fits: ${stripAnsi(line)}`);
+});
+
+test("a nonzero exit paints ✗ and a stopped job paints –", () => {
+	const lines = renderJobsCard([
+		{ ...exitedJob, exitCode: 1 },
+		{ id: "job-2", label: "Watcher CI", startedAt: 5_000, status: "stopped", endedAt: 60_000 },
+	], plainTheme, 50, 100_000, { collapsed: false });
+	const text = lines.join("\n");
+	assert.match(text, /✗\s+Build runtime/);
+	assert.match(text, /–\s+Watcher CI/);
+	assert.match(text, /2 finished/);
+});
+
+test("a failed job rides the tail with the ✗ glyph", () => {
+	const lines = renderJobsCard([{ ...exitedJob, status: "failed" as const }], plainTheme, 50, 100_000, { collapsed: false });
+	const text = lines.join("\n");
+	assert.match(text, /✗\s+Build runtime/);
+	assert.match(text, /1m 0s/, "elapsed freezes at endedAt like the other outcomes");
+	assert.match(text, /1 finished/);
+});
+
+test("finished jobs past the TTL paint nothing", () => {
+	// now - endedAt lands exactly on the TTL: not fresh anymore.
+	assert.deepEqual(renderJobsCard([{ ...exitedJob, endedAt: 40_000 }], plainTheme, 50, 100_000, { collapsed: false }), []);
+});
+
+test("at most the three newest finished jobs survive", () => {
+	const jobs = finishedJobs();
+	const shown = widgetJobs(jobs, 105_000);
+	assert.deepEqual(shown.map((job) => job.id), ["job-4", "job-3", "job-2"]);
+	assert.deepEqual(jobs, finishedJobs(), "the TTL filter never mutates the snapshot");
+});
+
+test("running entries sort before the finished tail and never expire", () => {
+	const snapshot = [
+		{ ...exitedJob, id: "done", label: "Old build", startedAt: 1_000 },
+		{ id: "old", label: "Old run", startedAt: 1_000 },
+		{ id: "new", label: "New run", startedAt: 50_000 },
+	];
+	const shown = widgetJobs(snapshot, 100_000);
+	assert.deepEqual(shown.map((job) => job.id), ["new", "old", "done"]);
+});
+
+test("the subtitle mixes running and finished counts", () => {
+	const lines = renderJobsCard([
+		{ id: "job-1", label: "New run", startedAt: 50_000 },
+		{ id: "job-2", label: "Watcher CI", startedAt: 5_000, status: "stopped", endedAt: 60_000 },
+	], plainTheme, 50, 100_000, { collapsed: false });
+	assert.match(lines.join("\n"), /1 running · 1 finished/);
+});

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

@@ -7,7 +7,7 @@ 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
+// consent. Persisted clear entries (an "inherit" saved from /gentle:profiles 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.
@@ -66,7 +66,7 @@ function preservedProfilesFixture(t: test.TestContext) {
 
 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
+	// Saved routing as /gentle:profiles 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);

package/tests/package-manifest.test.ts

@@ -1793,9 +1793,9 @@ test("pi-pretty wrapper uses cached ESM loading for compiled and pnpm symlink in
 	assert.match(wrapper, /quietToolsEnabled/);
 });
 
-test("Gentle Shell v4.4.0 package manifest declares the release version", () => {
+test("Gentle Shell v4.5.1 package manifest declares the release version", () => {
 	const packageJson = readPackageJson();
-	assert.equal(packageJson.version, "4.4.0", "the release manifest must be explicitly pinned to v4.4.0");
+	assert.equal(packageJson.version, "4.5.1", "the release manifest must be explicitly pinned to v4.5.1");
 	assert.equal(packageJson.scripts?.test, "node scripts/run-test-suite.mjs");
 	assert.ok(packageJson.files?.includes("assets/"));
 	assert.ok(packageJson.files?.includes("contracts/"));

package/tests/persona-reply-language.test.ts

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { __testing } from "../extensions/gentle-ai.ts";
+
+// gentle-shell #55 / #57 / #125: the reply language is inferred every turn,
+// never stored, so the persona prompt itself must say how to infer it. The
+// rule lives on the single existing language-match bullet (the concept-level
+// duplication guard allows exactly one), so these tests read the rendered
+// prompt rather than a second rule.
+
+for (const persona of ["gentleman", "neutral"] as const) {
+	test(`[${persona}] the reply language follows the user's latest message, never a Spanish default (#125, #57)`, () => {
+		const prompt = __testing.buildGentlePrompt(persona);
+		assert.match(prompt, /Always respond in the same language the user writes in\./);
+		assert.match(
+			prompt,
+			/latest message, never by earlier context or a compaction summary/,
+			`${persona} prompt must judge the reply language by the user's latest message, so a compaction summary cannot flip it (#57)`,
+		);
+		assert.match(
+			prompt,
+			/never default to Spanish: a message in English gets a reply in English/,
+			`${persona} prompt must forbid a Spanish default, so an English message never gets a Spanish reply (#125)`,
+		);
+	});
+}
+
+test("[neutral] the voseo prohibition covers regular and irregular forms, not only four irregular verbs (#55)", () => {
+	const prompt = __testing.buildGentlePrompt("neutral");
+	assert.match(prompt, /Do NOT use voseo/);
+	assert.match(prompt, /regular or irregular: use tú or usted forms, never vos forms/);
+	for (const pair of ["ajustas, not ajustás", "vives, not vivís", "mira, not mirá", "haz, not hacé"]) {
+		assert.ok(prompt.includes(pair), `neutral prompt must name the voseo replacement "${pair}"`);
+	}
+});
+
+test("[gentleman] Spanish replies keep Rioplatense voseo and get no neutral-only rule", () => {
+	const prompt = __testing.buildGentlePrompt("gentleman");
+	assert.match(prompt, /When the user writes Spanish, answer in natural Rioplatense Spanish with voseo\./);
+	assert.match(prompt, /Language: natural Rioplatense Spanish with voseo when the user writes Spanish\./);
+	assert.doesNotMatch(prompt, /never vos forms/, "gentleman prompt must not inherit the neutral voseo prohibition");
+});