gentle-pi 4.1.0 → 4.2.0

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

@@ -39,7 +39,7 @@ function fakeFs({ real = {}, files = {}, links = {} }: { real?: Record<string, s
 	};
 }
 
-const ID = "4.1.0-1.1.0";
+const ID = "4.1.0-1.2.0";
 const POSIX_ROOT = "/home/ana/.gentle-shell";
 const POSIX_VERSION = posix.join(POSIX_ROOT, "versions", ID);
 const POSIX_PACKAGE = posix.join(POSIX_VERSION, "node_modules", ".pnpm", "gentle-pi@4.1.0", "node_modules", "gentle-pi");
@@ -106,29 +106,29 @@ const install = { root: POSIX_ROOT, id: ID, versionDir: POSIX_VERSION };
 const messageOf = (pi: BundledPi) => ("message" in pi ? pi.message : "");
 
 test("bundledPi returns only the Pi the version pins, inside the version folder", () => {
-	assert.deepEqual(bundledPi(install, { platform: "linux", fs: fakeFs({ files: piFiles("1.1.0", "1.1.0") }) }),
-		{ ok: true, version: "1.1.0", cli: posix.join(PI_PACKAGE(POSIX_VERSION), "dist", "bundle", "cli.js") });
+	assert.deepEqual(bundledPi(install, { platform: "linux", fs: fakeFs({ files: piFiles("1.2.0", "1.2.0") }) }),
+		{ ok: true, version: "1.2.0", cli: posix.join(PI_PACKAGE(POSIX_VERSION), "dist", "bundle", "cli.js") });
 	const windows = { root: "C:\\G", id: ID, versionDir: `C:\\G\\versions\\${ID}` };
-	assert.deepEqual(bundledPi(windows, { platform: "win32", fs: fakeFs({ files: piFiles("1.1.0", "1.1.0", win32, windows.versionDir) }) }),
-		{ ok: true, version: "1.1.0", cli: win32.join(PI_PACKAGE(windows.versionDir, win32), "dist", "bundle", "cli.js") });
+	assert.deepEqual(bundledPi(windows, { platform: "win32", fs: fakeFs({ files: piFiles("1.2.0", "1.2.0", win32, windows.versionDir) }) }),
+		{ ok: true, version: "1.2.0", cli: win32.join(PI_PACKAGE(windows.versionDir, win32), "dist", "bundle", "cli.js") });
 });
 
 test("bundledPi fails with the version, the pinned Pi and the way to repair it", () => {
-	const repair = /Gentle Shell 4\.1\.0-1\.1\.0 .*Pi 1\.1\.0.*gentle-shell upgrade.*installer/s;
-	const mismatch = bundledPi(install, { platform: "linux", fs: fakeFs({ files: piFiles("1.1.0", "1.0.0") }) });
+	const repair = /Gentle Shell 4\.1\.0-1\.2\.0 .*Pi 1\.2\.0.*gentle-shell upgrade.*installer/s;
+	const mismatch = bundledPi(install, { platform: "linux", fs: fakeFs({ files: piFiles("1.2.0", "1.0.0") }) });
 	assert.equal(mismatch.ok, false);
 	assert.match(messageOf(mismatch), repair);
 	assert.match(messageOf(mismatch), /found Pi 1\.0\.0/);
-	const files = piFiles("1.1.0", "1.1.0");
+	const files = piFiles("1.2.0", "1.2.0");
 	delete files[posix.join(PI_PACKAGE(POSIX_VERSION), "dist", "bundle", "cli.js")];
 	const missing = bundledPi(install, { platform: "linux", fs: fakeFs({ files }) });
 	assert.match(messageOf(missing), repair);
 	// A Pi linked from outside the version folder is not the bundled one.
-	const outside = fakeFs({ real: { [PI_PACKAGE(POSIX_VERSION)]: "/usr/lib/node_modules/@earendil-works/pi-coding-agent" }, files: piFiles("1.1.0", "1.1.0") });
+	const outside = fakeFs({ real: { [PI_PACKAGE(POSIX_VERSION)]: "/usr/lib/node_modules/@earendil-works/pi-coding-agent" }, files: piFiles("1.2.0", "1.2.0") });
 	assert.equal(bundledPi(install, { platform: "linux", fs: outside }).ok, false);
 });
 
-const ISOLATION = { prefix: "/g", engram: "/g/runtime/engram-3.3.2/engram" };
+const ISOLATION = { prefix: "/g", engram: "/g/runtime/engram-3.4.0/engram" };
 
 test("bundledChildEnv keeps the user's environment and adds only the bundled Pi, the prefix and Engram, no Pi override and no Pi update check", () => {
 	const user = { PATH: "/home/ana/.nvm/bin:/usr/bin", NODE_OPTIONS: "--max-old-space-size=4096", npm_config_registry: "https://npm.example", npm_config_prefix: "/home/ana/.npm-global",
@@ -140,7 +140,7 @@ test("bundledChildEnv keeps the user's environment and adds only the bundled Pi,
 	// folder from the prefix, and Gentle AI 4.0.0 reads that variable as a parent.
 	assert.deepEqual(env, { PATH: user.PATH, NODE_OPTIONS: user.NODE_OPTIONS, npm_config_registry: user.npm_config_registry, npm_config_prefix: user.npm_config_prefix,
 		GENTLE_PI_CONFIG_HOME: user.GENTLE_PI_CONFIG_HOME, GENTLE_PI_AGENTS_PI: "/g/node /g/cli.js", PI_SKIP_VERSION_CHECK: "1", GENTLE_SHELL_PREFIX: "/g",
-		ENGRAM_BIN: "/g/runtime/engram-3.3.2/engram" });
+		ENGRAM_BIN: "/g/runtime/engram-3.4.0/engram" });
 	// The subagent runner splits that variable on whitespace: a spaced path falls
 	// back to its own default, the running node and cli.js.
 	const spaced = bundledChildEnv({ GENTLE_PI_AGENTS_PI: "pi" }, { node: "C:\\Users\\Ana Li\\node.exe", cli: "C:\\cli.js", ...ISOLATION });
@@ -205,10 +205,10 @@ test("bundledUpdateNext still updates extensions when the upgrade did not comple
 });
 
 test("bundledUpdateNotice explains the pinned Pi and runs or names gentle-shell upgrade", () => {
-	const interactive = bundledUpdateNotice({ piVersion: "1.1.0", interactive: true }).join("\n");
-	assert.match(interactive, /Pi ships pinned with Gentle Shell \(Pi 1\.1\.0\)/);
+	const interactive = bundledUpdateNotice({ piVersion: "1.2.0", interactive: true }).join("\n");
+	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.1.0", interactive: false }).join("\n"), /Run 'gentle-shell upgrade'/);
+	assert.match(bundledUpdateNotice({ piVersion: "1.2.0", interactive: false }).join("\n"), /Run 'gentle-shell upgrade'/);
 });
 
 test("parseBundledUpgradeArgs accepts the release channel and --rollback and refuses the main channel", () => {
@@ -233,7 +233,7 @@ test("parseBundledUpgradeArgs accepts the release channel and --rollback and ref
 const repository = dirname(dirname(fileURLToPath(import.meta.url)));
 const posixHost = process.platform === "win32" ? "the bundled prefix fixture uses a POSIX current symlink" : false;
 const SHELL = JSON.parse(readFileSync(join(repository, "package.json"), "utf8")).version;
-const FIXTURE_ID = `${SHELL}-1.1.0`;
+const FIXTURE_ID = `${SHELL}-1.2.0`;
 const FAKE_PI = [
 	"import {existsSync, mkdirSync, readFileSync, writeFileSync} from 'node:fs'; import {join, dirname} from 'node:path';",
 	"const args = process.argv.slice(2);",
@@ -244,7 +244,7 @@ const FAKE_PI = [
 	" if (process.env.FIXTURE_INSTALL_CAPABILITY !== 'metadata-only') { const packages = settings.packages ?? []; const index = packages.findIndex(p => /^npm:gentle-engram(?:@|$)/.test(typeof p === 'string' ? p : p.source));",
 	" if (index < 0) packages.push(args[1]); else packages[index] = typeof packages[index] === 'string' ? args[1] : {...packages[index], source:args[1]}; settings.packages = packages; writeFileSync(path, JSON.stringify(settings)); }",
 	"}",
-	"if (args.includes('--version')) { console.log('1.1.0'); process.exit(0); }",
+	"if (args.includes('--version')) { console.log('1.2.0'); process.exit(0); }",
 	// Stands in for gentle-engram creating the store through the bundled core during the session.
 	"if (process.env.FIXTURE_CREATE_STORE && args[0] !== 'install' && args[0] !== 'list') {",
 	" const data = join(process.env.HOME, '.engram');",
@@ -273,7 +273,7 @@ const FIXTURE_CORE = [
 	"",
 ].join("\n");
 
-function bundledPrefix(t: TestContext, { pi = "1.1.0", core = true } = {}) {
+function bundledPrefix(t: TestContext, { pi = "1.2.0", core = true } = {}) {
 	const base = realpathSync(mkdtempSync(join(tmpdir(), "gentle-shell-bundled-")));
 	t.after(() => rmSync(base, { recursive: true, force: true }));
 	const home = join(base, "home");
@@ -295,7 +295,7 @@ function bundledPrefix(t: TestContext, { pi = "1.1.0", core = true } = {}) {
 	mkdirSync(join(piDir, "dist", "bundle"), { recursive: true });
 	writeFileSync(join(piDir, "package.json"), JSON.stringify({ name: "@earendil-works/pi-coding-agent", version: pi, bin: { pi: "dist/bundle/cli.js" } }));
 	writeFileSync(join(piDir, "dist", "bundle", "cli.js"), FAKE_PI);
-	writeFileSync(join(version, "package.json"), JSON.stringify({ dependencies: { "gentle-pi": SHELL, "@earendil-works/pi-coding-agent": "1.1.0" } }));
+	writeFileSync(join(version, "package.json"), JSON.stringify({ dependencies: { "gentle-pi": SHELL, "@earendil-works/pi-coding-agent": "1.2.0" } }));
 	writeFileSync(join(version, ".gentle-shell-version"), `${FIXTURE_ID}\n`);
 	symlinkSync(`versions/${FIXTURE_ID}`, join(root, "current"));
 	// The bundled npm the npmCommand entry loads.
@@ -457,10 +457,20 @@ test("provenance mismatches disable memory behind the guard: instance, core dige
 		assert.equal(result.status, 0, `${name}: ${result.stderr}`);
 		const seen = lastLaunch(result);
 		assert.deepEqual([seen.env.ENGRAM_STARTUP_POLICY, seen.env.ENGRAM_BIN], ["disabled", prefix.guard], name);
-		assert.match(result.stderr, /memory disabled.*Back up.*update.*restart.*recheck/s, name);
+		assert.match(result.stderr, /memory disabled.*could not verify.*compatibility.*Back up/s, name);
 	}
 });
 
+test("public help explains compatibility evidence without promising update recovery", { skip: posixHost }, (t) => {
+	const prefix = bundledPrefix(t);
+	const result = prefix.run(["--help"]);
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(result.stderr, "");
+	assert.match(result.stdout, /Matching versions or updating alone do not prove compatibility/);
+	assert.match(result.stdout, /\/compatibility/);
+	assert.doesNotMatch(result.stdout, /update Engram, restart/);
+});
+
 test("a foreign pre-existing store stays disabled and never receives provenance", { skip: posixHost }, (t) => {
 	const prefix = bundledPrefix(t);
 	const data = join(prefix.home, ".engram");
@@ -510,6 +520,23 @@ test("a verified /compatibility server is reused through an explicit URL and the
 	assert.equal(lastLaunch(unready.run([], { FIXTURE_ENGRAM_PORT: notReady })).env.ENGRAM_STARTUP_POLICY, "disabled");
 });
 
+test("a foreign store behind a 3.3.2 server stays guarded and the launch names the server version to update", { skip: posixHost }, async (t) => {
+	const prefix = bundledPrefix(t);
+	const data = join(prefix.home, ".engram");
+	mkdirSync(data);
+	writeHeader(join(data, "engram.db"), 1);
+	const before = readFileSync(join(data, "engram.db"));
+	// Engram 3.3.2 has no /compatibility route (the fixture answers 404).
+	const port = await engramServer(t, { "/health": [200, { status: "ok", service: "engram", version: "3.3.2", instance_id: OTHER_STORE_ID }] });
+	const result = prefix.run([], { FIXTURE_ENGRAM_PORT: port });
+	assert.equal(result.status, 0, result.stderr);
+	const seen = lastLaunch(result);
+	assert.deepEqual([seen.env.ENGRAM_STARTUP_POLICY, seen.env.ENGRAM_BIN, seen.env.ENGRAM_URL], ["disabled", prefix.guard, undefined]);
+	assert.match(result.stderr, /memory disabled.*reports version 3\.3\.2.*update that server to 3\.4\.0 or later/s);
+	assert.deepEqual(readFileSync(join(data, "engram.db")), before);
+	assert.equal(existsSync(provenancePath(prefix)), false);
+});
+
 test("a fresh launch whose launcher is killed during Pi already has finalized provenance, and the next launch allows memory", { skip: posixHost }, (t) => {
 	const prefix = bundledPrefix(t);
 	const first = prefix.run([], { FIXTURE_CREATE_STORE: STORE_ID, FIXTURE_KILL_LAUNCHER: "1" });
@@ -634,7 +661,8 @@ test("setup with a foreign existing store runs the installer like the baseline,
 	assert.equal(setup.status, 0, setup.stderr);
 	assert.equal(installer.runs(), 1);
 	assert.equal(existsSync(prefix.engram), true);
-	assert.match(setup.stderr, /memory disabled.*Back up.*update.*restart.*recheck/s);
+	assert.match(setup.stderr, /memory disabled.*could not verify.*compatibility.*Back up/s);
+	assert.doesNotMatch(setup.stderr, /update Engram and restart/);
 	assert.doesNotMatch(setup.stderr, /deferred/);
 	const guarded = prefix.run([]);
 	assert.equal(guarded.status, 0, guarded.stderr);
@@ -768,7 +796,7 @@ test("the bundled launcher runs only its version's Pi, with the user's environme
 	const prefix = bundledPrefix(t);
 	const version = prefix.run(["--version"]);
 	assert.equal(version.status, 0, version.stderr);
-	assert.match(version.stdout, new RegExp(`^gentle-shell ${SHELL.replaceAll(".", "\\.")}\npi 1\\.1\\.0\n`));
+	assert.match(version.stdout, new RegExp(`^gentle-shell ${SHELL.replaceAll(".", "\\.")}\npi 1\\.2\\.0\n`));
 	const launched = prefix.run(["list"]);
 	assert.equal(launched.status, 0, launched.stderr);
 	const seen = JSON.parse(launched.stdout.trim().split("\n").at(-1) ?? "{}");
@@ -894,19 +922,19 @@ test("the version check before activation runs that version in bundled mode, nev
 		encoding: "utf8", input: "" });
 	const good = verify({ [BUNDLED_VERIFY_ENV]: FIXTURE_ID });
 	assert.equal(good.status, 0, good.stderr);
-	assert.match(good.stdout, /\npi 1\.1\.0\n/);
+	assert.match(good.stdout, /\npi 1\.2\.0\n/);
 	// The version's own Pi is broken, and the user's Pi prints the expected version.
-	writeFileSync(join(prefix.userBin, "pi"), "#!/bin/sh\necho 1.1.0\n", { mode: 0o755 });
+	writeFileSync(join(prefix.userBin, "pi"), "#!/bin/sh\necho 1.2.0\n", { mode: 0o755 });
 	rmSync(join(prefix.piDir, "dist", "bundle", "cli.js"));
 	const broken = verify({ [BUNDLED_VERIFY_ENV]: FIXTURE_ID });
 	assert.equal(broken.status, 1);
-	assert.match(broken.stderr, /bundled Pi 1\.1\.0/);
+	assert.match(broken.stderr, /bundled Pi 1\.2\.0/);
 	// Without the verification input, the same entry is an ordinary launcher that would pass.
-	assert.match(verify({}).stdout, /\npi 1\.1\.0\n/);
+	assert.match(verify({}).stdout, /\npi 1\.2\.0\n/);
 	// Only --version honors it.
 	const list = spawnSync(process.execPath, [prefix.entry, "list"], { env: { HOME: prefix.home, PATH: `${prefix.userBin}:/usr/bin:/bin`, [BUNDLED_VERIFY_ENV]: FIXTURE_ID,
 		GENTLE_SHELL_NO_AUTO_SETUP: "1" }, encoding: "utf8", input: "" });
-	assert.equal(list.stdout, "1.1.0\n");
+	assert.equal(list.stdout, "1.2.0\n");
 });
 
 test("the bundled launcher refuses a Pi that is not the pinned one", { skip: posixHost }, (t) => {
@@ -919,7 +947,7 @@ test("the bundled launcher refuses a Pi that is not the pinned one", { skip: pos
 test("gentle-shell update in a bundled install explains the pinned Pi instead of updating it", { skip: posixHost }, (t) => {
 	const result = bundledPrefix(t).run(["update"]);
 	assert.equal(result.status, 0, result.stderr);
-	assert.match(result.stdout, /Pi ships pinned with Gentle Shell \(Pi 1\.1\.0\)/);
+	assert.match(result.stdout, /Pi ships pinned with Gentle Shell \(Pi 1\.2\.0\)/);
 	assert.match(result.stdout, /Run 'gentle-shell upgrade'/);
 	assert.doesNotMatch(result.stdout, /"args"/);
 });
@@ -928,23 +956,29 @@ test("gentle-shell update pi --extensions in a bundled install redirects Pi's pa
 	const prefix = bundledPrefix(t);
 	const result = prefix.run(["update", "pi", "--extensions"]);
 	assert.equal(result.status, 0, result.stderr);
-	assert.match(result.stdout, /Pi ships pinned with Gentle Shell \(Pi 1\.1\.0\)/);
+	assert.match(result.stdout, /Pi ships pinned with Gentle Shell \(Pi 1\.2\.0\)/);
 	const seen = JSON.parse(result.stdout.trim().split("\n").at(-1) ?? "{}");
 	assert.deepEqual(seen.args, ["update", "--extensions"]);
 	assert.ok(JSON.parse(readFileSync(join(prefix.home, ".gentle-shell", "agent", "settings.json"), "utf8")).npmCommand);
 });
 
-test("a kept version that current does not name keeps the ordinary launcher, Pi override and Pi update included", { skip: posixHost }, (t) => {
+test("a kept version that current does not name keeps the ordinary Pi override and refuses an unowned update", { skip: posixHost }, (t) => {
 	const prefix = bundledPrefix(t);
 	const other = join(prefix.root, "versions", "0.0.1-1.0.0");
 	mkdirSync(other);
 	writeFileSync(join(other, ".gentle-shell-version"), "0.0.1-1.0.0\n");
 	rmSync(join(prefix.root, "current"));
 	symlinkSync("versions/0.0.1-1.0.0", join(prefix.root, "current"));
-	const update = spawnSync(process.execPath, [prefix.entry, "update"], { env: { HOME: dirname(prefix.root), PATH: "/usr/bin:/bin",
-		GENTLE_SHELL_PI: join(dirname(dirname(prefix.root)), "user-bin", "pi"), GENTLE_SHELL_NO_AUTO_SETUP: "1" }, encoding: "utf8", input: "" });
-	assert.equal(update.status, 0, update.stderr);
-	assert.equal(update.stdout, "9.9.9\n");
+	const options = { env: { HOME: dirname(prefix.root), PATH: "/usr/bin:/bin",
+		GENTLE_SHELL_PI: join(dirname(dirname(prefix.root)), "user-bin", "pi"), GENTLE_SHELL_NO_AUTO_SETUP: "1" }, encoding: "utf8" as const, input: "" };
+	const version = spawnSync(process.execPath, [prefix.entry, "--version"], options);
+	assert.equal(version.status, 0, version.stderr);
+	assert.match(version.stdout, /pi 9\.9\.9/);
+	const update = spawnSync(process.execPath, [prefix.entry, "update"], options);
+	assert.equal(update.status, 1);
+	assert.equal(update.stdout, "");
+	// The fake override is a plain script: neither a Pi entry nor a package-manager shim.
+	assert.match(update.stderr, /ownership selected executable is not a Pi entry or shim.*No installation changed\./);
 });
 
 test("gentle-shell upgrade in a bundled install refuses the main channel and rolls back to the kept version", { skip: posixHost }, (t) => {

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

@@ -683,9 +683,10 @@ test("checkPeerVersionPin passes for a matching pin", () => {
 	assert.deepEqual(result, { ok: true, pinned: ">=0.85.1" });
 });
 
-test("Pi 0.99.1 baseline and host peers follow the open development range policy", () => {
+test("Pi 1.2.0 baseline and host peers follow the open development range policy", () => {
 	const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-	assert.equal(MIN_PI_VERSION, "0.99.1");
+	assert.equal(MIN_PI_VERSION, "1.2.0");
+	assert.equal(pkg.peerDependencies["@earendil-works/pi-coding-agent"], ">=1.2.0");
 	assert.equal(pkg.engines.node, ">=22.19.0");
 	for (const name of ["@earendil-works/pi-ai", "@earendil-works/pi-tui"]) {
 		assert.equal(pkg.peerDependencies[name], "*");
@@ -695,34 +696,38 @@ test("Pi 0.99.1 baseline and host peers follow the open development range policy
 	// Development ranges are policy specifiers; their floor never drops below
 	// the runtime minimum the launcher enforces.
 	for (const name of ["@earendil-works/pi-coding-agent", "@earendil-works/pi-ai", "@earendil-works/pi-tui"]) {
-		assert.equal(pkg.devDependencies[name], ">=1.0.0", name);
+		assert.equal(pkg.devDependencies[name], ">=1.2.0", name);
 		assert.equal(checkPiVersion(pkg.devDependencies[name].slice(2)).ok, true, name);
 	}
 });
 
 test("checkPiVersion accepts a version equal to the minimum", () => {
-	assert.deepEqual(checkPiVersion("0.99.1"), { ok: true, version: "0.99.1" });
+	assert.deepEqual(checkPiVersion("1.2.0"), { ok: true, version: "1.2.0" });
 });
 
 test("checkPiVersion accepts a version above the minimum", () => {
-	assert.deepEqual(checkPiVersion("0.100.0"), { ok: true, version: "0.100.0" });
+	for (const version of ["1.2.1", "1.3.0", "2.0.0"]) {
+		assert.deepEqual(checkPiVersion(version), { ok: true, version });
+	}
 });
 
 test("checkPiVersion accepts a v-prefixed version", () => {
-	assert.deepEqual(checkPiVersion("v0.99.1"), { ok: true, version: "0.99.1" });
+	assert.deepEqual(checkPiVersion("v1.2.0"), { ok: true, version: "1.2.0" });
 });
 
 test("checkPiVersion accepts a prerelease suffix at the minimum", () => {
-	assert.deepEqual(checkPiVersion("pi version 0.99.1-rc.2"), { ok: true, version: "0.99.1" });
+	assert.deepEqual(checkPiVersion("pi version 1.2.0-rc.2"), { ok: true, version: "1.2.0" });
 });
 
 test("checkPiVersion rejects a version below the minimum and names both versions", () => {
-	const result = checkPiVersion("0.85.0");
+	const result = checkPiVersion("1.1.0");
 	assert.equal(result.ok, false);
 	if (result.ok) throw new Error("expected a failing result");
-	assert.equal(result.version, "0.85.0");
-	assert.match(result.message, /0\.85\.0/);
-	assert.match(result.message, /0\.99\.1/);
+	assert.equal(result.version, "1.1.0");
+	assert.match(result.message, /1\.1\.0/);
+	assert.match(result.message, /1\.2\.0/);
+	assert.equal(checkPiVersion("1.0.0").ok, false);
+	assert.equal(checkPiVersion("0.99.1").ok, false);
 });
 
 test("checkPiVersion rejects a prerelease below the minimum", () => {
@@ -736,7 +741,7 @@ test("checkPiVersion reports unparsable output with the raw text and the minimum
 	if (result.ok) throw new Error("expected a failing result");
 	assert.equal(result.version, undefined);
 	assert.match(result.message, /not a version/);
-	assert.match(result.message, /0\.99\.1/);
+	assert.match(result.message, /1\.2\.0/);
 });
 
 test("checkPiVersion accepts a custom minimum", () => {
@@ -2015,7 +2020,7 @@ test("the isolated-home bootstrap creates ~/.gentle-shell as 0700 under umask 00
 	const root = mkdtempSync(join(tmpdir(), "gentle-shell-umask-"));
 	try {
 		const piScript = join(root, "fake-pi.mjs");
-		writeFileSync(piScript, "#!/usr/bin/env node\nif (process.argv.includes('--version')) console.log('0.99.1');\n");
+		writeFileSync(piScript, "#!/usr/bin/env node\nif (process.argv.includes('--version')) console.log('1.2.0');\n");
 		chmodSync(piScript, 0o755);
 		const binPath = fileURLToPath(new URL("../bin/gentle-shell.mjs", import.meta.url));
 		const env = { HOME: root, USERPROFILE: root, PATH: process.env.PATH ?? "/usr/bin:/bin", GENTLE_SHELL_PI: piScript, GENTLE_SHELL_NO_AUTO_SETUP: "1" };

package/tests/gentle-shell.test.ts

@@ -4,19 +4,23 @@ import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSy
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import test, { after } from "node:test";
+import test, { after, afterEach } from "node:test";
 import { initTheme, type ExtensionAPI, type ExtensionContext, type SlashCommandInfo, type SourceInfo } from "@earendil-works/pi-coding-agent";
-import { CURSOR_MARKER, matchesKey, visibleWidth, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { CURSOR_MARKER, matchesKey, stripTerminalSequences as stripAnsi, TuiMainScreen, visibleWidth, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import installGentleShell, { backgroundChangeRefreshesSettled, buildShellBarModel, createActiveProfileReader, changesShortcut, devBinaryCard, extractQueuedText, fetchCodexUsage, fetchNanUsage, loadFileDiff, shellGitRunner, openInExternalEditor, usageShortcut, GentlePromptEditor } from "../extensions/gentle-shell.ts";
 import { CODEX_USAGE_URL, NAN_QUOTA_URL, USAGE_SOURCE_EVENT, USAGE_SOURCE_SCHEMA } from "../lib/shell-usage.ts";
 import { bindSessionProfile, clearSessionProfileBinding, resetSessionProfileBindingsForTesting } from "../lib/session-profile-binding.ts";
 import { createVimEditorAdapter, isAuditedPiEditorVersion } from "../lib/vim-editor-adapter.ts";
+import { readFrozenInheritedProfile, resetFrozenInheritedProfilesForTesting } from "../lib/session-profile-freeze.ts";
+
+// Fixture sessions share ids across tests; the inherited-profile freeze is
+// process state keyed by session id (gentle-shell#1064 slice 3b-ii).
+afterEach(() => resetFrozenInheritedProfilesForTesting());
 import { buildCommandPaletteGroups } from "../lib/command-palette-catalog.ts";
 import { CHANGE_STATUS, DIFF_MAX_BYTES, DIFF_MAX_LINES, DIFF_TOO_LARGE } from "../lib/shell-changes.ts";
 import { sidebarPart, sidebarState, type SidebarRail } from "../lib/shell-sidebar.ts";
 import { renderTodoCard } from "../lib/shell-todo.ts";
 import type { ShellBarTheme } from "../lib/shell-bar.ts";
-import { stripAnsi } from "../lib/terminal-theme.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";
@@ -751,7 +755,9 @@ test("profile polling refreshes both fullscreen surfaces only on change and stop
 	t.mock.method(globalThis, "clearInterval", (handle: { timer: (typeof intervals)[number] }) => { handle.timer.stopped = true; });
 	const { pi, handlers } = fakePi();
 	let resolutions = 0;
-	gentleShell(pi, { GENTLE_PI_CONFIG_HOME: home, GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off" }, {
+	// follow mode keeps the live p → P → G resolution, so a pin edit reaches the
+	// open session through the poll (gentle-shell#1064 slice 3b-ii).
+	gentleShell(pi, { GENTLE_PI_CONFIG_HOME: home, GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off", GENTLE_PI_PROFILE_FOLLOW: "1" }, {
 		resolveWorktree: () => { resolutions++; return { root: repo, commonDir }; },
 	});
 	const first = fakeContext();
@@ -1800,6 +1806,8 @@ function reverseColumns(row: string): number[] {
 	let inverse = false;
 	let column = 0;
 	const selected: number[] = [];
+	const host = TuiMainScreen.prototype as unknown as { resolveFakeCursors(rows: string[]): string[] };
+	row = host.resolveFakeCursors.call({ showHardwareCursor: false }, [row])[0]!;
 	const tokens = row.match(/\x1b\[[0-9;]*m|\x1b_pi:c\x07|[^\x1b]/g) ?? [];
 	assert.equal(tokens.join(""), row);
 	for (const token of tokens) {
@@ -5945,7 +5953,10 @@ test("after a profile switch the panel stops presenting the old profile's provid
 	ui.closeOverlay?.();
 	await opened;
 
-	writeProfilesStore(home, { team: { reviewer: { model: "nan/glm5.3" } }, solo: {} }, "solo");
+	// An open session changes profile only through its own Enter (gentle-shell#1064
+	// slice 3b-ii): a new global default would leave its frozen routing in place.
+	bindSessionProfile("shell-session", "solo", {});
+	t.after(() => resetSessionProfileBindingsForTesting());
 	const reopened = commands.get("gentle:usage")!.handler("", ctx);
 	await settle();
 	assert.equal(ui.overlayView!.render(90).map(stripAnsi).some((line) => line.includes("nan")), false, "a provider recorded under the previous profile's routing is not current scope");
@@ -5953,6 +5964,61 @@ test("after a profile switch the panel stops presenting the old profile's provid
 	await reopened;
 });
 
+test("an open session keeps its frozen profile in the status and Usage scope when the defaults change", async (t) => {
+	const home = mkdtempSync(join(tmpdir(), "shell-frozen-"));
+	const commonDir = mkdtempSync(join(tmpdir(), "shell-frozen-git-"));
+	t.after(() => {
+		rmSync(home, { recursive: true, force: true });
+		rmSync(commonDir, { recursive: true, force: true });
+	});
+	mkdirSync(join(commonDir, "gentle-ai"), { recursive: true });
+	writeProfilesStore(home, { team: { reviewer: { model: "nan/glm5.3" } }, solo: { reviewer: { model: "openai-codex/gpt-5.5" } } }, "team");
+	const { pi, handlers, commands } = fakePi();
+	gentleShell(pi, { GENTLE_PI_CONFIG_HOME: home, GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off" }, { fetch: fakeFetch(NAN_QUOTA_PAYLOAD).fetchFn, now: () => 1_788_600_000_000, resolveWorktree: () => ({ root: "/repo", commonDir }) });
+	const { ctx, ui } = fakeContext({ token: JWT });
+	await fire(handlers, "session_start", ctx);
+	assert.equal(readFrozenInheritedProfile("shell-session")?.profile?.name, "team", "the session froze the global active profile at start");
+	writeProfilesStore(home, { team: { reviewer: { model: "nan/glm5.3" } }, solo: { reviewer: { model: "openai-codex/gpt-5.5" } } }, "solo");
+	writeFileSync(join(commonDir, "gentle-ai", "profile-pin.json"), JSON.stringify({ kind: "gentle-pi.agent_model_profile_pin", version: 1, profile: "solo" }));
+	const opened = commands.get("gentle:usage")!.handler("", ctx);
+	await settle();
+	assert.ok(openPanelLines(ui).some((line) => /^│ nan ·/.test(line)), "Usage keeps the frozen profile's nan route");
+	ui.closeOverlay?.();
+	await opened;
+	const factory = ui.footerFactory as (tui: unknown, theme: ShellBarTheme, data: unknown) => { dispose(): void };
+	const tui = { terminal: { rows: 40, columns: 160 }, requestRender() {} };
+	const component = factory(tui, plainTheme, { getGitBranch: () => "main", getExtensionStatuses: () => new Map(), getAvailableProviderCount: () => 1, onBranchChange: () => () => {} });
+	try {
+		const status = (sidebarState(tui as unknown as TUI).parts.get("footer") as SidebarRail).render(60).join("\n");
+		assert.match(status, /Profile.*team/, "the status keeps the bare global name of the frozen profile");
+		assert.doesNotMatch(status, /solo/);
+	} finally {
+		component.dispose();
+	}
+});
+
+test("active profile reader: a bound session shows its frozen profile, and follow shows the live default", (t) => {
+	const root = mkdtempSync(join(tmpdir(), "shell-profile-frozen-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const commonDir = join(root, "git");
+	mkdirSync(join(commonDir, "gentle-ai"), { recursive: true });
+	writeFileSync(join(root, "profiles.json"), JSON.stringify({ kind: "gentle-pi.agent_model_profiles", version: 1, active: "team", profiles: { team: {}, other: {} } }));
+	const pin = (profile: string) => writeFileSync(join(commonDir, "gentle-ai", "profile-pin.json"), JSON.stringify({ kind: "gentle-pi.agent_model_profile_pin", version: 1, profile }));
+	pin("other");
+	const frozen = createActiveProfileReader({ GENTLE_PI_CONFIG_HOME: root });
+	frozen.bind(root, () => ({ root, commonDir }), "session-frozen");
+	assert.equal(frozen(), "other (local)");
+	const follow = createActiveProfileReader({ GENTLE_PI_CONFIG_HOME: root, GENTLE_PI_PROFILE_FOLLOW: "1" });
+	follow.bind(root, () => ({ root, commonDir }), "session-follow");
+	assert.equal(follow(), "other (local)");
+	rmSync(join(commonDir, "gentle-ai", "profile-pin.json"));
+	assert.equal(frozen.refresh(), false, "the frozen label does not move");
+	assert.equal(frozen(), "other (local)");
+	assert.equal(follow.refresh(), true);
+	assert.equal(follow(), "team", "follow falls to the global active profile");
+	assert.equal(readFrozenInheritedProfile("session-follow"), undefined);
+});
+
 function openPanelLines(ui: FakeUi): string[] {
 	return ui.overlayView!.render(90).map(stripAnsi);
 }

package/tests/gentle-todo.test.ts

@@ -114,12 +114,27 @@ test("long Todo widgets stay bounded, scroll, resize and keep their collapse con
 		assert.equal((result.details.gentleTodo as { tasks: { title: string; note: string }[] }).tasks[0].title, title.trim());
 		assert.equal((result.details.gentleTodo as { tasks: { title: string; note: string }[] }).tasks[0].note, note.trim());
 		await shortcuts.get("ctrl+shift+t")!.handler(ctx);
-		await shortcuts.get("ctrl+shift+down")!.handler(ctx);
+		await shortcuts.get("alt+shift+down")!.handler(ctx);
 		assert.notDeepEqual(bottom.render(40), collapsed, "keyboard scrolling is available without mouse");
 	}
 	t.after(() => setCardStyle(CARD_STYLE.NEON));
 });
 
+test("Todo shortcuts never take a key Pi binds by default, so startup reports no shortcut conflict", async () => {
+	// Pi keeps its default table in dist/core/keybindings.js, next to the package entry.
+	const { KEYBINDINGS } = await import(new URL("core/keybindings.js", import.meta.resolve("@earendil-works/pi-coding-agent")).href) as
+		{ KEYBINDINGS: Record<string, { defaultKeys?: string | string[] }> };
+	assert.ok("tui.altScreen.previousPrompt" in KEYBINDINGS, "the table includes Pi's built-in prompt navigation");
+	const owners = new Map<string, string[]>();
+	for (const [id, binding] of Object.entries(KEYBINDINGS)) {
+		for (const key of ([] as string[]).concat(binding.defaultKeys ?? [])) owners.set(key, [...(owners.get(key) ?? []), id]);
+	}
+	const { pi, shortcuts } = fakePi();
+	gentleTodo(pi, {});
+	assert.deepEqual([...shortcuts.keys()].sort(), ["alt+shift+down", "alt+shift+up", "ctrl+shift+t"]);
+	for (const key of shortcuts.keys()) assert.equal(owners.get(key), undefined, `${key} is a Pi default for ${owners.get(key)?.join(", ")}`);
+});
+
 test("Todo keyboard scrolling targets the visible card after a cached sidebar breakpoint round-trip", async (t) => {
 	const node = Symbol.for("@earendil-works/pi-tui/layout-node");
 	for (const style of [CARD_STYLE.NEON, CARD_STYLE.FLOAT]) {
@@ -146,11 +161,11 @@ test("Todo keyboard scrolling targets the visible card after a cached sidebar br
 			bottom.render(40);
 			tui.terminal.columns = 160;
 			const before = railLines();
-			await shortcuts.get("ctrl+shift+down")!.handler(ctx);
+			await shortcuts.get("alt+shift+down")!.handler(ctx);
 			const after = railLines();
 			assert.notDeepEqual(after, before, "DOWN changes the visible cached rail, not the hidden bottom widget");
 			assert.match(after.join("\n"), /↑↓ 4–/);
-			await shortcuts.get("ctrl+shift+up")!.handler(ctx);
+			await shortcuts.get("alt+shift+up")!.handler(ctx);
 			assert.deepEqual(railLines(), before, "UP restores the expanded viewport");
 		} finally {
 			dispose();
@@ -288,11 +303,25 @@ function toolTurn(toolName = "read") {
 	return { message: { role: "assistant", content: [{ type: "toolCall", id: "call", name: toolName, arguments: {} }] }, toolResults: [] };
 }
 
-async function contextReminder(fire: ReturnType<typeof fakePi>["fire"], ctx: ExtensionContext) {
+type ContextMessage = { role: string; content: unknown; customType?: string; display?: boolean; timestamp?: number };
+
+async function contextMessages(fire: ReturnType<typeof fakePi>["fire"], ctx: ExtensionContext): Promise<ContextMessage[] | undefined> {
 	const messages = [{ role: "user", content: "Keep working", timestamp: 1 }];
-	const result = await fire("context", ctx, { messages }) as { messages: Array<{ role: string; content: unknown }> } | undefined;
+	const result = await fire("context", ctx, { messages }) as { messages: ContextMessage[] } | undefined;
 	assert.deepEqual(messages, [{ role: "user", content: "Keep working", timestamp: 1 }], "request-local injection must not mutate the input transcript");
-	return result;
+	if (result === undefined) return undefined;
+	assert.deepEqual(result.messages[0], { role: "user", content: "Keep working", timestamp: 1 }, "the transcript stays first; todo messages trail it");
+	return result.messages;
+}
+
+/** The request-local reminder, if the next model request carries one. */
+async function contextReminder(fire: ReturnType<typeof fakePi>["fire"], ctx: ExtensionContext): Promise<ContextMessage | undefined> {
+	return (await contextMessages(fire, ctx))?.find((message) => message.customType === "gentle-todo-reminder");
+}
+
+/** The request-local current-list message, if the next model request carries one (#1662). */
+async function contextState(fire: ReturnType<typeof fakePi>["fire"], ctx: ExtensionContext): Promise<ContextMessage | undefined> {
+	return (await contextMessages(fire, ctx))?.find((message) => message.customType === "gentle-todo-state");
 }
 
 async function workTurns(fire: ReturnType<typeof fakePi>["fire"], ctx: ExtensionContext, count: number) {
@@ -312,13 +341,14 @@ test("runtime reminder arrives after four tool-use turns, only once, without cha
 	await workTurns(fire, ctx, 3);
 	assert.equal(await contextReminder(fire, ctx), undefined);
 	await workTurns(fire, ctx, 1);
-	const result = await contextReminder(fire, ctx);
-	assert.ok(result, "the next model request must carry a reminder within the same run");
-	assert.equal(result.messages.length, 2);
-	assert.deepEqual(result.messages[0], { role: "user", content: "Keep working", timestamp: 1 });
-	assert.deepEqual(result.messages[1], { role: "custom", customType: "gentle-todo-reminder", content: REMINDER, display: false, timestamp: (result.messages[1] as { timestamp?: number }).timestamp });
-	const converted = convertToLlm(result.messages as Parameters<typeof convertToLlm>[0]);
-	assert.deepEqual(converted[1], { role: "user", content: [{ type: "text", text: REMINDER }], timestamp: (result.messages[1] as { timestamp?: number }).timestamp }, "Pi forwards the reminder as provider-compatible text");
+	const messages = await contextMessages(fire, ctx);
+	assert.ok(messages, "the next model request must carry a reminder within the same run");
+	assert.equal(messages.length, 3, "transcript, current list, then the reminder");
+	assert.equal(messages[1]!.customType, "gentle-todo-state");
+	const reminder = messages[2]!;
+	assert.deepEqual(reminder, { role: "custom", customType: "gentle-todo-reminder", content: REMINDER, display: false, timestamp: reminder.timestamp });
+	const converted = convertToLlm(messages as Parameters<typeof convertToLlm>[0]);
+	assert.deepEqual(converted[2], { role: "user", content: [{ type: "text", text: REMINDER }], timestamp: reminder.timestamp }, "Pi forwards the reminder as provider-compatible text");
 	await workTurns(fire, ctx, 4);
 	assert.equal(await contextReminder(fire, ctx), undefined, "no repeated nagging without a todo write");
 	const listed = await tool.execute("list", { action: "list" }, undefined, undefined, ctx);
@@ -418,31 +448,53 @@ function promptEvent(): { systemPrompt: string; systemPromptOptions: { appendSys
 	return { systemPrompt: "base", systemPromptOptions: { appendSystemPrompt: "" } };
 }
 
-test("every turn carries the open tasks in appendSystemPrompt (never a returned systemPrompt) and the card goes stale after two silent turns", async () => {
+test("the system prompt carries only a byte-stable todo block; the current list travels as a request-local message (#1662)", async () => {
 	const { pi, tools, fire } = fakePi();
 	gentleTodo(pi, {});
 	const { ctx, widget } = fakeContext();
 	await fire("session_start", ctx);
-	await fire("before_agent_start", ctx, promptEvent());
+	const emptyEvent = promptEvent();
+	assert.equal(await fire("before_agent_start", ctx, emptyEvent), undefined, "the handler must not return a replacement systemPrompt");
+	assert.match(emptyEvent.systemPromptOptions.appendSystemPrompt, /^## Todo list/);
+	assert.match(emptyEvent.systemPromptOptions.appendSystemPrompt, /mark a task in_progress before starting/);
+	assert.equal(await contextState(fire, ctx), undefined, "an empty list sends no state message");
+
 	await tools.get("todo")!.execute("c1", { action: "write", tasks: [{ title: "Fix the bug" }] }, undefined, undefined, ctx);
 	await fire("tool_execution_end", ctx, { toolName: "todo" });
-
 	const withTasksEvent = promptEvent();
-	const withTasksResult = await fire("before_agent_start", ctx, withTasksEvent);
-	assert.equal(withTasksResult, undefined, "the handler must not return a replacement systemPrompt");
-	assert.match(withTasksEvent.systemPromptOptions.appendSystemPrompt, /^## Todo list/);
-	assert.match(withTasksEvent.systemPromptOptions.appendSystemPrompt, /1\. \[pending\] Fix the bug/);
+	await fire("before_agent_start", ctx, withTasksEvent);
+	assert.equal(withTasksEvent.systemPromptOptions.appendSystemPrompt, emptyEvent.systemPromptOptions.appendSystemPrompt, "writing a list must not change the system prompt");
+	assert.doesNotMatch(withTasksEvent.systemPromptOptions.appendSystemPrompt, /Fix the bug/, "task content never enters the system prompt");
+	const state = await contextState(fire, ctx);
+	assert.ok(state, "open tasks arrive as a trailing request-local message");
+	assert.equal(state.role, "custom");
+	assert.equal(state.display, false);
+	assert.match(String(state.content), /1\. \[pending\] Fix the bug/);
 	assert.doesNotMatch(widget()![0], /stale/);
 
-	const staleEvent = promptEvent();
-	await fire("before_agent_start", ctx, staleEvent);
-	assert.match(staleEvent.systemPromptOptions.appendSystemPrompt, /stale: 2 turns without an update/);
-	assert.match(widget()![0], /ctrl\+shift\+t collapse/);
-	assert.match(widget()![1], /stale · 2 turns/);
+	// Silent turns: the UI card goes stale, the system prompt stays frozen (#1367).
+	for (const expected of ["stale · 2 turns", "stale · 3 turns"]) {
+		const silent = promptEvent();
+		await fire("before_agent_start", ctx, silent);
+		assert.equal(silent.systemPromptOptions.appendSystemPrompt, emptyEvent.systemPromptOptions.appendSystemPrompt);
+		assert.match(widget()![1], new RegExp(expected));
+	}
 
+	// Status, note, title and ordering changes reach the model through the message only.
 	await tools.get("todo")!.execute("c2", { action: "update", id: 1, status: "in_progress", note: "on it" }, undefined, undefined, ctx);
 	await fire("tool_execution_end", ctx, { toolName: "todo" });
+	const updatedEvent = promptEvent();
+	await fire("before_agent_start", ctx, updatedEvent);
+	assert.equal(updatedEvent.systemPromptOptions.appendSystemPrompt, emptyEvent.systemPromptOptions.appendSystemPrompt, "a status change must not change the system prompt");
+	assert.match(String((await contextState(fire, ctx))!.content), /1\. \[in_progress\] Fix the bug — on it/);
 	assert.doesNotMatch(widget()![0], /stale/);
+
+	await tools.get("todo")!.execute("c3", { action: "update", id: 1, status: "done" }, undefined, undefined, ctx);
+	await fire("tool_execution_end", ctx, { toolName: "todo" });
+	assert.equal(await contextState(fire, ctx), undefined, "a finished list sends no state message");
+	const finishedEvent = promptEvent();
+	await fire("before_agent_start", ctx, finishedEvent);
+	assert.equal(finishedEvent.systemPromptOptions.appendSystemPrompt, emptyEvent.systemPromptOptions.appendSystemPrompt, "finishing the list must not change the system prompt");
 });
 
 test("before_agent_start is idempotent: a todo block already present in appendSystemPrompt is not duplicated", async () => {
@@ -555,8 +607,8 @@ test("a list left with only dropped tasks open finishes and clears; a blocked-on
 		await fire("agent_end", ctx);
 		const event = promptEvent();
 		await fire("before_agent_start", ctx, event);
-		assert.match(event.systemPromptOptions.appendSystemPrompt, /2\. \[blocked\] Deploy — waiting for an admin/);
-		assert.doesNotMatch(event.systemPromptOptions.appendSystemPrompt, /stale/);
+		assert.doesNotMatch(event.systemPromptOptions.appendSystemPrompt, /Deploy/);
+		assert.match(String((await contextState(fire, ctx))!.content), /2\. \[blocked\] Deploy — waiting for an admin/);
 	}
 	assert.match(widget()![2], /⊘ Deploy · waiting for an admin/);
 });