gentle-pi 4.2.0 → 4.4.0

package/tests/session-profile-disk-reader-pi.test.ts

@@ -0,0 +1,183 @@
+// Run only in the parent's isolated snapshot with supported existing Pi deps.
+// Public API fixtures, never providers or production flush/rollback workarounds.
+import assert from "node:assert/strict";
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	renameSync,
+	rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { test, type TestContext } from "node:test";
+import { fileURLToPath } from "node:url";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { readSessionProfileDisk } from "../lib/session-profile-disk-reader.ts";
+import { SESSION_PROFILE_CUSTOM_TYPE as customType } from "../lib/session-profile-persistence.ts";
+
+const packagePath = join(
+	dirname(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))),
+	"..",
+	"package.json",
+);
+const version: string = JSON.parse(readFileSync(packagePath, "utf8")).version;
+// Fail closed rather than silently skipping tests against stale feature deps.
+assert.match(version, /^\d+\.\d+\.\d+$/);
+assert.ok(
+	Number(version.split(".")[0]) >= 1,
+	`Pi >=1.0.0 required, installed ${version}`,
+);
+console.info(
+	`Public SessionManager fixture API: ${version}; minimum tested baseline 1.0.0`,
+);
+
+function fixture(t: TestContext) {
+	const root = mkdtempSync(join(tmpdir(), "profile-reader-pi-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const sessions = join(root, "sessions");
+	const manager = SessionManager.create(root, sessions);
+	return { manager, sessions };
+}
+function bind(name: string) {
+	return {
+		kind: "bind",
+		origin: "user",
+		name,
+		modelProfiles: { worker: { model: `offline/${name}` } },
+	};
+}
+function flushFixture(manager: SessionManager) {
+	// An ordinary test-owned conversation message triggers Pi's normal persistence.
+	manager.appendMessage({
+		role: "user",
+		content: "isolated reader fixture",
+		timestamp: Date.now(),
+	});
+}
+function expectBound(manager: SessionManager, name: string) {
+	const result = readSessionProfileDisk(manager);
+	assert.equal(result.status, "bound");
+	if (result.status !== "bound")
+		throw new Error("Expected corroborated binding");
+	assert.equal(result.binding.name, name);
+}
+
+test("custom-only public session cannot restore memory; ordinary fixture flush corroborates", (t) => {
+	const { manager } = fixture(t);
+	manager.appendCustomEntry(customType, bind("initial"));
+	const path = manager.getSessionFile();
+	assert.ok(path);
+	assert.equal(existsSync(path), false);
+	assert.equal(readSessionProfileDisk(manager).status, "indeterminate");
+	flushFixture(manager);
+	expectBound(manager, "initial");
+});
+
+test("malformed line Pi skips on open does not block corroboration", (t) => {
+	const { manager, sessions } = fixture(t);
+	manager.appendCustomEntry(customType, bind("before"));
+	flushFixture(manager);
+	const path = manager.getSessionFile();
+	assert.ok(path);
+	appendFileSync(path, '{"type":"custom","id":"torn\n');
+	const reopened = SessionManager.open(path, sessions);
+	expectBound(reopened, "before");
+	reopened.appendCustomEntry(customType, bind("after"));
+	flushFixture(reopened);
+	expectBound(reopened, "after");
+});
+
+test("public selected branch, sibling and extracted session stay separated", (t) => {
+	const { manager, sessions } = fixture(t);
+	manager.appendCustomEntry(customType, bind("base"));
+	flushFixture(manager);
+	const base = manager.getLeafId();
+	assert.ok(base);
+	manager.appendCustomEntry(customType, bind("left"));
+	const left = manager.getLeafId();
+	assert.ok(left);
+	manager.branch(base);
+	manager.appendCustomEntry(customType, bind("right"));
+	expectBound(manager, "right");
+	manager.branch(left);
+	expectBound(manager, "left");
+	const originalFile = manager.getSessionFile();
+	const extracted = manager.createBranchedSession(left);
+	assert.ok(extracted);
+	assert.notEqual(extracted, originalFile);
+	const reopened = SessionManager.open(extracted, sessions);
+	expectBound(reopened, "left");
+	assert.equal(
+		reopened
+			.getBranch()
+			.some(
+				(row) =>
+					row.type === "custom" && (row.data as { name?: string })?.name === "right",
+			),
+		false,
+	);
+});
+
+for (const recovery of ["bind", "clear"] as const) {
+	test(`real EISDIR ghost quarantined; new ${recovery} corroborates missing parent even after reopen`, (t) => {
+		const { manager, sessions } = fixture(t);
+		manager.appendCustomEntry(customType, bind("good"));
+		flushFixture(manager);
+		const file = manager.getSessionFile();
+		assert.ok(file);
+		const saved = `${file}.saved`;
+		renameSync(file, saved);
+		mkdirSync(file);
+		assert.throws(
+			() => manager.appendCustomEntry(customType, bind("failed")),
+			(error: unknown) => {
+				assert.equal((error as NodeJS.ErrnoException).code, "EISDIR");
+				return true;
+			},
+		);
+		const failedId = manager.getLeafId();
+		assert.ok(failedId);
+		assert.equal(readSessionProfileDisk(manager).status, "indeterminate");
+		renameSync(file, `${file}.fault-directory`);
+		renameSync(saved, file);
+		assert.equal(readSessionProfileDisk(manager).status, "indeterminate");
+		const knownFailedEntryIds = new Set([failedId]);
+		const old = readSessionProfileDisk(manager, { knownFailedEntryIds });
+		assert.equal(old.status, "bound");
+		if (old.status === "bound") assert.equal(old.binding.name, "good");
+		manager.appendCustomEntry(
+			customType,
+			recovery === "bind" ? bind("recovered") : { kind: "clear" },
+		);
+		const latest = manager.getBranch().at(-1);
+		assert.ok(latest);
+		assert.equal(latest.parentId, failedId);
+		const disk = readFileSync(file, "utf8")
+			.trim()
+			.split("\n")
+			.map((line) => JSON.parse(line));
+		assert.equal(
+			disk.some((row) => row.id === failedId),
+			false,
+		);
+		assert.deepEqual(
+			disk.find((row) => row.id === latest.id),
+			JSON.parse(JSON.stringify(latest)),
+		);
+		assert.equal(
+			readSessionProfileDisk(manager, { knownFailedEntryIds }).status,
+			recovery === "bind" ? "bound" : "cleared",
+		);
+		const reopened = SessionManager.open(file, sessions);
+		assert.equal(reopened.getBranch().length, 1);
+		assert.equal(reopened.getBranch()[0].id, latest.id);
+		assert.equal(
+			readSessionProfileDisk(reopened).status,
+			recovery === "bind" ? "bound" : "cleared",
+		);
+		if (recovery === "bind") expectBound(reopened, "recovered");
+	});
+}

package/tests/session-profile-disk-reader.test.ts

@@ -0,0 +1,311 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test, type TestContext } from "node:test";
+import {
+	type DiskProfileIndeterminateReason,
+	readSessionProfileDisk,
+} from "../lib/session-profile-disk-reader.ts";
+import { SESSION_PROFILE_CUSTOM_TYPE as customType } from "../lib/session-profile-persistence.ts";
+
+const header = { type: "session", id: "session", version: 3 };
+function entry(id = "selected", data: unknown = { kind: "clear" }) {
+	return {
+		type: "custom",
+		id,
+		parentId: null,
+		timestamp: "2026-10-05T00:00:00Z",
+		customType,
+		data,
+	};
+}
+function fixture(
+	t: TestContext,
+	branch: unknown[] = [],
+	rows: unknown[] = [header, ...branch],
+) {
+	const root = mkdtempSync(join(tmpdir(), "profile-reader-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const path = join(root, "session.jsonl");
+	writeFileSync(
+		path,
+		rows
+			.map((row) => (typeof row === "string" ? row : JSON.stringify(row)))
+			.join("\n") + "\n",
+	);
+	const source = {
+		getSessionId: () => "session",
+		getSessionFile: (): string | undefined => path,
+		getBranch: () => branch,
+	};
+	return { path, source, read: () => readSessionProfileDisk(source) };
+}
+
+test("header only establishes absence", (t) => {
+	assert.deepEqual(fixture(t).read(), { status: "absent" });
+});
+
+test("ordinary branch without family remains absent despite disk sibling", (t) => {
+	const message = {
+		type: "message",
+		id: "message",
+		parentId: null,
+		timestamp: "fixture",
+	};
+	assert.deepEqual(
+		fixture(t, [message], [header, message, entry("sibling")]).read(),
+		{ status: "absent" },
+	);
+});
+
+test("omitted data is terminal invalid or unsupported, never older resurrection", (t) => {
+	for (const identifier of [customType, "gentle-pi.session-profile/v9"]) {
+		const selected = { ...entry(), customType: identifier, data: undefined };
+		const result = fixture(t, [entry("older"), selected]).read();
+		assert.equal(
+			result.status,
+			identifier === customType ? "invalid" : "unsupported",
+		);
+	}
+});
+
+for (const [label, data, status] of [
+	["clear", { kind: "clear" }, "cleared"],
+	[
+		"empty",
+		{ kind: "bind", origin: "user", name: "chosen", modelProfiles: {} },
+		"bound",
+	],
+	["invalid", { kind: "broken" }, "invalid"],
+] as const) {
+	test(`corroborated ${label} retains semantic state and original positions`, (t) => {
+		const selected = entry("selected", data);
+		const message = {
+			type: "message",
+			id: "message",
+			parentId: null,
+			timestamp: "fixture",
+		};
+		const f = fixture(t, [message, selected], [header, "", message, selected]);
+		const result = f.read();
+		assert.equal(result.status, status);
+		assert.equal(result.entryIndex, 1);
+		assert.equal(result.lineNumber, 4);
+	});
+}
+
+test("future newest is terminal; sibling records never win", (t) => {
+	const older = entry("older");
+	const future = {
+		...entry("future"),
+		customType: "gentle-pi.session-profile/v2",
+	};
+	const f = fixture(
+		t,
+		[older, future],
+		[header, older, future, entry("sibling")],
+	);
+	assert.equal(f.read().status, "unsupported");
+});
+
+test("unknown unwritten newest never falls back; trusted failed evidence excludes only its ID", (t) => {
+	const older = entry("older");
+	const ghost = entry("ghost");
+	const f = fixture(t, [older, ghost], [header, older]);
+	assert.equal(f.read().status, "indeterminate");
+	const options = { knownFailedEntryIds: new Set(["ghost"]) };
+	assert.equal(readSessionProfileDisk(f.source, options).status, "cleared");
+	writeFileSync(
+		f.path,
+		[header, older, ghost].map((row) => JSON.stringify(row)).join("\n"),
+	);
+	assert.equal(readSessionProfileDisk(f.source, options).entryIndex, 0);
+	assert.equal(
+		readSessionProfileDisk(f.source, {
+			knownFailedEntryIds: new Set(["unrelated"]),
+		}).entryIndex,
+		1,
+	);
+});
+
+for (const [label, rows] of [
+	["wrong session", [{ ...header, id: "other" }, entry()]],
+	["wrong header", [{ ...header, type: "message" }, entry()]],
+	["duplicate ID", [header, entry(), entry()]],
+	["malformed", [header, "{secret"]],
+	["truncated", [header, '{"type":']],
+	["data mismatch", [header, entry("selected", { kind: "broken" })]],
+	["parent mismatch", [header, { ...entry(), parentId: "other" }]],
+	["metadata mismatch", [header, { ...entry(), timestamp: "other" }]],
+	["custom type mismatch", [header, { ...entry(), customType: "other" }]],
+	["extra metadata mismatch", [header, { ...entry(), extra: "changed" }]],
+	["nonobject record", [header, "null"]],
+	["empty file", []],
+	[
+		"missing metadata",
+		[
+			header,
+			{ type: "custom", id: "selected", customType, data: { kind: "clear" } },
+		],
+	],
+] as const) {
+	test(`${label} is explicitly indeterminate`, (t) => {
+		const result = fixture(t, [entry()], [...rows]).read();
+		assert.equal(result.status, "indeterminate");
+		assert.ok(!JSON.stringify(result).includes("secret"));
+	});
+}
+
+test("malformed lines are skipped like Pi's session parser, keeping physical line numbers", (t) => {
+	const selected = entry();
+	for (const rows of [
+		[header, "{bad private contents", selected],
+		["{bad private contents", header, selected],
+		[header, selected, '{"type":"custom","id":"torn'],
+	]) {
+		const result = fixture(t, [selected], rows).read();
+		assert.equal(result.status, "cleared");
+		assert.equal(result.lineNumber, rows.indexOf(selected) + 1);
+	}
+});
+
+test("malformed selected record is missing, never admitted", (t) => {
+	const result = fixture(t, [entry()], [header, "{secret"]).read();
+	assert.deepEqual(result, {
+		status: "indeterminate",
+		reason: "selected-record-missing",
+	});
+});
+
+test("file with only blank or malformed lines has no header", (t) => {
+	for (const rows of [[], ["", "{bad"]]) {
+		assert.deepEqual(fixture(t, [entry()], rows).read(), {
+			status: "indeterminate",
+			reason: "missing-header",
+		});
+	}
+});
+
+test("non-string customType is ordinary, non-string kind and empty agent name are invalid", (t) => {
+	const ordinary = { ...entry(), customType: 7 };
+	assert.deepEqual(fixture(t, [ordinary]).read(), { status: "absent" });
+	for (const data of [
+		{ kind: 1 },
+		{ kind: ["clear"] },
+		{
+			kind: "bind",
+			origin: "user",
+			name: "chosen",
+			modelProfiles: { "": "provider/model" },
+		},
+	]) {
+		const selected = entry("selected", data);
+		assert.equal(fixture(t, [selected]).read().status, "invalid");
+	}
+});
+
+test("every indeterminate reason is a named literal", () => {
+	const reasons = {
+		"missing-source": true,
+		"invalid-candidate-metadata": true,
+		"unreadable-file": true,
+		"source-changed": true,
+		"invalid-record": true,
+		"session-header-mismatch": true,
+		"duplicate-id": true,
+		"missing-header": true,
+		"selected-record-missing": true,
+		"selected-record-mismatch": true,
+		"unserializable-source": true,
+	} satisfies Record<DiskProfileIndeterminateReason, true>;
+	assert.equal(Object.keys(reasons).length, 11);
+});
+
+test("missing, undefined and unreadable paths are conservative", (t) => {
+	const f = fixture(t);
+	rmSync(f.path);
+	assert.equal(f.read().status, "indeterminate");
+	f.source.getSessionFile = () => undefined;
+	assert.equal(f.read().status, "indeterminate");
+	f.source.getSessionFile = () => f.path;
+	assert.equal(
+		readSessionProfileDisk(f.source, {
+			readFile: () => {
+				throw new Error("private");
+			},
+		}).status,
+		"indeterminate",
+	);
+});
+
+for (const change of ["id", "path", "branch"] as const) {
+	test(`source ${change} change during read invalidates authority`, (t) => {
+		const f = fixture(t, [entry()]);
+		const result = readSessionProfileDisk(f.source, {
+			readFile: (path) => {
+				const text = readFileSync(path, "utf8");
+				if (change === "id") f.source.getSessionId = () => "changed";
+				if (change === "path") f.source.getSessionFile = () => "changed";
+				if (change === "branch") f.source.getBranch().push(entry("changed"));
+				return text;
+			},
+		});
+		assert.equal(result.status, "indeterminate");
+	});
+}
+
+test("JSON key order and omitted undefined follow serialization; orphan parent is allowed", (t) => {
+	const selected = { ...entry(), parentId: "missing-failed", extra: undefined };
+	const reversed = Object.fromEntries(Object.entries(selected).reverse());
+	assert.equal(
+		fixture(t, [selected], [header, reversed]).read().status,
+		"cleared",
+	);
+});
+
+test("unserializable memory and malformed own candidate metadata fail closed", (t) => {
+	const circular: any = entry();
+	circular.extra = circular;
+	assert.equal(
+		fixture(t, [circular], [header, entry()]).read().status,
+		"indeterminate",
+	);
+	for (const field of ["id", "parentId", "timestamp"]) {
+		const candidate: any = entry();
+		delete candidate[field];
+		assert.equal(
+			fixture(t, [candidate], [header, candidate]).read().status,
+			"indeterminate",
+		);
+	}
+});
+
+test("all origins, legacy routes and orchestrator are detached and preserved", (t) => {
+	for (const origin of ["user", "local", "repo", "global"]) {
+		const selected = entry("selected", {
+			kind: "bind",
+			origin,
+			name: "chosen",
+			modelProfiles: {
+				worker: "provider/model",
+				orchestrator: { effort: "high" },
+			},
+		});
+		const f = fixture(t, [selected]);
+		const result = f.read();
+		assert.equal(result.status, "bound");
+		if (result.status !== "bound") throw new Error("expected binding");
+		assert.equal(result.binding.origin, origin);
+		assert.deepEqual(result.binding.modelProfiles.orchestrator, {
+			thinking: "high",
+		});
+		result.binding.modelProfiles.worker = { model: "changed" };
+		const next = f.read();
+		assert.equal(next.status, "bound");
+		if (next.status === "bound")
+			assert.deepEqual(next.binding.modelProfiles.worker, {
+				model: "provider/model",
+			});
+	}
+});

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

@@ -295,6 +295,29 @@ test("drift notice: shown once per distinct change of the defaults", () => {
 	assert.equal(readFrozenInheritedProfile("session-a")?.profile?.name, "frontier", "the notice never adopts the new default");
 });
 
+test("drift notice: an explicit binding learns its profile definition changed in profiles.json", () => {
+	const f = fixture({ team: { worker: { model: "openai/old" } } });
+	const opts = options(f, "session-a");
+	bindSessionProfile("session-a", "team", { worker: { model: "openai/old" } });
+	assert.equal(inheritedProfileDriftNotice(opts), undefined, "no drift while the definition matches the binding");
+
+	f.editProfile("team", { worker: { model: "openai/new" } });
+	const notice = inheritedProfileDriftNotice(opts);
+	assert.match(notice ?? "", /the profile definition changed to "team"/);
+	assert.match(notice ?? "", /this session keeps the binding from selection/);
+	assert.equal(inheritedProfileDriftNotice(opts), undefined, "the same change is not repeated");
+
+	f.editProfile("team", { worker: { model: "openai/older" } });
+	assert.match(inheritedProfileDriftNotice(opts) ?? "", /the profile definition changed to "team"/, "a different edit is a distinct change");
+	assert.equal(inheritedProfileDriftNotice(opts), undefined);
+	f.editProfile("team", { worker: { model: "openai/old" } });
+	assert.equal(inheritedProfileDriftNotice(opts), undefined, "reverting to the bound content is not drift");
+
+	const childOpts = options(f, "session-b", { GENTLE_PI_AGENTS_CHILD: "1" });
+	bindSessionProfile("session-b", "team", { worker: { model: "openai/old" } });
+	assert.equal(inheritedProfileDriftNotice(childOpts), undefined, "children never get the notice");
+});
+
 test("drift notice: an edit of the default profile's content counts as a change", () => {
 	const f = fixture();
 	f.setActive("frontier");