gentle-pi 4.1.0 → 4.2.0

package/tests/pi-update.test.ts

@@ -0,0 +1,186 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { managedUpdatePlan, updateSelectedPi } from '../scripts/pi-update.mjs';
+import { bundledUpdatePlan, bundledUpdateNext } from '../runtime/gentle-shell-bundled.mjs';
+
+const PI = '@earendil-works/pi-coding-agent';
+const CLI = 'dist/bundle/cli.js';
+
+// The layouts pnpm v11 and npm really produce. pnpm links each top-level
+// package from its own global group into the linked store, where Shell's
+// peer is a sibling of the Shell package; a separate global Pi links to the
+// same store entry. npm nests the peer under the Shell package.
+function fixture({windows = false, npm = false, runtime = 'adjacent', groups = 'both', peerAfter = '1.2.0', shellVersion = '4.1.0',
+ badManifest = false, failed = false, mismatch = false, linked = false, readback = true, unrelatedPeer = false, shim = ''} = {}) {
+ const base = windows ? 'C:/pnpm' : '/pnpm';
+ const storePi = (version: string) => `${base}/store/links/@earendil-works/pi-coding-agent/${version}/h/node_modules/${PI}`;
+ const shellModules = npm ? `${base}/npm/lib/node_modules` : `${base}/store/links/@/gentle-pi/4.1.0/h1/node_modules`;
+ const shell = `${shellModules}/gentle-pi`;
+ const nestedPeer = `${shell}/node_modules/${PI}`;
+ const g1 = npm ? shellModules : `${base}/global/v11/g1/node_modules`;
+ const g2 = npm ? shellModules : `${base}/global/v11/g2/node_modules`;
+ const g3 = `${base}/global/v11/g3/node_modules`;
+ const state = {peer: '1.1.0', group: '1.1.0'};
+ const peerRoot = () => npm ? nestedPeer : storePi(state.peer);
+ const selectedCli = `${npm ? (runtime === 'adjacent' ? nestedPeer : `${shellModules}/${PI}`) : storePi('1.1.0')}/${CLI}`;
+ // A package-manager shim on PATH: its text names the global Pi group's cli.js.
+ const shimFile = `${base}/bin/pi${windows ? '.CMD' : ''}`;
+ const shimText = shim === 'posix' ? `#!/bin/sh\nbasedir=$(dirname "$0")\nexec node  "$basedir/../global/v11/g2/node_modules/${PI}/${CLI}" "$@"\n`
+  : shim === 'windows' ? `@"%~dp0\\..\\global\\v11\\g2\\node_modules\\@earendil-works\\pi-coding-agent\\dist\\bundle\\cli.js" %*\r\n`
+  : shim === 'two' ? `"$basedir/../a/dist/bundle/cli.js" "$basedir/../b/dist/bundle/cli.js"` : shim === 'none' ? '#!/bin/sh\nexec something\n' : '';
+ const mutations: string[][] = [];
+ const out: string[] = [];
+ const cwds: unknown[] = [];
+ const entry = (pkg: string, modules: string, extra = {}) => ({[pkg]: {path: `${modules}/${pkg}`, ...extra}});
+ const shellEntry = entry('gentle-pi', g1, linked ? {link: true} : {});
+ const piEntry = entry(PI, g2, linked ? {resolved: 'file:/src/pi'} : {});
+ const listing = () => {
+  const deps = {...(groups !== 'pi' ? shellEntry : {}), ...(groups !== 'shell' ? piEntry : {}),
+   ...(groups === 'shared' ? entry('unrelated-tool', g1) : {}), ...(groups === 'separate' ? entry('unrelated-tool', g3) : {})};
+  const group = {path: npm ? shellModules : `${base}/global/v11`, dependencies: deps};
+  return npm ? group : [group];
+ };
+ const exists = (n: string) => [g1, g2, g3, shellModules, shell, storePi(state.peer), storePi(state.group), storePi('1.1.0'), nestedPeer]
+  .some(root => n === root || n.startsWith(root + '/'));
+ const realpath = async (value: string) => {
+  const n = value.replaceAll('\\', '/');
+  if (n === shimFile) return n;
+  // Symlinked components inside a longer path resolve like the real filesystem does.
+  if (n.startsWith(`${g2}/${PI}/`)) return (npm ? `${g2}/${PI}` : storePi(state.group)) + n.slice(`${g2}/${PI}`.length);
+  if (n === `${g1}/gentle-pi` || n === `${g1}/unrelated-tool` || n === `${g3}/unrelated-tool`) return n === `${g1}/gentle-pi` ? shell : n;
+  if (n === `${g2}/${PI}`) return npm ? n : storePi(state.group);
+  if (!npm && n === `${shellModules}/${PI}`) return storePi(state.peer);
+  if (!npm && n === nestedPeer) throw new Error('ENOENT nested peer');
+  // Only joined (backslash) paths mismatch: the selected CLI itself stays canonical.
+  if (mismatch && n.endsWith(CLI) && value.includes('\\')) return `${base}/other/cli.js`;
+  if (exists(n)) return n;
+  throw new Error(`ENOENT ${n}`);
+ };
+ const readFile = async (value: string) => {
+  const n = value.replaceAll('\\', '/');
+  if (n === shimFile) return shimText;
+  if (n === `${shell}/package.json`) return JSON.stringify({name: 'gentle-pi', ...(shellVersion ? {version: shellVersion} : {})});
+  if (n === `${g1}/unrelated-tool/package.json`) return JSON.stringify({name: 'unrelated-tool'});
+  const version = n.startsWith(nestedPeer) ? state.peer : /pi-coding-agent\/([\d.]+)\/h\//.exec(n)?.[1];
+  if (badManifest || unrelatedPeer) return JSON.stringify({name: unrelatedPeer ? 'other' : PI, version});
+  return JSON.stringify({name: PI, version, bin: {pi: CLI}});
+ };
+ const run = async (_command: string, args: string[], options?: {cwd?: unknown}) => {
+  cwds.push(options?.cwd);
+  if (args.includes('list') || args.includes('ls')) return {code: failed ? 1 : 0, stdout: readback || mutations.length === 0 ? JSON.stringify(listing()) : '{'};
+  mutations.push(args);
+  if (args.some(arg => arg.startsWith('gentle-pi@'))) state.peer = peerAfter;
+  if (args.some(arg => arg.startsWith(PI + '@'))) state.group = peerAfter;
+  return {code: 0};
+ };
+ return {mutations, out, cwds, state, shell, selectedCli, input: {platform: windows ? 'win32' : 'linux', packageRoot: `${g1}/gentle-pi`, currentVersion: '1.1.0', cwd: '/neutral',
+  runtime: runtime === 'adjacent' ? {kind: 'bundled', command: 'node', args: [selectedCli]} : {kind: runtime, command: shim ? shimFile : selectedCli, args: []},
+  out: (line: string) => out.push(line),
+  adapters: {which: async (name: string) => name === (npm ? 'npm' : 'pnpm') ? `/fake/${name}` : null, fs: {realpath, readFile}, run}}};
+}
+
+test('prefix distribution still redirects self update and forwards only extensions for all', () => {
+ assert.deepEqual(bundledUpdatePlan(['update']), {self: true});
+ assert.deepEqual(bundledUpdateNext(bundledUpdatePlan(['update']), 0), {exitCode: 0});
+ assert.deepEqual(bundledUpdatePlan(['update', '--all']), {self: true, piArgs: ['update', '--extensions']});
+ assert.deepEqual(bundledUpdatePlan(['update', '--extensions-only']), {self: false, piArgs: ['update', '--extensions-only']});
+});
+
+for (const args of [['update', '--extensions-only'], ['update', '--extensions'], ['update', 'npm:custom'], ['update', '--models'], ['update', '--help'], ['update', '--unknown']]) test(`no ownership interception for ${args.join(' ')}`, () => {
+ assert.deepEqual(managedUpdatePlan(args), {self: false, piArgs: args});
+});
+
+test('all strips only self update before forwarding extension flags', () => {
+ assert.deepEqual(managedUpdatePlan(['update', '--all', '--approve']), {self: true, piArgs: ['update', '--extensions', '--approve']});
+});
+
+for (const windows of [false, true]) test(`an adjacent peer is refreshed by reinstalling its Shell package at the same version, never the separate global Pi (windows: ${windows})`, async () => {
+ const f = fixture({windows});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.mutations, [['add', '-g', 'gentle-pi@4.1.0', '--allow-build=gentle-pi']]);
+ assert.deepEqual(f.out, ['pnpm installed gentle-pi@4.1.0; the selected Pi is now 1.2.0 (was 1.1.0).']);
+ assert.equal(f.state.group, '1.1.0');
+});
+
+for (const runtime of ['path', 'env']) test(`a ${runtime} runtime sharing the store entry is updated through its own global Pi package`, async () => {
+ const f = fixture({runtime});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.mutations, [['add', '-g', `${PI}@latest`]]);
+ assert.deepEqual(f.out, [`pnpm installed ${PI}@latest; the selected Pi is now 1.2.0 (was 1.1.0).`]);
+ assert.equal(f.state.peer, '1.1.0');
+});
+
+test('npm nests the peer under Shell and reinstalls Shell for it', async () => {
+ const f = fixture({npm: true});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.mutations, [['install', '-g', 'gentle-pi@4.1.0']]);
+ assert.deepEqual(f.out, ['npm installed gentle-pi@4.1.0; the selected Pi is now 1.2.0 (was 1.1.0).']);
+});
+
+test('an npm PATH runtime updates the global Pi without its scripts', async () => {
+ const f = fixture({npm: true, runtime: 'path'});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.mutations, [['install', '-g', `${PI}@latest`, '--ignore-scripts']]);
+});
+
+test('an unchanged pnpm result names the minimum-release-age rule instead of claiming latest', async () => {
+ const f = fixture({peerAfter: '1.1.0'});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.equal(f.out[0], 'pnpm installed gentle-pi@4.1.0, and the selected Pi is still 1.1.0.');
+ assert.match(f.out[1], /minimumReleaseAge/);
+ assert.equal(f.out.length, 2);
+});
+
+test('every package manager call runs from the neutral directory, never the project cwd', async () => {
+ const f = fixture();
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.cwds, ['/neutral', '/neutral', '/neutral']);
+});
+
+test('an unreadable readback is reported, not invented', async () => {
+ const f = fixture({readback: false});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.out, ['pnpm installed gentle-pi@4.1.0. The Pi version it now supplies could not be read back; run \'gentle-shell --version\' to check it.']);
+});
+
+test('separate aggregated groups do not block the Shell reinstall', async () => {
+ const f = fixture({groups: 'separate'});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.mutations, [['add', '-g', 'gentle-pi@4.1.0', '--allow-build=gentle-pi']]);
+});
+
+for (const [name, options] of Object.entries({
+ 'listing failed': {failed: true},
+ 'peer identity differs': {badManifest: true},
+ 'peer package is not Pi': {unrelatedPeer: true},
+ 'selected CLI mismatches on Windows': {windows: true, mismatch: true},
+ 'linked or file suppliers': {linked: true},
+ 'Shell shares its global group': {groups: 'shared'},
+ 'Shell version is missing': {shellVersion: ''},
+ 'only a separate global Pi is listed for an adjacent runtime': {groups: 'pi'},
+ 'only Shell is listed for a PATH runtime': {runtime: 'path', groups: 'shell'},
+})) test(`ownership rejects without mutation when ${name}`, async () => {
+ const f = fixture(options);
+ await assert.rejects(updateSelectedPi(f.input), /ownership/);
+ assert.deepEqual(f.mutations, []);
+ assert.deepEqual(f.out, []);
+});
+
+for (const [name, options] of Object.entries({'pnpm POSIX shim': {shim: 'posix', runtime: 'path'}, 'Windows .CMD shim': {shim: 'windows', runtime: 'path', windows: true}, 'GENTLE_SHELL_PI shim override': {shim: 'posix', runtime: 'env'}})) test(`a ${name} resolves to the global Pi it runs`, async () => {
+ const f = fixture(options);
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.mutations, [['add', '-g', `${PI}@latest`]]);
+});
+
+for (const [name, shim] of Object.entries({'names several targets': 'two', 'is not a Pi entry': 'none'})) test(`a shim that ${name} is refused without mutation`, async () => {
+ const f = fixture({shim, runtime: 'path'});
+ await assert.rejects(updateSelectedPi(f.input), /ownership/);
+ assert.deepEqual(f.mutations, []);
+});
+
+test('an unrelated selected override cannot authorize the adjacent Shell group', async () => {
+ const f = fixture();
+ f.input.runtime = {kind: 'env', command: '/unrelated/pi', args: []};
+ await assert.rejects(updateSelectedPi(f.input), /ownership/);
+ assert.deepEqual(f.mutations, []);
+});

package/tests/rdd-status-line.test.ts

@@ -306,3 +306,55 @@ test("the on and off renders are never longer than the unknown (worst-case) rend
 		}
 	}
 });
+
+// gentle-shell#1029: the rendered RDD line is part of the cached system-prompt
+// prefix. A re-read after the TTL that fails or times out must not flip a
+// known on/off line to "unknown" and back: the last successfully read status
+// stays until the native reader reports a different status.
+test("resolveRddModeStatus keeps the last known status when a later re-read fails", async () => {
+	clearRddStatusMemoForTesting();
+	const cwd = "/repo-sticky-status";
+	let clock = 1_000_000;
+	const now = () => clock;
+	let fail = false;
+	let calls = 0;
+	const cli: Pick<NativeReviewCli, "reviewMode"> = {
+		async reviewMode() {
+			calls += 1;
+			if (fail) throw new Error("native review CLI unavailable");
+			return modeResult("on", NATIVE_REVIEW_MODE_SOURCE.GLOBAL);
+		},
+	};
+	const first = await resolveRddModeStatus(cli, cwd, undefined, now);
+	assert.equal(first?.effective, "on");
+	fail = true;
+	clock += RDD_STATUS_MEMO_TTL_MS + 1;
+	const second = await resolveRddModeStatus(cli, cwd, undefined, now);
+	assert.equal(calls, 2, "the expired memo must still trigger a re-read");
+	assert.deepEqual(second, first, "a failed re-read must keep the last known status, not render unknown");
+	assert.equal(
+		await resolveRddStatusLine(cli, cwd, undefined, now),
+		"Receipt-driven development: on (decided by global)",
+	);
+});
+
+test("resolveRddModeStatus still follows a real status change after a re-read", async () => {
+	clearRddStatusMemoForTesting();
+	const cwd = "/repo-status-change";
+	let clock = 1_000_000;
+	const now = () => clock;
+	let effective: "on" | "off" = "on";
+	const cli: Pick<NativeReviewCli, "reviewMode"> = {
+		async reviewMode() { return modeResult(effective, NATIVE_REVIEW_MODE_SOURCE.GLOBAL); },
+	};
+	assert.equal((await resolveRddModeStatus(cli, cwd, undefined, now))?.effective, "on");
+	effective = "off";
+	clock += RDD_STATUS_MEMO_TTL_MS + 1;
+	assert.equal((await resolveRddModeStatus(cli, cwd, undefined, now))?.effective, "off");
+});
+
+test("resolveRddModeStatus stays unknown when no status was ever read", async () => {
+	clearRddStatusMemoForTesting();
+	const cli = fakeReviewMode(() => { throw new Error("never available"); });
+	assert.equal(await resolveRddModeStatus(cli, "/repo-never-known"), undefined);
+});

package/tests/selection-engine.test.ts

@@ -2,11 +2,16 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
 import { GentlePromptEditor } from "../extensions/gentle-shell.ts";
-import { SelectionEngine } from "../lib/selection-engine.ts";
+import { SelectionEngine, withReverseSpan } from "../lib/selection-engine.ts";
 import { decodePrintableKey } from "../lib/pi-tui-keys.ts";
-import { CURSOR_MARKER, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { CURSOR_MARKER, stripTerminalSequences as stripAnsi, TuiMainScreen, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { CARD_STYLE, cardStyle, setCardStyle } from "../lib/shell-card.ts";
-import { stripAnsi } from "../lib/terminal-theme.ts";
+import { withPromptHint } from "../lib/shell-prompt.ts";
+
+function resolveFakeCursors(rows: string[], hardware = false): string[] {
+	const host = TuiMainScreen.prototype as unknown as { resolveFakeCursors(rows: string[]): string[] };
+	return host.resolveFakeCursors.call({ showHardwareCursor: hardware }, rows);
+}
 
 // Native selection engine tests: drive a real CustomEditor through the
 // SelectionEngine the same way GentlePromptEditor wires it — engine.handleInput
@@ -45,6 +50,30 @@ const click = (x: number, y: number, width: number): TuiMouseEvent => ({
 	type: "click", button: "left", x, y, width, height: 30, screenX: x, screenY: y, shift: false, alt: false, ctrl: false,
 });
 
+test("legacy and APC cursors preserve native selection and empty hints", () => {
+	const legacy = `${CURSOR_MARKER}\x1b[7ma\x1b[0mbc`;
+	assert.equal(withReverseSpan(legacy, 0, 3), `\x1b[7m${CURSOR_MARKER}\x1b[7ma\x1b[0m\x1b[7mbc\x1b[27m`);
+	const apc = `${CURSOR_MARKER}\x1b_pi:fc\x07a\x1b_pi:/fc\x07bc`;
+	const selected = withReverseSpan(apc, 0, 3);
+	assert.ok(selected.includes(`${CURSOR_MARKER}\x1b_pi:fc\x07`));
+	for (const hardware of [false, true]) {
+		const resolved = resolveFakeCursors([selected], hardware)[0];
+		assert.ok(resolved.includes("\x1b[7mbc\x1b[27m"));
+		assert.equal(stripAnsi(resolved), "abc");
+	}
+	// Outside selection the host still suppresses only the focused fake cursor.
+	assert.equal(resolveFakeCursors([apc], true)[0], `${CURSOR_MARKER}abc`);
+	assert.ok(resolveFakeCursors([apc.replace(CURSOR_MARKER, "")], true)[0].includes("\x1b[7ma\x1b[27m"));
+	for (const cursor of ["\x1b[7m \x1b[0m", "\x1b_pi:fc\x07 \x1b_pi:/fc\x07"]) {
+		const row = `${CURSOR_MARKER}${cursor}${" ".repeat(30)}`;
+		const hinted = withPromptHint(row, "type here", (_role, text) => text);
+		assert.ok(hinted.startsWith(`${CURSOR_MARKER}${cursor}`));
+		assert.ok(hinted.includes("type here"));
+		assert.equal(visibleWidth(hinted), visibleWidth(row));
+		assert.equal(withPromptHint(row + "draft", "type here", (_role, text) => text), row + "draft");
+	}
+});
+
 test("T2 float prompt native cursor, selection, replacement and mouse share geometry", () => {
 	const previous = cardStyle();
 	setCardStyle(CARD_STYLE.FLOAT);
@@ -56,11 +85,12 @@ test("T2 float prompt native cursor, selection, replacement and mouse share geom
 		let rows = editor.render(80);
 		assert.match(rows[0], /\x1b\[35m▎\x1b\[39m/);
 		assert.equal(visibleWidth(rows[1].split(CURSOR_MARKER)[0]), 6);
-		assert.ok(rows[1].includes(`${CURSOR_MARKER}\x1b[7md\x1b[0m\x1b[44m`));
+		assert.ok(rows[1].includes(`${CURSOR_MARKER}\x1b_pi:fc\x07d\x1b_pi:/fc\x07`));
+		assert.ok(resolveFakeCursors(rows)[1].includes(`${CURSOR_MARKER}\x1b[7md\x1b[27m`));
 		editor.handleInput("\x1b[1;2H");
 		rows = editor.render(80);
 		assert.equal(stripAnsi(rows[1].replaceAll(CURSOR_MARKER, "")).trim(), "▎ abcd");
-		assert.ok(rows[1].includes(`${CURSOR_MARKER}\x1b[7ma\x1b[0m\x1b[44m\x1b[7mbc\x1b[27md`), "native selection inversion survives the software cursor reset");
+		assert.ok(rows[1].includes(`${CURSOR_MARKER}\x1b_pi:fc\x07a\x1b_pi:/fc\x07\x1b[7mbc\x1b[27md`), "native selection inversion survives the deferred software cursor reset");
 		assert.match(rows[2], /3 chars selected/);
 		assert.doesNotMatch(rows[2], /╯/);
 		assert.ok(rows[2].includes("\x1b[44m"));

package/tests/session-profile-freeze.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test, { after, beforeEach } from "node:test";
 import { createProfile, emptyProfilesFile, profilesFilePath, setActiveProfile, writeProfilesFileSync } from "../lib/agent-profiles.ts";
-import { clearProfilePinSync, localProfilePinPath, repoProfileDeclarationPath, writeProfilePinSync } from "../lib/agent-profile-pin.ts";
+import { clearProfilePinSync, localProfilePinPath, repoProfileDeclarationPath, setProfilePinWorktreeResolverForTesting, writeProfilePinSync } from "../lib/agent-profile-pin.ts";
 import type { AgentModelConfig } from "../lib/model-routing-authority.ts";
 import { bindSessionProfile, resetSessionProfileBindingsForTesting } from "../lib/session-profile-binding.ts";
 import {
@@ -120,6 +120,19 @@ test("resolveInheritedProfile falls to the global active profile in profiles.jso
 	});
 });
 
+test("resolveInheritedProfile asks the default worktree resolver once when no resolver is passed", (t) => {
+	const f = fixture();
+	f.setActive("local");
+	let lookups = 0;
+	setProfilePinWorktreeResolverForTesting(() => { lookups++; return f.identity; });
+	t.after(() => setProfilePinWorktreeResolverForTesting());
+	assert.equal(resolveInheritedProfile({ cwd: f.cwd, configHome: f.configHome })?.name, "local");
+	assert.equal(lookups, 1, "the no-pin path reuses one worktree lookup");
+	f.pinLocal("frontier");
+	assert.equal(resolveInheritedProfile({ cwd: f.cwd, configHome: f.configHome })?.origin, "local");
+	assert.equal(lookups, 2);
+});
+
 test("resolveInheritedProfile returns undefined when no layer has a profile", () => {
 	const f = fixture();
 	assert.equal(resolveInheritedProfile({ cwd: f.cwd, configHome: f.configHome, resolveWorktree: f.resolveWorktree }), undefined);

package/tests/session-profile-persistence.test.ts

@@ -0,0 +1,334 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	SESSION_PROFILE_CUSTOM_TYPE,
+	createSessionProfileBind,
+	createSessionProfileClear,
+	readSessionProfileEntry,
+	replaySessionProfileBranch,
+} from "../lib/session-profile-persistence.ts";
+
+import { normalizeModelConfig } from "../lib/model-routing-authority.ts";
+import {
+	normalizeProfilesFile,
+	PROFILES_KIND,
+	PROFILES_VERSION,
+} from "../lib/agent-profiles.ts";
+
+const custom = (data: unknown, customType = SESSION_PROFILE_CUSTOM_TYPE) => ({
+	type: "custom",
+	customType,
+	data,
+});
+const bind = (modelProfiles: unknown = {}) => ({
+	kind: "bind",
+	origin: "user",
+	name: "work",
+	modelProfiles,
+});
+
+// These are supplied branch entries, not evidence of persistence on disk.
+test("writer emits only the v1 user binding fields and a minimal clear", () => {
+	assert.equal(SESSION_PROFILE_CUSTOM_TYPE, "gentle-pi.session-profile/v1");
+	assert.deepEqual(createSessionProfileBind("work", {}), bind());
+	assert.deepEqual(createSessionProfileClear(), { kind: "clear" });
+});
+
+test("writer accepts real normalized optional fields without persisting undefined", () => {
+	const raw = {
+		worker: "provider/model",
+		reviewer: { effort: "high" },
+		orchestrator: { model: "provider/main" },
+		inheriting: {},
+	};
+	const routes = normalizeModelConfig(raw);
+	const profiles = normalizeProfilesFile({
+		kind: PROFILES_KIND,
+		version: PROFILES_VERSION,
+		profiles: { work: raw },
+	});
+	assert.ok(routes);
+	assert.ok(profiles);
+	assert.equal(Object.hasOwn(routes.reviewer, "model"), true);
+	assert.equal(Object.hasOwn(routes.reviewer, "thinking"), true);
+	const expected = bind({
+		worker: { model: "provider/model" },
+		reviewer: { thinking: "high" },
+		orchestrator: { model: "provider/main" },
+		inheriting: {},
+	});
+	for (const config of [routes, profiles.file.profiles.work]) {
+		const payload = createSessionProfileBind("work", config);
+		assert.deepEqual(payload, expected);
+		assert.deepEqual(readSessionProfileEntry(custom(payload)), {
+			status: "bound",
+			binding: expected,
+		});
+		assert.notEqual(payload.modelProfiles.reviewer, config.reviewer);
+	}
+	assert.equal(Object.hasOwn(routes.reviewer, "model"), true);
+});
+
+test("decoder stays strict about present undefined known fields", () => {
+	for (const route of [
+		{ model: undefined },
+		{ thinking: undefined },
+		{ effort: undefined },
+	]) {
+		assert.deepEqual(readSessionProfileEntry(custom(bind({ worker: route }))), {
+			status: "invalid",
+		});
+	}
+});
+
+test("bound empty snapshot is distinct from absent and cleared", () => {
+	assert.deepEqual(readSessionProfileEntry(custom(bind())), {
+		status: "bound",
+		binding: bind(),
+	});
+	assert.deepEqual(replaySessionProfileBranch([]), { status: "absent" });
+	assert.deepEqual(readSessionProfileEntry(custom({ kind: "clear" })), {
+		status: "cleared",
+	});
+});
+
+test("reader accepts all four origins and ignores unknown payload fields", () => {
+	for (const origin of ["user", "local", "repo", "global"]) {
+		assert.deepEqual(
+			readSessionProfileEntry(
+				custom({ ...bind(), origin, extra: true, version: 99 }),
+			),
+			{
+				status: "bound",
+				binding: { ...bind(), origin },
+			},
+		);
+	}
+	assert.deepEqual(
+		readSessionProfileEntry(custom({ kind: "clear", extra: true })),
+		{ status: "cleared" },
+	);
+});
+
+test("legacy strings and effort normalize while orchestrator remains in the snapshot", () => {
+	const result = readSessionProfileEntry(
+		custom(
+			bind({
+				worker: " provider/model ",
+				reviewer: { effort: "high", ignored: true },
+				orchestrator: { model: "provider/main", thinking: "low", effort: "max" },
+				inheriting: {},
+			}),
+		),
+	);
+	assert.deepEqual(result, {
+		status: "bound",
+		binding: bind({
+			worker: { model: "provider/model" },
+			reviewer: { thinking: "high" },
+			orchestrator: { model: "provider/main", thinking: "low" },
+			inheriting: {},
+		}),
+	});
+});
+
+test("missing required fields and invalid known meanings fail closed", () => {
+	const invalid: unknown[] = [
+		null,
+		[],
+		{},
+		{ kind: "other" },
+		{ kind: "bind", name: "work", modelProfiles: {} },
+		{ ...bind(), origin: "future" },
+		{ ...bind(), name: "../work" },
+		{ ...bind(), name: "constructor" },
+		{ ...bind(), modelProfiles: undefined },
+		{ ...bind(), modelProfiles: [] },
+	];
+	for (const data of invalid) {
+		assert.deepEqual(readSessionProfileEntry(custom(data)), {
+			status: "invalid",
+		});
+	}
+});
+
+test("one invalid route invalidates the whole snapshot instead of silently dropping it", () => {
+	const routes: unknown[] = [
+		null,
+		[],
+		3,
+		"bad model",
+		{ model: "bad model", thinking: "low" },
+		{ model: "provider/good", thinking: "extreme" },
+		{ effort: "extreme" },
+		{ thinking: "low", effort: "extreme" },
+		{ model: null },
+	];
+	for (const route of routes) {
+		assert.deepEqual(readSessionProfileEntry(custom(bind({ worker: route }))), {
+			status: "invalid",
+		});
+		assert.deepEqual(
+			readSessionProfileEntry(
+				custom(bind({ good: "provider/good", worker: route })),
+			),
+			{ status: "invalid" },
+		);
+	}
+	assert.deepEqual(readSessionProfileEntry(custom(bind({ "bad role": {} }))), {
+		status: "invalid",
+	});
+});
+
+test("unknown route fields are ignored, including an unknown-only route", () => {
+	assert.deepEqual(
+		readSessionProfileEntry(custom(bind({ worker: { future: true } }))),
+		{
+			status: "bound",
+			binding: bind({ worker: {} }),
+		},
+	);
+});
+
+test("hostile record keys remain own data without changing prototypes", () => {
+	const routes = JSON.parse(
+		'{"__proto__":{"model":"provider/safe"},"constructor":{},"prototype":{}}',
+	);
+	const result = readSessionProfileEntry(custom(bind(routes)));
+	assert.equal(result.status, "bound");
+	if (result.status !== "bound") return;
+	assert.equal(
+		Object.getPrototypeOf(result.binding.modelProfiles),
+		Object.prototype,
+	);
+	assert.equal(Object.hasOwn(result.binding.modelProfiles, "__proto__"), true);
+	assert.deepEqual(result.binding.modelProfiles["__proto__"], {
+		model: "provider/safe",
+	});
+	for (const key of ["constructor", "prototype"]) {
+		assert.equal(Object.hasOwn(result.binding.modelProfiles, key), true);
+		assert.deepEqual(result.binding.modelProfiles[key], {});
+	}
+});
+
+test("required fields cannot be supplied by prototypes", () => {
+	assert.deepEqual(readSessionProfileEntry(custom(Object.create(bind()))), {
+		status: "invalid",
+	});
+});
+
+test("writer rejects invalid input rather than manufacturing an empty snapshot", () => {
+	assert.throws(() => createSessionProfileBind("../bad", {}));
+	assert.throws(() =>
+		createSessionProfileBind("work", { worker: { model: "bad model" } }),
+	);
+	for (const route of [
+		{ model: null },
+		{ model: "bad model", thinking: undefined },
+		{ model: undefined, thinking: "extreme" },
+		{ effort: undefined },
+	]) {
+		assert.throws(() =>
+			createSessionProfileBind("work", {
+				good: { model: "provider/good" },
+				worker: route,
+			} as Parameters<typeof createSessionProfileBind>[1]),
+		);
+	}
+});
+
+test("writer and reader return defensive snapshots", () => {
+	const source = { worker: { model: "provider/first" } };
+	const payload = createSessionProfileBind("work", source);
+	source.worker.model = "provider/second";
+	assert.equal(payload.modelProfiles.worker.model, "provider/first");
+	const entry = custom(payload);
+	const first = readSessionProfileEntry(entry);
+	assert.equal(first.status, "bound");
+	if (first.status !== "bound") return;
+	first.binding.modelProfiles.worker.model = "provider/third";
+	const second = readSessionProfileEntry(entry);
+	assert.equal(second.status, "bound");
+	if (second.status === "bound")
+		assert.equal(second.binding.modelProfiles.worker.model, "provider/first");
+});
+
+test("noncustom and unrelated custom entries are absent even with matching payloads", () => {
+	for (const entry of [
+		{ type: "message", customType: SESSION_PROFILE_CUSTOM_TYPE, data: bind() },
+		{ type: "message", message: { role: "user", content: "hello" } },
+		custom(bind(), "other/v1"),
+	])
+		assert.deepEqual(readSessionProfileEntry(entry), { status: "absent" });
+});
+
+test("newest family entry is terminal and retains its actual branch index", () => {
+	const old = custom(bind({ worker: "provider/old" }));
+	const message = {
+		type: "message",
+		message: { role: "user", content: "hello" },
+	};
+	for (const [entry, status] of [
+		[custom({ kind: "clear" }), "cleared"],
+		[custom({ kind: "bind" }), "invalid"],
+		[custom(bind(), "gentle-pi.session-profile/v2"), "unsupported"],
+	] as const) {
+		assert.deepEqual(
+			replaySessionProfileBranch([old, message, entry, custom({}, "other/v1")]),
+			{
+				status,
+				entryIndex: 2,
+			},
+		);
+	}
+});
+
+test("family identifier, not payload version, determines support", () => {
+	for (const customType of [
+		"gentle-pi.session-profile/v0",
+		"gentle-pi.session-profile/v99",
+		"gentle-pi.session-profile/future",
+	]) {
+		assert.deepEqual(readSessionProfileEntry(custom(null, customType)), {
+			status: "unsupported",
+		});
+	}
+	assert.deepEqual(
+		readSessionProfileEntry(custom(bind(), "gentle-pi.session-profile-other/v1")),
+		{ status: "absent" },
+	);
+});
+
+test("branch order selects latest bind; clear and bad entries can be explicitly superseded", () => {
+	const latest = custom(bind({ worker: "provider/new" }));
+	for (const earlier of [
+		custom({ kind: "clear" }),
+		custom(null),
+		custom(null, "gentle-pi.session-profile/v2"),
+	]) {
+		assert.deepEqual(replaySessionProfileBranch([earlier, latest]), {
+			status: "bound",
+			entryIndex: 1,
+			binding: bind({ worker: { model: "provider/new" } }),
+		});
+	}
+});
+
+test("replay sees only caller-supplied active branch, not siblings or later paths", () => {
+	const ancestor = custom(bind());
+	const sibling = custom({ kind: "clear" });
+	const future = custom(null, "gentle-pi.session-profile/v2");
+	assert.equal(
+		replaySessionProfileBranch([ancestor, sibling]).status,
+		"cleared",
+	);
+	assert.equal(
+		replaySessionProfileBranch([ancestor, future]).status,
+		"unsupported",
+	);
+	assert.deepEqual(replaySessionProfileBranch([ancestor, { type: "message" }]), {
+		status: "bound",
+		entryIndex: 0,
+		binding: bind(),
+	});
+});