Fix Pi Codex subscription sessions

software/pi/agentos-package.json

@@ -3,8 +3,7 @@
   "agent": {
     "acpEntrypoint": "pi-acp",
     "env": {
-      "PI_ACP_PI_COMMAND": "/opt/agentos/bin/pi",
-      "PI_ACP_PI_ENTRYPOINT": "/opt/agentos/pkgs/pi/0.0.1/node_modules/@earendil-works/pi-coding-agent/dist/cli.js"
+      "PI_ACP_PI_COMMAND": "/opt/agentos/bin/pi-agentos"
     }
   },
   "registry": {

software/pi/package.json

@@ -6,8 +6,9 @@
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"bin": {
-		"pi": "./node_modules/@earendil-works/pi-coding-agent/dist/cli.js",
-		"pi-acp": "./dist/pi-acp/index.js"
+		"pi": "./dist/pi-command.mjs",
+		"pi-agentos": "./dist/pi-agentos.mjs",
+		"pi-acp": "./dist/pi-acp-agentos.mjs"
 	},
 	"exports": {
 		".": {
@@ -24,13 +25,13 @@
 		"agentos-package.json"
 	],
 	"scripts": {
-		"build": "rm -rf dist && node scripts/build-pi-acp.mjs && tsc && agentos-toolchain pack . --out dist/package --agent pi-acp --prune-native --omit-optional",
+		"build": "rm -rf dist && node scripts/build-pi-acp.mjs && tsc && agentos-toolchain pack . --out dist/package --agent pi-acp --prune-native --omit-optional && agentos-toolchain pack-aospkg dist/package.tar dist/package.aospkg",
 		"check-types": "tsc --noEmit",
 		"test": "pnpm build && node --test --test-force-exit tests/*.test.mjs"
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "1.2.1",
-		"@earendil-works/pi-coding-agent": "0.80.6",
+		"@earendil-works/pi-coding-agent": "0.83.0",
 		"pi-mcp-adapter": "2.11.0",
 		"zod": "3.25.76"
 	},

software/pi/scripts/build-pi-acp.mjs

@@ -26,6 +26,10 @@ const tarballPath = resolve(cacheDir, `pi-acp-${SOURCE_COMMIT}.tar.gz`);
 const sourceRoot = resolve(cacheDir, `pi-acp-${SOURCE_COMMIT}`);
 const outputDir = resolve(packageDir, "dist", "pi-acp");
 const manifestPath = resolve(packageDir, "dist", "pi-acp-upstream.json");
+const wrapperPath = resolve(packageDir, "wrappers", "pi-agentos.mjs");
+const acpWrapperPath = resolve(packageDir, "wrappers", "pi-acp-agentos.mjs");
+const acpErrorsPath = resolve(packageDir, "wrappers", "acp-errors.mjs");
+const piCommandPath = resolve(packageDir, "wrappers", "pi-command.mjs");
 
 function sha256(path) {
 	return createHash("sha256").update(readFileSync(path)).digest("hex");
@@ -110,6 +114,10 @@ cpSync(sourceEntrypoint, resolve(outputDir, "index.js"));
 cpSync(resolve(sourceRoot, "package.json"), resolve(outputDir, "package.json"));
 const sourceMap = `${sourceEntrypoint}.map`;
 if (existsSync(sourceMap)) cpSync(sourceMap, resolve(outputDir, "index.js.map"));
+cpSync(wrapperPath, resolve(packageDir, "dist", "pi-agentos.mjs"));
+cpSync(acpWrapperPath, resolve(packageDir, "dist", "pi-acp-agentos.mjs"));
+cpSync(acpErrorsPath, resolve(packageDir, "dist", "acp-errors.mjs"));
+cpSync(piCommandPath, resolve(packageDir, "dist", "pi-command.mjs"));
 
 mkdirSync(dirname(manifestPath), { recursive: true });
 writeFileSync(

software/pi/tests/package.test.mjs

@@ -34,19 +34,18 @@ test("Pi packages the commit-pinned rivet-dev ACP adapter and runtime closure",
 	assert.equal(manifest.agent.acpEntrypoint, "pi-acp");
 	assert.equal(manifest.agent.runtime, undefined);
 	assert.equal(manifest.agent.snapshot, undefined);
-	assert.equal(manifest.agent.env.PI_ACP_PI_COMMAND, "/opt/agentos/bin/pi");
-	assert.equal(
-		manifest.agent.env.PI_ACP_PI_ENTRYPOINT,
-		"/opt/agentos/pkgs/pi/0.0.1/node_modules/@earendil-works/pi-coding-agent/dist/cli.js",
-	);
-	assert.equal(packageJson.bin["pi-acp"], "./dist/pi-acp/index.js");
+	assert.equal(manifest.agent.env.PI_ACP_PI_COMMAND, "/opt/agentos/bin/pi-agentos");
+	assert.equal(manifest.agent.env.PI_ACP_PI_ENTRYPOINT, undefined);
+	assert.equal(manifest.agent.env.PI_ACP_PI_EXTENSION, undefined);
+	assert.equal(packageJson.bin["pi-acp"], "./dist/pi-acp-agentos.mjs");
+	assert.equal(packageJson.bin["pi-agentos"], "./dist/pi-agentos.mjs");
 	assert.equal(
 		packageJson.bin.pi,
-		"./node_modules/@earendil-works/pi-coding-agent/dist/cli.js",
+		"./dist/pi-command.mjs",
 	);
 	assert.equal(
 		packageJson.dependencies["@earendil-works/pi-coding-agent"],
-		"0.80.6",
+		"0.83.0",
 	);
 	assert.equal(packageJson.dependencies["pi-acp"], undefined);
 	assert.equal(packageJson.dependencies["pi-mcp-adapter"], "2.11.0");
@@ -60,6 +59,7 @@ test("Pi packages the commit-pinned rivet-dev ACP adapter and runtime closure",
 		"85bc7e133d28e9d870ecad7aa3de9e6a17ffea142443a177d618597a56c72cd7",
 	);
 	assert.equal(upstreamManifest.sourcePackageVersion, "0.0.31");
+	assert.equal(upstreamManifest.compatibilityPatches, undefined);
 	assert.deepEqual(upstreamManifest.buildCommands, ["npm ci", "npm run build"]);
 	assert.ok(adapterEntrypoint.startsWith("#!/usr/bin/env node"));
 	assert.equal(adapterPackageJson.name, "pi-acp");
@@ -68,15 +68,73 @@ test("Pi packages the commit-pinned rivet-dev ACP adapter and runtime closure",
 	assert.equal(packageJson.dependencies["@mariozechner/pi-coding-agent"], undefined);
 });
 
+test("AgentOS ACP shim normalizes only missing native Pi sessions", async () => {
+	const { acpRequestCwd, normalizeAcpResponse } = await import(
+		new URL(
+			"../dist/package/node_modules/@agentos-software/pi/dist/acp-errors.mjs",
+			import.meta.url,
+		)
+	);
+	const missing = JSON.stringify({
+		jsonrpc: "2.0",
+		id: 7,
+		error: { code: -32602, message: "Invalid params: Unknown sessionId: old-id", data: {} },
+	});
+	assert.deepEqual(JSON.parse(normalizeAcpResponse(missing)), {
+		jsonrpc: "2.0",
+		id: 7,
+		error: { code: -32002, message: "Resource not found", data: { kind: "unknown_session" } },
+	});
+	const wrongCwd = JSON.stringify({
+		jsonrpc: "2.0",
+		id: 9,
+		error: {
+			code: -32602,
+			message: "Invalid params: cwd does not match persisted session: expected /, received /workspace",
+			data: {},
+		},
+	});
+	assert.equal(JSON.parse(normalizeAcpResponse(wrongCwd)).error.code, -32002);
+	const unrelated = JSON.stringify({
+		jsonrpc: "2.0",
+		id: 8,
+		error: { code: -32602, message: "Invalid params: bad model", data: {} },
+	});
+	assert.equal(normalizeAcpResponse(unrelated), unrelated);
+	assert.equal(normalizeAcpResponse("not-json"), "not-json");
+	assert.equal(acpRequestCwd('{"method":"session/new","params":{"cwd":"/workspace"}}'), "/workspace");
+	assert.equal(acpRequestCwd('{"method":"session/prompt","params":{"cwd":"/other"}}'), null);
+	assert.equal(acpRequestCwd('{"method":"session/new","params":{"cwd":"relative"}}'), null);
+});
+
+test("AgentOS Pi command answers the guest-safe version probe", async () => {
+	const command = new URL("../dist/package/bin/pi", import.meta.url).pathname;
+	const child = spawn(command, ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
+	let stdout = "";
+	let stderr = "";
+	child.stdout.setEncoding("utf8");
+	child.stderr.setEncoding("utf8");
+	child.stdout.on("data", (chunk) => { stdout += chunk; });
+	child.stderr.on("data", (chunk) => { stderr += chunk; });
+	const code = await new Promise((resolve, reject) => {
+		child.once("error", reject);
+		child.once("exit", resolve);
+	});
+	assert.equal(code, 0);
+	assert.equal(stdout.trim(), "0.83.0");
+	assert.equal(stderr, "");
+});
+
 test("packaged pinned Pi adapter initializes with persistent session capabilities", async (t) => {
+	const piCommand = new URL("../dist/package/bin/pi-agentos", import.meta.url).pathname;
 	const child = spawn(
 		new URL("../dist/package/bin/pi-acp", import.meta.url).pathname,
 		[],
 		{
 			stdio: ["pipe", "pipe", "pipe"],
 			env: {
 				...process.env,
-				PI_ACP_PI_COMMAND: "/opt/agentos/bin/pi",
+				PI_ACP_PI_COMMAND: piCommand,
 			},
 		},
 	);
@@ -135,4 +193,40 @@ test("packaged pinned Pi adapter initializes with persistent session capabilitie
 		response.result.agentCapabilities.sessionCapabilities.close,
 		{},
 	);
+
+	const session = await new Promise((resolve, reject) => {
+		const timeout = setTimeout(
+			() => reject(new Error(`session/new timed out: ${stderr}`)),
+			10_000,
+		);
+		let buffer = "";
+		child.stdout.on("data", (chunk) => {
+			buffer += chunk;
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				const message = JSON.parse(line);
+				if (message.id !== 2) continue;
+				clearTimeout(timeout);
+				resolve(message);
+			}
+		});
+		child.stdin.write(
+			`${JSON.stringify({
+				jsonrpc: "2.0",
+				id: 2,
+				method: "session/new",
+				params: { cwd: new URL("..", import.meta.url).pathname, mcpServers: [] },
+			})}\n`,
+		);
+	});
+
+	assert.equal(session.error, undefined);
+	assert.equal(typeof session.result.sessionId, "string");
+	assert.ok(
+		session.result.models.availableModels.some(
+			(model) => model.modelId === "openai-codex/gpt-5.6-terra",
+		),
+	);
 });

software/pi/wrappers/acp-errors.mjs

@@ -0,0 +1,33 @@
+export function normalizeAcpResponse(line) {
+	let message;
+	try {
+		message = JSON.parse(line);
+	} catch {
+		return line;
+	}
+	const invalidSession = /unknown sessionid:|cwd does not match persisted session:/i.test(
+		message?.error?.message ?? "",
+	);
+	if (message?.error?.code !== -32602 || !invalidSession) return line;
+
+	return JSON.stringify({
+		...message,
+		error: {
+			...message.error,
+			code: -32002,
+			message: "Resource not found",
+			data: { kind: "unknown_session" },
+		},
+	});
+}
+
+export function acpRequestCwd(line) {
+	try {
+		const message = JSON.parse(line);
+		if (!["session/new", "session/load", "session/resume"].includes(message?.method)) return null;
+		const cwd = message?.params?.cwd;
+		return typeof cwd === "string" && cwd.startsWith("/") ? cwd : null;
+	} catch {
+		return null;
+	}
+}

software/pi/wrappers/pi-acp-agentos.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline";
+
+import { acpRequestCwd, normalizeAcpResponse } from "./acp-errors.mjs";
+
+const upstreamEntrypoint = new URL("./pi-acp/index.js", import.meta.url).pathname;
+const cwdPath = resolve(tmpdir(), `agentos-pi-cwd-${process.pid}`);
+const child = spawn(process.execPath, [upstreamEntrypoint, ...process.argv.slice(2)], {
+	env: { ...process.env, AGENTOS_PI_CWD_FILE: cwdPath },
+	stdio: ["pipe", "pipe", "inherit"],
+});
+
+let inputBuffer = "";
+let sessionCwd = "";
+let finished = false;
+function writeInput(value) {
+	if (child.stdin.write(value) || typeof process.stdin.pause !== "function") return;
+	process.stdin.pause();
+	child.stdin.once("drain", () => process.stdin.resume?.());
+}
+function forwardInput(line, newline = true) {
+	const cwd = acpRequestCwd(line);
+	if (cwd && !sessionCwd) {
+		sessionCwd = cwd;
+		writeFileSync(cwdPath, `${cwd}\n`, { mode: 0o600 });
+	} else if (cwd && cwd !== sessionCwd) {
+		throw new Error(`ACP adapter cannot change cwd from ${sessionCwd} to ${cwd}`);
+	}
+	writeInput(`${line}${newline ? "\n" : ""}`);
+}
+process.stdin.on("data", (chunk) => {
+	if (sessionCwd) {
+		writeInput(chunk);
+		return;
+	}
+	inputBuffer += chunk.toString();
+	for (;;) {
+		const newline = inputBuffer.indexOf("\n");
+		if (newline < 0) return;
+		const line = inputBuffer.slice(0, newline);
+		inputBuffer = inputBuffer.slice(newline + 1);
+		forwardInput(line);
+		if (!sessionCwd) continue;
+		if (inputBuffer) writeInput(inputBuffer);
+		inputBuffer = "";
+		return;
+	}
+});
+process.stdin.on("end", () => {
+	if (inputBuffer) forwardInput(inputBuffer, false);
+	child.stdin.end();
+});
+const output = createInterface({ input: child.stdout, crlfDelay: Infinity });
+output.on("line", (line) => process.stdout.write(`${normalizeAcpResponse(line)}\n`));
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+	process.once(signal, () => {
+		child.kill(signal);
+		setTimeout(() => child.kill("SIGKILL"), 2_000).unref?.();
+	});
+}
+child.once("error", (error) => {
+	process.stderr.write(`${error.stack ?? error}\n`);
+	finish(1);
+});
+child.once("close", (code, signal) => {
+	finish(code ?? 1, signal);
+});
+
+function finish(code, signal) {
+	if (finished) return;
+	finished = true;
+	process.stdin.removeAllListeners?.("data");
+	process.stdin.removeAllListeners?.("end");
+	output.close();
+	rmSync(cwdPath, { force: true });
+	process.exitCode = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : code;
+}