@selesai/code 0.2.1 → 0.3.1

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

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import {
+	getArtifactsDir,
+	getProjectArtifactsDir,
+	getProjectChainRunsDir,
+	getProjectSubagentsDir,
+} from "../../src/shared/artifacts.ts";
+
+describe("project-local artifact paths", () => {
+	it("places generated subagent files under .pi-subagents for a project cwd", () => {
+		const cwd = path.join("tmp", "repo");
+		assert.equal(getProjectSubagentsDir(cwd), path.join(cwd, ".pi-subagents"));
+		assert.equal(getProjectArtifactsDir(cwd), path.join(cwd, ".pi-subagents", "artifacts"));
+		assert.equal(getProjectChainRunsDir(cwd), path.join(cwd, ".pi-subagents", "chain-runs"));
+		assert.equal(getArtifactsDir(null, cwd), path.join(cwd, ".pi-subagents", "artifacts"));
+	});
+
+	it("keeps the session artifact fallback when no project cwd is available", () => {
+		const sessionFile = path.join("tmp", "sessions", "parent.jsonl");
+		assert.equal(getArtifactsDir(sessionFile), path.join("tmp", "sessions", "subagent-artifacts"));
+	});
+});

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

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { buildAsyncRunnerSteps, resolveAsyncRunnerLogPaths } from "../../src/runs/background/async-execution.ts";
+import type { AgentConfig } from "../../src/agents/agents.ts";
+
+const agent = (name: string, toolBudget?: AgentConfig["toolBudget"]): AgentConfig => ({
+	name,
+	description: `${name} agent`,
+	systemPromptMode: "replace",
+	inheritProjectContext: false,
+	inheritSkills: false,
+	systemPrompt: "You are a test agent.",
+	source: "project",
+	filePath: `${name}.md`,
+	...(toolBudget ? { toolBudget } : {}),
+});
+
+const ctx = {
+	cwd: process.cwd(),
+	currentSessionId: "session-1",
+	currentModel: undefined,
+	currentModelProvider: undefined,
+	modelScope: undefined,
+};
+
+describe("async runner execution", () => {
+	it("places detached runner stdio logs in the async run directory", () => {
+		const asyncDir = path.join("tmp", "async-run");
+		assert.deepEqual(resolveAsyncRunnerLogPaths({ asyncDir }), {
+			stdoutPath: path.join(asyncDir, "runner.stdout.log"),
+			stderrPath: path.join(asyncDir, "runner.stderr.log"),
+		});
+	});
+
+	it("omits runner log paths when asyncDir is unavailable", () => {
+		assert.equal(resolveAsyncRunnerLogPaths({}), undefined);
+	});
+
+	it("resolves async step tool budgets with step over run over agent over config precedence", () => {
+		const result = buildAsyncRunnerSteps("run-1", {
+			chain: [
+				{ agent: "worker", task: "agent beats config" },
+				{ agent: "worker", task: "step beats run", toolBudget: { hard: 2, block: ["grep"] } },
+			],
+			agents: [agent("worker", { hard: 4, block: ["read"] })],
+			ctx,
+			asyncDir: path.join(process.cwd(), ".tmp-async-test"),
+			maxSubagentDepth: 2,
+			toolBudget: { hard: 3, block: ["find"] },
+			configToolBudget: { hard: 5, block: ["ls"] },
+		});
+
+		assert.ok("steps" in result, "expected successful step build");
+		assert.deepEqual(result.steps[0]?.toolBudget, { hard: 3, block: ["find"] });
+		assert.deepEqual(result.steps[1]?.toolBudget, { hard: 2, block: ["grep"] });
+	});
+
+	it("uses agent tool budget before config default when no run override exists", () => {
+		const result = buildAsyncRunnerSteps("run-2", {
+			chain: [{ agent: "worker", task: "agent beats config" }],
+			agents: [agent("worker", { hard: 4, block: ["read"] })],
+			ctx,
+			asyncDir: path.join(process.cwd(), ".tmp-async-test"),
+			maxSubagentDepth: 2,
+			configToolBudget: { hard: 5, block: ["ls"] },
+		});
+
+		assert.ok("steps" in result, "expected successful step build");
+		assert.deepEqual(result.steps[0]?.toolBudget, { hard: 4, block: ["read"] });
+	});
+
+	it("uses config default when no step, run, or agent budget exists", () => {
+		const result = buildAsyncRunnerSteps("run-3", {
+			chain: [{ agent: "worker", task: "config default" }],
+			agents: [agent("worker")],
+			ctx,
+			asyncDir: path.join(process.cwd(), ".tmp-async-test"),
+			maxSubagentDepth: 2,
+			configToolBudget: { hard: 5, block: ["ls"] },
+		});
+
+		assert.ok("steps" in result, "expected successful step build");
+		assert.deepEqual(result.steps[0]?.toolBudget, { hard: 5, block: ["ls"] });
+	});
+});

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

@@ -0,0 +1,221 @@
+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 { consumeSteerRequests } from "../../src/runs/background/control-channel.ts";
+import { createSubagentExecutor } from "../../src/runs/foreground/subagent-executor.ts";
+import { ASYNC_DIR, RESULTS_DIR, type SubagentState } from "../../src/shared/types.ts";
+
+function createState(): SubagentState {
+	return {
+		baseCwd: "",
+		currentSessionId: null,
+		asyncJobs: new Map(),
+		foregroundRuns: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		pendingForegroundControlNotices: new Map(),
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	};
+}
+
+function writeJson(filePath: string, value: object): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+
+function createRunningAsync(state: SubagentState, runId: string, options: { track?: boolean } = {}): string {
+	const asyncDir = path.join(ASYNC_DIR, runId);
+	writeJson(path.join(asyncDir, "status.json"), {
+		runId,
+		mode: "single",
+		state: "running",
+		pid: 12345,
+		cwd: os.tmpdir(),
+		startedAt: 100,
+		lastUpdate: Date.now(),
+		steps: [{ agent: "worker", status: "running", startedAt: 100 }],
+	});
+	if (options.track !== false) {
+		state.asyncJobs.set(runId, {
+			asyncId: runId,
+			asyncDir,
+			status: "running",
+			pid: 12345,
+			agents: ["worker"],
+			updatedAt: 100,
+		});
+	}
+	return asyncDir;
+}
+
+function cleanup(runId: string, asyncDir: string): void {
+	fs.rmSync(asyncDir, { recursive: true, force: true });
+	fs.rmSync(path.join(RESULTS_DIR, `${runId}.json`), { force: true });
+}
+
+function executorWithKill(state: SubagentState, kill: (pid: number, signal?: NodeJS.Signals | 0) => boolean) {
+	return createSubagentExecutor({
+		pi: { events: { emit() {}, on() { return () => {}; } }, getSessionName() { return "parent"; } } as any,
+		state,
+		config: { maxSubagentDepth: 2, control: {}, intercomBridge: {} } as any,
+		asyncByDefault: false,
+		tempArtifactsDir: os.tmpdir(),
+		getSubagentSessionRoot: (parentSessionFile) => parentSessionFile ? path.join(path.dirname(parentSessionFile), path.basename(parentSessionFile, ".jsonl")) : os.tmpdir(),
+		expandTilde: (value) => value,
+		discoverAgents: () => ({ agents: [] }),
+		kill,
+	});
+}
+
+function ctx() {
+	return {
+		cwd: os.tmpdir(),
+		hasUI: false,
+		sessionManager: { getSessionId() { return "session"; }, getSessionFile() { return null; } },
+		modelRegistry: { getAvailable() { return []; } },
+	} as any;
+}
+
+function text(result: Awaited<ReturnType<ReturnType<typeof executorWithKill>["execute"]>>): string {
+	return result.content[0]?.type === "text" ? result.content[0].text : "";
+}
+
+describe("async interrupt action", () => {
+	it("queues steering for a running async child", async () => {
+		const state = createState();
+		const runId = `steer-disk-${Date.now().toString(36)}`;
+		const asyncDir = createRunningAsync(state, runId, { track: false });
+		try {
+			const result = await executorWithKill(state, () => true)
+				.execute("steer", { action: "steer", id: runId, message: "Focus on tests." }, new AbortController().signal, undefined, ctx());
+
+			assert.equal(result.isError, undefined);
+			assert.match(text(result), new RegExp(`Steering queued for async run ${runId}`));
+			const requests = consumeSteerRequests(asyncDir);
+			assert.equal(requests.length, 1);
+			assert.equal(requests[0]?.message, "Focus on tests.");
+			assert.equal(requests[0]?.source, "steer-action");
+			assert.equal(requests[0]?.targetIndex, undefined);
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+
+	it("queues steering for a running async child by directory", async () => {
+		const state = createState();
+		const runId = `steer-dir-${Date.now().toString(36)}`;
+		const asyncDir = createRunningAsync(state, runId, { track: false });
+		try {
+			const result = await executorWithKill(state, () => true)
+				.execute("steer", { action: "steer", dir: asyncDir, message: "Focus on validation." }, new AbortController().signal, undefined, ctx());
+
+			assert.equal(result.isError, undefined);
+			assert.match(text(result), new RegExp(`Steering queued for async run ${runId}`));
+			const requests = consumeSteerRequests(asyncDir);
+			assert.equal(requests.length, 1);
+			assert.equal(requests[0]?.message, "Focus on validation.");
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+
+	it("queues steering for a pending indexed async child", async () => {
+		const state = createState();
+		const runId = `steer-pending-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		writeJson(path.join(asyncDir, "status.json"), {
+			runId,
+			mode: "chain",
+			state: "running",
+			pid: 12345,
+			cwd: os.tmpdir(),
+			startedAt: 100,
+			lastUpdate: Date.now(),
+			steps: [
+				{ agent: "done", status: "complete", startedAt: 100 },
+				{ agent: "later", status: "pending" },
+			],
+		});
+		try {
+			const result = await executorWithKill(state, () => true)
+				.execute("steer", { action: "steer", id: runId, index: 1, message: "Use the new API." }, new AbortController().signal, undefined, ctx());
+
+			assert.equal(result.isError, undefined);
+			const requests = consumeSteerRequests(asyncDir);
+			assert.equal(requests.length, 1);
+			assert.equal(requests[0]?.message, "Use the new API.");
+			assert.equal(requests[0]?.targetIndex, 1);
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+
+	it("interrupts a running async run resolved from disk after in-memory tracking is gone", async () => {
+		const state = createState();
+		const runId = `interrupt-disk-${Date.now().toString(36)}`;
+		const asyncDir = createRunningAsync(state, runId, { track: false });
+		try {
+			const kills: Array<{ pid: number; signal?: NodeJS.Signals | 0 }> = [];
+			const result = await executorWithKill(state, (pid, signal) => {
+				kills.push({ pid, signal });
+				return true;
+			}).execute("interrupt", { action: "interrupt", id: runId }, new AbortController().signal, undefined, ctx());
+
+			assert.equal(result.isError, undefined);
+			assert.match(text(result), new RegExp(`Interrupt requested for async run ${runId}`));
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "interrupt.json")), true);
+			assert.deepEqual(kills, [{ pid: 12345, signal: 0 }, { pid: 12345, signal: process.platform === "win32" ? "SIGBREAK" : "SIGUSR2" }]);
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+
+	it("reports success and writes the portable request when the signal is unavailable", async () => {
+		const state = createState();
+		const runId = `interrupt-enosys-${Date.now().toString(36)}`;
+		const asyncDir = createRunningAsync(state, runId);
+		try {
+			const result = await executorWithKill(state, (_pid, signal) => {
+				if (signal === 0) return true;
+				const error = new Error("kill ENOSYS") as NodeJS.ErrnoException;
+				error.code = "ENOSYS";
+				throw error;
+			}).execute("interrupt", { action: "interrupt", id: runId }, new AbortController().signal, undefined, ctx());
+
+			assert.equal(result.isError, undefined);
+			assert.match(text(result), new RegExp(`Interrupt requested for async run ${runId}`));
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "interrupt.json")), true);
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+
+	it("does not report success for stale running status with a dead pid", async () => {
+		const state = createState();
+		const runId = `interrupt-esrch-${Date.now().toString(36)}`;
+		const asyncDir = createRunningAsync(state, runId);
+		try {
+			const result = await executorWithKill(state, () => {
+				const error = new Error("missing process") as NodeJS.ErrnoException;
+				error.code = "ESRCH";
+				throw error;
+			}).execute("interrupt", { action: "interrupt", id: runId }, new AbortController().signal, undefined, ctx());
+
+			assert.equal(result.isError, true);
+			assert.match(text(result), /No running async run with an interrupt-capable pid/);
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "interrupt.json")), false);
+			const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
+			assert.equal(status.state, "failed");
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+});

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

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import type { AgentConfig } from "../../src/agents/agents.ts";
+import { buildAsyncRunnerSteps } from "../../src/runs/background/async-execution.ts";
+
+function makeAgent(name: string): AgentConfig {
+	return {
+		name,
+		description: `${name} agent`,
+		systemPrompt: "Do work",
+		systemPromptMode: "replace",
+		inheritProjectContext: false,
+		inheritSkills: false,
+		source: "project",
+		filePath: `/tmp/${name}.md`,
+	};
+}
+
+describe("async permission forwarding session identity", () => {
+	it("uses the parent session id for permission forwarding instead of the async status identity", () => {
+		const currentSessionId = path.join("/tmp", "parent-session.jsonl");
+		const built = buildAsyncRunnerSteps("run-abc", {
+			chain: [{ agent: "worker", task: "Do work" }],
+			agents: [makeAgent("worker")],
+			ctx: {
+				pi: {} as never,
+				cwd: "/tmp/project",
+				currentSessionId,
+				parentSessionId: "session-abc123",
+			},
+			maxSubagentDepth: 1,
+			asyncDir: "/tmp/async-run",
+		});
+
+		assert.ok(!("error" in built));
+		const step = built.steps[0];
+		assert.ok(step && !("parallel" in step));
+		assert.equal(step.parentSessionId, "session-abc123");
+	});
+
+	it("consumes bounded dynamic fanout indexes before later static forked steps", () => {
+		const built = buildAsyncRunnerSteps("run-abc", {
+			chain: [
+				{ agent: "source", task: "produce targets", as: "targets" },
+				{
+					expand: { from: { output: "targets", path: "/items" }, maxItems: 2 },
+					parallel: { agent: "reviewer", task: "Review {item.path}" },
+					collect: { as: "reviews" },
+				},
+				{ agent: "worker", task: "Use reviews" },
+			],
+			agents: [makeAgent("source"), makeAgent("reviewer"), { ...makeAgent("worker"), model: "anthropic/claude-sonnet-4-5:high", thinking: "high" }],
+			ctx: {
+				pi: {} as never,
+				cwd: "/tmp/project",
+				currentSessionId: "/tmp/parent-session.jsonl",
+			},
+			sessionFilesByFlatIndex: [undefined, "/tmp/dynamic-0.jsonl", "/tmp/dynamic-1.jsonl", "/tmp/static-worker.jsonl"],
+			thinkingOverridesByFlatIndex: [undefined, "off", "off", "off"],
+			maxSubagentDepth: 1,
+			asyncDir: "/tmp/async-run",
+		});
+
+		assert.ok(!("error" in built));
+		const dynamic = built.steps[1];
+		assert.ok(dynamic && "expand" in dynamic && "collect" in dynamic);
+		assert.deepEqual(dynamic.sessionFiles, ["/tmp/dynamic-0.jsonl", "/tmp/dynamic-1.jsonl"]);
+		assert.deepEqual(dynamic.thinkingOverrides, ["off", "off"]);
+		const staticWorker = built.steps[2];
+		assert.ok(staticWorker && !("parallel" in staticWorker));
+		assert.equal(staticWorker.sessionFile, "/tmp/static-worker.jsonl");
+		assert.equal(staticWorker.model, "anthropic/claude-sonnet-4-5:off");
+		assert.equal(staticWorker.thinking, "off");
+	});
+
+	it("applies thinking overrides to async fallback candidates", () => {
+		const built = buildAsyncRunnerSteps("run-abc", {
+			chain: [{ agent: "worker", task: "Do work" }],
+			agents: [{ ...makeAgent("worker"), model: "openai/gpt-5-mini:high", fallbackModels: ["anthropic/claude-sonnet-4:low"], thinking: "high" }],
+			ctx: {
+				pi: {} as never,
+				cwd: "/tmp/project",
+				currentSessionId: "/tmp/parent-session.jsonl",
+			},
+			thinkingOverridesByFlatIndex: ["off"],
+			maxSubagentDepth: 1,
+			asyncDir: "/tmp/async-run",
+		});
+
+		assert.ok(!("error" in built));
+		const step = built.steps[0];
+		assert.ok(step && !("parallel" in step));
+		assert.equal(step.model, "openai/gpt-5-mini:off");
+		assert.deepEqual(step.modelCandidates, ["openai/gpt-5-mini:off", "anthropic/claude-sonnet-4:off"]);
+		assert.equal(step.thinking, "off");
+	});
+});