@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/unit/default-extensions.test.ts

@@ -9,6 +9,7 @@ import {
 	discoverAgentsAll,
 } from "../../src/agents/agents.ts";
 import { handleUpdate } from "../../src/agents/agent-management.ts";
+import { resolvePiLaunchToolPlan } from "../../src/api/child-tool-plan.ts";
 
 let tempHome = "";
 let tempProject = "";
@@ -21,17 +22,17 @@ function writeJson(filePath: string, value: unknown): void {
 	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
 }
 
-function writeProjectAgent(name: string, extensions?: string): void {
+function writeProjectAgent(name: string, extensionFrontmatter = ""): void {
 	const filePath = path.join(tempProject, ".selesai", "agents", `${name}.md`);
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
 	fs.writeFileSync(
 		filePath,
-		`---\nname: ${name}\ndescription: Test agent${extensions === undefined ? "" : `\nextensions:${extensions ? ` ${extensions}` : ""}`}\n---\n\nTest agent.\n`,
+		`---\nname: ${name}\ndescription: Test agent${extensionFrontmatter ? `\n${extensionFrontmatter}` : ""}\n---\n\nTest agent.\n`,
 		"utf-8",
 	);
 }
 
-describe("subagents.defaultExtensions", () => {
+describe("subagent extension defaults", () => {
 	beforeEach(() => {
 		tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-home-"));
 		tempProject = fs.mkdtempSync(
@@ -59,6 +60,7 @@ describe("subagents.defaultExtensions", () => {
 			(agent) => agent.name === "scout",
 		);
 		assert.equal(scout?.extensions, undefined);
+		assert.equal(scout?.subagentOnlyExtensions, undefined);
 
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: { defaultExtensions: [] },
@@ -69,13 +71,72 @@ describe("subagents.defaultExtensions", () => {
 		assert.deepEqual(scout?.extensions, []);
 	});
 
+	it("preserves ambient loading unless extensions defaults are also configured", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { defaultSubagentOnlyExtensions: ["  ./child.ts  "] },
+		});
+		const scout = discoverAgentsAll(tempProject).builtin.find((agent) => agent.name === "scout");
+		assert.ok(scout);
+		assert.equal(scout.extensions, undefined);
+		assert.deepEqual(scout.subagentOnlyExtensions, ["./child.ts"]);
+
+		const plan = resolvePiLaunchToolPlan(scout);
+		assert.equal(plan.disableAmbientExtensions, false);
+		assert.ok(plan.extensionArgs.includes("./child.ts"));
+
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				defaultExtensions: ["./allowlisted.ts"],
+				defaultSubagentOnlyExtensions: ["./child.ts"],
+			},
+		});
+		const allowlisted = discoverAgentsAll(tempProject).builtin.find((agent) => agent.name === "scout");
+		assert.ok(allowlisted);
+		const allowlistedPlan = resolvePiLaunchToolPlan(allowlisted);
+		assert.equal(allowlistedPlan.disableAmbientExtensions, true);
+		assert.ok(allowlistedPlan.extensionArgs.includes("./allowlisted.ts"));
+		assert.ok(allowlistedPlan.extensionArgs.includes("./child.ts"));
+	});
+
+	it("preserves an explicit child-only field and applies overrides after defaults", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				defaultSubagentOnlyExtensions: ["./default.ts"],
+				agentOverrides: {
+					replaced: { subagentOnlyExtensions: ["./user-replacement.ts"] },
+					cleared: { subagentOnlyExtensions: ["./user-cleared.ts"] },
+					scout: { subagentOnlyExtensions: [] },
+				},
+			},
+		});
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: {
+				agentOverrides: {
+					replaced: { subagentOnlyExtensions: ["./replacement.ts"] },
+					cleared: { subagentOnlyExtensions: false },
+				},
+			},
+		});
+		writeProjectAgent("empty", "subagentOnlyExtensions:");
+		writeProjectAgent("explicit", "subagentOnlyExtensions: ./explicit.ts");
+		writeProjectAgent("replaced");
+		writeProjectAgent("cleared");
+
+		const agents = discoverAgents(tempProject, "both").agents;
+		assert.deepEqual(agents.find((agent) => agent.name === "empty")?.subagentOnlyExtensions, []);
+		assert.deepEqual(agents.find((agent) => agent.name === "explicit")?.subagentOnlyExtensions, [path.join(tempProject, ".selesai", "agents", "explicit.ts")]);
+		assert.deepEqual(agents.find((agent) => agent.name === "replaced")?.subagentOnlyExtensions, ["./replacement.ts"]);
+		assert.equal(agents.find((agent) => agent.name === "cleared")?.subagentOnlyExtensions, undefined);
+		assert.deepEqual(agents.find((agent) => agent.name === "scout")?.subagentOnlyExtensions, []);
+	});
+
 	it("applies the allowlist only when an agent has no extensions field", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: { defaultExtensions: ["./shared.ts"] },
 		});
 		writeProjectAgent("inherited");
-		writeProjectAgent("explicit", "./explicit.ts");
-		writeProjectAgent("disabled", "");
+		writeProjectAgent("explicit", "extensions: ./explicit.ts");
+		writeProjectAgent("disabled", "extensions:");
 
 		const agents = discoverAgents(tempProject, "both").agents;
 		assert.deepEqual(
@@ -104,7 +165,7 @@ describe("subagents.defaultExtensions", () => {
 			},
 		});
 		writeProjectAgent("inherited");
-		writeProjectAgent("explicit", "./frontmatter.ts");
+		writeProjectAgent("explicit", "extensions: ./frontmatter.ts");
 
 		const agents = discoverAgents(tempProject, "both").agents;
 		assert.deepEqual(
@@ -125,6 +186,7 @@ describe("subagents.defaultExtensions", () => {
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
 			subagents: {
 				defaultExtensions: ["./default.ts"],
+				defaultSubagentOnlyExtensions: ["./child-default.ts"],
 				agentOverrides: {
 					overridden: { extensions: ["./override.ts"] },
 				},
@@ -132,12 +194,16 @@ describe("subagents.defaultExtensions", () => {
 		});
 		writeProjectAgent("defaulted");
 		writeProjectAgent("overridden");
+		writeProjectAgent("declared", "subagentOnlyExtensions: ./declared.ts");
+		const discovered = new Map(discoverAgents(tempProject, "both").agents.map((agent) => [agent.name, agent]));
+		for (const name of ["defaulted", "overridden"]) assert.deepEqual(discovered.get(name)?.subagentOnlyExtensions, ["./child-default.ts"]);
+		assert.deepEqual(discovered.get("declared")?.subagentOnlyExtensions, [path.join(tempProject, ".selesai", "agents", "declared.ts")]);
 
 		const ctx = {
 			cwd: tempProject,
 			modelRegistry: { getAvailable: () => [] },
 		} as unknown as Parameters<typeof handleUpdate>[1];
-		for (const agent of ["defaulted", "overridden"]) {
+		for (const agent of ["defaulted", "overridden", "declared"]) {
 			const updated = handleUpdate(
 				{ agent, config: { description: `Updated ${agent}` } },
 				ctx,
@@ -151,6 +217,8 @@ describe("subagents.defaultExtensions", () => {
 				"utf-8",
 			);
 			assert.doesNotMatch(content, /^extensions:/m);
+			if (agent === "declared") assert.match(content, /^subagentOnlyExtensions: \.\/declared\.ts$/m);
+			else assert.doesNotMatch(content, /^subagentOnlyExtensions:/m);
 		}
 	});
 
@@ -177,43 +245,47 @@ describe("subagents.defaultExtensions", () => {
 
 	it("uses project settings over user settings while respecting discovery scope", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { defaultExtensions: ["./user.ts"] },
+			subagents: {
+				defaultExtensions: ["./user.ts"],
+				defaultSubagentOnlyExtensions: ["./user-child.ts"],
+			},
 		});
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
 			subagents: { defaultExtensions: [] },
 		});
 
+		const both = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "scout");
+		const user = discoverAgents(tempProject, "user").agents.find((agent) => agent.name === "scout");
+		const project = discoverAgents(tempProject, "project").agents.find((agent) => agent.name === "scout");
+		assert.deepEqual(both?.extensions, []);
+		assert.deepEqual(both?.subagentOnlyExtensions, ["./user-child.ts"]);
+		assert.deepEqual(user?.extensions, ["./user.ts"]);
+		assert.deepEqual(user?.subagentOnlyExtensions, ["./user-child.ts"]);
+		assert.deepEqual(project?.extensions, []);
+		assert.equal(project?.subagentOnlyExtensions, undefined);
+
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: { defaultExtensions: [], defaultSubagentOnlyExtensions: [] },
+		});
 		assert.deepEqual(
-			discoverAgents(tempProject, "both").agents.find(
-				(agent) => agent.name === "scout",
-			)?.extensions,
-			[],
-		);
-		assert.deepEqual(
-			discoverAgents(tempProject, "user").agents.find(
-				(agent) => agent.name === "scout",
-			)?.extensions,
-			["./user.ts"],
-		);
-		assert.deepEqual(
-			discoverAgents(tempProject, "project").agents.find(
-				(agent) => agent.name === "scout",
-			)?.extensions,
+			discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "scout")?.subagentOnlyExtensions,
 			[],
 		);
 	});
 
 	it("rejects malformed values", () => {
 		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
-		for (const defaultExtensions of ["nope", 42, [""], [42], ["valid", 42]]) {
-			writeJson(settingsPath, { subagents: { defaultExtensions } });
-			assert.throws(
-				() => discoverAgents(tempProject, "both"),
-				(error: unknown) =>
-					error instanceof Error &&
-					error.message.includes(settingsPath) &&
-					error.message.includes("defaultExtensions"),
-			);
+		for (const settingName of ["defaultExtensions", "defaultSubagentOnlyExtensions"]) {
+			for (const value of ["nope", ["   "], [42], ["valid", 42]]) {
+				writeJson(settingsPath, { subagents: { [settingName]: value } });
+				assert.throws(
+					() => discoverAgents(tempProject, "both"),
+					(error: unknown) =>
+						error instanceof Error &&
+						error.message.includes(settingsPath) &&
+						error.message.includes(settingName),
+				);
+			}
 		}
 	});
 });

package/dist/extensions/pi-subagents/test/unit/delegation-api.test.ts

@@ -11,6 +11,7 @@ import {
 	type SubagentDelegationResponse,
 	type SubagentDelegationUpdate,
 } from "../../src/api/delegation.ts";
+import { toSubagentDelegationExecutionParams } from "../../src/slash/delegation-adapters.ts";
 import { parseSubagentDelegationRequest } from "../../src/slash/delegation-request.ts";
 import {
 	registerPromptTemplateDelegationBridge,
@@ -111,6 +112,29 @@ describe("public subagent delegation contract", () => {
 		}
 	});
 
+	it("accepts a per-launch intercomBridge override and forwards it to execution", () => {
+		const intercomBridge = { mode: "off" as const };
+		const parsed = parseSubagentDelegationRequest({ ...request, intercomBridge });
+		assert.equal(parsed.ok, true);
+		if (parsed.ok) {
+			assert.deepEqual(parsed.request.intercomBridge, intercomBridge);
+			assert.notEqual(parsed.request.intercomBridge, intercomBridge, "parsed request must not alias the caller's object");
+			assert.deepEqual(toSubagentDelegationExecutionParams(parsed.request).intercomBridge, intercomBridge);
+		}
+		assert.equal("intercomBridge" in toSubagentDelegationExecutionParams(request), false);
+		const malformed = [
+			[{ ...request, intercomBridge: { mode: "loud" } }, /intercomBridge\.mode is invalid/],
+			[{ ...request, intercomBridge: { extra: true } }, /intercomBridge\.extra is not supported/],
+			[{ ...request, intercomBridge: "off" }, /intercomBridge must be an object/],
+			[{ ...request, intercomBridge: { instructionFile: "x".repeat(1025) } }, /intercomBridge\.instructionFile exceeds 1 KiB/],
+		] as const;
+		for (const [input, expected] of malformed) {
+			const rejected = parseSubagentDelegationRequest(input);
+			assert.equal(rejected.ok, false);
+			if (!rejected.ok) assert.match(rejected.error, expected);
+		}
+	});
+
 	it("rejects non-JSON schemas without executing toJSON hooks", () => {
 		let calls = 0;
 		const parsed = parseSubagentDelegationRequest({
@@ -199,6 +223,41 @@ describe("public subagent delegation contract", () => {
 		bridge.dispose();
 	});
 
+	it("reports a blocked foreground tool attempt as tool_budget_exhausted", async () => {
+		const events = new FakeEvents();
+		const responses: SubagentDelegationResponse[] = [];
+		events.on(SUBAGENT_DELEGATION_RESPONSE_EVENT, (payload) => responses.push(payload as SubagentDelegationResponse));
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async () => { throw new Error("legacy executor must remain separate"); },
+			executeStructured: async () => ({
+				details: {
+					mode: "single",
+					results: [{
+						agent: "reviewer",
+						exitCode: 0,
+						toolBudgetBlocked: true,
+						finalOutput: "The required tool was blocked.",
+						usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 },
+					}],
+				},
+			}),
+		});
+		events.emit(SUBAGENT_DELEGATION_REQUEST_EVENT, { ...request, result: { kind: "text" as const } });
+		while (responses.length === 0) await tick();
+		assert.deepEqual(responses, [{
+			requestId: "attempt-1",
+			ownerRunId: "owner-1",
+			nodeId: "node-1",
+			status: "tool_budget_exhausted",
+			agent: "reviewer",
+			exitCode: 0,
+			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1, toolCalls: 0, durationMs: 0 },
+		} satisfies SubagentDelegationResponse]);
+		bridge.dispose();
+	});
+
 	it("suppresses unchanged structured delegation heartbeat snapshots", async () => {
 		const events = new FakeEvents();
 		const updates: SubagentDelegationUpdate[] = [];
@@ -272,6 +331,83 @@ describe("public subagent delegation contract", () => {
 		bridge.dispose();
 	});
 
+	it("emits a structured delegation update when only cumulative cache or turn counters change", async () => {
+		const events = new FakeEvents();
+		const updates: SubagentDelegationUpdate[] = [];
+		events.on(SUBAGENT_DELEGATION_UPDATE_EVENT, (payload) => updates.push(payload as SubagentDelegationUpdate));
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async () => { throw new Error("legacy executor must remain separate"); },
+			executeStructured: async (_id, _params, _signal, _ctx, onUpdate) => {
+				const base = {
+					index: 0,
+					agent: "reviewer",
+					currentTool: "read",
+					toolCount: 1,
+					durationMs: 1_000,
+					tokens: 16,
+					inputTokens: 8,
+					outputTokens: 8,
+					cacheRead: 0,
+					cacheWrite: 0,
+					turnCount: 1,
+				};
+				onUpdate({ details: { mode: "single", runId: "run-usage", results: [{ agent: "reviewer", model: "openai/gpt-5" }], progress: [base] } });
+				// Exact duplicate: tokens/tool progress and usage counters are unchanged, so this is a heartbeat.
+				onUpdate({ details: { mode: "single", runId: "run-usage", results: [{ agent: "reviewer", model: "openai/gpt-5" }], progress: [{ ...base }] } });
+				onUpdate({ details: { mode: "single", runId: "run-usage", results: [{ agent: "reviewer", model: "openai/gpt-5" }], progress: [{ ...base, cacheRead: 4 }] } });
+				onUpdate({ details: { mode: "single", runId: "run-usage", results: [{ agent: "reviewer", model: "openai/gpt-5" }], progress: [{ ...base, cacheRead: 4, cacheWrite: 2 }] } });
+				onUpdate({ details: { mode: "single", runId: "run-usage", results: [{ agent: "reviewer", model: "openai/gpt-5" }], progress: [{ ...base, cacheRead: 4, cacheWrite: 2, turnCount: 2 }] } });
+				return {
+					details: {
+						mode: "single",
+						runId: "run-usage",
+						results: [{ agent: "reviewer", exitCode: 0, model: "openai/gpt-5", finalOutput: "done", usage: { input: 8, output: 8, cacheRead: 4, cacheWrite: 2, cost: 0, turns: 2 } }],
+					},
+				};
+			},
+		});
+		const responsePromise = once(events, SUBAGENT_DELEGATION_RESPONSE_EVENT);
+		events.emit(SUBAGENT_DELEGATION_REQUEST_EVENT, { ...request, result: { kind: "text" as const } });
+		assert.equal((await responsePromise as SubagentDelegationResponse).status, "completed");
+		assert.equal(updates.length, 4);
+		assert.deepEqual(updates[0]?.usage, { input: 8, output: 8, cacheRead: 0, cacheWrite: 0, turns: 1 });
+		assert.deepEqual(updates[1]?.usage, { input: 8, output: 8, cacheRead: 4, cacheWrite: 0, turns: 1 });
+		assert.deepEqual(updates[2]?.usage, { input: 8, output: 8, cacheRead: 4, cacheWrite: 2, turns: 1 });
+		assert.deepEqual(updates[3]?.usage, { input: 8, output: 8, cacheRead: 4, cacheWrite: 2, turns: 2 });
+		bridge.dispose();
+	});
+
+	it("omits usage from a structured delegation update when counters are absent or invalid", async () => {
+		const events = new FakeEvents();
+		const updates: SubagentDelegationUpdate[] = [];
+		events.on(SUBAGENT_DELEGATION_UPDATE_EVENT, (payload) => updates.push(payload as SubagentDelegationUpdate));
+		const bridge = registerPromptTemplateDelegationBridge({
+			events,
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async () => { throw new Error("legacy executor must remain separate"); },
+			executeStructured: async (_id, _params, _signal, _ctx, onUpdate) => {
+				onUpdate({ details: { mode: "single", runId: "run-invalid", results: [{ agent: "reviewer", model: "openai/gpt-5" }], progress: [{ index: 0, agent: "reviewer", currentTool: "read", toolCount: 1, tokens: 8 }] } });
+				onUpdate({ details: { mode: "single", runId: "run-invalid", results: [{ agent: "reviewer", model: "openai/gpt-5" }], progress: [{ index: 0, agent: "reviewer", currentTool: "write", toolCount: 2, tokens: 16, inputTokens: -1, outputTokens: 8, cacheRead: 0, cacheWrite: 0, turnCount: 1 }] } });
+				onUpdate({ details: { mode: "single", runId: "run-invalid", results: [{ agent: "reviewer", model: "openai/gpt-5" }], progress: [{ index: 0, agent: "reviewer", currentTool: "grep", toolCount: 3, tokens: 16, inputTokens: 8, outputTokens: Number.NaN, cacheRead: 0, cacheWrite: 0, turnCount: 1 }] } });
+				return {
+					details: {
+						mode: "single",
+						runId: "run-invalid",
+						results: [{ agent: "reviewer", exitCode: 0, model: "openai/gpt-5", finalOutput: "done", usage: { input: 8, output: 8, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 } }],
+					},
+				};
+			},
+		});
+		const responsePromise = once(events, SUBAGENT_DELEGATION_RESPONSE_EVENT);
+		events.emit(SUBAGENT_DELEGATION_REQUEST_EVENT, { ...request, result: { kind: "text" as const } });
+		assert.equal((await responsePromise as SubagentDelegationResponse).status, "completed");
+		assert.equal(updates.length, 3);
+		for (const update of updates) assert.equal(update.usage, undefined);
+		bridge.dispose();
+	});
+
 	it("always delivers the complete structured terminal error after quiet heartbeats", async () => {
 		const events = new FakeEvents();
 		const updates: SubagentDelegationUpdate[] = [];
@@ -348,6 +484,7 @@ describe("public subagent delegation contract", () => {
 		}
 	});
 
+
 	it("isolates logical-node ownership, exact cancellation, pre-cancellation, and reuse", async () => {
 		const events = new FakeEvents();
 		const releases = new Map<string, () => void>();
@@ -585,4 +722,4 @@ describe("public subagent delegation contract", () => {
 		assert.equal(executeCalls, 0);
 		bridge.dispose();
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/disabled-features.test.ts

@@ -0,0 +1,227 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { SUBAGENT_FEATURES, resolveDisabledFeatureSurface, validateDisabledFeatures, type SubagentFeature } from "../../src/shared/disabled-features.ts";
+import { SubagentParams, createSubagentParamsSchema } from "../../src/extension/schemas.ts";
+import { SUBAGENT_RPC_PROTOCOL_VERSION, SUBAGENT_RPC_REQUEST_EVENT, registerSubagentRpcBridge, subagentRpcReplyEvent } from "../../src/extension/rpc.ts";
+import { readSubagentGuide } from "../../src/extension/subagent-guide.ts";
+import { buildSubagentToolDescription, SUBAGENT_SAFETY_GUIDANCE } from "../../src/extension/tool-description.ts";
+import { createSubagentExecutor } from "../../src/runs/foreground/subagent-executor.ts";
+import { createChildSafeState } from "../../src/extension/fanout-child.ts";
+import type { ExtensionConfig } from "../../src/shared/types.ts";
+import { makeMinimalCtx } from "../support/helpers.ts";
+
+const ALL_FEATURES = Object.keys(SUBAGENT_FEATURES) as SubagentFeature[];
+const ALL_DISABLED: ExtensionConfig = { disabledFeatures: ALL_FEATURES, scheduledRuns: { enabled: false } };
+
+const GROUPS: Array<{ name: string; config: ExtensionConfig; setting: string; params: string[]; actions: string[] }> = [
+	...([
+		["agent-management", ["config"], ["create", "update", "delete", "eject", "disable", "enable", "reset", "refine", "refine.show", "refine.rollback"]],
+		["watchdog", ["scope", "target", "thinking"], ["watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model"]],
+		["panes", ["focus"], ["inspector.open", "inspector.command", "inspector.status", "inspector.close", "project.open", "project.status", "project.close"]],
+		["missions", ["mission", "missionUpdate", "missionStatus", "missionScope", "missionId", "runMode", "runStatus", "summary"], ["mission.create", "mission.list", "mission.show", "mission.update", "mission.resolve-decision", "mission.attach-run", "mission.close"]],
+		["lane-management", ["handoffPath", "laneId", "merge", "supersession", "repo", "planId"], ["lane.status", "lane.recordMerge", "lane.recordSupersession", "worktree.discard", "worktree.cleanup"]],
+		["spawn-budget-grants", ["additional"], ["grant-spawn-budget"]],
+		["preflight", ["preflight"], []],
+		["lane-metadata", ["lane"], []],
+		["gates", ["gate"], []],
+		["usage-budgets", ["usageBudget"], []],
+		["tool-budgets", ["toolBudget"], []],
+		["control-overrides", ["control"], []],
+		["extension-bindings", ["extensionBindings"], []],
+		["external-machines", ["machine"], []],
+		["workflow-scripts", ["workflow", "args", "preflight", "globalConcurrencyLimit", "maxSubagentSpawnsPerRun"], ["validate"]],
+	] as const).map(([name, params, actions]) => ({ name, config: { disabledFeatures: [name] }, setting: `disabledFeatures "${name}"`, params: [...params], actions: [...actions] })),
+	{
+		name: "schedules",
+		config: { scheduledRuns: { enabled: false } },
+		setting: "scheduledRuns.enabled=false",
+		params: ["name", "at", "every", "sessionOnly", "quiet", "on", "timezone", "overlap", "catchUp"],
+		actions: ["schedule.create", "schedule.list", "schedule.show", "schedule.history", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"],
+	},
+];
+
+function schemaKeys(config: ExtensionConfig): string[] {
+	return Object.keys(createSubagentParamsSchema(resolveDisabledFeatureSurface(config)).properties);
+}
+
+function createExecutor(config: ExtensionConfig) {
+	return createSubagentExecutor({
+		pi: { events: { emit() {}, on() { return () => {}; } }, getSessionName() { return "parent"; } } as never,
+		state: createChildSafeState(),
+		config: { maxSubagentDepth: 2, control: {}, intercomBridge: {}, ...config } as never,
+		asyncByDefault: false,
+		tempArtifactsDir: os.tmpdir(),
+		getSubagentSessionRoot: () => os.tmpdir(),
+		expandTilde: (value) => value,
+		discoverAgents: () => ({ agents: [] as never[] }),
+	});
+}
+
+function ctx(cwd = os.tmpdir()) {
+	return makeMinimalCtx(cwd) as never;
+}
+
+function resultText(result: { content: Array<{ type: string; text?: string }> }): string {
+	return result.content.map((part) => part.text ?? "").join("\n");
+}
+
+describe("disabledFeatures config", () => {
+	it("covers every registered feature in this test table", () => {
+		assert.deepEqual(GROUPS.map((group) => group.name).filter((name) => name !== "schedules").sort(), [...ALL_FEATURES].sort());
+	});
+
+	it("rejects unknown, duplicate, and schedule entries", () => {
+		assert.doesNotThrow(() => validateDisabledFeatures(ALL_FEATURES));
+		assert.throws(() => validateDisabledFeatures("watchdog"), /must be an array/);
+		assert.throws(() => validateDisabledFeatures(["watchdogs"]), /"watchdogs" is not one of/);
+		assert.throws(() => validateDisabledFeatures(["gates", "gates"]), /more than once/);
+		assert.throws(() => validateDisabledFeatures(["schedules"]), /scheduledRuns\.enabled to false/);
+	});
+});
+
+describe("disabled feature groups", () => {
+	const fullKeys = schemaKeys({});
+
+	it("keeps the registered schema object when nothing is disabled", () => {
+		assert.equal(createSubagentParamsSchema(resolveDisabledFeatureSurface({})), SubagentParams);
+		assert.equal(createSubagentParamsSchema(resolveDisabledFeatureSurface({ scheduledRuns: { enabled: true } })), SubagentParams);
+	});
+
+	for (const group of GROUPS) {
+		it(`${group.name}: removes exactly its parameters from the schema`, () => {
+			for (const param of group.params) assert.ok(fullKeys.includes(param), `${param} is not a schema parameter`);
+			// workflow-scripts replaces the removed script parameters with chain/tasks after task.
+			const added = group.name === "workflow-scripts" ? ["tasks", "chain"] : [];
+			assert.deepEqual(schemaKeys(group.config), fullKeys.filter((key) => !group.params.includes(key)).flatMap((key) => key === "task" ? [key, ...added] : [key]));
+		});
+
+		it(`${group.name}: rejects its actions and parameters with the setting name`, async () => {
+			const executor = createExecutor(group.config);
+			for (const action of group.actions) {
+				const result = await executor.executePublic("disabled-action", { action }, new AbortController().signal, undefined, ctx());
+				assert.equal(result.isError, true);
+				assert.equal(resultText(result), `subagent action '${action}' is disabled by config ${group.setting}.`);
+				assert.equal(result.details.mode, "management");
+			}
+			const param = group.params[0]!;
+			const result = await executor.executePublic("disabled-option", { agent: "worker", task: "scan", [param]: "x" }, new AbortController().signal, undefined, ctx());
+			assert.equal(result.isError, true);
+			assert.equal(resultText(result), `subagent option '${param}' is disabled by config ${group.setting}.`);
+			assert.equal(result.details.mode, param === "workflow" ? "workflow" : "single");
+		});
+	}
+});
+
+describe("disabled feature execution boundaries", () => {
+	it("rejects a disabled option on delegated execution", async () => {
+		const result = await createExecutor({ disabledFeatures: ["gates"] }).executeDelegated("disabled-delegated", { agent: "worker", task: "scan", gate: "npm test" }, new AbortController().signal, undefined, ctx());
+		assert.equal(result.isError, true);
+		assert.equal(resultText(result), `subagent option 'gate' is disabled by config disabledFeatures "gates".`);
+	});
+
+	it("rejects a disabled option on a runs.all workflow child before it launches", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-disabled-features-workflow-"));
+		try {
+			const result = await createExecutor({ disabledFeatures: ["external-machines"] }).executePublic(
+				"disabled-workflow-child",
+				{
+					// A non-literal agent skips static agent validation and reaches launch admission.
+					workflowScript: `const agent = "worker"; return await runs.all([{ key: "local", agent, task: "scan" }, { key: "remote", agent, task: "scan", machine: "box" }]);`,
+					async: false,
+					chatProgress: "off",
+				},
+				new AbortController().signal,
+				undefined,
+				ctx(root),
+			);
+			// runs.all admits the batch together, so neither child launches.
+			const error = `workflow child 'remote' option 'machine' is disabled by config disabledFeatures "external-machines".`;
+			assert.deepEqual((result.details.workflow?.value as Array<{ key: string; ok: boolean; error?: string }>).map(({ key, ok, error }) => ({ key, ok, error })), [
+				{ key: "local", ok: false, error },
+				{ key: "remote", ok: false, error },
+			]);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("disabled feature discovery", () => {
+	const featureText = [
+		"not watchdog-only thinking",
+		"tool budget, fast",
+		"usageBudget is shared",
+		"unless mission:false",
+		"create/update/delete",
+		"mission.*",
+		"schedule.*",
+		"watchdog.*",
+		"inspector.*",
+		"lane.status",
+		"worktree.discard",
+		"grant-spawn-budget",
+		"Schedules take script inputs",
+	];
+
+	it("removes disabled-feature text from the built-in descriptions and keeps the safety guidance", () => {
+		const enabled = buildSubagentToolDescription({ toolDescriptionMode: "full" });
+		for (const text of featureText) assert.ok(enabled.includes(text), `enabled description lacks ${text}`);
+		assert.match(enabled, /Management discovery: list\/get\/models\/guide; create\/update\/delete\/eject\/disable\/enable\/reset\/refine; mission\.\*, schedule\.\*, watchdog\.\*, inspector\.\*, project\.\*, lane\.status\/recordMerge\/recordSupersession; worktree\.discard and reviewed worktree\.cleanup; doctor and grant-spawn-budget\. /);
+
+		const disabledFeatures = resolveDisabledFeatureSurface(ALL_DISABLED);
+		for (const toolDescriptionMode of [undefined, "full"] as const) {
+			const description = buildSubagentToolDescription({ toolDescriptionMode }, { disabledFeatures });
+			for (const text of featureText) assert.ok(!description.includes(text), `${toolDescriptionMode ?? "default"} description still has ${text}`);
+			// Every safety line stays; with workflow-scripts disabled only the script-writing wording changes.
+			for (const line of SUBAGENT_SAFETY_GUIDANCE.split("\n").filter((text) => !/runs\.|workflow call/.test(text))) assert.ok(description.includes(line), `${toolDescriptionMode ?? "default"} description lacks safety line ${line}`);
+			assert.match(description, /Thinking uses model suffix\./);
+		}
+		assert.match(buildSubagentToolDescription({ toolDescriptionMode: "full" }, { disabledFeatures }), /Management discovery: list\/get\/models\/guide; doctor\. Use guide topics agents, observability, tool-reference, configuration, models or extension-api for/);
+	});
+
+	it("lists only enabled actions for an unknown action", async () => {
+		const result = await createExecutor({ disabledFeatures: ["watchdog"], scheduledRuns: { enabled: false } }).executePublic("unknown-action", { action: "statsu" }, new AbortController().signal, undefined, ctx());
+		assert.equal(result.isError, true);
+		assert.match(resultText(result), /Did you mean status\?.*Valid: .*doctor/);
+		assert.doesNotMatch(resultText(result), /watchdog\.|schedule\./);
+	});
+
+	it("prepends a disabled-feature notice to the tool reference guide", async () => {
+		const guide = readSubagentGuide("tool-reference");
+		const request = { action: "guide", topic: "tool-reference" };
+		const enabled = await createExecutor({}).executePublic("guide", request, new AbortController().signal, undefined, ctx());
+		assert.equal(resultText(enabled), guide);
+		const disabled = resultText(await createExecutor({ disabledFeatures: ["watchdog"] }).executePublic("guide", request, new AbortController().signal, undefined, ctx()));
+		assert.ok(disabled.endsWith(guide));
+		assert.match(disabled.slice(0, -guide.length), /^Disabled by config[^\n]*\n- disabledFeatures "watchdog": options scope, target, thinking; actions watchdog\.status, watchdog\.check, watchdog\.configure, watchdog\.recommend-model\n\n$/);
+	});
+
+	it("advertises only enabled RPC management actions", async () => {
+		const handlers: Array<(data: unknown) => void> = [];
+		const replies = new Map<string, unknown>();
+		const events = {
+			on(event: string, handler: (data: unknown) => void) {
+				if (event === SUBAGENT_RPC_REQUEST_EVENT) handlers.push(handler);
+				return () => {};
+			},
+			emit(event: string, data: unknown) {
+				replies.set(event, data);
+			},
+		};
+		registerSubagentRpcBridge({
+			events: events as never,
+			getContext: () => ctx(),
+			execute: async () => assert.fail("disabled RPC actions must not execute"),
+			disabledFeatures: resolveDisabledFeatureSurface({ scheduledRuns: { enabled: false } }),
+		});
+		const request = async (requestId: string, method: string, params?: unknown) => {
+			for (const handler of handlers) await handler({ version: SUBAGENT_RPC_PROTOCOL_VERSION, requestId, method, params });
+			return replies.get(subagentRpcReplyEvent(requestId)) as { success: boolean; data?: { capabilities: { managementActions: string[] } }; error?: { message: string } };
+		};
+		assert.deepEqual((await request("ping", "ping")).data?.capabilities.managementActions, []);
+		assert.equal((await request("manage", "manage", { action: "schedule.bogus" })).error?.message, "RPC manage actions are all disabled by config.");
+	});
+});