@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/unit/scripted-workflow.test.ts

@@ -98,6 +98,68 @@ describe("scripted workflow runtime", () => {
 		assert.deepEqual(validateWorkflowScript(`return runs.run("same", { agent: selectedAgent });`), { ok: true, errors: [] });
 	});
 
+	it("reports literal child baseRef policy errors with source locations offline", () => {
+		for (const [call, value] of [
+			["run", JSON.stringify("a".repeat(40))],
+			["run", JSON.stringify("A".repeat(64))],
+			["all", JSON.stringify("A".repeat(40))],
+			["all", "`" + "a".repeat(64) + "`"],
+			["run", '"HEAD~1"'],
+			["all", '"refs/heads/bad..ref"'],
+			["run", "null"],
+			["all", "42"],
+			["run", "false"],
+		]) {
+			const script = [
+				call === "run" ? 'return runs.run("child", {' : "return runs.all([{",
+				'  key: "child", agent: "worker", task: "Check",',
+				`  baseRef: ${value}`,
+				call === "run" ? "});" : "}]);",
+			].join("\n");
+			const result = validateWorkflowScript(script);
+			assert.equal(result.ok, false, script);
+			assert.equal(result.errors.length, 1, script);
+			assert.equal(result.errors[0]?.line, 3);
+			assert.equal(result.errors[0]?.column, 12);
+			assert.match(result.errors[0]!.message, new RegExp(`runs\\.${call}.*baseRef`));
+			assert.match(result.errors[0]!.message, /HEAD.*named ref.*40\/64-character commit IDs.*revision expressions.*unsupported/);
+		}
+	});
+
+	it("validates only the final statically known child baseRef without guessing overwrites", () => {
+		for (const fields of [
+			"",
+			'baseRef: "HEAD"',
+			'baseRef: "refs/heads/release"',
+			'baseRef: "refs/tags/v1"',
+			'baseRef: "origin/main"',
+			'baseRef: "HEAD~1", baseRef: "HEAD"',
+			'baseRef: "HEAD~1", ["baseRef"]: `HEAD`',
+			'baseRef: "HEAD~1", baseRef: selectedRef',
+			'baseRef: "HEAD~1", baseRef: "refs/heads/" + branch',
+			'baseRef: "HEAD~1", ...overrides',
+			'baseRef: "HEAD~1", [field]: "HEAD"',
+			'baseRef: "HEAD~1", get baseRef() { return "HEAD"; }',
+			'baseRef: "HEAD~1", set baseRef(value) {}',
+		]) {
+			for (const script of [
+				`return runs.run("child", { agent: "worker", task: "Check", ${fields} });`,
+				`return runs.all([{ key: "child", agent: "worker", task: "Check", ${fields} }]);`,
+			]) assert.deepEqual(validateWorkflowScript(script), { ok: true, errors: [] }, script);
+		}
+		for (const fields of [
+			'baseRef: "HEAD", baseRef: "HEAD~1"',
+			'...defaults, baseRef: "HEAD~1"',
+			'[field]: "HEAD", ["baseRef"]: "HEAD~1"',
+			'get baseRef() { return "HEAD"; }, baseRef: "HEAD~1"',
+		]) {
+			const result = validateWorkflowScript(`return runs.run("child", { agent: "worker", task: "Check", ${fields} });`);
+			assert.equal(result.ok, false, fields);
+			assert.match(result.errors[0]!.message, /baseRef/);
+		}
+		assert.equal(validateWorkflowScript('return runs.run("child", { baseRef() { return "HEAD"; } });').ok, false);
+	});
+
 	it("validates runs.host shape offline without executing it", () => {
 		assert.deepEqual(validateWorkflowScript(`return runs.host("tests", { kind: "command", command: "npm test", timeoutMs: 1000, output: "reports/tests.log", role: "ci" });`), { ok: true, errors: [] });
 		for (const script of [
@@ -768,6 +830,13 @@ describe("scripted workflow runtime", () => {
 			async status(key) { return { key, ok: true, output: "ok", artifactPaths: [] }; },
 		});
 		assert.equal(launches[0]?.gate, "npm test");
+		await runWorkflowScript({
+			script: `return runs.run("gated-disabled", { agent: "worker", gate: "npm test", acceptance: false });`,
+			async launch(key, params) { launches.push(params); return { key, ok: true, output: "done", artifactPaths: [] }; },
+			async status(key) { return { key, ok: true, output: "ok", artifactPaths: [] }; },
+		});
+		assert.equal(launches[1]?.gate, "npm test");
+		assert.equal(launches[1]?.acceptance, false);
 		await assert.rejects(
 			runWorkflowScript({
 				script: `return runs.run("invalid", { agent: "worker", gate: "npm test", acceptance: "checked" });`,
@@ -778,6 +847,26 @@ describe("scripted workflow runtime", () => {
 		);
 	});
 
+	it("reuses a gated key when acceptance false is explicit", async () => {
+		const launches: string[] = [];
+		const result = await runWorkflowScript({
+			script: `
+				const first = await runs.run("g", { agent: "worker", gate: "npm test" });
+				const second = await runs.run("g", { agent: "worker", gate: "npm test", acceptance: false });
+				return { first: first.key, second: second.key };
+			`,
+			timeoutMs: 2_000,
+			async launch(key) {
+				launches.push(key);
+				return { key, ok: true, output: "ok", artifactPaths: [], results: [] };
+			},
+			async status(key) { return { key, ok: true, output: "ok", artifactPaths: [] }; },
+		});
+
+		assert.deepEqual(result.value, { first: "g", second: "g" });
+		assert.deepEqual(launches, ["g"]);
+	});
+
 	it("rejects retained resume with gate", async () => {
 		await assert.rejects(
 			runWorkflowScript({
@@ -1429,6 +1518,91 @@ describe("scripted workflow runtime", () => {
 		);
 	});
 
+	it("passes per-child baseRef through runs.run and runs.all", async () => {
+		const launches: Array<{ key: string; baseRef: unknown }> = [];
+		await runWorkflowScript({
+			script: `
+				const one = await runs.run("one", { agent: "worker", task: "one", baseRef: "refs/heads/release" });
+				const rest = await runs.all([
+					{ key: "two", agent: "worker", task: "two", baseRef: "refs/heads/topic" },
+					{ key: "head", agent: "worker", task: "head", baseRef: "HEAD" },
+					{ key: "default", agent: "worker", task: "default" }
+				]);
+				return [one.key, ...rest.map((entry) => entry.key)];
+			`,
+			timeoutMs: 2_000,
+			async launch(key, params) {
+				launches.push({ key, baseRef: params.baseRef });
+				return { key, ok: true, output: key, artifactPaths: [], results: [] };
+			},
+			async status(key) { return { key, ok: true, output: "ok", artifactPaths: [] }; },
+		});
+		assert.deepEqual(launches, [
+			{ key: "one", baseRef: "refs/heads/release" },
+			{ key: "two", baseRef: "refs/heads/topic" },
+			{ key: "head", baseRef: "HEAD" },
+			{ key: "default", baseRef: undefined },
+		]);
+	});
+
+	it("rejects unsupported literal and computed child baseRef values before dispatch", async () => {
+		const launches: string[] = [];
+		for (const [call, expression] of [
+			["run", JSON.stringify("a".repeat(40))],
+			["all", JSON.stringify("A".repeat(64))],
+			["run", '"a".repeat(64)'],
+			["all", '"A".repeat(40)'],
+			["run", '"HEAD" + "~1"'],
+			["all", '"@"'],
+			["run", "42"],
+		]) {
+			const script = call === "run"
+				? `return runs.run("invalid", { agent: "worker", task: "Check", baseRef: ${expression} });`
+				: `return runs.all([{ key: "valid", agent: "worker", task: "Check", baseRef: "HEAD" }, { key: "invalid", agent: "worker", task: "Check", baseRef: ${expression} }]);`;
+			if (expression.includes("repeat") || expression.includes(" + ")) {
+				assert.deepEqual(validateWorkflowScript(script), { ok: true, errors: [] });
+			}
+			await assert.rejects(
+				runWorkflowScript({
+					script,
+					timeoutMs: 2_000,
+					async launch(key) {
+						launches.push(key);
+						return { key, ok: true, output: key, artifactPaths: [], results: [] };
+					},
+					async status(key) { return { key, ok: true, output: "ok", artifactPaths: [] }; },
+				}),
+				(error: unknown) => error instanceof WorkflowScriptError
+					&& /baseRef.*HEAD.*named ref.*40\/64-character commit IDs.*revision expressions.*unsupported/.test(error.message),
+			);
+		}
+		assert.deepEqual(launches, []);
+	});
+
+	it("leaves accessor-derived baseRef values to runtime validation", async () => {
+		for (const baseRef of ["HEAD", "HEAD~1"]) {
+			const script = `return runs.run("child", { agent: "worker", task: "Check", baseRef: "invalid..ref", get baseRef() { return ${JSON.stringify(baseRef)}; } });`;
+			assert.deepEqual(validateWorkflowScript(script), { ok: true, errors: [] });
+			const launches: unknown[] = [];
+			const result = runWorkflowScript({
+				script,
+				timeoutMs: 2_000,
+				async launch(key, params) {
+					launches.push(params.baseRef);
+					return { key, ok: true, output: key, artifactPaths: [] };
+				},
+				async status(key) { return { key, ok: true, output: "ok", artifactPaths: [] }; },
+			});
+			if (baseRef === "HEAD") {
+				await result;
+				assert.deepEqual(launches, ["HEAD"]);
+			} else {
+				await assert.rejects(result, /baseRef.*revision expressions.*unsupported/);
+				assert.deepEqual(launches, []);
+			}
+		}
+	});
+
 	it("passes per-child workflow controls through runs.run and runs.all", async () => {
 		const launches: Array<{ key: string; worktree: unknown; control: unknown }> = [];
 		await runWorkflowScript({
@@ -2264,6 +2438,68 @@ describe("scripted workflow runtime", () => {
 		assert.equal(childAborted, true);
 	});
 
+	it("flushes result assembly after abort when every child is terminal", async () => {
+		const controller = new AbortController();
+		let launchCount = 0;
+		const result = await runWorkflowScript({
+			script: `const child = await runs.run("done", { agent: "worker", task: "finish" }); return { phase: "assembled", output: child.output };`,
+			signal: controller.signal,
+			continueAfterAbortWhenChildrenSettled: (error) => error.message === "Workflow stopped because the extension session was replaced or reloaded.",
+			onTrace(trace) {
+				if (!controller.signal.aborted && trace.some((entry) => entry.operation === "run" && entry.key === "done" && entry.state === "completed")) controller.abort(new Error("Workflow stopped because the extension session was replaced or reloaded."));
+			},
+			async launch(key) {
+				launchCount += 1;
+				return { key, ok: true, output: "child output", artifactPaths: [], results: [] };
+			},
+			async status(key) { return { key, ok: true, output: "ok", artifactPaths: [] }; },
+		});
+
+		assert.deepEqual(result.value, { phase: "assembled", output: "child output" });
+		assert.equal(launchCount, 1);
+	});
+
+	it("fails closed with diagnostics when graceful-abort eligibility throws", async () => {
+		const controller = new AbortController();
+		await assert.rejects(
+			runWorkflowScript({
+				script: `await runs.run("done", { agent: "worker", task: "finish" }); return { phase: "assembled" };`,
+				signal: controller.signal,
+				continueAfterAbortWhenChildrenSettled: () => { throw new Error("liveness unavailable"); },
+				onTrace(trace) {
+					if (!controller.signal.aborted && trace.some((entry) => entry.operation === "run" && entry.key === "done" && entry.state === "completed")) controller.abort(new Error("Workflow stopped because the extension session was replaced or reloaded."));
+				},
+				async launch(key) {
+					return { key, ok: true, output: "child output", artifactPaths: [], results: [] };
+				},
+				async status(key) { return { key, ok: true, output: "ok", artifactPaths: [] }; },
+			}),
+			(error: unknown) => error instanceof WorkflowScriptError && /liveness unavailable/.test(error.message),
+		);
+	});
+
+	it("fails closed if assembly tries to launch after a graceful abort", async () => {
+		const controller = new AbortController();
+		let launchCount = 0;
+		await assert.rejects(
+			runWorkflowScript({
+				script: `await runs.run("done", { agent: "worker", task: "finish" }); return runs.run("late", { agent: "worker", task: "must not launch" });`,
+				signal: controller.signal,
+				continueAfterAbortWhenChildrenSettled: (error) => error.message === "Workflow stopped because the extension session was replaced or reloaded.",
+				onTrace(trace) {
+					if (!controller.signal.aborted && trace.some((entry) => entry.operation === "run" && entry.key === "done" && entry.state === "completed")) controller.abort(new Error("Workflow stopped because the extension session was replaced or reloaded."));
+				},
+				async launch(key) {
+					launchCount += 1;
+					return { key, ok: true, output: "child output", artifactPaths: [], results: [] };
+				},
+				async status(key) { return { key, ok: true, output: "ok", artifactPaths: [] }; },
+			}),
+			(error: unknown) => error instanceof WorkflowScriptError && error.message === "Workflow stopped because the extension session was replaced or reloaded.",
+		);
+		assert.equal(launchCount, 1);
+	});
+
 	it("ignores a queued child launch message after workflow abort", async () => {
 		const originalOn = Worker.prototype.on;
 		const controller = new AbortController();
@@ -2498,4 +2734,4 @@ describe("scripted workflow runtime", () => {
 		assert.ok(children.every((child) => child.ok), "every child should still report success");
 		assert.equal(result.children.filter((child) => !child.ok).length, 0);
 	});
-});
+});

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

@@ -4,7 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
 import { writeAtomicJson, writePrivateAtomicJson } from "../../src/shared/atomic-json.ts";
-import { closeSteerInbox, interruptRequestPath, steerRequestsDir, writeSteerAck, type SteerRequest } from "../../src/runs/background/control-channel.ts";
+import { closeSteerInbox, interruptRequestPath, steerRequestsDir, type SteerRequest } from "../../src/runs/background/control-channel.ts";
 import { steerAsyncRun } from "../../src/runs/foreground/async-steering-action.ts";
 import { createSteeringStatus, recordSteeringRequest, updateSteeringTarget } from "../../src/runs/background/steering.ts";
 import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
@@ -309,7 +309,6 @@ describe("acknowledged steering action", () => {
 					recoveryCommitted = true;
 					assert.ok(request);
 					assert.ok(routed);
-					writeSteerAck(asyncDir, { requestId: request.id, index: 0, ts: Date.now(), state: "delivered", message: "accepted after runner pause" });
 					writeStatus(asyncDir, {
 						...routed,
 						state: "paused",
@@ -332,7 +331,6 @@ describe("acknowledged steering action", () => {
 			assert.equal(result.details.steering?.state, "recovered");
 			assert.match(result.content[0]!.text, /Message sent:\n```text\ncorrect course\n```/);
 			assert.equal(result.details.steering?.replacementRunId, "replacement");
-			assert.ok(result.details.steering?.targets[0]?.lateDeliveredAt);
 			const limits = receivedLimits as { timeoutMs: number; absoluteDeadlineAt: number; toolBudget: unknown };
 			assert.ok(limits.timeoutMs > 0 && limits.timeoutMs <= 10_000);
 			assert.ok(limits.absoluteDeadlineAt >= Date.now());
@@ -341,7 +339,6 @@ describe("acknowledged steering action", () => {
 			});
 			const persisted = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatus;
 			assert.equal(persisted.steering?.recent[0]?.targets[0]?.state, "recovered");
-			assert.ok(persisted.steering?.recent[0]?.targets[0]?.lateDeliveredAt);
 			assert.equal(persisted.steps?.[0]?.steering?.recent[0]?.targets[0]?.state, "recovered");
 		} finally {
 			removeAsyncDir(asyncDir);
@@ -432,4 +429,4 @@ describe("acknowledged steering action", () => {
 			removeAsyncDir(asyncDir);
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/streamed-progress-bounds.test.ts

@@ -64,7 +64,7 @@ describe("streamed progress snapshot bounds", () => {
 		assert.equal(boundStreamedToolCalls({ toolCalls: undefined, messages: undefined }), undefined);
 	});
 
-	it("bounds a pathological running snapshot well under the child-stdout protocol cap", () => {
+	it("bounds a pathological running snapshot", () => {
 		// Simulates a long, deep nested fan-out: many tool calls + long output lines.
 		const recentTools = Array.from({ length: 5000 }, (_, i) => ({ tool: "read", args: `services/pkg/file-${i}.ts`, endMs: i }));
 		const recentOutput = Array.from({ length: 50 }, () => "y".repeat(60_000));
@@ -75,4 +75,4 @@ describe("streamed progress snapshot bounds", () => {
 		const bytes = Buffer.byteLength(JSON.stringify(snapshot), "utf8");
 		assert.ok(bytes < 256 * 1024, `bounded snapshot should be small, was ${bytes} bytes`);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/subagent-guide.test.ts

@@ -27,6 +27,19 @@ describe("subagent guide", () => {
 		assert.match(readSubagentGuide("agents"), /External CLI agents use their own runner contract[\s\S]*native Pi child options/);
 	});
 
+	it("documents failed-lane recovery boundaries in packaged guide topics", () => {
+		const workflows = readSubagentGuide("workflows");
+		const toolReference = readSubagentGuide("tool-reference");
+		assert.match(workflows, /subagent workflow[\s\S]*child launch[\s\S]*prompt runtime[\s\S]*extension loading[\s\S]*child tooling setup[\s\S]*lane infrastructure blocker/);
+		assert.match(workflows, /exact failure[\s\S]*run\/status[\s\S]*(?:repo|repository)\/cwd\/worktree\/branch\/ref/);
+		assert.match(workflows, /clean[\s\S]*partial diff/);
+		assert.match(workflows, /same-protocol retry/);
+		assert.match(workflows, /asking the owner/);
+		assert.match(workflows, /external\/foreground\/CLI fallback requires explicit owner approval/);
+		assert.match(workflows, /Pi core[\s\S]*pi -ne[\s\S]*out-of-repo hint[\s\S]*not protocol-approved fallback/);
+		assert.match(toolReference, /lane infrastructure blocker[\s\S]*external\/foreground\/CLI fallback requires explicit owner approval[\s\S]*interactive_shell[\s\S]*pi -ne/);
+	});
+
 	it("keeps advanced workflow details in the packaged guide", () => {
 		const guide = readSubagentGuide("workflows");
 
@@ -34,4 +47,4 @@ describe("subagent guide", () => {
 		assert.match(guide, /### Host command steps[\s\S]*runs\.host/);
 		assert.match(guide, /### Advanced rolling child runs[\s\S]*Promise\.race[\s\S]*Promise\.all/);
 	});
-});
+});