gentle-pi 4.0.0 → 4.2.0

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

@@ -0,0 +1,163 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { AgentModelConfig } from "../lib/model-routing-authority.ts";
+import {
+	bindSessionProfile,
+	clearSessionProfileBinding,
+	readSessionProfileBinding,
+	resetSessionProfileBindingsForTesting,
+	sessionOrPinModelProfiles,
+} from "../lib/session-profile-binding.ts";
+
+const ROUTING: AgentModelConfig = {
+	worker: { model: "zai/glm-4.7", thinking: "medium" },
+	reviewer: { model: "openai/o4-mini" },
+};
+
+test("bind and read roundtrip the snapshot by session id", () => {
+	resetSessionProfileBindingsForTesting();
+	bindSessionProfile("session-a", "work", ROUTING);
+	const binding = readSessionProfileBinding("session-a");
+	assert.equal(binding?.name, "work");
+	assert.equal(binding?.modelProfiles.worker?.model, "zai/glm-4.7");
+	assert.equal(binding?.modelProfiles.worker?.thinking, "medium");
+});
+
+test("bindings are isolated per session id", () => {
+	resetSessionProfileBindingsForTesting();
+	bindSessionProfile("session-a", "work", ROUTING);
+	bindSessionProfile("session-b", "personal", { solo: { model: "openai/o4-mini" } });
+	assert.equal(readSessionProfileBinding("session-a")?.name, "work");
+	assert.equal(readSessionProfileBinding("session-b")?.name, "personal");
+	assert.equal(readSessionProfileBinding("session-c"), undefined);
+});
+
+test("rebinding one session replaces its binding without touching others", () => {
+	resetSessionProfileBindingsForTesting();
+	bindSessionProfile("session-a", "work", ROUTING);
+	bindSessionProfile("session-b", "personal", ROUTING);
+	bindSessionProfile("session-a", "review", { auditor: { model: "zai/glm-4.7" } });
+	assert.equal(readSessionProfileBinding("session-a")?.name, "review");
+	assert.equal(readSessionProfileBinding("session-b")?.name, "personal");
+});
+
+test("stored snapshots are immune to later mutation of the source object", () => {
+	resetSessionProfileBindingsForTesting();
+	const source: AgentModelConfig = { worker: { model: "zai/glm-4.7" } };
+	bindSessionProfile("session-a", "work", source);
+	source.worker!.model = "openai/o4-mini";
+	assert.equal(readSessionProfileBinding("session-a")?.modelProfiles.worker?.model, "zai/glm-4.7");
+});
+
+test("read snapshots are copies: callers cannot corrupt the store", () => {
+	resetSessionProfileBindingsForTesting();
+	bindSessionProfile("session-a", "work", ROUTING);
+	const first = readSessionProfileBinding("session-a");
+	first!.modelProfiles.worker!.model = "mutated/evil";
+	const second = readSessionProfileBinding("session-a");
+	assert.equal(second?.modelProfiles.worker?.model, "zai/glm-4.7");
+});
+
+test("readSessionProfileBinding(undefined) never resolves a binding", () => {
+	resetSessionProfileBindingsForTesting();
+	bindSessionProfile("session-a", "work", ROUTING);
+	assert.equal(readSessionProfileBinding(undefined), undefined);
+});
+
+test("clearSessionProfileBinding removes only the named session", () => {
+	resetSessionProfileBindingsForTesting();
+	bindSessionProfile("session-a", "work", ROUTING);
+	bindSessionProfile("session-b", "personal", ROUTING);
+	clearSessionProfileBinding("session-a");
+	assert.equal(readSessionProfileBinding("session-a"), undefined);
+	assert.equal(readSessionProfileBinding("session-b")?.name, "personal");
+});
+
+test("sessionOrPinModelProfiles keeps the wholesale-replacement contract: session wins, pin alone, else undefined", () => {
+	resetSessionProfileBindingsForTesting();
+	const session: AgentModelConfig = { worker: { model: "zai/glm-4.7" } };
+	const pin: AgentModelConfig = { worker: { model: "openai/o4-mini" } };
+	assert.equal(sessionOrPinModelProfiles(session, pin), session);
+	assert.equal(sessionOrPinModelProfiles(undefined, pin), pin);
+	assert.equal(sessionOrPinModelProfiles(session, undefined), session);
+	assert.equal(sessionOrPinModelProfiles(undefined, undefined), undefined);
+});
+
+test("session bindings from one process never leak into a fresh map state", () => {
+	resetSessionProfileBindingsForTesting();
+	bindSessionProfile("session-a", "work", ROUTING);
+	resetSessionProfileBindingsForTesting();
+	assert.equal(readSessionProfileBinding("session-a"), undefined);
+});
+
+// Cross-entrypoint sharing of the store (gentle-shell#1558).
+//
+// Pi loads every extension entrypoint with its own Jiti instance and
+// `moduleCache: false`, so each entrypoint re-evaluates `lib/` modules and a
+// module-local store would give the panel (gentle-ai.ts) one Map while the
+// launch, usage, and status readers (gentle-agents.ts, gentle-shell.ts) hold
+// their own empty copies. These tests reproduce that isolation the same way
+// the loader creates it: a second import of the module under a distinct URL is
+// a separate module record in the same process, standing in for a second
+// extension entrypoint.
+//
+// The specifier is built as a URL string because the TypeScript checker
+// cannot resolve a literal query-string import; at runtime Node still keys
+// the module cache on the full URL, giving this evaluation its own copy.
+const secondEntrypointSpecifier = new URL("../lib/session-profile-binding.ts?gentle-agents-entrypoint", import.meta.url).href;
+const otherEntrypoint = await import(secondEntrypointSpecifier);
+
+test("a binding written by one entrypoint is visible to every other entrypoint", (t) => {
+	resetSessionProfileBindingsForTesting();
+	otherEntrypoint.resetSessionProfileBindingsForTesting();
+	t.after(() => {
+		resetSessionProfileBindingsForTesting();
+		otherEntrypoint.resetSessionProfileBindingsForTesting();
+	});
+	bindSessionProfile("session-1", "work", { worker: { model: "zai/glm-4.7" } });
+	const read = otherEntrypoint.readSessionProfileBinding("session-1");
+	assert.equal(read?.name, "work", "the launch-path entrypoint must see what the panel wrote");
+	assert.equal(read?.modelProfiles.worker?.model, "zai/glm-4.7", "the routing snapshot crosses entrypoints intact");
+	resetSessionProfileBindingsForTesting();
+});
+
+test("a binding written by a non-panel entrypoint is visible to the panel entrypoint", (t) => {
+	resetSessionProfileBindingsForTesting();
+	t.after(() => {
+		resetSessionProfileBindingsForTesting();
+		otherEntrypoint.resetSessionProfileBindingsForTesting();
+	});
+	otherEntrypoint.bindSessionProfile("session-2", "beta", { explore: { model: "openai-codex/gpt-5.6-terra" } });
+	assert.equal(readSessionProfileBinding("session-2")?.name, "beta");
+	resetSessionProfileBindingsForTesting();
+});
+
+test("clearing from one entrypoint unbinds every entrypoint", (t) => {
+	resetSessionProfileBindingsForTesting();
+	t.after(() => {
+		resetSessionProfileBindingsForTesting();
+		otherEntrypoint.resetSessionProfileBindingsForTesting();
+	});
+	bindSessionProfile("session-3", "work", { worker: { model: "zai/glm-4.7" } });
+	otherEntrypoint.clearSessionProfileBinding("session-3");
+	assert.equal(readSessionProfileBinding("session-3"), undefined, "a cleared binding falls back in every entrypoint");
+	assert.equal(otherEntrypoint.readSessionProfileBinding("session-3"), undefined);
+	resetSessionProfileBindingsForTesting();
+});
+
+test("each entrypoint still hands out private copies of the shared store", (t) => {
+	resetSessionProfileBindingsForTesting();
+	t.after(() => {
+		resetSessionProfileBindingsForTesting();
+		otherEntrypoint.resetSessionProfileBindingsForTesting();
+	});
+	bindSessionProfile("session-4", "work", { worker: { model: "zai/glm-4.7" } });
+	const first = otherEntrypoint.readSessionProfileBinding("session-4");
+	first!.modelProfiles.worker!.model = "mutated/elsewhere";
+	assert.equal(
+		otherEntrypoint.readSessionProfileBinding("session-4")?.modelProfiles.worker?.model,
+		"zai/glm-4.7",
+		"mutating one reader's copy never reaches another reader",
+	);
+	resetSessionProfileBindingsForTesting();
+});

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

@@ -0,0 +1,394 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+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, 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 {
+	PROFILE_FOLLOW_ENV,
+	freezeSessionProfileAtStartup,
+	inheritedProfileDriftNotice,
+	profileFollowEnabled,
+	sessionProfileRoutingAt,
+	readFrozenInheritedProfile,
+	resetFrozenInheritedProfilesForTesting,
+	resolveInheritedProfile,
+	resolveSessionProfile,
+	sessionProfileLabel,
+	sessionProfileModelProfiles,
+} from "../lib/session-profile-freeze.ts";
+import type { WorktreeIdentity, WorktreeResolver } from "../lib/session-worktree-registry.ts";
+
+// Inherited profile freeze (gentle-shell#1064 slice 3b-ii). A parent session that
+// never pressed Enter resolves `p → P → G` once and keeps that snapshot; `follow`
+// keeps the live resolution; children never freeze. The worktree identity is
+// injected, so these tests never run Git.
+
+const root = mkdtempSync(join(tmpdir(), "gentle-pi-profile-freeze-"));
+after(() => rmSync(root, { recursive: true, force: true }));
+
+const FRONTIER: AgentModelConfig = { worker: { model: "anthropic/claude-opus", thinking: "high" } };
+const LOCAL: AgentModelConfig = { worker: { model: "ollama/qwen", thinking: "low" } };
+const TEAM: AgentModelConfig = { worker: { model: "openai/gpt-5" }, orchestrator: { model: "openai/gpt-5" } };
+
+let caseIndex = 0;
+interface Fixture {
+	configHome: string;
+	identity: WorktreeIdentity;
+	resolveWorktree: WorktreeResolver;
+	cwd: string;
+	setActive(name: string | undefined): void;
+	pinLocal(name: string | undefined): void;
+	declareRepo(name: string | undefined): void;
+	editProfile(name: string, config: AgentModelConfig): void;
+}
+
+function fixture(profiles: Record<string, AgentModelConfig> = { frontier: FRONTIER, local: LOCAL, team: TEAM }): Fixture {
+	const base = join(root, `case-${caseIndex++}`);
+	const configHome = join(base, "config");
+	const identity = { root: join(base, "worktree"), commonDir: join(base, "git-common") };
+	mkdirSync(identity.root, { recursive: true });
+	let current = profiles;
+	let active: string | undefined;
+	const write = () => {
+		let file = Object.entries(current).reduce((acc, [name, config]) => createProfile(acc, name, config), emptyProfilesFile());
+		if (active !== undefined) file = setActiveProfile(file, active);
+		writeProfilesFileSync(profilesFilePath(configHome), file);
+	};
+	write();
+	return {
+		configHome,
+		identity,
+		resolveWorktree: () => identity,
+		cwd: identity.root,
+		setActive(name) { active = name; write(); },
+		pinLocal(name) {
+			const path = localProfilePinPath(identity.commonDir);
+			if (name === undefined) clearProfilePinSync(path); else writeProfilePinSync(path, name);
+		},
+		declareRepo(name) {
+			const path = repoProfileDeclarationPath(identity.root);
+			if (name === undefined) clearProfilePinSync(path); else writeProfilePinSync(path, name);
+		},
+		editProfile(name, config) { current = { ...current, [name]: config }; write(); },
+	};
+}
+
+function options(f: Fixture, sessionId: string | undefined, env: NodeJS.ProcessEnv = {}) {
+	return { sessionId, cwd: f.cwd, configHome: f.configHome, resolveWorktree: f.resolveWorktree, env };
+}
+
+beforeEach(() => {
+	resetFrozenInheritedProfilesForTesting();
+	resetSessionProfileBindingsForTesting();
+});
+
+test("resolveInheritedProfile reports the local pin with its origin", () => {
+	const f = fixture();
+	f.pinLocal("frontier");
+	f.declareRepo("team");
+	f.setActive("local");
+	assert.deepEqual(resolveInheritedProfile({ cwd: f.cwd, configHome: f.configHome, resolveWorktree: f.resolveWorktree }), {
+		name: "frontier",
+		origin: "local",
+		modelProfiles: FRONTIER,
+	});
+});
+
+test("resolveInheritedProfile falls to the repository declaration, without the orchestrator key", () => {
+	const f = fixture();
+	f.declareRepo("team");
+	f.setActive("local");
+	const profile = resolveInheritedProfile({ cwd: f.cwd, configHome: f.configHome, resolveWorktree: f.resolveWorktree });
+	assert.deepEqual(JSON.parse(JSON.stringify(profile)), {
+		name: "team",
+		origin: "repo",
+		modelProfiles: { worker: { model: "openai/gpt-5" } },
+	});
+});
+
+test("resolveInheritedProfile falls to the global active profile in profiles.json", () => {
+	const f = fixture();
+	f.setActive("local");
+	assert.deepEqual(resolveInheritedProfile({ cwd: f.cwd, configHome: f.configHome, resolveWorktree: f.resolveWorktree }), {
+		name: "local",
+		origin: "global",
+		modelProfiles: LOCAL,
+	});
+});
+
+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);
+});
+
+test("resolveInheritedProfile reads the repository declaration of a non-Git project", () => {
+	const f = fixture();
+	f.declareRepo("team");
+	f.setActive("local");
+	const profile = resolveInheritedProfile({ cwd: f.cwd, configHome: f.configHome, resolveWorktree: () => undefined });
+	assert.equal(profile?.name, "team");
+	assert.equal(profile?.origin, "repo");
+});
+
+test("a session freezes the inherited profile once: later pin and active changes do not move it", () => {
+	const f = fixture();
+	f.pinLocal("frontier");
+	const first = resolveSessionProfile(options(f, "session-a"));
+	assert.equal(first.kind, "inherited");
+	f.pinLocal("local");
+	f.setActive("team");
+	const second = resolveSessionProfile(options(f, "session-a"));
+	assert.deepEqual(second, { kind: "inherited", profile: { name: "frontier", origin: "local", modelProfiles: FRONTIER } });
+	assert.deepEqual(sessionProfileModelProfiles(second), FRONTIER);
+});
+
+test("editing the frozen profile in profiles.json does not change the frozen content", () => {
+	const f = fixture();
+	f.setActive("frontier");
+	freezeSessionProfileAtStartup(options(f, "session-a"));
+	f.editProfile("frontier", LOCAL);
+	assert.deepEqual(sessionProfileModelProfiles(resolveSessionProfile(options(f, "session-a"))), FRONTIER);
+});
+
+test("a session started after the change freezes the new default; the open one keeps its own", () => {
+	const f = fixture();
+	f.pinLocal("frontier");
+	freezeSessionProfileAtStartup(options(f, "session-a"));
+	f.pinLocal("local");
+	freezeSessionProfileAtStartup(options(f, "session-b"));
+	assert.equal(readFrozenInheritedProfile("session-a")?.profile?.name, "frontier");
+	assert.equal(readFrozenInheritedProfile("session-b")?.profile?.name, "local");
+});
+
+test("startup freeze is idempotent: a second call keeps the first snapshot", () => {
+	const f = fixture();
+	f.setActive("frontier");
+	freezeSessionProfileAtStartup(options(f, "session-a"));
+	f.setActive("local");
+	freezeSessionProfileAtStartup(options(f, "session-a"));
+	assert.equal(readFrozenInheritedProfile("session-a")?.profile?.name, "frontier");
+});
+
+test("a session with no profile anywhere freezes 'no profile' and keeps today's routing", () => {
+	const f = fixture();
+	const first = resolveSessionProfile(options(f, "session-a"));
+	assert.deepEqual(first, { kind: "inherited", profile: undefined });
+	assert.equal(sessionProfileModelProfiles(first), undefined);
+	f.pinLocal("frontier");
+	const second = resolveSessionProfile(options(f, "session-a"));
+	assert.deepEqual(second, { kind: "inherited", profile: undefined });
+	assert.equal(sessionProfileModelProfiles(second), undefined);
+	assert.equal(sessionProfileLabel(second), undefined);
+});
+
+test("an explicit Enter binding outranks the frozen inherited profile", () => {
+	const f = fixture();
+	f.pinLocal("frontier");
+	freezeSessionProfileAtStartup(options(f, "session-a"));
+	bindSessionProfile("session-a", "team", { worker: { model: "openai/gpt-5" } });
+	const resolution = resolveSessionProfile(options(f, "session-a"));
+	assert.deepEqual(resolution, { kind: "explicit", name: "team", modelProfiles: { worker: { model: "openai/gpt-5" } } });
+	assert.equal(sessionProfileLabel(resolution), "team (session)");
+});
+
+test("follow mode re-resolves p → P → G on every call and never freezes", () => {
+	const f = fixture();
+	const env = { [PROFILE_FOLLOW_ENV]: "1" };
+	f.pinLocal("frontier");
+	freezeSessionProfileAtStartup(options(f, "session-a", env));
+	assert.equal(readFrozenInheritedProfile("session-a"), undefined);
+	assert.equal(resolveSessionProfile(options(f, "session-a", env)).kind, "follow");
+	assert.deepEqual(sessionProfileModelProfiles(resolveSessionProfile(options(f, "session-a", env))), FRONTIER);
+	f.pinLocal("local");
+	assert.deepEqual(sessionProfileModelProfiles(resolveSessionProfile(options(f, "session-a", env))), LOCAL);
+	assert.equal(readFrozenInheritedProfile("session-a"), undefined);
+});
+
+test("Enter in follow mode makes the binding explicit: later defaults no longer apply", () => {
+	const f = fixture();
+	const env = { [PROFILE_FOLLOW_ENV]: "1" };
+	f.pinLocal("frontier");
+	bindSessionProfile("session-a", "team", { worker: { model: "openai/gpt-5" } });
+	f.pinLocal("local");
+	const resolution = resolveSessionProfile(options(f, "session-a", env));
+	assert.equal(resolution.kind, "explicit");
+	assert.deepEqual(sessionProfileModelProfiles(resolution), { worker: { model: "openai/gpt-5" } });
+});
+
+test("profileFollowEnabled accepts only GENTLE_PI_PROFILE_FOLLOW=1", () => {
+	assert.equal(PROFILE_FOLLOW_ENV, "GENTLE_PI_PROFILE_FOLLOW");
+	assert.equal(profileFollowEnabled({ GENTLE_PI_PROFILE_FOLLOW: "1" }), true);
+	assert.equal(profileFollowEnabled({ GENTLE_PI_PROFILE_FOLLOW: "0" }), false);
+	assert.equal(profileFollowEnabled({ GENTLE_PI_PROFILE_FOLLOW: "" }), false);
+	assert.equal(profileFollowEnabled({}), false);
+});
+
+test("subagent children never freeze: they resolve live", () => {
+	const f = fixture();
+	const env = { GENTLE_PI_AGENTS_CHILD: "1" };
+	f.pinLocal("frontier");
+	freezeSessionProfileAtStartup(options(f, "child-a", env));
+	assert.equal(readFrozenInheritedProfile("child-a"), undefined);
+	const resolution = resolveSessionProfile(options(f, "child-a", env));
+	assert.equal(resolution.kind, "live");
+	assert.equal(readFrozenInheritedProfile("child-a"), undefined);
+	f.pinLocal("local");
+	assert.deepEqual(sessionProfileModelProfiles(resolveSessionProfile(options(f, "child-a", env))), LOCAL);
+});
+
+test("without a session id the resolution is live and nothing is frozen", () => {
+	const f = fixture();
+	f.pinLocal("frontier");
+	const resolution = resolveSessionProfile(options(f, undefined));
+	assert.equal(resolution.kind, "live");
+	assert.deepEqual(sessionProfileModelProfiles(resolution), FRONTIER);
+});
+
+test("labels keep today's spelling: (session), (local), (repo), bare global name", () => {
+	const f = fixture();
+	f.pinLocal("frontier");
+	assert.equal(sessionProfileLabel(resolveSessionProfile(options(f, "s-local"))), "frontier (local)");
+	f.pinLocal(undefined);
+	f.declareRepo("team");
+	assert.equal(sessionProfileLabel(resolveSessionProfile(options(f, "s-repo"))), "team (repo)");
+	f.declareRepo(undefined);
+	f.setActive("local");
+	assert.equal(sessionProfileLabel(resolveSessionProfile(options(f, "s-global"))), "local");
+});
+
+test("drift notice: shown once per distinct change of the defaults", () => {
+	const f = fixture();
+	f.pinLocal("frontier");
+	const opts = options(f, "session-a");
+	freezeSessionProfileAtStartup(opts);
+	assert.equal(inheritedProfileDriftNotice(opts), undefined, "no drift while the defaults match");
+	f.pinLocal("local");
+	assert.equal(
+		inheritedProfileDriftNotice(opts),
+		'el Gentleman: the default profile changed to "local" (local), this session keeps "frontier" (local). Press Enter on a profile in /gentle:profiles to adopt it.',
+	);
+	assert.equal(inheritedProfileDriftNotice(opts), undefined, "the same change is not repeated");
+	f.pinLocal(undefined);
+	f.setActive("team");
+	assert.equal(
+		inheritedProfileDriftNotice(opts),
+		'el Gentleman: the default profile changed to "team" (global), this session keeps "frontier" (local). Press Enter on a profile in /gentle:profiles to adopt it.',
+	);
+	assert.equal(inheritedProfileDriftNotice(opts), undefined);
+	assert.equal(readFrozenInheritedProfile("session-a")?.profile?.name, "frontier", "the notice never adopts the new default");
+});
+
+test("drift notice: an edit of the default profile's content counts as a change", () => {
+	const f = fixture();
+	f.setActive("frontier");
+	const opts = options(f, "session-a");
+	freezeSessionProfileAtStartup(opts);
+	f.editProfile("frontier", LOCAL);
+	assert.match(inheritedProfileDriftNotice(opts) ?? "", /changed to "frontier" \(global\), this session keeps "frontier" \(global\)/);
+});
+
+test("drift notice: memory is per session", () => {
+	const f = fixture();
+	f.pinLocal("frontier");
+	freezeSessionProfileAtStartup(options(f, "session-a"));
+	freezeSessionProfileAtStartup(options(f, "session-b"));
+	f.pinLocal("local");
+	assert.notEqual(inheritedProfileDriftNotice(options(f, "session-a")), undefined);
+	assert.notEqual(inheritedProfileDriftNotice(options(f, "session-b")), undefined);
+});
+
+test("drift notice covers a session frozen without a profile and a default that disappears", () => {
+	const f = fixture();
+	const none = options(f, "session-none");
+	freezeSessionProfileAtStartup(none);
+	f.pinLocal("frontier");
+	assert.equal(
+		inheritedProfileDriftNotice(none),
+		'el Gentleman: the default profile changed to "frontier" (local), this session keeps no profile. Press Enter on a profile in /gentle:profiles to adopt it.',
+	);
+	const kept = options(f, "session-kept");
+	freezeSessionProfileAtStartup(kept);
+	f.pinLocal(undefined);
+	assert.equal(
+		inheritedProfileDriftNotice(kept),
+		'el Gentleman: the default profile changed to no profile, this session keeps "frontier" (local). Press Enter on a profile in /gentle:profiles to adopt it.',
+	);
+});
+
+test("drift notice is never shown after an explicit Enter, in follow mode, or in a child", () => {
+	const f = fixture();
+	f.pinLocal("frontier");
+	const explicit = options(f, "session-explicit");
+	freezeSessionProfileAtStartup(explicit);
+	bindSessionProfile("session-explicit", "team", TEAM);
+	const follow = options(f, "session-follow", { [PROFILE_FOLLOW_ENV]: "1" });
+	const child = options(f, "session-child", { GENTLE_PI_AGENTS_CHILD: "1" });
+	f.pinLocal("local");
+	assert.equal(inheritedProfileDriftNotice(explicit), undefined);
+	assert.equal(inheritedProfileDriftNotice(follow), undefined);
+	assert.equal(inheritedProfileDriftNotice(child), undefined);
+});
+
+test("drift comparison on a session not frozen yet freezes the current default and reports nothing", () => {
+	const f = fixture();
+	f.pinLocal("frontier");
+	assert.equal(inheritedProfileDriftNotice(options(f, "session-a")), undefined);
+	assert.equal(readFrozenInheritedProfile("session-a")?.profile?.name, "frontier");
+});
+
+test("sessionProfileRoutingAt: explicit and frozen profiles apply to any target, a foreign repository included", () => {
+	const session = fixture();
+	session.pinLocal("frontier");
+	const foreign = fixture();
+	foreign.pinLocal("local");
+	const target = { cwd: foreign.cwd, configHome: foreign.configHome, resolveWorktree: foreign.resolveWorktree, foreignRepository: true };
+	assert.deepEqual(sessionProfileRoutingAt(resolveSessionProfile(options(session, "session-a")), target), FRONTIER);
+	bindSessionProfile("session-b", "team", TEAM);
+	assert.deepEqual(sessionProfileRoutingAt(resolveSessionProfile(options(session, "session-b")), target), TEAM);
+});
+
+test("sessionProfileRoutingAt: a session frozen without a profile keeps a foreign repository's own defaults", () => {
+	const session = fixture();
+	const foreign = fixture();
+	foreign.pinLocal("local");
+	const resolution = resolveSessionProfile(options(session, "session-a"));
+	session.pinLocal("frontier");
+	assert.deepEqual(sessionProfileRoutingAt(resolution, { cwd: foreign.cwd, configHome: foreign.configHome, resolveWorktree: foreign.resolveWorktree, foreignRepository: true }), LOCAL);
+	assert.equal(sessionProfileRoutingAt(resolution, { cwd: session.cwd, configHome: session.configHome, resolveWorktree: session.resolveWorktree }), undefined, "its own clone keeps no profile");
+});
+
+test("sessionProfileRoutingAt: a session frozen without a profile never picks up the global active profile in a foreign repository", () => {
+	const session = fixture();
+	const resolution = resolveSessionProfile(options(session, "session-a"));
+	const foreign = fixture();
+	foreign.setActive("team");
+	assert.equal(sessionProfileRoutingAt(resolution, { cwd: foreign.cwd, configHome: foreign.configHome, resolveWorktree: foreign.resolveWorktree, foreignRepository: true }), undefined);
+	foreign.declareRepo("local");
+	assert.deepEqual(sessionProfileRoutingAt(resolution, { cwd: foreign.cwd, configHome: foreign.configHome, resolveWorktree: foreign.resolveWorktree, foreignRepository: true }), LOCAL, "the foreign repository's own declaration still applies");
+});
+
+test("sessionProfileRoutingAt: follow reads the defaults of the target", () => {
+	const session = fixture();
+	session.pinLocal("frontier");
+	const other = fixture();
+	other.pinLocal("local");
+	const resolution = resolveSessionProfile(options(session, "session-a", { [PROFILE_FOLLOW_ENV]: "1" }));
+	assert.deepEqual(sessionProfileRoutingAt(resolution, { cwd: other.cwd, configHome: other.configHome, resolveWorktree: other.resolveWorktree }), LOCAL);
+});