gentle-pi 4.0.0 → 4.2.0

package/tests/test-strength-contract.test.ts

@@ -0,0 +1,124 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { __testing } from "../extensions/gentle-ai.ts";
+
+// gentle-shell#1731 T26 (L54): in the final bench blind review of x2, the
+// Gentle Shell inline solutions ranked below Codex on tests: they skipped the
+// empty-stdout check, put the bad row last (no proof that later valid rows are
+// not saved), missed the empty value, and asserted internal storage instead of
+// the public output. The verify-backed arm ranked first because verify's probe
+// checklist covers exactly these. Writers and inline work get the same
+// checklist for the tests they write. Instruction-delivery contract only.
+
+const TEST_RULE = [
+	"Each test asserts every observable effect of the rule it covers",
+	"exit code, exact stdout and stderr",
+	"rejected input leaves stored data and counters unchanged",
+	"covers the cases the rule itself names (its examples, boundaries, and errors)",
+	"through the public interface, never internal storage",
+];
+
+const read = (relative: string): string => readFileSync(join(import.meta.dirname, "..", relative), "utf8");
+
+test("T26: the always-on Implement step gives inline work the test checklist", () => {
+	for (const persona of ["gentleman", "neutral"] as const) {
+		const step = __testing.buildGentlePrompt(persona).split("\n").find((line) => line.startsWith("6. **Implement"));
+		assert.ok(step, "ODD step 6 Implement is missing");
+		for (const clause of TEST_RULE) assert.ok(step.includes(clause), `${persona} Implement step is missing: ${clause}`);
+	}
+});
+
+test("T26: the worker test discipline carries the same checklist", () => {
+	const worker = read("assets/agents/gentle-ai-worker.md");
+	for (const clause of TEST_RULE) assert.ok(worker.includes(clause), `worker test discipline is missing: ${clause}`);
+	assert.ok(!worker.includes("add the smallest behavior-level test"), "RED must not ask for the smallest test");
+});
+
+// T26b (L56): blind review of x5 ranked Codex above the inline Gentle Shell
+// arms partly because they added options without updating help and README.
+test("T26b: inline and delegated work update the help and docs that describe a changed option", () => {
+	const clause = "When you add or change a command, option, or message, update the help text and docs that describe it";
+	for (const persona of ["gentleman", "neutral"] as const) {
+		const step = __testing.buildGentlePrompt(persona).split("\n").find((line) => line.startsWith("6. **Implement"));
+		assert.ok(step?.includes(clause), `${persona} Implement step is missing the docs rule`);
+	}
+	assert.ok(read("assets/agents/gentle-ai-worker.md").includes(clause), "worker is missing the docs rule");
+});
+
+// T27 (L56): in `pi --mode json` the runtime already rejects background
+// launches (T18), but the prompt still said "Background subagent policy: on",
+// so B-bg tried background twice and took the parallel-writer path; its worker
+// shipped the silent `budget set --year` defect. Single-shot hosts render off.
+test("T27: single-shot host modes render the background policy as off", () => {
+	for (const mode of ["json", "print"]) {
+		const prompt = __testing.buildGentlePrompt("gentleman", process.cwd(), undefined, undefined, mode);
+		assert.match(prompt, /Background subagent policy: off \(single-shot mode\)/, `${mode} must render off`);
+	}
+	for (const mode of ["tui", "rpc", undefined]) {
+		const prompt = __testing.buildGentlePrompt("gentleman", process.cwd(), undefined, undefined, mode);
+		assert.doesNotMatch(prompt, /single-shot mode/, `${String(mode)} must keep the configured policy`);
+	}
+});
+
+// T28b (L60-L62): a fixed quota of generic edge cases is test padding. Every
+// real defect in the blind reviews came from a case derived from the request
+// or from an existing command the change touched (budget set --year, edit
+// --amount ignored), never from an invented edge. Tests are derived: one per
+// requested rule with the cases it names, plus one per touched existing
+// command or option proving its previous behavior still holds. Nothing else.
+const PRESERVE = "For every existing command or option the change touches, add one test proving its previous behavior still holds; add no other cases";
+test("T28b: inline test-first derives cases from the rules and touched commands, with no edge-case quota", () => {
+	for (const persona of ["gentleman", "neutral"] as const) {
+		const prompt = __testing.buildGentlePrompt(persona);
+		const principle = prompt.split("\n").find((line) => line.includes("use test-first by default"));
+		assert.ok(principle?.includes("observe RED, GREEN, then refactor with focused checks"), `${persona} principle keeps RED, GREEN, refactor`);
+		assert.ok(principle?.includes("one RED test per requested rule"), `${persona} principle must ask for one RED test per rule`);
+		assert.ok(principle?.includes(PRESERVE), `${persona} principle must add the preserve test`);
+		assert.doesNotMatch(prompt, /TRIANGULATE|at least two edge cases/, `${persona} prompt must not keep the edge-case quota`);
+	}
+});
+
+test("T28b: the worker preserves touched behavior instead of inventing edge cases", () => {
+	const worker = read("assets/agents/gentle-ai-worker.md");
+	assert.ok(worker.includes(`3. PRESERVE — ${PRESERVE}`), "worker step 3 must be PRESERVE");
+	assert.doesNotMatch(worker, /at least two edge cases|3\. TRIANGULATE/, "worker must not keep the edge-case quota");
+});
+
+// T31 (L68-L70): T30 named a CLI-parser case and did not work (0/2 probes
+// wrote the sibling test); it was fixture-specific. Replaced with the general
+// definition of "touched", and high-risk item 3 now separates a requested
+// contract change (covered by the request's tests) from existing behavior
+// nobody asked to change that shares the changed code (the real regressions).
+const TOUCHED = "An existing behavior counts as touched when it shares the code you changed (options, parsers, helpers, validation)";
+test("T31: PRESERVE uses the general definition of touched, not a parser-specific case", () => {
+	for (const persona of ["gentleman", "neutral"] as const) {
+		const prompt = __testing.buildGentlePrompt(persona);
+		assert.ok(prompt.includes(TOUCHED), `${persona} prompt must define touched behavior`);
+		assert.doesNotMatch(prompt, /shared parser or command, test that every sibling subcommand/, `${persona} must drop the T30 parser case`);
+	}
+	const worker = read("assets/agents/gentle-ai-worker.md");
+	assert.ok(worker.includes(TOUCHED), "worker must define touched behavior");
+	assert.doesNotMatch(worker, /shared parser or command, test that every sibling subcommand/, "worker must drop the T30 parser case");
+});
+
+test("T31: high-risk item 3 is about unrequested breaks, not the requested change", () => {
+	const core = read("assets/orchestrator.md");
+	assert.ok(
+		core.includes("requested changes are not; unrequested breaks in shared code are"),
+		"item 3 must separate requested changes from unrequested breaks",
+	);
+});
+
+// T33 (L74): in p31 x5 both runs declared `Risk: none` after adding --year to
+// the shared budget options; one shipped `budget set --year` silently saving a
+// wrong budget, the regression verify used to catch. The Risk line must check
+// shared code before claiming none.
+const SHARED_CHECK = "Before writing `Risk: none`, check whether your diff changes code that existing behavior the request did not mention also uses (shared options, parsers, helpers); if it does, that is item 3";
+test("T33: the Close step checks shared code before Risk: none", () => {
+	for (const persona of ["gentleman", "neutral"] as const) {
+		const step = __testing.buildGentlePrompt(persona).split("\n").find((line) => line.startsWith("7. **Close"));
+		assert.ok(step?.includes(SHARED_CHECK), `${persona} Close step must check shared code before Risk: none`);
+	}
+});

package/tests/verify-agent-contract.test.ts

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+
+// gentle-shell#1731 T11 (S4, S5; L24): in the bench the independent verifier
+// re-ran the writer's own tests and happy-path examples and missed defects that
+// blind adversarial probes found (an import accepting invalid split groups; a
+// budget ignoring refund parts whose own test locked the bug in). The verifier
+// now derives its own probes from the spec. These are instruction-delivery
+// contracts, not proof of model adherence.
+
+const read = (relative: string): string => readFileSync(join(import.meta.dirname, "..", relative), "utf8");
+const verify = read("assets/agents/gentle-ai-verify.md");
+
+function checklistItem(n: number): string {
+	const line = verify.split("\n").find((entry) => entry.startsWith(`${n}. **`));
+	assert.ok(line, `verify checklist item ${n} is missing`);
+	return line;
+}
+
+function containsAll(text: string, clauses: readonly string[], label: string): void {
+	for (const clause of clauses) assert.ok(text.includes(clause), `${label} is missing: ${clause}`);
+}
+
+test("T11.1: verify derives its own probes from every numbered rule and never trusts the writer's tests", () => {
+	assert.ok(verify.includes("The writer's tests and examples are never evidence of correctness"), "verify must not treat the writer's tests as evidence");
+	containsAll(checklistItem(1), [
+		"verbatim request",
+		"every numbered rule or requirement",
+		"derive your own probes",
+		"positive examples",
+		"negative and boundary cases",
+		"exact error messages and exit codes",
+	], "probe item");
+});
+
+test("T11.2: verify checks stored-data and legacy-output invariants against the baseline", () => {
+	containsAll(checklistItem(2), [
+		"after every rejected or failing command",
+		"byte-identical",
+		"hash before and after",
+		"commands that existed before the change",
+		"same output as at the baseline commit",
+		"unless the request changes them",
+	], "invariant item");
+});
+
+test("T11.3: verify probes the cross-feature interactions the request implies", () => {
+	containsAll(checklistItem(3), ["cross-feature interactions", "new data", "existing reports, totals, and exports"], "interaction item");
+});
+
+test("T11.4: verify runs the typecheck or build and flags scope creep", () => {
+	containsAll(checklistItem(4), ["typecheck or build", "when the project has one", "outside the request's scope"], "build and scope item");
+});
+
+test("T11.5: verify returns a verdict for every spec item with no partial-scope carve-out", () => {
+	containsAll(checklistItem(5), [
+		"verdict for EVERY spec item",
+		"met, unmet, or not implemented",
+		"no partial-scope carve-out",
+		"even when the parent named one task or unit",
+		"the parent resolves every unmet item before closing, with one correction batch and one recheck limited to the reported blockers",
+	], "verdict item");
+	assert.ok(verify.includes("verdict per `S#`"), "the feature-document verdict per S# must stay");
+});
+
+test("T11.6: verify leaves its probes as regression tests the writer commits", () => {
+	containsAll(checklistItem(6), [
+		"regression tests",
+		"the project's test suite",
+		"the writer to commit",
+		"you never write them",
+	], "durable probe item");
+});
+
+// T16 replaced "Run every probe only through command forms the parent authorized and only on isolated state the
+// parent named": probes now run on the first launch in a fresh scratch copy (verify-first-launch-contract).
+test("T11: probes stay inside the authorized commands or the scratch copy, and verify stays read-only", () => {
+	containsAll(verify, [
+		"execute only exact test, build, lint, or spec example commands explicitly authorized by the parent",
+		"only inside your scratch copy or on isolated state the parent named",
+		"report that probe as unverified with its exact command instead of running it",
+		"Do not edit, write, or fix findings.",
+		"Treat every unexpected mutation as a blocker",
+		"at most ~2k tokens",
+	], "verify agent");
+	const tools = verify.split("---")[1] ?? "";
+	assert.ok(!/\n {2}- (edit|write)\n/.test(tools), "verify must not gain edit or write tools");
+});

package/tests/verify-first-launch-contract.test.ts

@@ -0,0 +1,139 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { __testing } from "../extensions/gentle-ai.ts";
+
+// gentle-shell#1731 T16 (S5; L33-L34): in the after3 bench (B x4/x5) the first
+// verify launch ran no probes because the handoff said only "read-only" and
+// named no probe commands or isolated state, so every probe was reported
+// unverified and the parent continued the task (~2 min per cell). Read-only now
+// means no repository or git-state edits, and probes in a fresh scratch copy run
+// on the first launch.
+// T17 (S3; L33-L34): B x4 delegated a 1.2 min exploration and then the parent
+// re-read the same 10 files; exploration is delegated only for a map the parent
+// needs to decide or route.
+// These are instruction-delivery contracts, not proof of model adherence.
+
+const read = (relative: string): string => readFileSync(join(import.meta.dirname, "..", relative), "utf8");
+const verify = read("assets/agents/gentle-ai-verify.md");
+const verification = read("assets/orchestrator-verification.md");
+
+function containsAll(text: string, clauses: readonly string[], label: string): void {
+	for (const clause of clauses) assert.ok(text.includes(clause), `${label} is missing: ${clause}`);
+}
+
+test("T16: read-only means no repository or git-state edits", () => {
+	containsAll(verify, [
+		"read-only technical verifier for generic ODD work",
+		"Read-only means no edits to the repository or its git state",
+	], "verify agent");
+});
+
+test("T16: verify probes on its first launch inside a fresh mktemp scratch copy without waiting for authorization", () => {
+	containsAll(verify, [
+		"Probe on your first launch; never wait for further authorization",
+		"fresh `mktemp -d` scratch copy of the workspace",
+		"the project's own test, CLI, and typecheck commands",
+		"No network, no installs, no writes outside the scratch directory",
+		"report that probe as unverified with its exact command instead of running it",
+	], "first-launch probe rule");
+	assert.ok(
+		!verify.includes("Run every probe only through command forms the parent authorized and only on isolated state the parent named"),
+		"the old rule makes every probe unverified when the handoff names no commands",
+	);
+});
+
+test("T16/W1: the scratch copy method cannot write outside the scratch directory", () => {
+	containsAll(verify, [
+		"copy the workspace files without `.git`",
+		"never `git worktree`, `git stash`, or a symlink into the workspace",
+		"set `HOME` and `TMPDIR` inside the scratch directory",
+	], "scratch copy method");
+});
+
+// T21 (L44): in after4, verify reported a behavior already present at the
+// baseline (B x5, unchecked import amounts the request kept "as they do today")
+// and a value far outside the realistic domain (B x4, sums near 9e15) as
+// blockers; each forced a correction round. Blockers need provenance and
+// realistic inputs; the rest are reported as advisories.
+test("T21: verify grades severity by provenance and realistic inputs", () => {
+	containsAll(verify, [
+		"## Severity",
+		"A blocker is a defect the change caused or a spec item the change leaves unmet",
+		"Before calling a finding a blocker, reproduce it at the baseline",
+		"already present at the baseline and not asked to change is a pre-existing advisory",
+		"only with inputs outside the realistic domain",
+		"is an advisory",
+		"Any file, flag, or value a user can feed through the program's own commands is realistic input, hand-edited files included",
+		"a rule the request sets for one entry path holds for every path that creates the same data",
+		"Silently ignoring an option or value the user passed explicitly, with a success exit, is always a blocker",
+		"An unrequested change to the output, error text, or line numbering of a command that existed at the baseline is change-caused and a blocker, even when it looks like an improvement",
+	], "verify severity rule");
+});
+
+// T22 (L45): R-xh x4 ran about six verify/fix/recheck rounds on one delivery
+// (each recheck found something new) and hit the 60 min timeout; the only rule
+// was "resolve every unmet item before closing". Corrections are bounded.
+test("T22: verify blockers get one correction batch and one scoped recheck", () => {
+	containsAll(verification, [
+		"5. **One correction**",
+		"one correction batch that fixes every reported blocker",
+		"one re-verify limited to those blockers",
+		"never a new full sweep",
+		"Blockers still open after that stop as one **Needs your decision**",
+		"Advisories never start a correction",
+		"A second correction runs automatically only when the recheck shows the same blocker still failing",
+		"a new finding never earns one",
+	], "verification correction bound");
+	containsAll(verify, [
+		"Keep the scratch path in your commands; never write it, or anything else, to a file outside the scratch",
+		"NO_UPDATE_NOTIFIER=1",
+		"Create the scratch directory with `mktemp -d` under the system temp directory, never inside the workspace",
+		"`NODE_COMPILE_CACHE`",
+		"leave no new file in the workspace",
+	], "verify scratch hygiene");
+});
+
+test("T16: verify keeps its repository and tool boundaries", () => {
+	containsAll(verify, [
+		"Do not edit, write, or fix findings.",
+		"install dependencies, or mutate repository state",
+		"Treat every unexpected mutation as a blocker",
+	], "verify boundaries");
+	const tools = verify.split("---")[1] ?? "";
+	assert.ok(!/\n {2}- (edit|write)\n/.test(tools), "verify must not gain edit or write tools");
+});
+
+test("T16: the verify handoff names probe command forms and the scratch location, never just read-only", () => {
+	const item = verification.split("\n").find((line) => line.startsWith("4. **Verify handoff**"));
+	assert.ok(item, "verify handoff item is missing");
+	containsAll(item, [
+		"the probe command forms (tests, CLI, typecheck)",
+		"probes on isolated state",
+		"fresh `mktemp -d` scratch copy",
+		"never just \"read-only\"",
+	], "verify handoff");
+});
+
+// T17b (L42): after4 B x5 read two files, then the core Evidence-budget rule
+// fired and delegated a 1.5 min exploration on a small task the parent then
+// implemented inline. The trigger itself must exclude reading for an inline write.
+test("T17b: the core Evidence-budget rule never fires to prepare an inline write", () => {
+	const core = read("assets/orchestrator.md");
+	const rule = core.split("\n").find((line) => line.includes("**Evidence-budget rule**"));
+	assert.ok(rule, "Evidence-budget rule is missing");
+	assert.ok(rule.includes("never for reading before an inline write"), "Evidence-budget rule must exclude reading for an inline write");
+});
+
+test("T17: the always-on Explore step delegates exploration only for a map the parent needs", () => {
+	for (const persona of ["gentleman", "neutral"] as const) {
+		const prompt = __testing.buildGentlePrompt(persona);
+		const step = prompt.split("\n").find((line) => line.startsWith("2. **Explore.**"));
+		assert.ok(step, "ODD step 2 Explore is missing");
+		containsAll(step, [
+			"Do not delegate exploration of files you will read anyway to work inline",
+			"explore only for a map you need to decide or route",
+		], "ODD Explore step");
+	}
+});

package/tests/verify-package-files.test.ts

@@ -1,16 +1,30 @@
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import test from "node:test";
 import {
 	gentleAiVersionPinMismatches,
+	installerPaths,
+	missingRequiredPaths,
 	reconcileContractsOnDisk,
 	reconcileGeneratedRuntimeSources,
+	requiredPaths,
 } from "../scripts/verify-package-files.mjs";
 import { INSTALLER_VERSION, RELEASE_BASE_URL, GENTLE_AI_WINDOWS_SOURCE_TAG } from "../scripts/gentle-ai-installer.mjs";
 import { GENTLE_AI_VERSION } from "../lib/gentle-ai-binary.ts";
 
+test("package resource CLI reconciles the STATUS diagnostic runtime with the generated inventory", () => {
+	const result = spawnSync(process.execPath, [join(process.cwd(), "scripts/verify-package-files.mjs")], {
+		cwd: process.cwd(), encoding: "utf8", env: { ...process.env, NODE_NO_WARNINGS: "1" },
+	});
+	assert.equal(result.status, 0, result.stderr || result.stdout);
+	assert.equal(result.stderr, "");
+	assert.match(result.stdout, /^gentle-pi package resource check passed \(/);
+});
+
 function makeFixtureRoot(): string {
 	return mkdtempSync(join(tmpdir(), "gentle-pi-verify-package-files-"));
 }
@@ -179,3 +193,45 @@ test("both walks report no drift when sources, runtime/*.mjs, requiredPaths, and
 		rmSync(fixtureRoot, { recursive: true, force: true });
 	}
 });
+
+test("required package paths include every browser installation wizard file", () => {
+	const expected = [
+		"bin/gentle-shell-install.mjs",
+		"scripts/installer-server.mjs",
+		"scripts/installer-runner.mjs",
+		"scripts/installer-preflight.mjs",
+		"scripts/installer-probes.mjs",
+		"scripts/installer-downloads.mjs",
+		"scripts/main-channel.mjs",
+		"scripts/installer-windows.mjs",
+		"scripts/installer-windows-artifacts.json",
+		// The bundled install the wizard runs for a new release installation (T1c).
+		"scripts/bundled-wizard.mjs",
+		"scripts/bundled-install.mjs",
+		"scripts/bootstrap.sh",
+		"scripts/bootstrap.cmd",
+		"assets/install-wizard/index.html",
+		"assets/install-wizard/wizard.js",
+		"assets/install-wizard/wizard.css",
+	];
+	assert.deepEqual([...installerPaths].sort(), [...expected].sort());
+	for (const relativePath of expected) assert.ok(requiredPaths.includes(relativePath), relativePath);
+	const repositoryRoot = fileURLToPath(new URL("..", import.meta.url));
+	assert.deepEqual(missingRequiredPaths(repositoryRoot, installerPaths), []);
+});
+
+test("missing required paths are reported, including directories in place of files", () => {
+	const fixtureRoot = makeFixtureRoot();
+	try {
+		mkdirSync(join(fixtureRoot, "bin"), { recursive: true });
+		mkdirSync(join(fixtureRoot, "assets/install-wizard/index.html"), { recursive: true });
+		writeFileSync(join(fixtureRoot, "bin/gentle-shell-install.mjs"), "// entry\n");
+
+		assert.deepEqual(
+			missingRequiredPaths(fixtureRoot, ["bin/gentle-shell-install.mjs", "assets/install-wizard/index.html", "scripts/installer-server.mjs"]),
+			["assets/install-wizard/index.html", "scripts/installer-server.mjs"],
+		);
+	} finally {
+		rmSync(fixtureRoot, { recursive: true, force: true });
+	}
+});

package/tests/vim-editor-adapter.test.ts

@@ -5,12 +5,17 @@ import { tmpdir } from "node:os";
 import { createRequire } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname, resolve } from "node:path";
-import { CURSOR_MARKER, Editor, visibleWidth } from "@earendil-works/pi-tui";
+import { CURSOR_MARKER, Editor, TuiMainScreen, visibleWidth } from "@earendil-works/pi-tui";
 import { AUDITED_PI_EDITOR_VERSIONS, createVimEditorAdapter, isAuditedPiEditorVersion } from "../lib/vim-editor-adapter.ts";
 import { resolveVimRuntime, VIM_AGENT_INDEX_PATTERN, VIM_CLI_ENTRY_PATTERN } from "../extensions/gentle-shell.ts";
 import { VimOperatorEngine } from "../lib/vim-operator-engine.ts";
 import { VimVisualEngine } from "../lib/vim-visual-engine.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);
+}
+
 function editor(): Editor {
   return new Editor({ terminal: { rows: 24 }, requestRender() {} } as never, { borderColor: (s: string) => s } as never);
 }
@@ -20,6 +25,8 @@ function editor(): Editor {
 function paintedCells(row: string): Array<{ char: string; inverse: boolean }> {
   const cells: Array<{ char: string; inverse: boolean }> = [];
   let inverse = false;
+  // Decode the actual host post-pass, including hardware cursor suppression.
+  row = resolveFakeCursors([row])[0]!;
   const tokens = row.match(/\x1b\[[0-9;]*m|\x1b_pi:c\x07|[^\x1b]/g) ?? [];
   assert.equal(tokens.join(""), row, "only known editor escape sequences are present");
   for (const token of tokens) {
@@ -229,8 +236,8 @@ function assertInstalledPiPairBehavior(version: string, EditorClass: typeof Edit
   assert.equal(adapter.renderSelection(18, { line: 0, col: 0 }, { line: 0, col: 6 }, scrolled).length, scrolled.length);
 }
 
-test("actual bundled Pi 1.0.0 proves editing, undo, paste, selection, wrap and autocomplete", () => {
-  assert.equal(bundledAgent.VERSION, "1.0.0");
+test(`actual bundled Pi ${INSTALLED_PI} proves editing, undo, paste, selection, wrap and autocomplete`, () => {
+  assert.equal(bundledAgent.VERSION, INSTALLED_PI);
   assertInstalledPiPairBehavior(bundledAgent.VERSION, BundledEditor, bundledAgent.CustomEditor, bundledAgent.VERSION);
 });
 
@@ -270,12 +277,12 @@ test("resolveVimRuntime resolves local bundle cli entrypoint when provided", ()
 });
 
 test("audited Pi editor releases are one frozen exact allowlist that includes the installed TUI", () => {
-  assert.deepEqual([...AUDITED_PI_EDITOR_VERSIONS], ["0.99.1", "0.99.2", "1.0.0"]);
-  assert.equal(INSTALLED_PI, "1.0.0", "this audit must exercise actual Pi 1.0.0, not a fabricated release");
+  assert.deepEqual([...AUDITED_PI_EDITOR_VERSIONS], ["0.99.1", "0.99.2", "1.0.0", "1.1.0", "1.2.0"]);
+  assert.equal(bundledAgent.VERSION, INSTALLED_PI, "bundled and local metadata must describe the same actual installed release");
   assert.ok(Object.isFrozen(AUDITED_PI_EDITOR_VERSIONS));
   assert.throws(() => (AUDITED_PI_EDITOR_VERSIONS as unknown as string[]).push("0.99.3"), TypeError);
   assert.ok(isAuditedPiEditorVersion(INSTALLED_PI), `installed pi-tui ${INSTALLED_PI} must be audited`);
-  for (const unknown of ["0.99.3", "0.99.10", "0.99", "v0.99.2", " 0.99.2", "0.99.2-rc.1", ">=0.99.2", "1.0.1", ">=1.0.0", "v1.0.0", " 1.0.0", "1.0.0-rc.1", undefined, 99.2]) {
+  for (const unknown of ["0.99.3", "0.99.10", "0.99", "v0.99.2", " 0.99.2", "0.99.2-rc.1", ">=0.99.2", "1.0.1", ">=1.0.0", "v1.0.0", " 1.0.0", "1.0.0-rc.1", "1.2.1", "1.2.0-rc.1", "v1.2.0", ">=1.2.0", undefined, 99.2]) {
     assert.equal(isAuditedPiEditorVersion(unknown), false, String(unknown));
   }
 });
@@ -302,17 +309,19 @@ function fabricatedPiCli(t: test.TestContext, version: string, tuiVersion = vers
 }
 
 test("bundled host admits each audited release and rejects unknown or mismatched bundle metadata", (t) => {
-  for (const version of ["0.99.1", "0.99.2", "1.0.0"]) {
+  for (const version of AUDITED_PI_EDITOR_VERSIONS) {
     assert.deepEqual(resolveVimRuntime(fabricatedPiCli(t, version), bundledAgent.CustomEditor), { version, editorClass: BundledEditor }, version);
   }
   for (const version of ["0.99.3", "1.0.1", ">=1.0.0", "v1.0.0"]) {
     assert.equal(resolveVimRuntime(fabricatedPiCli(t, version), bundledAgent.CustomEditor), undefined, version);
   }
   assert.equal(resolveVimRuntime(fabricatedPiCli(t, "1.0.0", "1.0.0", "0.99.2"), bundledAgent.CustomEditor), undefined);
+  assert.equal(resolveVimRuntime(fabricatedPiCli(t, "1.2.1"), bundledAgent.CustomEditor), undefined);
+  assert.equal(resolveVimRuntime(fabricatedPiCli(t, "1.2.0", "1.2.0", "1.1.0"), bundledAgent.CustomEditor), undefined);
 });
 
 test("installed agent/TUI pair admits each audited release and skips unknown or mismatched pairs", (t) => {
-  for (const version of ["0.99.1", "0.99.2", "1.0.0"]) {
+  for (const version of AUDITED_PI_EDITOR_VERSIONS) {
     assert.deepEqual(resolveVimRuntime(fabricatedPiCli(t, version), runtimeAgent.CustomEditor), { version, editorClass: runtimeTui.Editor }, version);
   }
   // Rejected candidates must resolve to the real local pair, not their claim.
@@ -325,7 +334,7 @@ test("installed agent/TUI pair admits each audited release and skips unknown or
 
 test("adapter admits each verified audited release and rejects unknown or mismatched claims without mutation", () => {
   const host = () => new BundledEditor!({ terminal: { rows: 6 }, requestRender() {} } as never, { borderColor: (s: string) => s } as never);
-  for (const version of ["0.99.1", "0.99.2", "1.0.0"]) {
+  for (const version of AUDITED_PI_EDITOR_VERSIONS) {
     const e = host();
     e.setText("alpha beta");
     const adapter = createVimEditorAdapter(e, version, BundledEditor, version);
@@ -343,6 +352,8 @@ test("adapter admits each verified audited release and rejects unknown or mismat
     assert.throws(() => createVimEditorAdapter(editor(), version), /unsupported/i, version);
   }
   assert.throws(() => createVimEditorAdapter(e, "1.0.0", BundledEditor, "0.99.2"), /unsupported/i);
+  assert.throws(() => createVimEditorAdapter(e, "1.2.1", BundledEditor, "1.2.1"), /unsupported/i);
+  assert.throws(() => createVimEditorAdapter(e, "1.2.0", BundledEditor, "1.1.0"), /unsupported/i);
   assert.equal(e.getText(), "untouched");
   assert.deepEqual(e.getCursor(), cursor);
   assert.deepEqual(e.render(30), frame);
@@ -638,24 +649,39 @@ test("operator insertion and registered marker guards keep one undo snapshot", (
   assert.equal(paste.getExpandedText(), "z".repeat(1001));
 });
 
+test("Pi 1.2 selection preserves fake markers and host hardware-cursor suppression", () => {
+  const e = editor();
+  e.setText("abcd");
+  e.focused = true;
+  const adapter = createVimEditorAdapter(e, INSTALLED_PI);
+  adapter.move({ line: 0, col: 1 });
+  const rows = adapter.renderSelection(20, { line: 0, col: 0 }, { line: 0, col: 4 });
+  assert.ok(rows[1]!.includes(`${CURSOR_MARKER}\x1b_pi:fc\x07`));
+  assert.ok(rows[1]!.includes("\x1b_pi:/fc\x07"));
+  for (const hardware of [false, true]) {
+    const resolved = resolveFakeCursors(rows, hardware);
+    assert.deepEqual(paintedCells(resolved[1]!).slice(0, 4), "abcd".split("").map(char => ({ char, inverse: true })));
+    assert.ok(resolved.every(row => visibleWidth(row) === 20));
+  }
+  const boundary = adapter.renderSelection(20, { line: 0, col: 0 }, { line: 0, col: 1 });
+  assert.ok(boundary[1]!.includes(`${CURSOR_MARKER}\x1b_pi:fc\x07`));
+  assert.deepEqual(selectedColumns(resolveFakeCursors(boundary, true)[1]!), [0]);
+  assert.deepEqual(selectedColumns(resolveFakeCursors(boundary, false)[1]!), [0, 1]);
+  const legacy = e.render(20);
+  legacy[1] = legacy[1]!.replaceAll("\x1b_pi:fc\x07", "\x1b[7m").replaceAll("\x1b_pi:/fc\x07", "\x1b[0m");
+  assert.deepEqual(selectedColumns(adapter.renderSelection(20, { line: 0, col: 0 }, { line: 0, col: 4 }, legacy)[1]!), [0, 1, 2, 3]);
+  const unknown = e.render(20).map(row => row.replace("\x1b_pi:fc\x07", "\x1b_pi:unknown\x07"));
+  assert.deepEqual(adapter.renderSelection(20, { line: 0, col: 0 }, { line: 0, col: 4 }, unknown), unknown);
+});
+
 test("selection survives fake cursor reset and retains surrounding color", () => {
   const e = editor();
   e.setText("abcd");
   createVimEditorAdapter(e, INSTALLED_PI).move({ line: 0, col: 1 });
   const frame = createVimEditorAdapter(e, INSTALLED_PI).renderSelection(20, { line: 0, col: 0 }, { line: 0, col: 4 });
   const row = frame.find((line) => line.includes("a")) ?? frame.join("");
-  let reverse = false;
-  const selected: string[] = [];
-  for (const token of row.matchAll(/\x1b\[[0-9;]*m|[^\x1b]/g)) {
-    const value = token[0];
-    if (value.startsWith("\x1b[")) {
-      for (const code of value.slice(2, -1).split(";").map(Number)) {
-        if (code === 0 || code === 27) reverse = false;
-        if (code === 7) reverse = true;
-      }
-    } else if ("abcd".includes(value)) selected.push(reverse ? value : `!${value}`);
-  }
-  assert.deepEqual(selected, ["a", "b", "c", "d"], "every visible cell must have effective reverse SGR");
+  assert.deepEqual(paintedCells(row).slice(0, 4), "abcd".split("").map(char => ({ char, inverse: true })),
+    "every visible cell must have effective reverse SGR after the host post-pass");
 });
 
 test("truecolor channels do not change inverse state across selected and unselected cells", () => {

package/tests/visual-customization-policy.test.ts

@@ -13,7 +13,7 @@ test("missing settings use responsive defaults and return independent copies", (
 		assert.equal(DEFAULT_VISUAL_SETTINGS.statusPlacement, "auto");
 		assert.equal(DEFAULT_VISUAL_SETTINGS.headerPlacement, "top");
 		assert.equal(DEFAULT_VISUAL_SETTINGS.density, "comfortable");
-		assert.deepEqual(DEFAULT_VISUAL_SETTINGS.visibility, { changes: true, rdd: true, agents: true, todo: true, usageCost: true, modelDetails: true });
+		assert.deepEqual(DEFAULT_VISUAL_SETTINGS.visibility, { changes: true, rdd: true, agents: true, todo: true, usageCost: true, modelDetails: true, contextWarning: true });
 		resolved.settings.visibility.agents = false;
 		assert.equal(DEFAULT_VISUAL_SETTINGS.visibility.agents, true);
 		assert.equal(resolveVisualSettings({ gentlePiConfigHome: home }).settings.visibility.agents, true);
@@ -29,13 +29,13 @@ test("strict versioned parsing rejects malformed and partial settings", () => {
 });
 
 test("Sections rows follow one ordered key list that covers every visibility key", () => {
-	assert.deepEqual(VISUAL_SECTION_KEYS, ["changes", "rdd", "agents", "todo", "usageCost", "modelDetails"]);
+	assert.deepEqual(VISUAL_SECTION_KEYS, ["changes", "rdd", "agents", "todo", "usageCost", "modelDetails", "contextWarning"]);
 	assert.deepEqual([...VISUAL_SECTION_KEYS].sort(), Object.keys(DEFAULT_VISUAL_SETTINGS.visibility).sort());
 });
 
 test("settings saved before the rdd section existed load as valid with rdd shown", () => {
 	const legacy = { schema: VISUAL_SCHEMA, ...DEFAULT_VISUAL_SETTINGS, visibility: { changes: false, agents: true, todo: false, usageCost: true, modelDetails: false } };
-	const expected = { ...DEFAULT_VISUAL_SETTINGS, visibility: { changes: false, rdd: true, agents: true, todo: false, usageCost: true, modelDetails: false } };
+	const expected = { ...DEFAULT_VISUAL_SETTINGS, visibility: { changes: false, rdd: true, agents: true, todo: false, usageCost: true, modelDetails: false, contextWarning: true } };
 	assert.deepEqual(parseVisualSettingsFile(JSON.stringify(legacy)), expected);
 	assert.deepEqual(parseVisualSettingsFile(JSON.stringify({ ...legacy, visibility: { ...expected.visibility, rdd: false } })), { ...expected, visibility: { ...expected.visibility, rdd: false } });
 	for (const visibility of [{ ...legacy.visibility, extra: true }, { ...legacy.visibility, rdd: "no" }, { ...legacy.visibility, todo: "yes" }, { agents: true, todo: true, usageCost: true, modelDetails: true, rdd: true }]) {
@@ -52,6 +52,35 @@ test("settings saved before the rdd section existed load as valid with rdd shown
 	} finally { rmSync(home, { recursive: true, force: true }); }
 });
 
+test("settings saved before contextWarning existed load it shown and preserve rdd", () => {
+	// Both historical shapes: the earliest pre-rdd visibility and the previous-current shape that
+	// already had rdd but not contextWarning. Only the missing added keys default to shown.
+	const shared = { schema: VISUAL_SCHEMA, ...DEFAULT_VISUAL_SETTINGS };
+	const preRdd = { ...shared, visibility: { changes: false, agents: true, todo: false, usageCost: true, modelDetails: false } };
+	assert.deepEqual(parseVisualSettingsFile(JSON.stringify(preRdd)), { ...DEFAULT_VISUAL_SETTINGS,
+		visibility: { changes: false, rdd: true, agents: true, todo: false, usageCost: true, modelDetails: false, contextWarning: true } });
+	const preContext = { ...shared, visibility: { changes: false, rdd: false, agents: true, todo: false, usageCost: true, modelDetails: false } };
+	assert.deepEqual(parseVisualSettingsFile(JSON.stringify(preContext)), { ...DEFAULT_VISUAL_SETTINGS,
+		visibility: { changes: false, rdd: false, agents: true, todo: false, usageCost: true, modelDetails: false, contextWarning: true } });
+	const withoutRdd = { ...shared, visibility: { changes: true, agents: true, todo: true, usageCost: true, modelDetails: true, contextWarning: false } };
+	assert.deepEqual(parseVisualSettingsFile(JSON.stringify(withoutRdd)), { ...DEFAULT_VISUAL_SETTINGS,
+		visibility: { changes: true, rdd: true, agents: true, todo: true, usageCost: true, modelDetails: true, contextWarning: false } });
+});
+
+test("a present non-boolean added key in a partial legacy shape is rejected before default fill", () => {
+	// Missing added keys default to shown, but a key that is present must already be a
+	// boolean: `null` (or any other value) must not be silently coerced by the fill.
+	const base = { changes: true, agents: true, todo: true, usageCost: true, modelDetails: true };
+	for (const visibility of [{ ...base, rdd: null }, { ...base, contextWarning: null }]) {
+		assert.equal(parseVisualSettingsFile(JSON.stringify({ schema: VISUAL_SCHEMA, ...DEFAULT_VISUAL_SETTINGS, visibility })), undefined,
+			`${JSON.stringify(visibility)} must stay invalid`);
+	}
+	const previousCurrent = structuredClone(DEFAULT_VISUAL_SETTINGS) as unknown as { visibility: Record<string, unknown> };
+	delete previousCurrent.visibility.contextWarning;
+	previousCurrent.visibility.rdd = null;
+	assert.equal(parseVisualSettingsFile(JSON.stringify({ schema: VISUAL_SCHEMA, ...previousCurrent })), undefined);
+});
+
 test("an unreadable settings path is a read error, not malformed content", () => {
 	const home = mkdtempSync(join(tmpdir(), "visual-policy-"));
 	try {