@selesai/code 0.6.3 → 0.8.0

package/dist/extensions/pi-subagents/test/integration/chain-execution.test.ts

@@ -25,6 +25,7 @@ import {
 	events,
 } from "../support/helpers.ts";
 import { INTERCOM_DETACH_REQUEST_EVENT } from "../../src/shared/types.ts";
+import { PERMISSION_AUDIT_PATH_ENV, PERMISSION_POLICY_ENV } from "../../src/runs/shared/permissions.ts";
 
 interface TestSequentialStep {
 	agent: string;
@@ -220,12 +221,12 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 	it("pauses foreground chains at approval checkpoints without launching the next child", async () => {
 		mockPi.onCall({ output: "analysis done" });
 		mockPi.onCall({ output: "should not run" });
-		const agents = [makeAgent("analyst"), makeAgent("worker")];
+		const agents = [makeAgent("analyst"), makeAgent("builder")];
 
 		const result = await executeChain!(makeChainParams([
 			{ agent: "analyst", task: "Analyze" },
 			{ checkpoint: "review", message: "Approve implementation?" },
-			{ agent: "worker", task: "Implement" },
+			{ agent: "builder", task: "Implement" },
 		], agents));
 
 		assert.equal(result.isError, undefined);
@@ -238,6 +239,22 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		assert.equal(mockPi.callCount(), 1);
 	});
 
+	it("applies global permissions to foreground chain children", async () => {
+		mockPi.onCall({ echoEnv: [PERMISSION_POLICY_ENV, PERMISSION_AUDIT_PATH_ENV] });
+		const agents = [makeAgent("builder")];
+
+		const result = await executeChain!(makeChainParams(
+			[{ agent: "builder", task: "Work" }],
+			agents,
+			{ permissions: { rules: { write: "ask" } } },
+		));
+
+		assert.equal(result.isError, undefined);
+		const env = JSON.parse(result.details.results[0]?.finalOutput ?? "{}") as Record<string, string | null>;
+		assert.equal(env[PERMISSION_POLICY_ENV], JSON.stringify({ write: "ask" }));
+		assert.match(env[PERMISSION_AUDIT_PATH_ENV] ?? "", /permission-audit\.jsonl$/);
+	});
+
 	it("runs a 2-step chain", async () => {
 		mockPi.onCall({ output: "Analysis complete: found 3 issues" });
 		const agents = [makeAgent("analyst"), makeAgent("reporter")];
@@ -367,9 +384,8 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		assert.doesNotMatch(firstTaskArg, /\[Write to:|Write your findings to exactly this path/);
 		assert.ok(result.details.results[0]?.savedOutputPath);
 		assert.equal(fs.readFileSync(result.details.results[0].savedOutputPath, "utf-8"), "full chain output\nwith details");
-		assert.equal(result.details.results[0]?.finalOutput, undefined);
-		assert.match(result.details.results[0]?.outputReference?.message ?? "", /Output saved to:/);
-		assert.doesNotMatch(result.details.results[0]?.outputReference?.message ?? "", /full chain output/);
+		assert.match(result.details.results[0]?.finalOutput ?? "", /Output saved to:/);
+		assert.doesNotMatch(result.details.results[0]?.finalOutput ?? "", /full chain output/);
 		const secondTaskArg = readCallArgs(1).at(-1) ?? "";
 		assert.match(secondTaskArg, /Output saved to:/);
 		assert.match(secondTaskArg, /2 lines/);
@@ -394,19 +410,18 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 				"```",
 			].join("\n"),
 		});
-		const agents = [makeAgent("worker", { completionGuard: false })];
+		const agents = [makeAgent("builder", { completionGuard: false })];
 
 		const result = await executeChain(
 			makeChainParams(
-				[{ agent: "worker", task: "Implement fix", output: "accepted.md", outputMode: "file-only", acceptance: { level: "checked", criteria: ["Patch bug"] } }],
+				[{ agent: "builder", task: "Implement fix", output: "accepted.md", outputMode: "file-only", acceptance: { level: "checked", criteria: ["Patch bug"] } }],
 				agents,
 				{ chainDir: tempDir },
 			),
 		);
 
 		assert.ok(!result.isError, `chain should succeed: ${JSON.stringify(result.content)}`);
-		assert.equal(result.details.results[0]?.finalOutput, undefined);
-		assert.match(result.details.results[0]?.outputReference?.message ?? "", /Output saved to:/);
+		assert.match(result.details.results[0]?.finalOutput ?? "", /Output saved to:/);
 		assert.equal(result.details.results[0]?.acceptance?.status, "checked");
 		assert.ok(result.details.results[0]?.acceptance?.childReport);
 
@@ -427,7 +442,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 		const failed = await executeChain(
 			makeChainParams(
-				[{ agent: "worker", task: "Implement fix", acceptance: { level: "checked" } }],
+				[{ agent: "builder", task: "Implement fix", acceptance: { level: "checked" } }],
 				agents,
 			),
 		);
@@ -452,11 +467,11 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 			"```",
 		].join("\n");
 		mockPi.onCall({ output: acceptanceReport });
-		const agents = [makeAgent("worker", { completionGuard: false })];
+		const agents = [makeAgent("builder", { completionGuard: false })];
 
 		const result = await executeChain(
 			makeChainParams(
-				[{ agent: "worker", task: "Implement fix", acceptance: { level: "verified", verify: [{ id: "runtime-pass", command: "node -e \"process.exit(0)\"" }] } }],
+				[{ agent: "builder", task: "Implement fix", acceptance: { level: "verified", verify: [{ id: "runtime-pass", command: "node -e \"process.exit(0)\"" }] } }],
 				agents,
 			),
 		);
@@ -467,7 +482,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		mockPi.onCall({ output: acceptanceReport });
 		const failed = await executeChain(
 			makeChainParams(
-				[{ agent: "worker", task: "Implement fix", acceptance: { level: "verified", verify: [{ id: "runtime-fail", command: "node -e \"process.exit(5)\"" }] } }],
+				[{ agent: "builder", task: "Implement fix", acceptance: { level: "verified", verify: [{ id: "runtime-fail", command: "node -e \"process.exit(5)\"" }] } }],
 				agents,
 			),
 		);
@@ -545,8 +560,8 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 		const result = await executeChain(
 			makeChainParams(
-				[{ agent: "worker", task: "Do work" }],
-				[makeAgent("worker")],
+				[{ agent: "builder", task: "Do work" }],
+				[makeAgent("builder")],
 				{
 					ctx: {
 						...makeMinimalCtx(tempDir),
@@ -567,8 +582,8 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 		const result = await executeChain(
 			makeChainParams(
-				[{ agent: "worker", task: "Do work", model: "inherit" }],
-				[makeAgent("worker")],
+				[{ agent: "builder", task: "Do work", model: "inherit" }],
+				[makeAgent("builder")],
 				{
 					ctx: {
 						...makeMinimalCtx(tempDir),
@@ -586,11 +601,11 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 	it("suppresses progress for {task} chain templates when the top-level task is review-only", async () => {
 		mockPi.onCall({ output: "Review done" });
-		const agents = [makeAgent("reviewer", { defaultProgress: true })];
+		const agents = [makeAgent("commentator", { defaultProgress: true })];
 
 		await executeChain(
 			makeChainParams(
-				[{ agent: "reviewer" }],
+				[{ agent: "commentator" }],
 				agents,
 				{ task: "Review-only. Do not edit files. Return findings." },
 			),
@@ -603,13 +618,13 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 	it("foreground chains still resolve defaultProgress inside the chain directory", async () => {
 		mockPi.onCall({ output: "Progress done" });
-		const agents = [makeAgent("reviewer", { defaultProgress: true })];
+		const agents = [makeAgent("commentator", { defaultProgress: true })];
 		const chainDir = path.join(tempDir, "chain-progress");
 		const runId = "chain-progress-run";
 
 		await executeChain(
 			makeChainParams(
-				[{ agent: "reviewer", task: "Track chain work" }],
+				[{ agent: "commentator", task: "Track chain work" }],
 				agents,
 				{ chainDir, runId },
 			),
@@ -632,13 +647,10 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 		assert.ok(!result.isError);
 		const step2Task = result.details.results[1].task;
-		// Reference-first handoff: {previous} carries the saved-output reference and
-		// the step reads the named path instead of re-inlined prose.
 		assert.ok(
-			step2Task.includes("Output saved to:"),
-			`step 2 task should contain the saved-output reference via {previous}: ${step2Task.slice(0, 200)}`,
+			step2Task.includes("MARKER_ABC_123"),
+			`step 2 task should contain step 1 output via {previous}: ${step2Task.slice(0, 200)}`,
 		);
-		assert.doesNotMatch(step2Task, /MARKER_ABC_123/);
 	});
 
 	it("passes named sequential outputs through {outputs.name}", async () => {
@@ -657,8 +669,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		);
 
 		assert.ok(!result.isError);
-		assert.match(readCallArgs(1).at(-1) ?? "", /Output saved to: /);
-		assert.doesNotMatch(readCallArgs(1).at(-1) ?? "", /CTX_123/);
+		assert.match(readCallArgs(1).at(-1) ?? "", /CTX_123/);
 		assert.equal(result.details.workflowGraph?.nodes[0]?.outputName, "contextOutput");
 	});
 
@@ -670,16 +681,16 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		mockPi.onCall({ output: "review-a", structuredOutput: { ok: "a" } });
 		mockPi.onCall({ output: "review-b", structuredOutput: { ok: "b" } });
 		mockPi.onCall({ output: "synthesized" });
-		const agents = [makeAgent("scout"), makeAgent("reviewer"), makeAgent("writer")];
+		const agents = [makeAgent("explorer"), makeAgent("commentator"), makeAgent("writer")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
 						parallel: {
-							agent: "reviewer",
+							agent: "commentator",
 							task: "Review {target.path}",
 							label: "Review {target.path}",
 							outputSchema: { type: "object" },
@@ -698,15 +709,47 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		assert.match(readCallArgs(1).at(-1) ?? "", /Review src\/a\.ts/);
 		assert.match(readCallArgs(2).at(-1) ?? "", /Review src\/b\.ts/);
 		assert.match(readCallArgs(3).at(-1) ?? "", /"key":"src\/a\.ts"/);
-		// Terminal details strip chain outputs text/structured; bindings remain
-		// reference-first via {outputs.name} and the workflow graph keeps item keys.
-		assert.equal(result.details.outputs?.reviews?.text, "");
-		assert.equal(result.details.outputs?.reviews?.structured, undefined);
+		const collected = result.details.outputs?.reviews?.structured as Array<{ key: string; structured: unknown }>;
+		assert.deepEqual(collected.map((item) => item.key), ["src/a.ts", "src/b.ts"]);
+		assert.deepEqual(collected.map((item) => item.structured), [{ ok: "a" }, { ok: "b" }]);
 		const dynamicNode = result.details.workflowGraph?.nodes[1];
 		assert.equal(dynamicNode?.kind, "dynamic-parallel-group");
 		assert.deepEqual(dynamicNode?.children?.map((child) => child.itemKey), ["src/a.ts", "src/b.ts"]);
 	});
 
+	it("applies global permissions to materialized dynamic parallel children", async () => {
+		mockPi.onCall({
+			output: "targets",
+			structuredOutput: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] },
+		});
+		mockPi.onCall({ echoEnv: [PERMISSION_POLICY_ENV, PERMISSION_AUDIT_PATH_ENV], structuredOutput: { ok: "a" } });
+		mockPi.onCall({ echoEnv: [PERMISSION_POLICY_ENV, PERMISSION_AUDIT_PATH_ENV], structuredOutput: { ok: "b" } });
+		const agents = [makeAgent("explorer"), makeAgent("commentator")];
+
+		const result = await executeChain!(makeChainParams(
+			[
+				{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+				{
+					expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
+					parallel: { agent: "commentator", task: "Review {item.path}", outputSchema: { type: "object" } },
+					collect: { as: "reviews" },
+					concurrency: 1,
+				},
+			],
+			agents,
+			{ permissions: { rules: { write: "ask" } } },
+		));
+
+		assert.equal(result.isError, undefined);
+		const reviewerResults = result.details.results.filter((entry) => entry.agent === "commentator");
+		assert.equal(reviewerResults.length, 2);
+		for (const child of reviewerResults) {
+			const env = JSON.parse(child.finalOutput ?? "{}") as Record<string, string | null>;
+			assert.equal(env[PERMISSION_POLICY_ENV], JSON.stringify({ write: "ask" }));
+			assert.match(env[PERMISSION_AUDIT_PATH_ENV] ?? "", /permission-audit\.jsonl$/);
+		}
+	});
+
 	it("persists checked child evidence and pending aggregate review for dynamic fanout", async () => {
 		mockPi.onCall({
 			output: "targets",
@@ -714,15 +757,15 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		});
 		mockPi.onCall({ output: acceptanceReport({ changedFiles: ["src/a.ts"] }), structuredOutput: { ok: "a" } });
 		mockPi.onCall({ output: acceptanceReport({ changedFiles: ["src/b.ts"] }), structuredOutput: { ok: "b" } });
-		const agents = [makeAgent("scout"), makeAgent("reviewer", { completionGuard: false })];
+		const agents = [makeAgent("explorer"), makeAgent("commentator", { completionGuard: false })];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-						parallel: { agent: "reviewer", task: "Review {item.path}", outputSchema: { type: "object" }, acceptance: { level: "checked" } },
+						parallel: { agent: "commentator", task: "Review {item.path}", outputSchema: { type: "object" }, acceptance: { level: "checked" } },
 						collect: { as: "reviews" },
 						acceptance: { level: "checked" },
 						concurrency: 1,
@@ -736,7 +779,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		const dynamicNode = result.details.workflowGraph?.nodes[1];
 		assert.equal(dynamicNode?.acceptanceStatus, "review-required");
 		assert.deepEqual(dynamicNode?.children?.map((child) => child.acceptanceStatus), ["checked", "checked"]);
-		assert.deepEqual(result.details.results.filter((child) => child.agent === "reviewer").map((child) => child.acceptance?.evidenceStatus), ["checked", "checked"]);
+		assert.deepEqual(result.details.results.filter((child) => child.agent === "commentator").map((child) => child.acceptance?.evidenceStatus), ["checked", "checked"]);
 	});
 
 	it("applies read-only acceptance roles to dynamic children and their aggregate group", async () => {
@@ -753,15 +796,15 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		});
 		mockPi.onCall({ output: readOnlyReport, structuredOutput: { ok: "a" } });
 		mockPi.onCall({ output: readOnlyReport, structuredOutput: { ok: "b" } });
-		const agents = [makeAgent("scout"), makeAgent("explorer", { acceptanceRole: "read-only" })];
+		const agents = [makeAgent("explorer"), makeAgent("recapper", { acceptanceRole: "read-only" })];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-						parallel: { agent: "explorer", task: "Explore {item.path}", outputSchema: { type: "object" } },
+						parallel: { agent: "recapper", task: "Explore {item.path}", outputSchema: { type: "object" } },
 						collect: { as: "reviews" },
 						concurrency: 1,
 					},
@@ -771,7 +814,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		);
 
 		assert.ok(!result.isError, `chain should succeed: ${JSON.stringify(result.content)}`);
-		const explorerResults = result.details.results.filter((child) => child.agent === "explorer");
+		const explorerResults = result.details.results.filter((child) => child.agent === "recapper");
 		assert.deepEqual(explorerResults.map((child) => child.acceptance?.effectiveAcceptance.level), ["attested", "attested"]);
 		const dynamicNode = result.details.workflowGraph?.nodes[1];
 		assert.equal(dynamicNode?.acceptanceStatus, "attested");
@@ -785,15 +828,15 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		});
 		mockPi.onCall({ output: acceptanceReport({ changedFiles: ["src/a.ts"] }), structuredOutput: { ok: "a" } });
 		mockPi.onCall({ output: acceptanceReport({ changedFiles: ["src/b.ts"] }), structuredOutput: { ok: "b" } });
-		const agents = [makeAgent("scout"), makeAgent("explorer", { acceptanceRole: "read-only" })];
+		const agents = [makeAgent("explorer"), makeAgent("recapper", { acceptanceRole: "read-only" })];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-						parallel: { agent: "explorer", task: "Patch {item.path}", outputSchema: { type: "object" } },
+						parallel: { agent: "recapper", task: "Patch {item.path}", outputSchema: { type: "object" } },
 						collect: { as: "reviews" },
 						concurrency: 1,
 					},
@@ -803,7 +846,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		);
 
 		assert.ok(!result.isError, `chain should succeed: ${JSON.stringify(result.content)}`);
-		const explorerResults = result.details.results.filter((child) => child.agent === "explorer");
+		const explorerResults = result.details.results.filter((child) => child.agent === "recapper");
 		assert.deepEqual(explorerResults.map((child) => child.acceptance?.effectiveAcceptance.level), ["checked", "checked"]);
 		const dynamicNode = result.details.workflowGraph?.nodes[1];
 		assert.equal(dynamicNode?.acceptanceStatus, "rejected");
@@ -817,15 +860,15 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		});
 		mockPi.onCall({ output: "review-a", structuredOutput: { ok: "a" } });
 		mockPi.onCall({ exitCode: 1, stderr: "review-b failed" });
-		const agents = [makeAgent("scout"), makeAgent("reviewer")];
+		const agents = [makeAgent("explorer"), makeAgent("commentator")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-						parallel: { agent: "reviewer", task: "Review {item.path}", outputSchema: { type: "object" } },
+						parallel: { agent: "commentator", task: "Review {item.path}", outputSchema: { type: "object" } },
 						collect: { as: "reviews" },
 						concurrency: 1,
 					},
@@ -842,15 +885,15 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 	it("fails dynamic fanout before spawning children for invalid source arrays", async () => {
 		mockPi.onCall({ output: "targets", structuredOutput: { items: [{ path: "a" }, { path: "b" }] } });
-		const agents = [makeAgent("scout"), makeAgent("reviewer")];
+		const agents = [makeAgent("explorer"), makeAgent("commentator")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 1 },
-						parallel: { agent: "reviewer", task: "Review {item.path}" },
+						parallel: { agent: "commentator", task: "Review {item.path}" },
 						collect: { as: "reviews" },
 					},
 				],
@@ -867,15 +910,15 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 	it("marks dynamic file-only validation failures as failed graph groups before spawning children", async () => {
 		mockPi.onCall({ output: "targets", structuredOutput: { items: [{ path: "src/a.ts" }] } });
-		const agents = [makeAgent("scout"), makeAgent("reviewer")];
+		const agents = [makeAgent("explorer"), makeAgent("commentator")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-						parallel: { agent: "reviewer", task: "Review {item.path}", output: false, outputMode: "file-only" },
+						parallel: { agent: "commentator", task: "Review {item.path}", outputMode: "file-only" },
 						collect: { as: "reviews" },
 					},
 				],
@@ -894,15 +937,15 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 	it("marks empty dynamic fanout skip as a completed graph group", async () => {
 		mockPi.onCall({ output: "targets", structuredOutput: { items: [] } });
 		mockPi.onCall({ output: "used empty reviews" });
-		const agents = [makeAgent("scout"), makeAgent("reviewer"), makeAgent("writer")];
+		const agents = [makeAgent("explorer"), makeAgent("commentator"), makeAgent("writer")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4, onEmpty: "skip" },
-						parallel: { agent: "reviewer", task: "Review {item.path}" },
+						parallel: { agent: "commentator", task: "Review {item.path}" },
 						collect: { as: "reviews" },
 					},
 					{ agent: "writer", task: "Use {outputs.reviews}" },
@@ -913,8 +956,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 		assert.ok(!result.isError, `chain should succeed: ${JSON.stringify(result.content)}`);
 		assert.equal(mockPi.callCount(), 2);
-		assert.equal(result.details.outputs?.reviews?.text, "");
-		assert.equal(result.details.outputs?.reviews?.structured, undefined);
+		assert.deepEqual(result.details.outputs?.reviews?.structured, []);
 		assert.equal(result.details.workflowGraph?.nodes[1]?.status, "completed");
 		assert.deepEqual(result.details.workflowGraph?.nodes[1]?.children, []);
 	});
@@ -922,15 +964,15 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 	it("marks dynamic collect schema failures as failed graph groups", async () => {
 		mockPi.onCall({ output: "targets", structuredOutput: { items: [{ path: "src/a.ts" }] } });
 		mockPi.onCall({ output: "review-a", structuredOutput: { ok: "a" } });
-		const agents = [makeAgent("scout"), makeAgent("reviewer")];
+		const agents = [makeAgent("explorer"), makeAgent("commentator")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-						parallel: { agent: "reviewer", task: "Review {item.path}", outputSchema: { type: "object" } },
+						parallel: { agent: "commentator", task: "Review {item.path}", outputSchema: { type: "object" } },
 						collect: { as: "reviews", outputSchema: { type: "object" } },
 					},
 				],
@@ -951,16 +993,16 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		mockPi.onCall({ output: "review-a", structuredOutput: { ok: "a" } });
 		mockPi.onCall({ output: "review-b", structuredOutput: { ok: "b" } });
 		mockPi.onCall({ steps: [{ jsonl: [events.assistantMessage("writer started")] }] });
-		const agents = [makeAgent("scout"), makeAgent("reviewer"), makeAgent("writer")];
+		const agents = [makeAgent("explorer"), makeAgent("commentator"), makeAgent("writer")];
 		let writerUpdateChildren: Array<{ itemKey?: string; status?: string }> | undefined;
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+					{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-						parallel: { agent: "reviewer", task: "Review {item.path}", outputSchema: { type: "object" } },
+						parallel: { agent: "commentator", task: "Review {item.path}", outputSchema: { type: "object" } },
 						collect: { as: "reviews" },
 						concurrency: 1,
 					},
@@ -1021,10 +1063,10 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 			properties: { ok: { type: "boolean" }, note: { type: "string" } },
 		};
 		mockPi.onCall({ output: "prose", structuredOutput: { ok: true, note: "captured" } });
-		const agents = [makeAgent("worker")];
+		const agents = [makeAgent("builder")];
 
 		const result = await executeChain(
-			makeChainParams([{ agent: "worker", task: "Return structured", outputSchema: schema }], agents),
+			makeChainParams([{ agent: "builder", task: "Return structured", outputSchema: schema }], agents),
 		);
 
 		assert.ok(!result.isError);
@@ -1033,7 +1075,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		mockPi.reset();
 		mockPi.onCall({ structuredOutput: { ok: true, note: "tool-only" } });
 		const structuredOnly = await executeChain(
-			makeChainParams([{ agent: "worker", task: "Return structured", outputSchema: schema }], agents),
+			makeChainParams([{ agent: "builder", task: "Return structured", outputSchema: schema }], agents),
 		);
 		assert.ok(!structuredOnly.isError);
 		assert.deepEqual(structuredOnly.details.results[0]?.structuredOutput, { ok: true, note: "tool-only" });
@@ -1041,7 +1083,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		mockPi.reset();
 		mockPi.onCall({ output: "prose only" });
 		const missing = await executeChain(
-			makeChainParams([{ agent: "worker", task: "Return structured", outputSchema: schema }], agents),
+			makeChainParams([{ agent: "builder", task: "Return structured", outputSchema: schema }], agents),
 		);
 		assert.equal(missing.isError, true);
 		assert.match(missing.details.results[0]?.error ?? "", /Missing structured_output call/);
@@ -1049,7 +1091,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		mockPi.reset();
 		mockPi.onCall({ output: "invalid", structuredOutput: { ok: "yes" } });
 		const invalid = await executeChain(
-			makeChainParams([{ agent: "worker", task: "Return structured", outputSchema: schema, phase: "Validate", label: "Structured worker", as: "result" }], agents),
+			makeChainParams([{ agent: "builder", task: "Return structured", outputSchema: schema, phase: "Validate", label: "Structured builder", as: "result" }], agents),
 		);
 		assert.equal(invalid.isError, true);
 		assert.match(invalid.details.results[0]?.error ?? "", /Structured output validation failed/);
@@ -1060,11 +1102,11 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 	it("substitutes {task} in templates", async () => {
 		mockPi.onCall({ output: "Done" });
-		const agents = [makeAgent("worker")];
+		const agents = [makeAgent("builder")];
 
 		const result = await executeChain(
 			makeChainParams(
-				[{ agent: "worker", task: "Review {task} carefully" }],
+				[{ agent: "builder", task: "Review {task} carefully" }],
 				agents,
 				{ task: "the authentication module" },
 			),
@@ -1080,11 +1122,11 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 	it("creates and uses chain_dir", async () => {
 		mockPi.onCall({ output: "Done" });
-		const agents = [makeAgent("worker")];
+		const agents = [makeAgent("builder")];
 
 		const result = await executeChain(
 			makeChainParams(
-				[{ agent: "worker", task: "Write to {chain_dir}" }],
+				[{ agent: "builder", task: "Write to {chain_dir}" }],
 				agents,
 			),
 		);
@@ -1131,9 +1173,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		assert.equal(result.details.results.length, 2);
 		assert.equal(result.details.results[0]?.acceptance?.status, "rejected");
 		assert.equal(result.details.results[0]?.exitCode, 0);
-		assert.equal(result.details.results[1]?.finalOutput, undefined);
-		assert.ok(result.details.results[1]?.savedOutputPath);
-		assert.equal(fs.readFileSync(result.details.results[1]!.savedOutputPath!, "utf-8"), "Step 2 ran");
+		assert.match(result.details.results[1]?.finalOutput ?? "", /Step 2 ran/);
 	});
 
 	it("agent contract v1 chain can gate progression on acceptance", async () => {
@@ -1159,13 +1199,13 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 	it("runs a 3-step chain end-to-end", async () => {
 		mockPi.onCall({ output: "Step output" });
-		const agents = [makeAgent("scout"), makeAgent("planner"), makeAgent("executor")];
+		const agents = [makeAgent("explorer"), makeAgent("architect"), makeAgent("executor")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Survey the codebase" },
-					{ agent: "planner" },
+					{ agent: "explorer", task: "Survey the codebase" },
+					{ agent: "architect" },
 					{ agent: "executor" },
 				],
 				agents,
@@ -1177,16 +1217,16 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		assert.ok(result.details.results.every((r) => r.exitCode === 0));
 	});
 
-	it("runs a 40-step alternating worker and reviewer chain", async () => {
+	it("runs a 40-step alternating builder and commentator chain", async () => {
 		const chainLength = 40;
 		for (let i = 0; i < chainLength; i++) {
 			mockPi.onCall({ output: `step-${i}-output` });
 		}
 		const chain = Array.from({ length: chainLength }, (_, i): TestSequentialStep => ({
-			agent: i % 2 === 0 ? "worker" : "reviewer",
-			...(i === 0 ? { task: "Start long worker/reviewer chain" } : {}),
+			agent: i % 2 === 0 ? "builder" : "commentator",
+			...(i === 0 ? { task: "Start long builder/commentator chain" } : {}),
 		}));
-		const agents = [makeAgent("worker"), makeAgent("reviewer")];
+		const agents = [makeAgent("builder"), makeAgent("commentator")];
 
 		const result = await executeChain(makeChainParams(chain, agents));
 
@@ -1196,7 +1236,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		assert.equal(result.details.totalSteps, chainLength);
 		assert.equal(result.details.chainAgents?.length, chainLength);
 		assert.equal(result.details.workflowGraph?.nodes.length, chainLength);
-		assert.equal(result.details.workflowGraph?.nodes.at(-1)?.agent, "reviewer");
+		assert.equal(result.details.workflowGraph?.nodes.at(-1)?.agent, "commentator");
 		assert.equal(result.details.workflowGraph?.nodes.at(-1)?.flatIndex, chainLength - 1);
 		assert.ok(result.details.results.every((r) => r.exitCode === 0));
 		assert.deepEqual(
@@ -1205,18 +1245,17 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		);
 
 		const finalTaskArg = readCallArgs(chainLength - 1).at(-1) ?? "";
-		assert.match(finalTaskArg, /Output saved to: /);
-		assert.doesNotMatch(finalTaskArg, /step-38-output/);
+		assert.match(finalTaskArg, /step-38-output/);
 		assert.doesNotMatch(finalTaskArg, /step-37-output/);
 		assert.match(result.content[0]?.text ?? "", /40 steps/);
 	});
 
 	it("returns error for unknown agent in chain", async () => {
-		const agents = [makeAgent("scout")];
+		const agents = [makeAgent("explorer")];
 
 		const result = await executeChain(
 			makeChainParams(
-				[{ agent: "scout", task: "Start" }, { agent: "nonexistent" }],
+				[{ agent: "explorer", task: "Start" }, { agent: "nonexistent" }],
 				agents,
 			),
 		);
@@ -1262,12 +1301,12 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 	it("uses custom chainDir when provided", async () => {
 		mockPi.onCall({ output: "Done" });
-		const agents = [makeAgent("worker")];
+		const agents = [makeAgent("builder")];
 		const customChainDir = path.join(tempDir, "my-chain");
 
 		const result = await executeChain(
 			makeChainParams(
-				[{ agent: "worker", task: "Use {chain_dir}" }],
+				[{ agent: "builder", task: "Use {chain_dir}" }],
 				agents,
 				{ chainDir: customChainDir },
 			),
@@ -1284,20 +1323,18 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
 		try {
 			mockPi.onCall({ echoEnv: ["SELESAI_SUBAGENT_DEPTH", "SELESAI_SUBAGENT_MAX_DEPTH"] });
-			const agents = [makeAgent("worker", { maxSubagentDepth: 1 })];
+			const agents = [makeAgent("builder", { maxSubagentDepth: 1 })];
 
 			const result = await executeChain(
 				makeChainParams(
-					[{ agent: "worker", task: "Inspect env" }],
+					[{ agent: "builder", task: "Inspect env" }],
 					agents,
 					{ maxSubagentDepth: 3 },
 				),
 			);
 
 			assert.ok(!result.isError);
-			const depthChild = result.details.results[0];
-			assert.ok(depthChild.savedOutputPath);
-			assert.deepEqual(JSON.parse(fs.readFileSync(depthChild.savedOutputPath, "utf-8")), {
+			assert.deepEqual(JSON.parse(result.details.results[0].finalOutput ?? "{}"), {
 				SELESAI_SUBAGENT_DEPTH: "1",
 				SELESAI_SUBAGENT_MAX_DEPTH: "1",
 			});
@@ -1379,15 +1416,15 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 
 	it("runs parallel tasks within a chain step", async () => {
 		mockPi.onCall({ output: "Parallel task done" });
-		const agents = [makeAgent("reviewer-a"), makeAgent("reviewer-b")];
+		const agents = [makeAgent("commentator-a"), makeAgent("commentator-b")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
 					{
 						parallel: [
-							{ agent: "reviewer-a", task: "Review auth module" },
-							{ agent: "reviewer-b", task: "Review data layer" },
+							{ agent: "commentator-a", task: "Review auth module" },
+							{ agent: "commentator-b", task: "Review data layer" },
 						],
 					},
 				],
@@ -1400,6 +1437,31 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 		assert.deepEqual(result.details.results.map((row) => row.index), [0, 1]);
 	});
 
+	it("applies global permissions to foreground static parallel children", async () => {
+		mockPi.onCall({ echoEnv: [PERMISSION_POLICY_ENV, PERMISSION_AUDIT_PATH_ENV] });
+		mockPi.onCall({ echoEnv: [PERMISSION_POLICY_ENV, PERMISSION_AUDIT_PATH_ENV] });
+		const agents = [makeAgent("commentator-a"), makeAgent("commentator-b")];
+
+		const result = await executeChain!(makeChainParams(
+			[{
+				parallel: [
+					{ agent: "commentator-a", task: "Review A" },
+					{ agent: "commentator-b", task: "Review B" },
+				],
+			}],
+			agents,
+			{ permissions: { rules: { write: "ask" } } },
+		));
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details.results.length, 2);
+		for (const child of result.details.results) {
+			const env = JSON.parse(child.finalOutput ?? "{}") as Record<string, string | null>;
+			assert.equal(env[PERMISSION_POLICY_ENV], JSON.stringify({ write: "ask" }));
+			assert.match(env[PERMISSION_AUDIT_PATH_ENV] ?? "", /permission-audit\.jsonl$/);
+		}
+	});
+
 	it("aggregates worktree handoffs across foreground chain groups", { skip: process.platform === "win32" ? "worktree paths differ on Windows" : undefined }, async () => {
 		git(["init"]);
 		git(["config", "user.email", "test@example.com"]);
@@ -1412,8 +1474,8 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 		const artifactsDir = path.join(tempDir, "artifacts");
 		const result = await executeChain(
 			makeChainParams(
-				[{ parallel: [{ agent: "reviewer-a", task: "Review in isolation" }], worktree: true }],
-				[makeAgent("reviewer-a")],
+				[{ parallel: [{ agent: "commentator-a", task: "Review in isolation" }], worktree: true }],
+				[makeAgent("commentator-a")],
 				{ runId, artifactsDir },
 			),
 		);
@@ -1426,7 +1488,7 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 			groups: Array<{ stepIndex: number; children: Array<{ agent: string; patch: { path: string } }>; cleanup: { state: string } }>;
 		};
 		assert.equal(handoff.groups[0]!.stepIndex, 0);
-		assert.equal(handoff.groups[0]!.children[0]!.agent, "reviewer-a");
+		assert.equal(handoff.groups[0]!.children[0]!.agent, "commentator-a");
 		assert.equal(handoff.groups[0]!.cleanup.state, "complete");
 		assert.equal(fs.existsSync(handoff.groups[0]!.children[0]!.patch.path), true);
 		assert.match(handoff.groups[0]!.children[0]!.patch.path, /worktree-diffs\/foreground-chain-handoff\/step-0\//);
@@ -1434,15 +1496,15 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 
 	it("aggregates parallel outputs for next sequential step", async () => {
 		mockPi.onCall({ output: "Review findings here" });
-		const agents = [makeAgent("reviewer-a"), makeAgent("reviewer-b"), makeAgent("synthesizer")];
+		const agents = [makeAgent("commentator-a"), makeAgent("commentator-b"), makeAgent("synthesizer")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
 					{
 						parallel: [
-							{ agent: "reviewer-a", task: "Review security" },
-							{ agent: "reviewer-b", task: "Review performance" },
+							{ agent: "commentator-a", task: "Review security" },
+							{ agent: "commentator-b", task: "Review performance" },
 						],
 					},
 					{ agent: "synthesizer" },
@@ -1455,12 +1517,12 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 		assert.equal(result.details.results.length, 3);
 		const synthTask = result.details.results[2].task;
 		assert.ok(
-			synthTask.includes("=== Parallel Task 1 (reviewer-a) ==="),
-			"synthesizer should include reviewer-a output block",
+			synthTask.includes("=== Parallel Task 1 (commentator-a) ==="),
+			"synthesizer should include commentator-a output block",
 		);
 		assert.ok(
-			synthTask.includes("=== Parallel Task 2 (reviewer-b) ==="),
-			"synthesizer should include reviewer-b output block",
+			synthTask.includes("=== Parallel Task 2 (commentator-b) ==="),
+			"synthesizer should include commentator-b output block",
 		);
 	});
 
@@ -1487,9 +1549,8 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 
 		assert.ok(!result.isError);
 		const finalTask = readCallArgs(2).at(-1) ?? "";
-		assert.match(finalTask, /Output saved to: /);
-		assert.doesNotMatch(finalTask, /Alpha named output/);
-		assert.doesNotMatch(finalTask, /Beta named output/);
+		assert.match(finalTask, /Alpha named output/);
+		assert.match(finalTask, /Beta named output/);
 	});
 
 	it("funnels an initial parallel step through one agent, then fans the funnel output back out", async () => {
@@ -1498,15 +1559,15 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 		mockPi.onCall({ matchArgIncludes: "Synthesize:", output: "Funnel synthesis" });
 		mockPi.onCall({ matchArgIncludes: "Review funnel A:", output: "Reviewer A done" });
 		mockPi.onCall({ matchArgIncludes: "Review funnel B:", output: "Reviewer B done" });
-		const agents = [makeAgent("scout-a"), makeAgent("scout-b"), makeAgent("synthesizer"), makeAgent("review-a"), makeAgent("review-b")];
+		const agents = [makeAgent("explorer-a"), makeAgent("explorer-b"), makeAgent("synthesizer"), makeAgent("review-a"), makeAgent("review-b")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
 					{
 						parallel: [
-							{ agent: "scout-a", task: "Scout API" },
-							{ agent: "scout-b", task: "Scout UI" },
+							{ agent: "explorer-a", task: "Scout API" },
+							{ agent: "explorer-b", task: "Scout UI" },
 						],
 					},
 					{ agent: "synthesizer", task: "Synthesize:\n{previous}" },
@@ -1522,18 +1583,17 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 		);
 
 		assert.ok(!result.isError, `should succeed: ${JSON.stringify(result.content)}`);
-		assert.deepEqual(result.details.results.map((entry) => entry.agent), ["scout-a", "scout-b", "synthesizer", "review-a", "review-b"]);
+		assert.deepEqual(result.details.results.map((entry) => entry.agent), ["explorer-a", "explorer-b", "synthesizer", "review-a", "review-b"]);
 		assert.equal(result.details.totalSteps, 3);
 		const funnelTask = readCallArgsMatching("Synthesize:").at(-1) ?? "";
-		assert.match(funnelTask, /=== Parallel Task 1 \(scout-a\) ===/);
-		assert.match(funnelTask, /=== Parallel Task 2 \(scout-b\) ===/);
-		assert.match(funnelTask, /Output saved to: /);
-		assert.doesNotMatch(funnelTask, /Scout A findings/);
-		assert.doesNotMatch(funnelTask, /Scout B findings/);
+		assert.match(funnelTask, /=== Parallel Task 1 \(explorer-a\) ===/);
+		assert.match(funnelTask, /Scout A findings/);
+		assert.match(funnelTask, /=== Parallel Task 2 \(explorer-b\) ===/);
+		assert.match(funnelTask, /Scout B findings/);
 		const fanoutTaskA = readCallArgsMatching("Review funnel A:").at(-1) ?? "";
 		const fanoutTaskB = readCallArgsMatching("Review funnel B:").at(-1) ?? "";
-		assert.match(fanoutTaskA, /Review funnel A:\nOutput saved to: /);
-		assert.match(fanoutTaskB, /Review funnel B:\nOutput saved to: /);
+		assert.match(fanoutTaskA, /Review funnel A:\nFunnel synthesis/);
+		assert.match(fanoutTaskB, /Review funnel B:\nFunnel synthesis/);
 		assert.equal(result.details.workflowGraph?.nodes[0]?.kind, "parallel-group");
 		assert.equal(result.details.workflowGraph?.nodes[1]?.kind, "step");
 		assert.equal(result.details.workflowGraph?.nodes[2]?.kind, "parallel-group");
@@ -1541,15 +1601,15 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 
 	it("aggregates file-only parallel outputs as file references for the next step", async () => {
 		mockPi.onCall({ output: "full parallel chain output\nwith details" });
-		const agents = [makeAgent("reviewer-a"), makeAgent("reviewer-b"), makeAgent("synthesizer")];
+		const agents = [makeAgent("commentator-a"), makeAgent("commentator-b"), makeAgent("synthesizer")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
 					{
 						parallel: [
-							{ agent: "reviewer-a", task: "Review A", output: "a.md", outputMode: "file-only" },
-							{ agent: "reviewer-b", task: "Review B", output: "b.md", outputMode: "file-only" },
+							{ agent: "commentator-a", task: "Review A", output: "a.md", outputMode: "file-only" },
+							{ agent: "commentator-b", task: "Review B", output: "b.md", outputMode: "file-only" },
 						],
 					},
 					{ agent: "synthesizer" },
@@ -1569,14 +1629,14 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 	});
 
 	it("rejects chain parallel file-only output without spawning siblings", async () => {
-		const agents = [makeAgent("reviewer-a"), makeAgent("reviewer-b")];
+		const agents = [makeAgent("commentator-a"), makeAgent("commentator-b")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[{
 					parallel: [
-						{ agent: "reviewer-a", task: "Review A", output: false, outputMode: "file-only" },
-						{ agent: "reviewer-b", task: "Review B", output: "b.md" },
+						{ agent: "commentator-a", task: "Review A", outputMode: "file-only" },
+						{ agent: "commentator-b", task: "Review B", output: "b.md" },
 					],
 				}],
 				agents,
@@ -1719,12 +1779,12 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 
 	it("sequential → parallel → sequential (mixed chain)", async () => {
 		mockPi.onCall({ output: "Step complete" });
-		const agents = [makeAgent("scout"), makeAgent("rev-a"), makeAgent("rev-b"), makeAgent("writer")];
+		const agents = [makeAgent("explorer"), makeAgent("rev-a"), makeAgent("rev-b"), makeAgent("writer")];
 
 		const result = await executeChain(
 			makeChainParams(
 				[
-					{ agent: "scout", task: "Initial scan" },
+					{ agent: "explorer", task: "Initial scan" },
 					{
 						parallel: [
 							{ agent: "rev-a", task: "Deep review A" },