@selesai/code 0.3.0 → 0.3.1

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

@@ -0,0 +1,159 @@
+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 { afterEach, beforeEach, describe, it } from "node:test";
+import { waitForImportedAsyncRoot } from "../../src/runs/background/chain-root-attachment.ts";
+
+let tempDir: string;
+
+function writeJson(filePath: string, value: unknown): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+
+function root(runId = "root-run", index = 0) {
+	return {
+		runId,
+		index,
+		asyncDir: path.join(tempDir, runId),
+		resultPath: path.join(tempDir, "results", `${runId}.json`),
+	};
+}
+
+describe("async chain root attachment", () => {
+	beforeEach(() => {
+		tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-chain-root-attachment-"));
+	});
+
+	afterEach(() => {
+		fs.rmSync(tempDir, { recursive: true, force: true });
+	});
+
+	it("imports an already completed async child result", async () => {
+		const importedRoot = root();
+		const sessionFile = path.join(tempDir, "child.jsonl");
+		fs.writeFileSync(sessionFile, "", "utf-8");
+		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
+			runId: importedRoot.runId,
+			mode: "single",
+			state: "complete",
+			startedAt: 1,
+			steps: [{ agent: "worker", status: "complete", sessionFile }],
+		});
+		writeJson(importedRoot.resultPath, {
+			state: "complete",
+			success: true,
+			results: [{ agent: "worker", output: "root output", success: true, sessionFile }],
+		});
+
+		const result = await waitForImportedAsyncRoot(importedRoot, { pollIntervalMs: 1 });
+
+		assert.deepEqual({
+			agent: result.agent,
+			output: result.output,
+			exitCode: result.exitCode,
+			sessionFile: result.sessionFile,
+		}, {
+			agent: "worker",
+			output: "root output",
+			exitCode: 0,
+			sessionFile,
+		});
+	});
+
+	it("waits for a running async child to write its terminal result", async () => {
+		const importedRoot = root();
+		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
+			runId: importedRoot.runId,
+			mode: "single",
+			state: "running",
+			startedAt: 1,
+			steps: [{ agent: "worker", status: "running" }],
+		});
+
+		const waiting = waitForImportedAsyncRoot(importedRoot, { pollIntervalMs: 5 });
+		setTimeout(() => {
+			writeJson(importedRoot.resultPath, {
+				state: "complete",
+				success: true,
+				results: [{ agent: "worker", output: "late root output", success: true }],
+			});
+		}, 20);
+
+		const result = await waiting;
+
+		assert.equal(result.output, "late root output");
+		assert.equal(result.exitCode, 0);
+	});
+
+	it("imports a failed root as a failed first chain step", async () => {
+		const importedRoot = root();
+		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
+			runId: importedRoot.runId,
+			mode: "single",
+			state: "failed",
+			startedAt: 1,
+			error: "root failed",
+			steps: [{ agent: "worker", status: "failed", error: "root failed" }],
+		});
+		writeJson(importedRoot.resultPath, {
+			state: "failed",
+			success: false,
+			summary: "root failed",
+			results: [{ agent: "worker", output: "root failed", error: "root failed", success: false }],
+		});
+
+		const result = await waitForImportedAsyncRoot(importedRoot, { pollIntervalMs: 1 });
+
+		assert.equal(result.exitCode, 1);
+		assert.equal(result.error, "root failed");
+		assert.equal(result.output, "root failed");
+	});
+
+	it("fails a terminal root that never produced a result file", async () => {
+		const importedRoot = root();
+		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
+			runId: importedRoot.runId,
+			mode: "single",
+			state: "complete",
+			startedAt: 1,
+			steps: [{ agent: "worker", status: "complete" }],
+		});
+
+		const result = await waitForImportedAsyncRoot(importedRoot, {
+			pollIntervalMs: 1,
+			terminalResultGraceMs: 0,
+		});
+
+		assert.equal(result.exitCode, 1);
+		assert.match(result.error ?? "", /ended without a result file/);
+	});
+
+	it("stops waiting when the parent timeout aborts an attached root", async () => {
+		const importedRoot = root();
+		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
+			runId: importedRoot.runId,
+			mode: "single",
+			state: "running",
+			startedAt: 1,
+			steps: [{ agent: "worker", status: "running" }],
+		});
+		let timedOut = false;
+		const waiting = waitForImportedAsyncRoot(importedRoot, {
+			pollIntervalMs: 1,
+			shouldAbort: () => timedOut,
+			timeoutMessage: "parent timed out",
+		});
+		setTimeout(() => {
+			timedOut = true;
+		}, 10);
+
+		const result = await waiting;
+
+		assert.equal(result.exitCode, 1);
+		assert.equal(result.timedOut, true);
+		assert.equal(result.error, "parent timed out");
+		assert.equal(result.output, "parent timed out");
+	});
+});

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

@@ -0,0 +1,229 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { parseChain, parseJsonChain, serializeChain, serializeJsonChain } from "../../src/agents/chain-serializer.ts";
+
+const chainContent = `---
+name: review-chain
+description: Review chain
+---
+
+## reviewer
+output: report.md
+outputMode: file-only
+
+Review the diff
+`;
+
+describe("chain serializer", () => {
+	it("round-trips step outputMode", () => {
+		const parsed = parseChain(chainContent, "project", "/tmp/review-chain.md");
+
+		assert.equal(parsed.steps[0]?.outputMode, "file-only");
+		assert.match(serializeChain(parsed), /outputMode: file-only/);
+	});
+
+	it("round-trips phase, label, as, and path-based outputSchema", () => {
+		const parsed = parseChain(`---
+name: review-chain
+description: Review chain
+---
+
+## reviewer
+phase: Review
+label: correctness pass
+as: correctnessFindings
+outputSchema: ./schemas/finding.schema.json
+
+Review the diff
+`, "project", "/tmp/review-chain.md");
+
+		assert.equal(parsed.steps[0]?.phase, "Review");
+		assert.equal(parsed.steps[0]?.label, "correctness pass");
+		assert.equal(parsed.steps[0]?.as, "correctnessFindings");
+		assert.equal(parsed.steps[0]?.outputSchema, "./schemas/finding.schema.json");
+		const serialized = serializeChain(parsed);
+		assert.match(serialized, /phase: Review/);
+		assert.match(serialized, /label: correctness pass/);
+		assert.match(serialized, /as: correctnessFindings/);
+		assert.match(serialized, /outputSchema: \.\/schemas\/finding\.schema\.json/);
+	});
+
+	it("round-trips markdown chain toolBudget", () => {
+		const parsed = parseChain(`---
+name: review-chain
+description: Review chain
+---
+
+## reviewer
+toolBudget: {"soft":3,"hard":5,"block":["read","grep"]}
+
+Review the diff
+`, "project", "/tmp/review-chain.md");
+
+		assert.deepEqual(parsed.steps[0]?.toolBudget, { soft: 3, hard: 5, block: ["read", "grep"] });
+		assert.match(serializeChain(parsed), /toolBudget: \{"soft":3,"hard":5,"block":\["read","grep"\]\}/);
+	});
+
+	it("rejects invalid markdown chain toolBudget", () => {
+		assert.throws(
+			() => parseChain(`---
+name: review-chain
+description: Review chain
+---
+
+## reviewer
+toolBudget: {"soft":6,"hard":5}
+
+Review the diff
+`, "project", "/tmp/review-chain.md"),
+			/toolBudget for step 'reviewer'\.soft must be <= toolBudget for step 'reviewer'\.hard/,
+		);
+	});
+
+	it("rejects inline outputSchema values in markdown chains", () => {
+		assert.throws(
+			() => parseChain(`---
+name: review-chain
+description: Review chain
+---
+
+## reviewer
+outputSchema: {"type":"object"}
+
+Review the diff
+`, "project", "/tmp/review-chain.md"),
+			/Inline outputSchema values are not supported/,
+		);
+	});
+
+	it("rejects invalid dynamic JSON chains with useful diagnostics", () => {
+		assert.throws(
+			() => parseJsonChain(JSON.stringify({
+				name: "bad-dynamic-review",
+				description: "Bad dynamic targets",
+				chain: [
+					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{
+						expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+						parallel: [{ agent: "reviewer", task: "Review" }],
+						collect: { as: "reviews" },
+					},
+				],
+			}), "project", "/tmp/bad-dynamic-review.chain.json"),
+			/static parallel arrays/,
+		);
+		assert.throws(
+			() => parseJsonChain(JSON.stringify({ name: "bad", description: "Bad", chain: [1] }), "project", "/tmp/bad.chain.json"),
+			/step 1 must be an object/,
+		);
+	});
+
+	it("serializes JSON chains back to JSON", () => {
+		const parsed = parseJsonChain(JSON.stringify({
+			name: "dynamic-review",
+			package: "code-analysis",
+			description: "Review dynamic targets",
+			chain: [
+				{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+				{
+					expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
+					parallel: { agent: "reviewer", task: "Review {target.path}", outputSchema: { type: "object" } },
+					collect: { as: "reviews" },
+				},
+			],
+		}), "project", "/tmp/dynamic-review.chain.json");
+
+		const serialized = serializeJsonChain(parsed);
+		assert.doesNotMatch(serialized, /^---/);
+		const reparsed = JSON.parse(serialized) as { name?: string; package?: string; chain?: Array<{ collect?: { as?: string } }> };
+		assert.equal(reparsed.name, "dynamic-review");
+		assert.equal(reparsed.package, "code-analysis");
+		assert.equal(reparsed.chain?.[1]?.collect?.as, "reviews");
+	});
+
+	it("parses declarative JSON chains with dynamic fanout toolBudget", () => {
+		const parsed = parseJsonChain(JSON.stringify({
+			name: "dynamic-review",
+			description: "Review dynamic targets",
+			chain: [
+				{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" }, toolBudget: { hard: 4 } },
+				{
+					expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
+					parallel: { agent: "reviewer", task: "Review {target.path}", outputSchema: { type: "object" }, toolBudget: { soft: 3, hard: 5 } },
+					collect: { as: "reviews" },
+				},
+			],
+		}), "project", "/tmp/dynamic-review.chain.json");
+
+		assert.deepEqual((parsed.steps[0] as { toolBudget?: unknown }).toolBudget, { hard: 4 });
+		assert.deepEqual((parsed.steps[1] as { parallel?: { toolBudget?: unknown } }).parallel?.toolBudget, { soft: 3, hard: 5 });
+	});
+
+	it("rejects invalid JSON chain toolBudget", () => {
+		assert.throws(
+			() => parseJsonChain(JSON.stringify({
+				name: "bad-tool-budget",
+				description: "Bad tool budget",
+				chain: [{ agent: "worker", toolBudget: { hard: 0 } }],
+			}), "project", "/tmp/bad-tool-budget.chain.json"),
+			/step 1 toolBudget\.hard must be an integer >= 1/,
+		);
+		assert.throws(
+			() => parseJsonChain(JSON.stringify({
+				name: "bad-dynamic-tool-budget",
+				description: "Bad dynamic tool budget",
+				chain: [
+					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ expand: { from: { output: "targets", path: "/items" }, maxItems: 4 }, parallel: { agent: "worker", toolBudget: { hard: 3, block: [] } }, collect: { as: "reviews" } },
+				],
+			}), "project", "/tmp/bad-dynamic-tool-budget.chain.json"),
+			/step 2 dynamic template toolBudget\.block must contain at least one tool name/,
+		);
+	});
+
+	it("parses declarative JSON chains with dynamic fanout", () => {
+		const parsed = parseJsonChain(JSON.stringify({
+			name: "dynamic-review",
+			description: "Review dynamic targets",
+			chain: [
+				{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+				{
+					expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
+					parallel: { agent: "reviewer", task: "Review {target.path}", outputSchema: { type: "object" } },
+					collect: { as: "reviews" },
+				},
+			],
+		}), "project", "/tmp/dynamic-review.chain.json");
+
+		assert.equal(parsed.name, "dynamic-review");
+		assert.equal(parsed.steps.length, 2);
+		assert.deepEqual((parsed.steps[1] as { collect?: { as?: string } }).collect, { as: "reviews" });
+		assert.deepEqual((parsed.steps[0] as { outputSchema?: unknown }).outputSchema, { type: "object" });
+	});
+
+	it("parses and validates acceptance in JSON chains", () => {
+		const parsed = parseJsonChain(JSON.stringify({
+			name: "accepted-chain",
+			description: "Chain with acceptance gates",
+			chain: [
+				{ agent: "worker", task: "Fix bug", acceptance: { level: "checked", evidence: ["changed-files", "commands-run"] } },
+				{
+					parallel: [
+						{ agent: "reviewer", task: "Review", acceptance: "attested" },
+					],
+				},
+			],
+		}), "project", "/tmp/accepted-chain.chain.json");
+
+		assert.deepEqual((parsed.steps[0] as { acceptance?: unknown }).acceptance, { level: "checked", evidence: ["changed-files", "commands-run"] });
+		assert.equal(((parsed.steps[1] as { parallel?: Array<{ acceptance?: unknown }> }).parallel?.[0]?.acceptance), "attested");
+		assert.throws(
+			() => parseJsonChain(JSON.stringify({
+				name: "bad-acceptance",
+				description: "Bad acceptance",
+				chain: [{ agent: "worker", acceptance: { level: "none" } }],
+			}), "project", "/tmp/bad-acceptance.chain.json"),
+			/step 1 acceptance\.reason is required/,
+		);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/child-transcript.test.ts

@@ -0,0 +1,225 @@
+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 { createChildTranscriptWriter, CHILD_TRANSCRIPT_ARTIFACT_VERSION } from "../../src/shared/child-transcript.ts";
+
+function tmpDir(): string {
+	return fs.mkdtempSync(path.join(os.tmpdir(), "child-transcript-test-"));
+}
+
+function readRecords(file: string): Record<string, unknown>[] {
+	return fs.readFileSync(file, "utf-8").trim().split("\n").filter(Boolean).map((line) => JSON.parse(line) as Record<string, unknown>);
+}
+
+describe("createChildTranscriptWriter", () => {
+	it("writes a versioned initial user message record with run metadata", () => {
+		const dir = tmpDir();
+		const transcriptPath = path.join(dir, "out", "run-1_worker_transcript.jsonl");
+		const writer = createChildTranscriptWriter({
+			transcriptPath,
+			source: "foreground",
+			runId: "run-1",
+			agent: "worker",
+			childIndex: 0,
+			cwd: "/repo",
+		});
+		writer.writeInitialUserMessage("do the thing");
+
+		assert.equal(writer.getError(), undefined);
+		const records = readRecords(transcriptPath);
+		assert.equal(records.length, 1);
+		const record = records[0]!;
+		assert.equal(record.version, CHILD_TRANSCRIPT_ARTIFACT_VERSION);
+		assert.equal(record.recordType, "message");
+		assert.equal(record.source, "foreground");
+		assert.equal(record.runId, "run-1");
+		assert.equal(record.agent, "worker");
+		assert.equal(record.childIndex, 0);
+		assert.equal(record.cwd, "/repo");
+		assert.equal(record.sourceEventType, "initial_prompt");
+		assert.equal(record.role, "user");
+		assert.equal(record.text, "do the thing");
+		assert.equal(typeof record.ts, "number");
+		assert.equal(typeof record.timestamp, "string");
+	});
+
+	it("omits childIndex when not provided", () => {
+		const dir = tmpDir();
+		const transcriptPath = path.join(dir, "run_transcript.jsonl");
+		const writer = createChildTranscriptWriter({
+			transcriptPath,
+			source: "async",
+			runId: "run-2",
+			agent: "reviewer",
+			cwd: "/repo",
+		});
+		writer.writeInitialUserMessage("review it");
+		const record = readRecords(transcriptPath)[0]!;
+		assert.equal(Object.prototype.hasOwnProperty.call(record, "childIndex"), false);
+		assert.equal(record.source, "async");
+	});
+
+	it("writes message records for message_end and tool_result_end events", () => {
+		const dir = tmpDir();
+		const transcriptPath = path.join(dir, "transcript.jsonl");
+		const writer = createChildTranscriptWriter({
+			transcriptPath,
+			source: "async",
+			runId: "run-3",
+			agent: "worker",
+			childIndex: 1,
+			cwd: "/repo",
+		});
+		writer.writeChildEvent({
+			type: "message_end",
+			message: {
+				role: "assistant",
+				content: [{ type: "text", text: "all done" }],
+				model: "gpt-5.5",
+				stopReason: "end_turn",
+				usage: { input: 10, output: 5, cost: { total: 0.01 } },
+			},
+		});
+		writer.writeChildEvent({
+			type: "tool_result_end",
+			message: { role: "toolResult", toolName: "bash", content: [{ type: "text", text: "ok" }] },
+		});
+
+		const records = readRecords(transcriptPath);
+		assert.equal(records.length, 2);
+		assert.equal(records[0]!.recordType, "message");
+		assert.equal(records[0]!.sourceEventType, "message_end");
+		assert.equal(records[0]!.role, "assistant");
+		assert.equal(records[0]!.text, "all done");
+		assert.equal(records[0]!.model, "gpt-5.5");
+		assert.equal(records[0]!.stopReason, "end_turn");
+		assert.deepEqual(records[0]!.usage, { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, cost: 0.01 });
+		assert.equal(records[1]!.recordType, "message");
+		assert.equal(records[1]!.sourceEventType, "tool_result_end");
+		assert.equal(records[1]!.role, "toolResult");
+	});
+
+	it("writes tool_start and tool_end records and ignores unhandled event types", () => {
+		const dir = tmpDir();
+		const transcriptPath = path.join(dir, "transcript.jsonl");
+		const writer = createChildTranscriptWriter({
+			transcriptPath,
+			source: "foreground",
+			runId: "run-4",
+			agent: "worker",
+			cwd: "/repo",
+		});
+		writer.writeChildEvent({ type: "tool_execution_start", toolName: "bash", args: { command: "ls" } });
+		writer.writeChildEvent({ type: "tool_execution_start", toolName: "read" });
+		writer.writeChildEvent({ type: "tool_execution_end", toolName: "bash" });
+		writer.writeChildEvent({ type: "some_unhandled_event" });
+
+		const records = readRecords(transcriptPath);
+		assert.equal(records.length, 3);
+		assert.equal(records[0]!.recordType, "tool_start");
+		assert.equal(records[0]!.sourceEventType, "tool_execution_start");
+		assert.equal(records[0]!.toolName, "bash");
+		assert.equal(typeof records[0]!.argsPreview, "string");
+		assert.ok(String(records[0]!.argsPreview).length > 0);
+		assert.equal(records[1]!.recordType, "tool_start");
+		assert.equal(Object.prototype.hasOwnProperty.call(records[1]!, "argsPreview"), false);
+		assert.equal(records[2]!.recordType, "tool_end");
+		assert.equal(records[2]!.toolName, "bash");
+	});
+
+	it("skips blank stdout/stderr lines and splits multi-line stderr text", () => {
+		const dir = tmpDir();
+		const transcriptPath = path.join(dir, "transcript.jsonl");
+		const writer = createChildTranscriptWriter({
+			transcriptPath,
+			source: "async",
+			runId: "run-5",
+			agent: "worker",
+			cwd: "/repo",
+		});
+		writer.writeStdoutLine("first line");
+		writer.writeStdoutLine("   ");
+		writer.writeStderrText("warn one\nwarn two\n\n");
+
+		const records = readRecords(transcriptPath);
+		assert.equal(records.length, 3);
+		assert.equal(records[0]!.recordType, "stdout");
+		assert.equal(records[0]!.text, "first line");
+		assert.equal(records[1]!.recordType, "stderr");
+		assert.equal(records[1]!.text, "warn one");
+		assert.equal(records[2]!.recordType, "stderr");
+		assert.equal(records[2]!.text, "warn two");
+	});
+
+	it("truncates after the byte cap and stops writing further records without erroring", () => {
+		const dir = tmpDir();
+		const transcriptPath = path.join(dir, "transcript.jsonl");
+		const writer = createChildTranscriptWriter({
+			transcriptPath,
+			source: "foreground",
+			runId: "run-6",
+			agent: "worker",
+			cwd: "/repo",
+			maxBytes: 900,
+		});
+		writer.writeInitialUserMessage("seed record that fits within the cap");
+		// This single line exceeds the remaining budget and triggers truncation.
+		writer.writeStdoutLine("x".repeat(5_000));
+		// Further writes must be no-ops.
+		writer.writeStdoutLine("after truncation");
+
+		assert.equal(writer.getError(), undefined);
+		const records = readRecords(transcriptPath);
+		const types = records.map((r) => r.recordType);
+		assert.ok(types.includes("message"), "seed message should be present");
+		assert.ok(types.includes("truncated"), "a truncated marker should be recorded");
+		assert.ok(!types.includes("stdout"), "no stdout records should be written once truncated");
+	});
+
+	it("reserves space for a truncation marker before accepting another record", () => {
+		const dir = tmpDir();
+		const transcriptPath = path.join(dir, "transcript.jsonl");
+		const writer = createChildTranscriptWriter({
+			transcriptPath,
+			source: "foreground",
+			runId: "r",
+			agent: "a",
+			cwd: "/repo",
+			maxBytes: 420,
+		});
+		writer.writeStdoutLine("a");
+		writer.writeStdoutLine("b");
+		writer.writeStdoutLine("after truncation");
+
+		assert.equal(writer.getError(), undefined);
+		const records = readRecords(transcriptPath);
+		assert.deepEqual(records.map((record) => record.recordType), ["stdout", "truncated"]);
+		assert.equal(records[0]!.text, "a");
+		assert.equal(records[1]!.maxBytes, 420);
+		assert.ok(fs.statSync(transcriptPath).size <= 420);
+	});
+
+	it("reports an init error and drops subsequent writes when the transcript path cannot be created", () => {
+		const dir = tmpDir();
+		// Precreate a regular file where a directory is expected so mkdirSync fails deterministically.
+		const blocker = path.join(dir, "blocker-file");
+		fs.writeFileSync(blocker, "blocks the transcript dir", "utf-8");
+		const transcriptPath = path.join(blocker, "transcript.jsonl");
+
+		const writer = createChildTranscriptWriter({
+			transcriptPath,
+			source: "foreground",
+			runId: "run-7",
+			agent: "worker",
+			cwd: "/repo",
+		});
+		writer.writeInitialUserMessage("should not be written");
+
+		const error = writer.getError();
+		assert.ok(typeof error === "string" && error.length > 0, "an init error should be reported");
+		assert.ok(error.includes(transcriptPath) || error.includes("blocker-file"), "error should reference the transcript path");
+		assert.equal(fs.existsSync(transcriptPath), false);
+	});
+});