@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/test/unit/owned-process-tree.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { spawn, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import test from "node:test";
+import { createOwnedProcessTreeController } from "../../src/runs/background/owned-process-tree.ts";
+
+function processIsActive(pid: number): boolean {
+	const result = spawnSync("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf-8" });
+	return result.status === 0 && Boolean(result.stdout.trim()) && !result.stdout.trim().startsWith("Z");
+}
+
+test("owned process tree fails closed when process-group ownership is unsupported", { skip: process.platform !== "win32" }, async () => {
+	const proof = await createOwnedProcessTreeController(999_999).terminate();
+	assert.deepEqual(proof, { state: "unknown", reason: "unsupported-platform" });
+});
+
+test("owned process tree kills descendants and verifies a TERM-resistant POSIX group", { skip: process.platform === "win32" }, async () => {
+	const writer = spawn(process.execPath, ["-e", `
+		const { spawn } = require("node:child_process");
+		const child = spawn(process.execPath, ["-e", "process.on('SIGTERM', () => {}); setInterval(() => {}, 1000)"], { stdio: "ignore" });
+		process.on("SIGTERM", () => {});
+		process.stdout.write(String(child.pid) + "\\n");
+		setInterval(() => {}, 1000);
+	`], { detached: true, stdio: ["ignore", "pipe", "ignore"] });
+	assert.ok(writer.pid);
+	const grandchildPid = await new Promise<number>((resolve, reject) => {
+		writer.once("error", reject);
+		writer.stdout!.once("data", (chunk) => resolve(Number(String(chunk).trim())));
+	});
+	const proof = await createOwnedProcessTreeController(writer.pid, { termGraceMs: 50, killVerifyMs: 1000 }).terminate();
+	assert.equal(proof.state, "observed", JSON.stringify(proof));
+	assert.equal(processIsActive(writer.pid), false);
+	assert.equal(processIsActive(grandchildPid), false);
+
+	const fixtureDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-process-tree-ps-"));
+	const realPs = spawnSync("sh", ["-c", "command -v ps"], { encoding: "utf-8" }).stdout.trim();
+	const marker = path.join(fixtureDir, "failed-once");
+	const originalPath = process.env.PATH;
+	try {
+		fs.writeFileSync(path.join(fixtureDir, "ps"), `#!/bin/sh\nif [ ! -e "$PI_TEST_PS_MARKER" ]; then\n  : > "$PI_TEST_PS_MARKER"\n  exit 1\nfi\nexec "$PI_TEST_REAL_PS" "$@"\n`);
+		fs.chmodSync(path.join(fixtureDir, "ps"), 0o755);
+		process.env.PATH = `${fixtureDir}${path.delimiter}${originalPath ?? ""}`;
+		process.env.PI_TEST_PS_MARKER = marker;
+		process.env.PI_TEST_REAL_PS = realPs;
+		const enumerationFailureWriter = spawn(process.execPath, ["-e", `
+			process.on("SIGTERM", () => {});
+			process.stdout.write("ready\\n");
+			setInterval(() => {}, 1000);
+		`], { detached: true, stdio: ["ignore", "pipe", "ignore"] });
+		assert.ok(enumerationFailureWriter.pid);
+		await new Promise<void>((resolve, reject) => {
+			enumerationFailureWriter.once("error", reject);
+			enumerationFailureWriter.stdout!.once("data", () => resolve());
+		});
+		const termGraceMs = 50;
+		const startedAt = Date.now();
+		const failedProof = await createOwnedProcessTreeController(enumerationFailureWriter.pid, { termGraceMs, killVerifyMs: 1000 }).terminate();
+		assert.ok(Date.now() - startedAt >= termGraceMs, "enumeration failure still waits through the TERM grace before SIGKILL");
+		assert.equal(failedProof.state, "observed", JSON.stringify(failedProof));
+		assert.equal(processIsActive(enumerationFailureWriter.pid), false);
+	} finally {
+		process.env.PATH = originalPath;
+		delete process.env.PI_TEST_PS_MARKER;
+		delete process.env.PI_TEST_REAL_PS;
+		fs.rmSync(fixtureDir, { recursive: true, force: true });
+	}
+});

package/dist/extensions/pi-subagents/test/unit/package-manifest.test.ts

@@ -26,9 +26,8 @@ const expectedHostPeerRanges = {
 const expectedHostDevVersions = {
 	"@earendil-works/pi-agent-core": "0.81.0",
 	"@earendil-works/pi-ai": "0.81.0",
-	"@selesai/code": "0.8.2",
 	"@earendil-works/pi-tui": "0.81.0",
-} satisfies Record<(typeof hostPeerPackages)[number], string>;
+} satisfies Record<Exclude<(typeof hostPeerPackages)[number], "@selesai/code">, string>;
 
 function collectSourceFiles(dir: string): string[] {
 	const files: string[] = [];
@@ -64,6 +63,7 @@ test("published extension APIs use supported package entrypoints", async () => {
 		"./intercom-bridge": "./src/api/intercom-bridge.ts",
 		"./pi-args": "./src/api/pi-args.ts",
 		"./shared-types": "./src/api/shared-types.ts",
+		"./project-panes": "./src/api/project-panes.ts",
 	});
 	const backgroundWork = await import("pi-subagents/background-work");
 	assert.equal(backgroundWork.BACKGROUND_WORK_PROTOCOL_VERSION, 1);
@@ -90,6 +90,11 @@ test("published extension APIs use supported package entrypoints", async () => {
 	assert.equal(typeof sharedTypes.wrapForkTask, "function");
 	assert.equal(typeof sharedTypes.DEFAULT_FORK_PREAMBLE, "string");
 	assert.equal("TEMP_ROOT_DIR" in sharedTypes, false);
+	const projectPanes = await import("pi-subagents/project-panes");
+	assert.equal(projectPanes.PROJECT_PANES_API_VERSION, 1);
+	assert.equal(typeof projectPanes.openProjectPane, "function");
+	assert.equal(typeof projectPanes.getProjectPaneStatus, "function");
+	assert.equal(typeof projectPanes.closeProjectPane, "function");
 });
 
 test("direct @earendil-works runtime imports are declared for CI installs", () => {
@@ -118,6 +123,10 @@ test("direct dependency declarations are exact version pins", () => {
 
 	for (const section of ["dependencies", "devDependencies"] as const) {
 		for (const [name, version] of Object.entries<string>(packageJson[section] ?? {})) {
+			if (name === "@selesai/code") {
+				assert.equal(version, "file:./test/fixtures/pi-coding-agent-shim");
+				continue;
+			}
 			assert.match(version, exactVersionPattern, `${section}.${name} should use an exact version`);
 		}
 	}
@@ -147,6 +156,11 @@ test("host-owned development packages use the supported SDK baseline", () => {
 	for (const [name, version] of Object.entries(expectedHostDevVersions)) {
 		assert.equal(packageJson.devDependencies?.[name], version, `${name} should use ${version}`);
 	}
+	assert.equal(
+		packageJson.devDependencies?.["@selesai/code"],
+		"file:./test/fixtures/pi-coding-agent-shim",
+		"pi-coding-agent should use the local type/runtime shim until upstream Pi no longer pins vulnerable Undici",
+	);
 });
 
 test("old pi package scope is not used by source or tests", () => {

package/dist/extensions/pi-subagents/test/unit/parallel-handoff.test.ts

@@ -89,16 +89,16 @@ describe("parallel handoff", () => {
 				stepIndex: 2,
 				flatStartIndex: 3,
 				setup: setup("/repo", "base-1"),
-				diffs: [diff(dir, 0, "builder", true)],
+				diffs: [diff(dir, 0, "worker", true)],
 				cleanup: cleanup(),
 				results: [{
-					agent: "builder",
+					agent: "worker",
 					status: "completed",
 					summary: "implemented",
 					outputPath: "/artifacts/output.md",
 					structuredOutput: { ok: true },
 					structuredOutputPath: "/artifacts/structured.json",
-					sessionPath: "/sessions/builder.jsonl",
+					sessionPath: "/sessions/worker.jsonl",
 				}],
 				now: 100,
 			});
@@ -120,9 +120,9 @@ describe("parallel handoff", () => {
 				stepIndex: 1,
 				flatStartIndex: 1,
 				setup: setup("/repo", "base-1"),
-				diffs: [diff(dir, 1, "commentator", false)],
+				diffs: [diff(dir, 1, "reviewer", false)],
 				cleanup: cleanup("partial"),
-				results: [{ agent: "commentator", status: "failed", summary: "blocked" }],
+				results: [{ agent: "reviewer", status: "failed", summary: "blocked" }],
 				now: 200,
 			});
 			assert.equal(second.groupCount, 2);
@@ -189,9 +189,9 @@ describe("parallel handoff", () => {
 				stepIndex: 0,
 				flatStartIndex: 0,
 				setup: setup("/repo", "base-1"),
-				diffs: [diff(dir, 0, "builder", false)],
+				diffs: [diff(dir, 0, "worker", false)],
 				cleanup: cleanup(),
-				results: [{ agent: "builder", status: "completed" as const, summary: "done" }],
+				results: [{ agent: "worker", status: "completed" as const, summary: "done" }],
 			};
 			writeParallelHandoffGroup({ ...common, runId: "run-1" });
 			assert.throws(

package/dist/extensions/pi-subagents/test/unit/parallel-utils.test.ts

@@ -49,11 +49,11 @@ describe("flattenSteps", () => {
 
 	it("expands parallel groups into individual steps", () => {
 		const steps: RunnerStep[] = [
-			{ agent: "explorer", task: "find info" },
+			{ agent: "scout", task: "find info" },
 			{
 				parallel: [
-					{ agent: "commentator-a", task: "review part 1" },
-					{ agent: "commentator-b", task: "review part 2" },
+					{ agent: "reviewer-a", task: "review part 1" },
+					{ agent: "reviewer-b", task: "review part 2" },
 				],
 			},
 			{ agent: "summarizer", task: "combine" },
@@ -62,7 +62,7 @@ describe("flattenSteps", () => {
 		assert.equal(flat.length, 4);
 		assert.deepEqual(
 			flat.map((s) => s.agent),
-			["explorer", "commentator-a", "commentator-b", "summarizer"],
+			["scout", "reviewer-a", "reviewer-b", "summarizer"],
 		);
 	});
 
@@ -149,8 +149,8 @@ describe("mapConcurrent", () => {
 		// All workers should start nearly simultaneously
 		const d1 = startTimes[1]! - startTimes[0]!;
 		const d2 = startTimes[2]! - startTimes[0]!;
-		assert.ok(d1 < 20, `builder 1 should start immediately, got ${d1}ms delay`);
-		assert.ok(d2 < 20, `builder 2 should start immediately, got ${d2}ms delay`);
+		assert.ok(d1 < 20, `worker 1 should start immediately, got ${d1}ms delay`);
+		assert.ok(d2 < 20, `worker 2 should start immediately, got ${d2}ms delay`);
 	});
 
 	it("notifies scheduling settlement only after workers outliving an early rejection stop", async () => {
@@ -222,12 +222,12 @@ describe("DEFAULT_GLOBAL_CONCURRENCY_LIMIT", () => {
 describe("aggregateParallelOutputs", () => {
 	it("aggregates successful outputs with headers", () => {
 		const result = aggregateParallelOutputs([
-			{ agent: "commentator-a", output: "Looks good", exitCode: 0 },
-			{ agent: "commentator-b", output: "Needs fixes", exitCode: 0 },
+			{ agent: "reviewer-a", output: "Looks good", exitCode: 0 },
+			{ agent: "reviewer-b", output: "Needs fixes", exitCode: 0 },
 		]);
-		assert.ok(result.includes("=== Parallel Task 1 (commentator-a) ==="));
+		assert.ok(result.includes("=== Parallel Task 1 (reviewer-a) ==="));
 		assert.ok(result.includes("Looks good"));
-		assert.ok(result.includes("=== Parallel Task 2 (commentator-b) ==="));
+		assert.ok(result.includes("=== Parallel Task 2 (reviewer-b) ==="));
 		assert.ok(result.includes("Needs fixes"));
 	});
 

package/dist/extensions/pi-subagents/test/unit/path-handling.test.ts

@@ -96,7 +96,7 @@ describe("path.join vs template string concatenation", () => {
 
 	it("parallel subdir naming should use path.join", () => {
 		// settings.ts:302,306 pattern: `${subdir}/${task.output}`
-		const subdir = "parallel-0/0-_code-commentator";
+		const subdir = "parallel-0/0-_code-reviewer";
 		const output = "review.md";
 
 		const templateResult = `${subdir}/${output}`;
@@ -104,10 +104,10 @@ describe("path.join vs template string concatenation", () => {
 
 		// Both produce forward slashes here (subdir itself uses /).
 		// But if subdir comes from path.join on Windows, it would have backslashes.
-		const windowsSubdir = path.join("parallel-0", "0-_code-commentator");
+		const windowsSubdir = path.join("parallel-0", "0-_code-reviewer");
 		const windowsJoin = path.join(windowsSubdir, output);
 		// Consistent: all native separators
-		assert.equal(windowsJoin, path.join("parallel-0", "0-_code-commentator", output));
+		assert.equal(windowsJoin, path.join("parallel-0", "0-_code-reviewer", output));
 	});
 });
 

package/dist/extensions/pi-subagents/test/unit/path-resolution.test.ts

@@ -6,29 +6,40 @@ import * as path from "node:path";
 import { discoverAgents } from "../../src/agents/agents.ts";
 import { resolveSkillPath, clearSkillCache } from "../../src/agents/skills.ts";
 
-const tmpDir = path.join(os.tmpdir(), "pi-path-resolution-test");
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-path-resolution-"));
 const cwdDir = path.join(tmpDir, "cwd");
+const homeDir = path.join(tmpDir, "home");
+const userAgentsDir = path.join(homeDir, ".agents");
+const userAgentsCanary = path.join(userAgentsDir, ".data-loss-canary");
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+const originalAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
 
-const realHomeDir = os.homedir();
-const realUserAgentsDir = path.join(realHomeDir, ".agents");
-const userAgentsDirBackup = path.join(tmpDir, ".agents_backup");
+function restoreEnv(name: "HOME" | "USERPROFILE" | "SELESAI_CODING_AGENT_DIR", value: string | undefined): void {
+	if (value === undefined) delete process.env[name];
+	else process.env[name] = value;
+}
 
 before(() => {
 	fs.mkdirSync(cwdDir, { recursive: true });
-
-	if (fs.existsSync(realUserAgentsDir)) {
-		fs.cpSync(realUserAgentsDir, userAgentsDirBackup, { recursive: true });
-	}
+	fs.mkdirSync(path.join(userAgentsDir, "skills"), { recursive: true });
+	fs.writeFileSync(userAgentsCanary, "preserve me");
+	process.env.HOME = homeDir;
+	process.env.USERPROFILE = homeDir;
+	assert.equal(os.homedir(), homeDir);
+	process.env.SELESAI_CODING_AGENT_DIR = path.join(homeDir, ".selesai", "agent");
 });
 
 after(() => {
-	if (fs.existsSync(userAgentsDirBackup)) {
-		fs.rmSync(realUserAgentsDir, { recursive: true, force: true });
-		fs.cpSync(userAgentsDirBackup, realUserAgentsDir, { recursive: true });
-	} else {
-		fs.rmSync(realUserAgentsDir, { recursive: true, force: true });
+	try {
+		assert.equal(fs.readFileSync(userAgentsCanary, "utf-8"), "preserve me");
+	} finally {
+		restoreEnv("HOME", originalHome);
+		restoreEnv("USERPROFILE", originalUserProfile);
+		restoreEnv("SELESAI_CODING_AGENT_DIR", originalAgentDir);
+		clearSkillCache();
+		fs.rmSync(tmpDir, { recursive: true, force: true });
 	}
-	fs.rmSync(tmpDir, { recursive: true, force: true });
 });
 
 describe("Path resolution for .agents and ~/.agents", () => {
@@ -44,7 +55,7 @@ describe("Path resolution for .agents and ~/.agents", () => {
 	});
 
 	test("should resolve skills in ~/.agents/skills", () => {
-		const userSkillsDir = path.join(realHomeDir, ".agents", "skills");
+		const userSkillsDir = path.join(userAgentsDir, "skills");
 		fs.mkdirSync(userSkillsDir, { recursive: true });
 		fs.writeFileSync(path.join(userSkillsDir, "test-skill-2.md"), "---\nname: test-skill-2\ndescription: test desc\n---\nSkill content");
 
@@ -79,8 +90,6 @@ describe("Path resolution for .agents and ~/.agents", () => {
 	});
 
 	test("should resolve agents in ~/.agents", () => {
-		const userAgentsDir = path.join(realHomeDir, ".agents");
-		fs.mkdirSync(userAgentsDir, { recursive: true });
 		fs.writeFileSync(
 			path.join(userAgentsDir, "test-agent-2.md"),
 			"---\nname: test-agent-2\ndescription: Test agent\n---\nAgent content"