@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/integration/foreign-workflow-steering.test.ts

@@ -27,7 +27,7 @@ describe("foreign workflow tool steering (separate processes)", () => {
 		ctx.sessionManager.getSessionFile = () => sessionFile;
 		ctx.sessionManager.getSessionId = () => "different-runtime-id-in-owner";
 		const state: any = { baseCwd: tempDir, currentSessionId: null, asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null };
-		const executor = createSubagentExecutor({ pi: { events: createEventBus(), getSessionName: () => undefined }, state, config: {}, asyncByDefault: false, tempArtifactsDir: tempDir, getSubagentSessionRoot: () => tempDir, expandTilde: p => p, discoverAgents: () => ({ agents: [makeAgent("worker", { completionGuard: false })] }) });
+		const executor = createSubagentExecutor({ pi: { events: createEventBus(), getSessionName: () => undefined }, state, config: {}, asyncByDefault: false, tempArtifactsDir: tempDir, getSubagentSessionRoot: () => tempDir, expandTilde: p => p, discoverAgents: () => ({ agents: [makeAgent("worker")] }) });
 		const launch = await executor.execute("owner", { workflowScript: 'return await runs.run("A", { agent: "worker", task: "Wait" });', async: true, mission: false }, new AbortController().signal, undefined, ctx);
 		assert.notEqual(launch.isError, true, JSON.stringify(launch));
 		const runId = launch.details.asyncId!;
@@ -70,16 +70,20 @@ describe("foreign workflow tool steering (separate processes)", () => {
 		const sessionFile = path.join(tempDir, "parent.jsonl");
 		const status = JSON.stringify({ runId, mode: "workflow", state: "running", sessionId: sessionFile, completionOwnerId: "unavailable-owner", pid: 99999999, updatedAt: 1, steps: [{ status: "running", workflowKey: "A" }, { status: "running", workflowKey: "B" }] });
 		fs.writeFileSync(path.join(dir, "status.json"), status);
-		for (const policy of ["forbid", "confirm"]) {
-			const refused = await hostB(sessionFile, { dir }, policy, policy);
+		const [forbidden, confirmation, mismatch, b] = await hostB(sessionFile, [
+			{ params: { dir }, policy: "forbid" },
+			{ params: { dir }, policy: "confirm" },
+			{ params: { dir, id: "another-workflow" } },
+			{ params: { id: runId } },
+		], "unavailable-owner");
+		for (const refused of [forbidden, confirmation]) {
 			assert.equal(refused.result.isError, true);
 			assert.match(refused.result.content[0].text, /Authority policy/);
-			assert.equal(fs.existsSync(steerRequestsDir(dir)), false);
+			assert.equal(refused.requestCount, 0);
 		}
-		const mismatch = await hostB(sessionFile, { dir, id: "another-workflow" }, "mismatch");
 		assert.equal(mismatch.result.isError, true);
 		assert.match(mismatch.result.content[0].text, /does not match directory/);
-		const b = await hostB(sessionFile, { id: runId }, "noack");
+		assert.equal(mismatch.requestCount, 0);
 		assert.notEqual(b.result.isError, true, JSON.stringify(b));
 		assert.equal(b.result.details.steering.state, "pending");
 		assert.equal(b.result.details.steering.deliveryStatus, "queued");

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

@@ -5,8 +5,8 @@ import * as path from "node:path";
 import type { MockPi } from "../support/helpers.ts";
 import { createEventBus, createMockPi, createTempDir, events, removeTempDir, resolveMockPiCallArgs, tryImport } from "../support/helpers.ts";
 import { discoverAgents } from "../../src/agents/agents.ts";
+import { registerSubagentCapabilityCeiling } from "../../src/api/capability-ceiling.ts";
 import { ACTIVE_ASYNC_CAPACITY_DIR, acquireActiveAsyncCapacity, activeAsyncCapacitySessionKey } from "../../src/runs/background/active-async-capacity.ts";
-import { clearExclusions } from "../../src/runs/shared/model-exclusions.ts";
 import { DEFAULT_FORK_PREAMBLE, INTERCOM_DETACH_REQUEST_EVENT, SUBAGENT_ASYNC_STARTED_EVENT } from "../../src/shared/types.ts";
 
 interface ExecutorModule {
@@ -107,11 +107,9 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		tempDir = createTempDir("pi-subagent-fork-test-");
 		mockPi.reset();
 		mockPi.onCall({ output: "ok" });
-		clearExclusions();
 	});
 
 	afterEach(() => {
-		clearExclusions();
 		if (originalHome === undefined) delete process.env.HOME;
 		else process.env.HOME = originalHome;
 		if (originalUserProfile === undefined) delete process.env.USERPROFILE;
@@ -133,7 +131,7 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		}), config);
 	}
 
-	function makeExecutorWithDiscoverAgents(discoverAgentsImpl: typeof discoverAgents, config: Record<string, unknown> = {}) {
+	function makeExecutorWithDiscoverAgents(discoverAgentsImpl: typeof discoverAgents, config: Record<string, unknown> = {}, extraDeps: Record<string, unknown> = {}) {
 		let sessionName: string | undefined;
 		const eventsApi = createEventBus();
 		return Object.assign(createSubagentExecutor({
@@ -152,6 +150,7 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 			getSubagentSessionRoot: () => tempDir,
 			expandTilde: (p: string) => p,
 			discoverAgents: discoverAgentsImpl,
+			...extraDeps,
 		}), { eventsApi });
 	}
 
@@ -311,7 +310,7 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		assert.match(args[systemIndex + 1] ?? "", /## Acceptance Contract/);
 	});
 
-	it("fails pruned fork model auth before child spawn", async () => {
+	it("does not manually preflight pruned fork model auth before child spawn", async () => {
 		const parentSessionFile = path.join(tempDir, "parent.jsonl");
 		const { manager } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
 		const executor = makeExecutorWithConfig({ forkContext: { mode: "pruned", model: "test/pruner" } });
@@ -321,14 +320,95 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 			modelRegistry: {
 				getAvailable: () => [model],
 				find: () => model,
-				getApiKeyAndHeaders: async () => ({ ok: false as const, error: "credentials unavailable" }),
+				getApiKeyAndHeaders: async () => { throw new Error("manual auth extraction must not run"); },
 			},
 		};
 
 		const result = await executor.execute("id", { agent: "echo", task: "test", context: "fork" }, new AbortController().signal, undefined, ctx);
+		assert.equal(result.isError, undefined);
+		assert.equal(fs.readdirSync(mockPi.dir).some((name) => name.startsWith("call-") && name.endsWith(".json")), true);
+	});
+
+	for (const forkMode of ["pruned", "full"] as const) {
+		it(`denies a ceiling-restricted agent before ${forkMode} fork preparation`, async () => {
+			const parentSessionFile = path.join(tempDir, "parent.jsonl");
+			const { manager, openedPaths } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+			const executor = makeExecutorWithConfig(forkMode === "pruned" ? { forkContext: { mode: "pruned", model: "test/pruner" } } : {});
+			const model = { provider: "test", id: "pruner", api: "test-api", maxTokens: 1024 };
+			const registryCalls: string[] = [];
+			const ctx = {
+				...makeCtx(manager),
+				modelRegistry: {
+					getAvailable: () => { registryCalls.push("getAvailable"); return [model]; },
+					find: () => { registryCalls.push("find"); return model; },
+					getApiKeyAndHeaders: async () => { registryCalls.push("getApiKeyAndHeaders"); return {}; },
+				},
+			};
+			const handle = registerSubagentCapabilityCeiling({ sessionId: parentSessionFile, source: "plan-mode", ceiling: { allowedAgents: ["second"] } });
+			try {
+				const result = await executor.execute("id", { agent: "echo", task: "test", context: "fork" }, new AbortController().signal, undefined, ctx);
+				assert.equal(result.isError, true);
+				assert.match(result.content[0]?.text ?? "", /does not allow agent 'echo'/);
+				assert.deepEqual(openedPaths, []);
+				assert.deepEqual(registryCalls, []);
+				assert.equal(fs.readdirSync(mockPi.dir).some((name) => name.startsWith("call-") && name.endsWith(".json")), false);
+			} finally {
+				handle.dispose();
+			}
+		});
+	}
+
+	for (const scenario of [
+		{ name: "an allowed agent listed before it", params: { tasks: [{ agent: "echo", task: "a" }, { agent: "second", task: "b" }] }, hasUI: false },
+		{ name: "clarify with a UI", params: { agent: "second", task: "b", clarify: true }, hasUI: true },
+	] as const) {
+		it(`denies a ceiling-restricted agent before any fork with ${scenario.name}`, async () => {
+			const parentSessionFile = path.join(tempDir, "parent.jsonl");
+			const { manager, openedPaths } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+			const handle = registerSubagentCapabilityCeiling({ sessionId: parentSessionFile, source: "plan-mode", ceiling: { allowedAgents: ["echo"] } });
+			try {
+				const result = await makeExecutor().execute("id", { ...scenario.params, context: "fork" }, new AbortController().signal, undefined, { ...makeCtx(manager), hasUI: scenario.hasUI });
+				assert.equal(result.isError, true);
+				assert.match(result.content[0]?.text ?? "", /does not allow agent 'second'/);
+				assert.deepEqual(openedPaths, []);
+			} finally {
+				handle.dispose();
+			}
+		});
+	}
+
+	it("denies before any fork when only the inherited child-runtime ceiling excludes the agent", async () => {
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const { manager, openedPaths } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [{ name: "echo", description: "Echo test agent" }, { name: "second", description: "Second test agent" }],
+			projectAgentsDir: null,
+		}), {}, { childRuntime: { fanoutChild: false, capabilityCeiling: { version: 1, allowedAgents: ["echo"], denyExtensions: false, sources: ["parent"] } } });
+		const result = await executor.execute("id", { agent: "second", task: "b", context: "fork" }, new AbortController().signal, undefined, makeCtx(manager));
 		assert.equal(result.isError, true);
-		assert.match(result.content.map((block) => block.text).join("\n"), /Pruned fork model auth failed.*credentials unavailable/);
-		assert.equal(fs.readdirSync(mockPi.dir).some((name) => name.startsWith("call-") && name.endsWith(".json")), false);
+		assert.match(result.content[0]?.text ?? "", /does not allow agent 'second'/);
+		assert.deepEqual(openedPaths, []);
+	});
+
+	it("does not deny a ceiling-restricted dynamic template that fork preflight never prepares", async () => {
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const { manager, openedPaths } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+		const handle = registerSubagentCapabilityCeiling({ sessionId: parentSessionFile, source: "plan-mode", ceiling: { allowedAgents: ["echo"] } });
+		try {
+			const result = await makeExecutor().execute("id", {
+				context: "fork",
+				chain: [
+					{ agent: "echo", task: "Produce targets", as: "targets", outputSchema: { type: "object" } },
+					{ expand: { from: { output: "targets", path: "/items" }, item: "target", maxItems: 0 }, parallel: { agent: "second", task: "Review {target}" }, collect: { as: "reviews" } },
+				],
+				clarify: false,
+			}, new AbortController().signal, undefined, makeCtx(manager));
+			assert.doesNotMatch(result.content[0]?.text ?? "", /does not allow agent/);
+			// The allowed step's fork was prepared, so preflight got past the zero-item template.
+			assert.notDeepEqual(openedPaths, []);
+		} finally {
+			handle.dispose();
+		}
 	});
 
 
@@ -478,7 +558,7 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		assert.match(result.content[0]?.text ?? "", /context: "profile" requires agent 'worker' to declare defaultContext/);
 	});
 
-	it("sanitizes inherited signed thinking and forces child thinking off", async () => {
+	it("sanitizes inherited signed thinking and keeps child thinking", async () => {
 		const parentSessionFile = path.join(tempDir, "parent.jsonl");
 		const childSessionFile = path.join(tempDir, "fork-with-thinking.jsonl");
 		fs.writeFileSync(parentSessionFile, '{"type":"session","version":1,"id":"parent","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
@@ -514,14 +594,14 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 
 		assert.equal(result.isError, undefined);
 		const args = readCallArgs();
-		assert.equal(args[args.indexOf("--model") + 1], "anthropic/claude-sonnet-4-5:off");
+		assert.equal(args[args.indexOf("--model") + 1], "anthropic/claude-sonnet-4-5:high");
 		const entries = fs.readFileSync(childSessionFile, "utf-8").trim().split("\n").map((line) => JSON.parse(line));
 		assert.deepEqual(entries[2].message.content, [{ type: "text", text: "answer" }]);
-		assert.equal(entries[3].type, "thinking_level_change");
-		assert.equal(entries[3].thinkingLevel, "off");
+		assert.equal(entries.length, 3);
+		assert.ok(!entries.some((entry) => entry.type === "thinking_level_change"));
 	});
 
-	it("uses an explicit Anthropic model for fork thinking preparation", async () => {
+	it("keeps thinking for an explicit Anthropic model on a forked child", async () => {
 		const parentSessionFile = path.join(tempDir, "parent.jsonl");
 		const childSessionFile = path.join(tempDir, "fork-explicit-anthropic.jsonl");
 		fs.writeFileSync(parentSessionFile, '{"type":"session","version":1,"id":"parent","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
@@ -565,76 +645,13 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 
 		assert.equal(result.isError, undefined);
 		const args = readCallArgs();
-		assert.equal(args[args.indexOf("--model") + 1], "anthropic/claude-sonnet-4-5:off");
+		assert.equal(args[args.indexOf("--model") + 1], "anthropic/claude-sonnet-4-5:high");
 		const entries = fs.readFileSync(childSessionFile, "utf-8").trim().split("\n").map((line) => JSON.parse(line));
 		assert.deepEqual(entries[1].message.content, [{ type: "text", text: "answer" }]);
-		assert.equal(entries[2].type, "thinking_level_change");
-		assert.equal(entries[2].thinkingLevel, "off");
-	});
-
-	it("forces every foreground fallback attempt off after sanitizing inherited signed thinking", async () => {
-		mockPi.reset();
-		mockPi.onCall({
-			jsonl: [{
-				type: "message_end",
-				message: {
-					role: "assistant",
-					content: [{ type: "text", text: "temporary provider failure" }],
-					model: "openai/gpt-5-mini",
-					errorMessage: "rate limit exceeded",
-					usage: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, cost: { total: 0.01 } },
-				},
-			}],
-			exitCode: 1,
-		});
-		mockPi.onCall({ output: "Recovered on fallback" });
-		const parentSessionFile = path.join(tempDir, "parent.jsonl");
-		const childSessionFile = path.join(tempDir, "fork-with-thinking.jsonl");
-		fs.writeFileSync(parentSessionFile, '{"type":"session","version":1,"id":"parent","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
-		const manager = {
-			getSessionId: () => "session-123",
-			getSessionFile: () => parentSessionFile,
-			getLeafId: () => "assistant-1",
-			openSession: () => ({
-				createBranchedSession: () => {
-					fs.writeFileSync(childSessionFile, [
-						{ type: "session", version: 1, id: "child", timestamp: "2026-04-16T00:00:00.000Z", cwd: "/tmp", parentSession: parentSessionFile },
-						{ type: "message", id: "assistant-1", parentId: null, timestamp: "2026-04-16T00:00:02.000Z", message: { role: "assistant", provider: "anthropic", api: "anthropic-messages", model: "anthropic/claude-sonnet-4-5", content: [{ type: "thinking", thinking: "private chain", thinkingSignature: "signed" }, { type: "text", text: "answer" }] } },
-					].map((entry) => JSON.stringify(entry)).join("\n") + "\n", "utf-8");
-					return childSessionFile;
-				},
-			}),
-		};
-		const executor = makeExecutorWithDiscoverAgents(() => ({
-			agents: [
-				{ name: "worker", description: "Worker", defaultContext: "fork", model: "openai/gpt-5-mini:high", fallbackModels: ["anthropic/claude-sonnet-4:low"], thinking: "high" },
-			],
-			projectAgentsDir: null,
-		}));
-
-		const ctx = {
-			...makeCtx(manager),
-			modelRegistry: {
-				getAvailable: () => [
-					{ provider: "openai", id: "gpt-5-mini", api: "openai-responses", reasoning: true },
-					{ provider: "anthropic", id: "claude-sonnet-4", api: "anthropic-messages", reasoning: true },
-				],
-			},
-		};
-		const result = await executor.execute(
-			"id",
-			{ agent: "worker", task: "test" },
-			new AbortController().signal,
-			undefined,
-			ctx,
-		);
-
-		assert.equal(result.isError, undefined);
-		const modelArgs = readAllCallArgs().map((args) => args[args.indexOf("--model") + 1]);
-		assert.deepEqual(modelArgs, ["openai/gpt-5-mini:off", "anthropic/claude-sonnet-4:off"]);
+		assert.equal(entries.length, 2);
+		assert.ok(!entries.some((entry) => entry.type === "thinking_level_change"));
 	});
-
-	it("keeps requested thinking for non-Anthropic forked children without Anthropic fallbacks", async () => {
+	it("keeps requested thinking for non-Anthropic forked children", async () => {
 		mockPi.reset();
 		mockPi.onCall({ output: "done" });
 		const parentSessionFile = path.join(tempDir, "parent.jsonl");
@@ -764,7 +781,7 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		}
 	});
 
-	it("notes the forced thinking downgrade in the result for Anthropic forked children", async () => {
+	it("reports no thinking downgrade for Anthropic forked children", async () => {
 		mockPi.reset();
 		mockPi.onCall({ output: "done" });
 		const parentSessionFile = path.join(tempDir, "parent.jsonl");
@@ -807,10 +824,12 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 
 		assert.equal(result.isError, undefined);
 		const text = result.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
-		assert.equal(text.includes("fork context forced thinking off for worker (child 0)"), true);
+		assert.equal(text.includes("forced thinking off"), false);
+		const noteArgs = readCallArgs();
+		assert.equal(noteArgs[noteArgs.indexOf("--model") + 1], "anthropic/claude-sonnet-4-5:high");
 	});
 
-	it("resolves inherit before classifying a forked child", async () => {
+	it("resolves inherit for a forked child without downgrading thinking", async () => {
 		const childSessionFile = path.join(tempDir, "fork-inherit-thinking.jsonl");
 		const manager = makeSignedThinkingSessionManager(childSessionFile);
 		const executor = makeExecutorWithDiscoverAgents(() => ({
@@ -837,7 +856,7 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 
 		assert.equal(result.isError, undefined);
 		const args = readCallArgs();
-		assert.equal(args[args.indexOf("--model") + 1], "anthropic/claude-sonnet-4-5:off");
+		assert.equal(args[args.indexOf("--model") + 1], "anthropic/claude-sonnet-4-5:high");
 	});
 
 	it("keeps inherited parent models outside the registry during foreground fork preparation", async () => {
@@ -883,7 +902,7 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 
 
 
-	it("includes the fork-thinking downgrade note on failed results", async () => {
+	it("adds no fork-thinking downgrade note to failed results", async () => {
 		mockPi.reset();
 		mockPi.onCall({ stderr: "task failed", exitCode: 1 });
 		const childSessionFile = path.join(tempDir, "fork-failed-thinking.jsonl");
@@ -911,7 +930,7 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 
 		assert.equal(result.isError, true);
 		const text = result.content.filter((block) => block.text).map((block) => block.text).join("\n");
-		assert.equal(text.includes("fork context forced thinking off for worker (child 0)"), true);
+		assert.equal(text.includes("forced thinking off"), false);
 	});
 
 	it("keeps default-fork context on run-path errors", async () => {