@selesai/code 0.5.19 → 0.5.21

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

@@ -0,0 +1,326 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, it } from "node:test";
+import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../../src/runs/shared/pi-args.ts";
+import { WAIT_TOOL_ENABLED_ENV } from "../../src/runs/background/subagent-wait.ts";
+
+type JsonSchemaNode = Record<string, unknown>;
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+function parentToolEnv(): NodeJS.ProcessEnv {
+	const env = { ...process.env };
+	delete env[SUBAGENT_CHILD_ENV];
+	delete env[SUBAGENT_FANOUT_CHILD_ENV];
+	delete env[WAIT_TOOL_ENABLED_ENV];
+	return env;
+}
+
+function missingPackageName(error: unknown): string | undefined {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.match(/Cannot find package ['"]([^'"]+)['"]/i)?.[1];
+}
+
+let validateChainInput: (args: unknown) => void = () => {};
+let validateSubagentParams: (args: unknown) => boolean = () => true;
+let chainItemProperties: Record<string, unknown> | undefined;
+let dynamicTemplateProperties: Record<string, unknown> | undefined;
+let schemasAvailable = true;
+try {
+	const mod = await import("../../src/extension/chain-validation.ts") as {
+		validateChainInput: (args: unknown) => void;
+		CHAIN_STEP_KEYS: string[];
+		PARALLEL_TASK_KEYS: string[];
+		DYNAMIC_TEMPLATE_KEYS: string[];
+	};
+	validateChainInput = mod.validateChainInput;
+	const schemas = await import("../../src/extension/schemas.ts") as {
+		ChainItem: JsonSchemaNode;
+		DynamicParallelTemplateSchema: JsonSchemaNode;
+		SubagentParams: JsonSchemaNode;
+	};
+	const { Compile } = await import("typebox/compile") as unknown as {
+		Compile: (schema: JsonSchemaNode) => { Check(value: unknown): boolean };
+	};
+	const subagentParamsValidator = Compile(schemas.SubagentParams);
+	validateSubagentParams = (args) => subagentParamsValidator.Check(args);
+	chainItemProperties = schemas.ChainItem.properties as Record<string, unknown> | undefined;
+	dynamicTemplateProperties = schemas.DynamicParallelTemplateSchema.properties as Record<string, unknown> | undefined;
+} catch (error) {
+	if (missingPackageName(error) !== "typebox") throw error;
+	schemasAvailable = false;
+}
+
+function expectInvalid(args: unknown, ...patterns: RegExp[]): void {
+	assert.throws(
+		() => validateChainInput(args),
+		(error) => {
+			assert.ok(error instanceof Error, "validation should throw an Error");
+			const message = error.message;
+			for (const pattern of patterns) {
+				assert.match(message, pattern, `expected message to match ${pattern}; got: ${message}`);
+			}
+			return true;
+		},
+		`expected validation to fail for ${JSON.stringify(args)}`,
+	);
+}
+
+describe("chain input validation", { skip: !schemasAvailable ? "typebox not available" : undefined }, () => {
+	it("is a no-op when chain is absent or not an array", () => {
+		assert.doesNotThrow(() => validateChainInput({}));
+		assert.doesNotThrow(() => validateChainInput({ agent: "worker", task: "do X" }));
+		assert.doesNotThrow(() => validateChainInput({ chain: "not-an-array" }));
+		assert.doesNotThrow(() => validateChainInput({ action: "status" }));
+		assert.doesNotThrow(() => validateChainInput(undefined));
+		assert.doesNotThrow(() => validateChainInput(null));
+	});
+
+	it("accepts valid chain steps without throwing", () => {
+		assert.doesNotThrow(() => validateChainInput({ chain: [{ agent: "worker", task: "do X" }] }));
+		assert.doesNotThrow(() =>
+			validateChainInput({ chain: [{ agent: "worker", task: "do X", parallel: [{ agent: "reviewer", task: "review" }] }] }),
+		);
+		assert.doesNotThrow(() =>
+			validateChainInput({
+				chain: [{
+					expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+					parallel: { agent: "reviewer", task: "Review {item.path}" },
+					collect: { as: "reviews" },
+				}],
+			}),
+		);
+	});
+
+	it("names the disallowed property and lists allowed properties for a chain step", () => {
+		expectInvalid(
+			{ chain: [{ agent: "worker", task: "do X", bogus: true }] },
+			/chain\[0\]/,
+			/"bogus" is not allowed/,
+			/Allowed properties:/,
+			/Example:/,
+		);
+	});
+
+	it("lists every allowed chain step property from the schema", () => {
+		const allowed = Object.keys(chainItemProperties ?? {});
+		assert.ok(allowed.includes("agent"));
+		assert.ok(allowed.includes("parallel"));
+		assert.ok(allowed.includes("expand"));
+		try {
+			validateChainInput({ chain: [{ notReal: 1 }] });
+			assert.fail("should have thrown");
+		} catch (error) {
+			assert.ok(error instanceof Error);
+			for (const key of allowed) {
+				assert.match(error.message, new RegExp(`\\b${key}\\b`), `allowed key ${key} should appear in message: ${error.message}`);
+			}
+		}
+	});
+
+	it("reports multiple disallowed properties at once", () => {
+		expectInvalid(
+			{ chain: [{ agent: "worker", foo: 1, bar: 2 }] },
+			/chain\[0\]/,
+			/"foo"/,
+			/"bar"/,
+		);
+	});
+
+	it("explains expected shape when a chain step is not an object", () => {
+		expectInvalid(
+			{ chain: ["not-an-object"] },
+			/chain\[0\]/,
+			/expected an object/,
+			/string/,
+			/Allowed properties:/,
+			/Example:/,
+		);
+		expectInvalid(
+			{ chain: [42] },
+			/chain\[0\]/,
+			/expected an object/,
+			/number/,
+		);
+	});
+
+	it("preserves static parallel extra properties accepted by the TypeBox schema", () => {
+		const args = { chain: [{ parallel: [{ agent: "worker", extensionField: true }] }] };
+		assert.equal(validateSubagentParams(args), true);
+		assert.doesNotThrow(() => validateChainInput(args));
+	});
+
+	it("names disallowed properties on a dynamic fanout template", () => {
+		expectInvalid(
+			{
+				chain: [{
+					expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
+					parallel: { agent: "worker", bogus: true },
+					collect: { as: "reviews" },
+				}],
+			},
+			/chain\[0\]\.parallel/,
+			/"bogus" is not allowed/,
+			/Allowed properties:/,
+		);
+	});
+
+	it("lists every allowed dynamic template property from the schema", () => {
+		const allowed = Object.keys(dynamicTemplateProperties ?? {});
+		assert.ok(allowed.includes("agent"));
+		assert.ok(allowed.includes("outputSchema"));
+		try {
+			validateChainInput({
+				chain: [{
+					expand: { from: { output: "x", path: "/items" }, maxItems: 4 },
+					parallel: { notReal: 1 },
+					collect: { as: "reviews" },
+				}],
+			});
+			assert.fail("should have thrown");
+		} catch (error) {
+			assert.ok(error instanceof Error);
+			for (const key of allowed) {
+				assert.match(error.message, new RegExp(`\\b${key}\\b`), `allowed key ${key} should appear: ${error.message}`);
+			}
+		}
+	});
+
+	it("guides the agent when parallel is neither an array nor an object", () => {
+		expectInvalid(
+			{ chain: [{ parallel: "nope" }] },
+			/chain\[0\]\.parallel/,
+			/expected an array of task objects or a dynamic fanout template object/,
+			/string/,
+		);
+	});
+
+	it("names disallowed properties on expand", () => {
+		expectInvalid(
+			{
+				chain: [{
+					expand: { from: { output: "x", path: "/items" }, maxItems: 4, bogus: true },
+					parallel: { agent: "worker" },
+					collect: { as: "reviews" },
+				}],
+			},
+			/chain\[0\]\.expand/,
+			/"bogus" is not allowed/,
+			/Allowed properties:/,
+		);
+	});
+
+	it("names disallowed properties on expand.from", () => {
+		expectInvalid(
+			{
+				chain: [{
+					expand: { from: { output: "x", path: "/items", bogus: true }, maxItems: 4 },
+					parallel: { agent: "worker" },
+					collect: { as: "reviews" },
+				}],
+			},
+			/chain\[0\]\.expand\.from/,
+			/"bogus" is not allowed/,
+			/Allowed properties:/,
+		);
+	});
+
+	it("names disallowed properties on collect", () => {
+		expectInvalid(
+			{
+				chain: [{
+					expand: { from: { output: "x", path: "/items" }, maxItems: 4 },
+					parallel: { agent: "worker" },
+					collect: { as: "reviews", bogus: true },
+				}],
+			},
+			/chain\[0\]\.collect/,
+			/"bogus" is not allowed/,
+			/Allowed properties:/,
+		);
+	});
+
+	it("reports the correct chain index for multi-step chains", () => {
+		expectInvalid(
+			{ chain: [{ agent: "worker", task: "ok" }, { agent: "worker", bogus: true }] },
+			/chain\[1\]/,
+			/"bogus" is not allowed/,
+		);
+	});
+});
+
+describe("registered subagent tool prepareArguments", { skip: !schemasAvailable ? "typebox not available" : undefined }, () => {
+	function runPrepare(args: unknown): { error?: string; ok: true } | { error: string; ok: false } {
+		const script = String.raw`
+			import registerSubagentExtension from "./src/extension/index.ts";
+			const events = { on() { return () => {}; }, emit() {} };
+			let registeredTool;
+			const fakePi = new Proxy({
+				events,
+				registerTool(tool) { if (tool.name === "subagent") registeredTool = tool; },
+				registerCommand() {},
+				registerShortcut() {},
+				registerMessageRenderer() {},
+				sendMessage() {},
+				getSessionName() { return undefined; },
+			}, {
+				get(target, prop) {
+					if (prop in target) return target[prop];
+					return () => undefined;
+				},
+			});
+			registerSubagentExtension(fakePi);
+			if (!registeredTool) throw new Error("tool not registered");
+			if (typeof registeredTool.prepareArguments !== "function") throw new Error("prepareArguments not attached");
+			const args = JSON.parse(process.argv[process.argv.length - 1] ?? "{}");
+			try {
+				registeredTool.prepareArguments(args);
+				process.stdout.write(JSON.stringify({ ok: true }));
+			} catch (error) {
+				process.stdout.write(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+			}
+		`;
+		const output = execFileSync(
+			process.execPath,
+			[
+				"--experimental-transform-types",
+				"--import",
+				"./test/support/register-loader.mjs",
+				"--input-type=module",
+				"--eval",
+				script,
+				"--",
+				JSON.stringify(args),
+			],
+			{ cwd: projectRoot, env: parentToolEnv(), encoding: "utf-8", stdio: "pipe" },
+		);
+		return JSON.parse(output) as { error?: string; ok: boolean };
+	}
+
+	it("throws a friendly chain error before schema validation when a step has a disallowed property", () => {
+		const result = runPrepare({ chain: [{ agent: "worker", task: "do X", bogus: true }] });
+		assert.equal(result.ok, false);
+		assert.match(result.error ?? "", /chain\[0\]/);
+		assert.match(result.error ?? "", /"bogus" is not allowed/);
+		assert.match(result.error ?? "", /Allowed properties:/);
+		assert.match(result.error ?? "", /Example:/);
+	});
+
+	it("passes valid chain arguments through unchanged", () => {
+		const result = runPrepare({ chain: [{ agent: "worker", task: "do X" }] });
+		assert.equal(result.ok, true);
+	});
+
+	it("preserves static parallel extra properties accepted by the registered schema", () => {
+		const result = runPrepare({ chain: [{ parallel: [{ agent: "worker", extensionField: true }] }] });
+		assert.equal(result.ok, true);
+	});
+
+	it("is a no-op for management actions and single/parallel calls", () => {
+		assert.equal(runPrepare({ action: "status" }).ok, true);
+		assert.equal(runPrepare({ agent: "worker", task: "do X" }).ok, true);
+		assert.equal(runPrepare({ tasks: [{ agent: "worker", task: "do X" }] }).ok, true);
+	});
+});

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

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import { Buffer } from "node:buffer";
+import { describe, it } from "node:test";
+import {
+	createBoundedByteTail,
+	createBoundedLineReader,
+	formatProtocolOutputLimit,
+	MAX_CHILD_PENDING_LINE_BYTES,
+	projectChildLifecycle,
+	type ProtocolOutputLimit,
+} from "../../src/runs/shared/child-protocol.ts";
+
+describe("bounded child protocol reader", () => {
+	it("reassembles fragmented lines and flushes a final unterminated line", () => {
+		const lines: string[] = [];
+		const reader = createBoundedLineReader({ maxPendingLineBytes: 100, onLine: (line) => lines.push(line), onLimit: () => assert.fail("unexpected limit") });
+		reader.push('{"type":"message');
+		reader.push('_end"}\n{"type":"agent_settled"}');
+		reader.end();
+		assert.deepEqual(lines, ['{"type":"message_end"}', '{"type":"agent_settled"}']);
+	});
+
+	it("preserves UTF-8 characters split across byte chunks", () => {
+		const lines: string[] = [];
+		const bytes = Buffer.from('{"text":"你好"}\n');
+		const split = bytes.indexOf(Buffer.from("你")) + 1;
+		const reader = createBoundedLineReader({ maxPendingLineBytes: 100, onLine: (line) => lines.push(line), onLimit: () => assert.fail("unexpected limit") });
+		reader.push(bytes.subarray(0, split));
+		reader.push(bytes.subarray(split));
+		reader.end();
+		assert.deepEqual(lines, ['{"text":"你好"}']);
+	});
+
+	it("accepts Pi-sized image payload lines by default", () => {
+		const lines: string[] = [];
+		const reader = createBoundedLineReader({ onLine: (line) => lines.push(line), onLimit: () => assert.fail("unexpected limit") });
+		const imageSizedLine = "x".repeat(5 * 1024 * 1024);
+		reader.push(imageSizedLine);
+		reader.push("\n");
+		reader.end();
+		assert.equal(MAX_CHILD_PENDING_LINE_BYTES, 16 * 1024 * 1024);
+		assert.equal(lines.length, 1);
+		assert.equal(lines[0]?.length, imageSizedLine.length);
+	});
+
+	it("stops buffering an oversized line and returns bounded diagnostics", () => {
+		let failure: ProtocolOutputLimit | undefined;
+		const reader = createBoundedLineReader({ maxPendingLineBytes: 8, onLine: () => assert.fail("oversized line must not emit"), onLimit: (limit) => { failure = limit; } });
+		reader.push("prefix-");
+		reader.push("oversized-tail");
+		reader.push("ignored");
+		reader.end();
+		assert.equal(reader.exceeded(), true);
+		assert.equal(failure?.code, "protocol_output_limit");
+		assert.equal(failure?.limitBytes, 8);
+		assert.equal(failure?.observedBytes, 21);
+		assert.match(failure?.diagnosticPrefix ?? "", /^prefix-/);
+		assert.match(failure?.diagnosticTail ?? "", /tail$/);
+		assert.match(formatProtocolOutputLimit(failure!), /protocol_output_limit.*exceeded 8 bytes/);
+	});
+});
+
+describe("bounded child stderr tail", () => {
+	it("keeps only the configured UTF-8-safe byte tail", () => {
+		const tail = createBoundedByteTail(8);
+		const bytes = Buffer.from("old-你好-tail");
+		tail.push(bytes.subarray(0, 7));
+		tail.push(bytes.subarray(7));
+		assert.ok(tail.byteLength() <= 8);
+		assert.equal(tail.text(), "好-tail");
+	});
+});
+
+describe("child lifecycle projection", () => {
+	it("cancels legacy drain for retries and starts it when settled", () => {
+		assert.equal(projectChildLifecycle({ type: "message_end" }, true), "start-drain");
+		assert.equal(projectChildLifecycle({ type: "agent_end", willRetry: true }), "cancel-drain");
+		assert.equal(projectChildLifecycle({ type: "agent_end", willRetry: false }), "none");
+		assert.equal(projectChildLifecycle({ type: "agent_settled" }), "start-drain");
+		assert.equal(projectChildLifecycle({ type: "tool_execution_start" }), "none");
+	});
+});

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

@@ -84,7 +84,7 @@ describe("createChildTranscriptWriter", () => {
 		});
 		writer.writeChildEvent({
 			type: "tool_result_end",
-			message: { role: "toolResult", toolName: "bash", content: [{ type: "text", text: "ok" }] },
+			message: { role: "toolResult", toolCallId: "call-1", toolName: "bash", content: [{ type: "text", text: "ok" }], isError: false },
 		});
 
 		const records = readRecords(transcriptPath);
@@ -99,6 +99,17 @@ describe("createChildTranscriptWriter", () => {
 		assert.equal(records[1]!.recordType, "message");
 		assert.equal(records[1]!.sourceEventType, "tool_result_end");
 		assert.equal(records[1]!.role, "toolResult");
+		assert.equal(records[1]!.toolCallId, "call-1");
+		assert.equal(records[1]!.toolName, "bash");
+		assert.equal(records[1]!.isError, false);
+		assert.equal(records[1]!.text, "ok");
+		assert.deepEqual(records[1]!.message, {
+			role: "toolResult",
+			toolCallId: "call-1",
+			toolName: "bash",
+			isError: false,
+			content: [{ type: "text", text: "ok" }],
+		});
 	});
 
 	it("writes tool_start and tool_end records and ignores unhandled event types", () => {
@@ -111,22 +122,53 @@ describe("createChildTranscriptWriter", () => {
 			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: "tool_execution_start", toolCallId: "call-1", toolName: "bash", args: { command: "ls" } });
+		writer.writeChildEvent({ type: "tool_execution_start", toolCallId: "call-2", toolName: "read" });
+		writer.writeChildEvent({ type: "tool_execution_end", toolCallId: "call-1", toolName: "bash", isError: false });
 		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]!.toolCallId, "call-1");
 		assert.equal(records[0]!.toolName, "bash");
 		assert.equal(typeof records[0]!.argsPreview, "string");
 		assert.ok(String(records[0]!.argsPreview).length > 0);
+		assert.equal(records[0]!.argsPayload, JSON.stringify({ command: "ls" }, null, 2));
 		assert.equal(records[1]!.recordType, "tool_start");
+		assert.equal(records[1]!.toolCallId, "call-2");
 		assert.equal(Object.prototype.hasOwnProperty.call(records[1]!, "argsPreview"), false);
 		assert.equal(records[2]!.recordType, "tool_end");
+		assert.equal(records[2]!.toolCallId, "call-1");
 		assert.equal(records[2]!.toolName, "bash");
+		assert.equal(records[2]!.isError, false);
+	});
+
+	it("bounds persisted tool arguments and successful output", () => {
+		const dir = tmpDir();
+		const transcriptPath = path.join(dir, "transcript.jsonl");
+		const writer = createChildTranscriptWriter({
+			transcriptPath,
+			source: "foreground",
+			runId: "run-bounded",
+			agent: "worker",
+			cwd: "/repo",
+		});
+		writer.writeChildEvent({ type: "tool_execution_start", toolCallId: "large", toolName: "bash", args: { command: "🧪".repeat(10_000) } });
+		writer.writeChildEvent({
+			type: "tool_result_end",
+			message: { role: "toolResult", toolCallId: "large", toolName: "bash", content: [{ type: "text", text: "🧪".repeat(10_000) }], isError: false },
+		});
+
+		const records = readRecords(transcriptPath);
+		assert.ok(Buffer.byteLength(String(records[0]!.argsPayload), "utf-8") <= 32 * 1024);
+		assert.match(String(records[0]!.argsPayload), /… payload truncated$/);
+		assert.doesNotMatch(String(records[0]!.argsPayload), /�/);
+		assert.ok(Buffer.byteLength(String(records[1]!.text), "utf-8") <= 32 * 1024);
+		assert.match(String(records[1]!.text), /… payload truncated$/);
+		assert.doesNotMatch(String(records[1]!.text), /�/);
+		assert.equal(records[1]!.outputTruncated, true);
 	});
 
 	it("skips blank stdout/stderr lines and splits multi-line stderr text", () => {

package/dist/extensions/pi-subagents/test/unit/completion-batcher.test.ts

@@ -170,7 +170,9 @@ describe("createCompletionBatcher", () => {
 		});
 
 		batcher.push(item("a"));
-		batcher.dispose();
+		const abandoned = batcher.dispose();
+		assert.deepEqual(abandoned.map((entry) => entry.label), ["a"]);
+		assert.deepEqual(batcher.dispose(), []);
 		assert.deepEqual(emitted, []);
 		assert.equal(clock.pendingCount(), 0);
 		clock.advance(1000);

package/dist/extensions/pi-subagents/test/unit/completion-dedupe.test.ts

@@ -1,17 +1,19 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "../../src/runs/background/completion-dedupe.ts";
+import { buildCompletionKey, markSeenWithTtl } from "../../src/runs/background/completion-dedupe.ts";
 
 describe("buildCompletionKey", () => {
-	it("uses id as canonical key when present", () => {
-		const key = buildCompletionKey({ id: "run-123", agent: "reviewer", timestamp: 123 }, "fallback");
-		assert.equal(key, "id:run-123");
+	it("scopes ids to their owning session", () => {
+		const first = buildCompletionKey({ id: "run-123", sessionId: "session-a" }, "fallback");
+		const second = buildCompletionKey({ id: "run-123", sessionId: "session-b" }, "fallback");
+		assert.equal(first, "session:session-a:id:run-123");
+		assert.notEqual(first, second);
 	});
 
 	it("builds deterministic fallback key when id is missing", () => {
-		const a = buildCompletionKey({ agent: "reviewer", timestamp: 123, taskIndex: 1, totalTasks: 2, success: true }, "x");
-		const b = buildCompletionKey({ agent: "reviewer", timestamp: 123, taskIndex: 1, totalTasks: 2, success: true }, "x");
-		assert.equal(a, b);
+		const first = buildCompletionKey({ agent: "reviewer", timestamp: 123, taskIndex: 1, totalTasks: 2, success: true }, "x");
+		const second = buildCompletionKey({ agent: "reviewer", timestamp: 123, taskIndex: 1, totalTasks: 2, success: true }, "x");
+		assert.equal(first, second);
 	});
 });
 
@@ -24,13 +26,3 @@ describe("markSeenWithTtl", () => {
 		assert.equal(markSeenWithTtl(seen, "k", 1201, ttlMs), false);
 	});
 });
-
-describe("getGlobalSeenMap", () => {
-	it("returns the same map for the same global store key", () => {
-		const a = getGlobalSeenMap("__test_seen_key__");
-		a.set("x", 1);
-		const b = getGlobalSeenMap("__test_seen_key__");
-		assert.equal(b.get("x"), 1);
-		assert.equal(a, b);
-	});
-});