@selesai/code 0.3.0 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/async-resume.test.ts

@@ -0,0 +1,285 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../../src/runs/background/async-resume.ts";
+
+function writeJson(filePath: string, value: object): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+
+describe("async resume lookup", () => {
+	it("resolves a completed single-child run from persisted status", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const sessionFile = path.join(root, "session.jsonl");
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			writeJson(path.join(asyncRoot, "run-abc", "status.json"), {
+				runId: "run-abc",
+				mode: "single",
+				state: "complete",
+				startedAt: 100,
+				endedAt: 200,
+				lastUpdate: 200,
+				cwd: root,
+				sessionFile,
+				steps: [{ agent: "worker", status: "complete" }],
+			});
+
+			const target = resolveAsyncResumeTarget({ id: "run-a" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+
+			assert.equal(target.kind, "revive");
+			assert.equal(target.runId, "run-abc");
+			assert.equal(target.agent, "worker");
+			assert.equal(target.sessionFile, sessionFile);
+			assert.equal(target.cwd, root);
+			assert.equal(target.intercomTarget, "subagent-worker-run-abc-1");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects ambiguous run id prefixes", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-ambiguous-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			writeJson(path.join(asyncRoot, "run-aa", "status.json"), {
+				runId: "run-aa",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "scout", status: "running" }],
+			});
+			writeJson(path.join(asyncRoot, "run-ab", "status.json"), {
+				runId: "run-ab",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-a" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+				/Ambiguous async run id prefix 'run-a' matched: run-aa, run-ab/,
+			);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects path-like ids and directories outside the async root", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-paths-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "../run" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+				/id must be an async run id or prefix, not a path/,
+			);
+			assert.throws(
+				() => resolveAsyncResumeTarget({ dir: path.join(root, "outside") }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+				/Async run directory must be inside/,
+			);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects non-jsonl session files before reviving", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-session-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const sessionFile = path.join(root, "session.txt");
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			writeJson(path.join(asyncRoot, "run-session", "status.json"), {
+				runId: "run-session",
+				mode: "single",
+				state: "complete",
+				startedAt: 100,
+				lastUpdate: 200,
+				sessionFile,
+				steps: [{ agent: "worker", status: "complete" }],
+			});
+
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-session" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+				/session file must be a \.jsonl file/,
+			);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects malformed result metadata before using session fields", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-malformed-result-"));
+		try {
+			const resultsDir = path.join(root, "results");
+			writeJson(path.join(resultsDir, "run-result.json"), {
+				id: "run-result",
+				agent: "worker",
+				success: true,
+				state: "complete",
+				results: [{ agent: "worker", sessionFile: { path: "session.jsonl" } }],
+			});
+
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-result" }, { asyncDirRoot: path.join(root, "runs"), resultsDir }),
+				/results\[0\].sessionFile must be a string/,
+			);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects malformed status session ids", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-malformed-session-id-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			writeJson(path.join(asyncRoot, "run-session-id", "status.json"), {
+				runId: "run-session-id",
+				sessionId: { value: "session" },
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-session-id" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+				/sessionId must be a string/,
+			);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("returns a live intercom target for a running child", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-live-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			writeJson(path.join(asyncRoot, "run-live", "status.json"), {
+				runId: "run-live",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				lastUpdate: 100,
+				steps: [{ agent: "scout", status: "running" }],
+			});
+
+			const target = resolveAsyncResumeTarget({ id: "run-live" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+
+			assert.equal(target.kind, "live");
+			assert.equal(target.intercomTarget, "subagent-scout-run-live-1");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("revives a completed child by index while a sibling async child is still running", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-partial-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const sessionFile = path.join(root, "done.jsonl");
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			writeJson(path.join(asyncRoot, "run-partial", "status.json"), {
+				runId: "run-partial",
+				mode: "parallel",
+				state: "running",
+				startedAt: 100,
+				lastUpdate: 200,
+				steps: [
+					{ agent: "done", status: "complete", sessionFile },
+					{ agent: "active", status: "running" },
+				],
+			});
+
+			const target = resolveAsyncResumeTarget({ id: "run-partial", index: 0 }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+			assert.equal(target.kind, "revive");
+			assert.equal(target.agent, "done");
+			assert.equal(target.sessionFile, sessionFile);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects pending indexed children in still-running async runs", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-pending-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const sessionFile = path.join(root, "pending.jsonl");
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			writeJson(path.join(asyncRoot, "run-pending", "status.json"), {
+				runId: "run-pending",
+				mode: "chain",
+				state: "running",
+				startedAt: 100,
+				lastUpdate: 200,
+				steps: [
+					{ agent: "active", status: "running" },
+					{ agent: "later", status: "pending", sessionFile },
+				],
+			});
+
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-pending", index: 1 }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+				/pending and has not started yet/,
+			);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("resolves a completed multi-child run when an index and per-child session file are available", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-multi-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const firstSession = path.join(root, "a.jsonl");
+			const secondSession = path.join(root, "b.jsonl");
+			fs.writeFileSync(firstSession, "", "utf-8");
+			fs.writeFileSync(secondSession, "", "utf-8");
+			writeJson(path.join(asyncRoot, "run-multi", "status.json"), {
+				runId: "run-multi",
+				mode: "chain",
+				state: "complete",
+				startedAt: 100,
+				lastUpdate: 200,
+				steps: [
+					{ agent: "a", status: "complete", sessionFile: firstSession },
+					{ agent: "b", status: "complete", sessionFile: secondSession },
+				],
+			});
+
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-multi" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+				/Provide index to choose one/,
+			);
+			const target = resolveAsyncResumeTarget({ id: "run-multi", index: 1 }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+			assert.equal(target.kind, "revive");
+			assert.equal(target.agent, "b");
+			assert.equal(target.index, 1);
+			assert.equal(target.sessionFile, secondSession);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("frames the revived follow-up with original run context", () => {
+		const task = buildRevivedAsyncTask({
+			kind: "revive",
+			runId: "run-old",
+			state: "complete",
+			agent: "worker",
+			index: 0,
+			intercomTarget: "subagent-worker-run-old-1",
+			sessionFile: "/tmp/session.jsonl",
+		}, "What changed?");
+
+		assert.match(task, /Original run: run-old/);
+		assert.doesNotMatch(task, /async subagent conversation/);
+		assert.match(task, /Original agent: worker/);
+		assert.match(task, /Original session file: \/tmp\/session\.jsonl/);
+		assert.match(task, /Follow-up:\nWhat changed\?/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/atomic-json.test.ts

@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { createAtomicJsonWriter } from "../../src/shared/atomic-json.ts";
+
+class FakeFs {
+	files = new Map<string, string>();
+	madeDirs: string[] = [];
+	renameCalls = 0;
+	failRenameCodes: string[] = [];
+
+	mkdirSync(dirPath: string): void {
+		this.madeDirs.push(dirPath);
+	}
+
+	writeFileSync(filePath: string, contents: string): void {
+		this.files.set(filePath, contents);
+	}
+
+	renameSync(sourcePath: string, targetPath: string): void {
+		this.renameCalls++;
+		const failureCode = this.failRenameCodes.shift();
+		if (failureCode) {
+			const error = new Error(`rename failed with ${failureCode}`) as NodeJS.ErrnoException;
+			error.code = failureCode;
+			throw error;
+		}
+		const contents = this.files.get(sourcePath);
+		if (contents === undefined) throw new Error(`missing source file: ${sourcePath}`);
+		this.files.delete(sourcePath);
+		this.files.set(targetPath, contents);
+	}
+
+	rmSync(filePath: string): void {
+		this.files.delete(filePath);
+	}
+}
+
+function createWriter(fakeFs: FakeFs, waits: number[]) {
+	return createAtomicJsonWriter({
+		fs: fakeFs as any,
+		now: () => 12345,
+		pid: 678,
+		random: () => 0.5,
+		retryRenameErrors: true,
+		retryDelaysMs: [1, 2, 3],
+		wait: (delayMs) => waits.push(delayMs),
+	});
+}
+
+describe("writeAtomicJson", () => {
+	it("retries transient rename failures before replacing the target", () => {
+		const fakeFs = new FakeFs();
+		fakeFs.failRenameCodes = ["EPERM", "EBUSY"];
+		const waits: number[] = [];
+		const writeAtomicJson = createWriter(fakeFs, waits);
+		const targetPath = path.join("/tmp", "status.json");
+
+		writeAtomicJson(targetPath, { state: "running" });
+
+		assert.equal(fakeFs.renameCalls, 3);
+		assert.deepEqual(waits, [1, 2]);
+		assert.deepEqual(fakeFs.madeDirs, [path.dirname(targetPath)]);
+		assert.equal(fakeFs.files.get(targetPath), JSON.stringify({ state: "running" }, null, 2));
+		assert.equal(fakeFs.files.size, 1);
+	});
+
+	it("uses longer default retries for transient Windows rename locks", () => {
+		const fakeFs = new FakeFs();
+		fakeFs.failRenameCodes = ["EPERM", "EPERM", "EPERM", "EPERM", "EPERM", "EPERM"];
+		const waits: number[] = [];
+		const writeAtomicJson = createAtomicJsonWriter({
+			fs: fakeFs as any,
+			now: () => 12345,
+			pid: 678,
+			random: () => 0.5,
+			retryRenameErrors: true,
+			wait: (delayMs) => waits.push(delayMs),
+		});
+
+		writeAtomicJson(path.join("/tmp", "status.json"), { state: "running" });
+
+		assert.equal(fakeFs.renameCalls, 7);
+		assert.deepEqual(waits, [10, 25, 50, 100, 200, 500]);
+	});
+
+	it("throws non-retryable rename failures without retrying", () => {
+		const fakeFs = new FakeFs();
+		fakeFs.failRenameCodes = ["ENOENT"];
+		const waits: number[] = [];
+		const writeAtomicJson = createWriter(fakeFs, waits);
+
+		assert.throws(() => writeAtomicJson(path.join("/tmp", "status.json"), { state: "running" }), /ENOENT/);
+		assert.equal(fakeFs.renameCalls, 1);
+		assert.deepEqual(waits, []);
+		assert.equal(fakeFs.files.size, 0);
+	});
+
+	it("cleans up the temp file after retryable failures are exhausted", () => {
+		const fakeFs = new FakeFs();
+		fakeFs.failRenameCodes = ["EPERM", "EPERM", "EPERM", "EPERM"];
+		const waits: number[] = [];
+		const writeAtomicJson = createWriter(fakeFs, waits);
+		const targetPath = path.join("/tmp", "status.json");
+
+		assert.throws(() => writeAtomicJson(targetPath, { state: "running" }), /EPERM/);
+		assert.equal(fakeFs.renameCalls, 4);
+		assert.deepEqual(waits, [1, 2, 3]);
+		assert.equal(fakeFs.files.has(targetPath), false);
+		assert.equal(fakeFs.files.size, 0);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/chain-append.test.ts

@@ -0,0 +1,206 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import {
+	appendRunnerStepsToStatus,
+	consumeChainAppendRequests,
+	countPendingChainAppendRequests,
+	enqueueChainAppendRequest,
+	readPendingChainAppendRequests,
+	runnerStepOutputNames,
+} from "../../src/runs/background/chain-append.ts";
+import type { AsyncStatus } from "../../src/shared/types.ts";
+import type { RunnerStep } from "../../src/runs/shared/parallel-utils.ts";
+import { createTempDir, removeTempDir } from "../support/helpers.ts";
+
+function writeStatus(asyncDir: string, status: Partial<AsyncStatus> & Pick<AsyncStatus, "runId" | "mode" | "state" | "startedAt">): void {
+	fs.mkdirSync(asyncDir, { recursive: true });
+	fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+}
+
+function readStatus(asyncDir: string): AsyncStatus {
+	return JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatus;
+}
+
+function runnerStep(agent: string, task = "Use {previous}"): RunnerStep {
+	return {
+		agent,
+		task,
+		inheritProjectContext: false,
+		inheritSkills: false,
+	};
+}
+
+describe("chain append requests", () => {
+	it("persists append requests for running async chains and records pending status", () => {
+		const root = createTempDir("pi-chain-append-");
+		try {
+			const asyncDir = path.join(root, "run-a");
+			writeStatus(asyncDir, {
+				runId: "run-a",
+				mode: "chain",
+				state: "running",
+				startedAt: 100,
+				lastUpdate: 100,
+				chainStepCount: 1,
+				steps: [{ agent: "scout", status: "running" }],
+			});
+
+			const result = enqueueChainAppendRequest({
+				asyncDir,
+				runId: "run-a",
+				steps: [runnerStep("worker")],
+				now: 200,
+			});
+
+			assert.equal(result.pendingCount, 1);
+			assert.equal(countPendingChainAppendRequests(asyncDir), 1);
+			const status = readStatus(asyncDir);
+			assert.equal(status.pendingAppends, 1);
+			assert.equal(status.lastUpdate, 200);
+			const eventLog = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8");
+			assert.match(eventLog, /subagent\.chain\.append\.requested/);
+
+			const consumed = consumeChainAppendRequests(asyncDir);
+			assert.equal(consumed.length, 1);
+			assert.equal(consumed[0]!.id, result.request.id);
+			assert.equal(countPendingChainAppendRequests(asyncDir), 0);
+		} finally {
+			removeTempDir(root);
+		}
+	});
+
+	it("reads pending append requests without consuming them and reports reserved output names", () => {
+		const root = createTempDir("pi-chain-append-pending-");
+		try {
+			const asyncDir = path.join(root, "run-pending");
+			writeStatus(asyncDir, {
+				runId: "run-pending",
+				mode: "chain",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "scout", status: "running" }],
+			});
+			enqueueChainAppendRequest({
+				asyncDir,
+				runId: "run-pending",
+				steps: [{
+					parallel: [
+						{ ...runnerStep("worker"), outputName: "draft" },
+						{ ...runnerStep("reviewer"), outputName: "review" },
+					],
+				}],
+				now: 200,
+			});
+
+			const pending = readPendingChainAppendRequests(asyncDir);
+
+			assert.equal(pending.length, 1);
+			assert.deepEqual(runnerStepOutputNames(pending[0]!.steps), ["draft", "review"]);
+			assert.equal(countPendingChainAppendRequests(asyncDir), 1);
+		} finally {
+			removeTempDir(root);
+		}
+	});
+
+	it("rejects terminal and non-chain async runs", () => {
+		const root = createTempDir("pi-chain-append-reject-");
+		try {
+			const completeDir = path.join(root, "complete");
+			writeStatus(completeDir, {
+				runId: "complete",
+				mode: "chain",
+				state: "complete",
+				startedAt: 100,
+				steps: [{ agent: "scout", status: "complete" }],
+			});
+			assert.throws(
+				() => enqueueChainAppendRequest({ asyncDir: completeDir, runId: "complete", steps: [runnerStep("worker")] }),
+				/only running chain runs/,
+			);
+
+			const parallelDir = path.join(root, "parallel");
+			writeStatus(parallelDir, {
+				runId: "parallel",
+				mode: "parallel",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "scout", status: "running" }],
+			});
+			assert.throws(
+				() => enqueueChainAppendRequest({ asyncDir: parallelDir, runId: "parallel", steps: [runnerStep("worker")] }),
+				/only active chain runs/,
+			);
+
+			const drainedDir = path.join(root, "drained");
+			writeStatus(drainedDir, {
+				runId: "drained",
+				mode: "chain",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "scout", status: "complete" }],
+			});
+			assert.throws(
+				() => enqueueChainAppendRequest({ asyncDir: drainedDir, runId: "drained", steps: [runnerStep("worker")] }),
+				/no running or pending chain steps left/,
+			);
+		} finally {
+			removeTempDir(root);
+		}
+	});
+
+	it("extends async chain status, parallel groups, and workflow graph", () => {
+		const status: AsyncStatus = {
+			runId: "run-graph",
+			mode: "chain",
+			state: "running",
+			startedAt: 100,
+			currentStep: 0,
+			chainStepCount: 1,
+			steps: [{ agent: "scout", status: "complete" }],
+			parallelGroups: [],
+			workflowGraph: {
+				runId: "run-graph",
+				mode: "chain",
+				phases: [],
+				nodes: [{
+					id: "step-0",
+					kind: "step",
+					agent: "scout",
+					label: "scout",
+					status: "completed",
+					flatIndex: 0,
+					stepIndex: 0,
+				}],
+			},
+		};
+		const appended: RunnerStep[] = [
+			runnerStep("worker"),
+			{
+				parallel: [
+					runnerStep("reviewer"),
+					runnerStep("auditor"),
+				],
+				concurrency: 2,
+			},
+		];
+
+		const result = appendRunnerStepsToStatus({ status, steps: appended, now: 300, pendingAppends: 0 });
+
+		assert.deepEqual(result, { addedChainSteps: 2, addedFlatSteps: 3 });
+		assert.equal(status.chainStepCount, 3);
+		assert.equal(status.pendingAppends, 0);
+		assert.equal(status.lastUpdate, 300);
+		assert.deepEqual(status.steps?.map((step) => `${step.agent}:${step.status}`), [
+			"scout:complete",
+			"worker:pending",
+			"reviewer:pending",
+			"auditor:pending",
+		]);
+		assert.deepEqual(status.parallelGroups, [{ start: 2, count: 2, stepIndex: 2 }]);
+		assert.equal(status.workflowGraph?.nodes[1]?.id, "step-1");
+		assert.equal(status.workflowGraph?.nodes[2]?.kind, "parallel-group");
+		assert.deepEqual(status.workflowGraph?.nodes[2]?.children?.map((child) => child.flatIndex), [2, 3]);
+	});
+});