gentle-pi 4.3.0 → 4.4.0

package/tests/yolo-session-policy-capture.test.ts

@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { registerYoloSessionPolicy } from "../lib/yolo-session-policy.ts";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+// Identity is re-captured for every tool admission: freshness is a security
+// invariant, so cross-admission reuse is never allowed. Within one admission
+// the redundant mode() lookups share at most ONE capture, keyed by that
+// admission's tool call id; a different or absent id re-captures. Generation
+// bumps and cwd changes still invalidate a shared slot.
+
+const isolatedConfigHomes: string[] = [];
+process.once("exit", () => { for (const home of isolatedConfigHomes) rmSync(home, { recursive: true, force: true }); });
+
+function harness() {
+	const home = mkdtempSync(join(tmpdir(), "yolo-capture-config-"));
+	isolatedConfigHomes.push(home);
+	let resolveCalls = 0, statusCalls = 0, widgetCalls = 0;
+	const commands = new Map<string, { handler: (args: string, ctx: ExtensionContext) => Promise<void> }>();
+	const pi = {
+		registerCommand: (name: string, command: { handler: (args: string, ctx: ExtensionContext) => Promise<void> }) => commands.set(name, command),
+		events: { on: () => () => {} },
+	} as unknown as ExtensionAPI;
+	const controller = registerYoloSessionPolicy(pi, { GENTLE_PI_CONFIG_HOME: home }, {
+		// Test seam: observe identity resolution without spawning Git.
+		resolveIdentity: async () => { resolveCalls += 1; return undefined; },
+	});
+	const ctx = {
+		cwd: process.cwd(), mode: "tui", hasUI: true,
+		sessionManager: { getSessionId: () => "capture-test" },
+		ui: {
+			notify() {},
+			setStatus: () => { statusCalls += 1; },
+			setWidget: () => { widgetCalls += 1; },
+		},
+	} as unknown as ExtensionContext;
+	return {
+		controller, ctx, commands,
+		resolveCalls: () => resolveCalls,
+		uiCalls: () => ({ status: statusCalls, widget: widgetCalls }),
+	};
+}
+
+test("lookups of one tool admission share one capture; a second admission re-captures", async () => {
+	const h = harness();
+	assert.equal(await h.controller.mode(h.ctx, { toolCallId: "call-1" }), "normal");
+	assert.equal(h.resolveCalls(), 1, "the first admission captures");
+	await h.controller.mode(h.ctx, { toolCallId: "call-1" });
+	assert.equal(h.resolveCalls(), 1, "lookups of one tool call share one capture");
+	await h.controller.mode(h.ctx, { toolCallId: "call-2" });
+	assert.equal(h.resolveCalls(), 2, "a second admission re-captures even with unchanged generation and cwd");
+	await h.controller.mode(h.ctx);
+	assert.equal(h.resolveCalls(), 3, "an absent admission id keeps the uncached capture path");
+});
+
+// The tool admission key never outranks the generation: a bump mid-admission
+// (a reselected mode, a revocation) must force a fresh capture, never replay.
+test("a generation bump invalidates a shared admission slot", async () => {
+	const h = harness();
+	assert.equal(await h.controller.mode(h.ctx, { toolCallId: "call-1" }), "normal");
+	assert.equal(await h.controller.setMode("yolo", h.ctx), true);
+	const before = h.resolveCalls();
+	assert.equal(await h.controller.mode(h.ctx, { toolCallId: "call-1" }), "yolo", "the same admission id never answers a mode captured before the bump");
+	assert.equal(h.resolveCalls(), before + 1, "the bump forced a fresh capture");
+});
+
+test("after a mode change the next mode() re-captures and never answers the stale mode", async () => {
+	const h = harness();
+	assert.equal(await h.controller.mode(h.ctx), "normal");
+	assert.equal(await h.controller.setMode("yolo", h.ctx), true);
+	const resolveBefore = h.resolveCalls();
+	assert.equal(await h.controller.mode(h.ctx), "yolo", "a generation bump re-reads the live mode");
+	assert.equal(h.resolveCalls(), resolveBefore + 1, "the invalidated cache is re-captured, not reused");
+});
+
+test("publish writes UI only when the rendered strings change", async () => {
+	const h = harness();
+	await h.controller.mode(h.ctx);
+	const first = h.uiCalls();
+	assert.ok(first.status > 0 && first.widget > 0, "the first publication paints the status and widget");
+	await h.controller.mode(h.ctx);
+	assert.deepEqual(h.uiCalls(), first, "an unchanged mode() costs zero UI writes");
+	await h.controller.setMode("yolo", h.ctx);
+	const second = h.uiCalls();
+	assert.ok(second.status > first.status && second.widget > first.widget, "an actual change still publishes");
+	await h.controller.mode(h.ctx);
+	assert.deepEqual(h.uiCalls(), second, "reading the settled mode does not repaint");
+});
+
+test("a cwd change re-captures and revokes instead of answering a stale workspace mode", async () => {
+	const h = harness();
+	assert.equal(await h.controller.setMode("yolo", h.ctx), true);
+	const other = realpathSync(mkdtempSync(join(tmpdir(), "yolo-capture-cwd-")));
+	try {
+		Object.assign(h.ctx, { cwd: other });
+		assert.equal(await h.controller.mode(h.ctx), "normal", "the new workspace never inherits the old binding");
+		assert.equal(h.resolveCalls(), 2, "the cwd change forced a fresh capture");
+		await h.controller.mode(h.ctx);
+		assert.equal(h.resolveCalls(), 3, "a call without an admission id keeps the uncached capture path");
+	} finally { rmSync(other, { recursive: true, force: true }); }
+});