@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-subagents/test/unit/runtime-agent-registration.test.ts

@@ -4,7 +4,8 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
 import type { ExtensionAPI } from "@selesai/code";
-import { registerAgent } from "../../src/api/agents.ts";
+import { RUNTIME_AGENT_REGISTER_EVENT, registerAgent, registerAgentViaEvents, type RuntimeAgentRegistrationRequest } from "../../src/api/agents.ts";
+import { registerRuntimeAgentEventListener } from "../../src/agents/runtime-agent-events.ts";
 import { handleList } from "../../src/agents/agent-management.ts";
 import { discoverAgents, discoverAgentsAll } from "../../src/agents/agents.ts";
 import { clearRuntimeAgentsForPi, mergeRuntimeAgents } from "../../src/agents/runtime-agent-registry.ts";
@@ -24,6 +25,25 @@ function makePi(): ExtensionAPI {
 	} as unknown as ExtensionAPI;
 }
 
+function makeEventBus(): ExtensionAPI["events"] {
+	const handlers = new Map<string, Set<(data: unknown) => void>>();
+	return {
+		emit(channel, data) {
+			for (const handler of handlers.get(channel) ?? []) handler(data);
+		},
+		on(channel, handler) {
+			const listeners = handlers.get(channel) ?? new Set();
+			listeners.add(handler);
+			handlers.set(channel, listeners);
+			return () => listeners.delete(handler);
+		},
+	};
+}
+
+function makePiWithEvents(events: ExtensionAPI["events"]): ExtensionAPI {
+	return { on() {}, registerTool() {}, events } as unknown as ExtensionAPI;
+}
+
 function writeProjectAgent(name: string, aliases: string[] = []): void {
 	const filePath = path.join(tempProject, ".selesai", "agents", `${name}.md`);
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -83,6 +103,103 @@ describe("runtime agent registration", () => {
 		registration.dispose();
 	});
 
+	it("accepts inheritGlobalContext in a runtime agent definition", () => {
+		const registration = registerAgent({
+			pi,
+			name: "runtime-global-helper",
+			definition: {
+				description: "Runtime global helper",
+				systemPrompt: "Help at runtime.",
+				inheritProjectContext: true,
+				inheritGlobalContext: true,
+			},
+		});
+
+		const agents = mergeRuntimeAgents(pi, discoverAgents(tempProject, "both")).agents;
+		const agent = agents.find((candidate) => candidate.name === "runtime-global-helper");
+		assert.equal(agent?.inheritProjectContext, true);
+		assert.equal(agent?.inheritGlobalContext, true);
+
+		registration.dispose();
+	});
+
+	it("registers through the owner runtime when consumer and owner API objects differ", () => {
+		const events = makeEventBus();
+		const ownerPi = makePiWithEvents(events);
+		const consumerPi = makePiWithEvents(events);
+		const unsubscribe = registerRuntimeAgentEventListener(ownerPi);
+		const registration = registerAgentViaEvents({
+			pi: consumerPi,
+			name: "runtime-event-helper",
+			definition: { description: "Event helper", systemPrompt: "Help through the owner." },
+		});
+
+		assert.equal(mergeRuntimeAgents(ownerPi, discoverAgents(tempProject, "both")).agents.some((agent) => agent.name === "runtime-event-helper"), true);
+		assert.equal(mergeRuntimeAgents(consumerPi, discoverAgents(tempProject, "both")).agents.some((agent) => agent.name === "runtime-event-helper"), false);
+		assert.throws(
+			() => registerAgentViaEvents({ pi: consumerPi, name: "runtime-event-helper", definition: { description: "Duplicate", systemPrompt: "Duplicate." } }),
+			/collides with runtime agent 'runtime-event-helper'/,
+		);
+
+		registration.dispose();
+		assert.equal(mergeRuntimeAgents(ownerPi, discoverAgents(tempProject, "both")).agents.some((agent) => agent.name === "runtime-event-helper"), false);
+		unsubscribe();
+		clearRuntimeAgentsForPi(ownerPi);
+	});
+
+	it("uses first-handler-wins semantics for duplicate owners", () => {
+		const events = makeEventBus();
+		const firstOwner = makePiWithEvents(events);
+		const secondOwner = makePiWithEvents(events);
+		const consumer = makePiWithEvents(events);
+		const unsubscribeFirst = registerRuntimeAgentEventListener(firstOwner);
+		const unsubscribeSecond = registerRuntimeAgentEventListener(secondOwner);
+
+		const registration = registerAgentViaEvents({
+			pi: consumer,
+			name: "first-owner-agent",
+			definition: { description: "First owner", systemPrompt: "Use the first owner." },
+		});
+		assert.equal(mergeRuntimeAgents(firstOwner, discoverAgents(tempProject, "both")).agents.some((agent) => agent.name === "first-owner-agent"), true);
+		assert.equal(mergeRuntimeAgents(secondOwner, discoverAgents(tempProject, "both")).agents.some((agent) => agent.name === "first-owner-agent"), false);
+
+		registration.dispose();
+		unsubscribeFirst();
+		unsubscribeSecond();
+		clearRuntimeAgentsForPi(firstOwner);
+		clearRuntimeAgentsForPi(secondOwner);
+	});
+
+	it("returns useful event registration errors and detects a missing owner", () => {
+		const events = makeEventBus();
+		const owner = makePiWithEvents(events);
+		const consumer = makePiWithEvents(events);
+		const unsubscribe = registerRuntimeAgentEventListener(owner);
+		const unsupported = { version: 2, name: "bad-version", definition: {} } as unknown as RuntimeAgentRegistrationRequest;
+		events.emit(RUNTIME_AGENT_REGISTER_EVENT, unsupported);
+		assert.equal(unsupported.result?.ok, false);
+		if (unsupported.result?.ok === false) assert.match(unsupported.result.error.message, /Unsupported runtime agent registration event version '2'/);
+
+		const malformed = { version: 1, name: "bad-definition" } as unknown as RuntimeAgentRegistrationRequest;
+		events.emit(RUNTIME_AGENT_REGISTER_EVENT, malformed);
+		assert.equal(malformed.result?.ok, false);
+		if (malformed.result?.ok === false) assert.match(malformed.result.error.message, /definition must be an object/i);
+		unsubscribe();
+		assert.throws(
+			() => registerAgentViaEvents({ pi: consumer, name: "no-owner", definition: { description: "Missing", systemPrompt: "Missing." } }),
+			/not installed, not ready, or does not support/,
+		);
+		const unsubscribeMalformed = events.on(RUNTIME_AGENT_REGISTER_EVENT, (raw) => {
+			(raw as { result?: unknown }).result = {};
+		});
+		assert.throws(
+			() => registerAgentViaEvents({ pi: consumer, name: "malformed-result", definition: { description: "Malformed", systemPrompt: "Malformed." } }),
+			/malformed runtime agent registration result/,
+		);
+		unsubscribeMalformed();
+		clearRuntimeAgentsForPi(owner);
+	});
+
 	it("lists runtime agents for the matching Pi runtime", () => {
 		registerAgent({
 			pi,
@@ -96,6 +213,24 @@ describe("runtime agent registration", () => {
 	});
 
 	it("fails closed for builtin and duplicate runtime identities", () => {
+		assert.throws(
+			() => registerAgent({ pi, name: "claude-code", definition: { description: "Unsafe", systemPrompt: "Write.", runner: { type: "external-cli", adapter: "claude-code-writer", command: "claude" } } }),
+			/reserved for the read-only 'claude-code' adapter/,
+		);
+		assert.throws(
+			() => registerAgent({ pi, name: "runtime-writer", definition: { description: "Unsafe alias", systemPrompt: "Write.", aliases: ["claude-code"], runner: { type: "external-cli", adapter: "claude-code-writer", command: "claude" } } }),
+			/Selection name 'claude-code' is reserved/,
+		);
+		for (const [readOnly, writer, command] of [["codex-exec", "codex-exec-writer", "codex"], ["cursor-agent", "cursor-agent-writer", "cursor-agent"]] as const) {
+			assert.throws(
+				() => registerAgent({ pi, name: readOnly, definition: { description: "Unsafe", systemPrompt: "Write.", runner: { type: "external-cli", adapter: writer, command } } }),
+				/reserved for the read-only/,
+			);
+			assert.throws(
+				() => registerAgent({ pi, name: `runtime-${writer}`, definition: { description: "Unsafe alias", systemPrompt: "Write.", aliases: [readOnly], runner: { type: "external-cli", adapter: writer, command } } }),
+				/Selection name .* is reserved/,
+			);
+		}
 		assert.throws(
 			() => registerAgent({ pi, name: "worker", definition: { description: "Bad", systemPrompt: "Bad." } }),
 			/Worker|builtin agent 'worker'|collides with builtin agent 'worker'/i,
@@ -110,7 +245,6 @@ describe("runtime agent registration", () => {
 
 	it("rejects malformed nested runtime definition fields at registration", () => {
 		const cases: Array<[string, Record<string, unknown>, RegExp]> = [
-			["defaultTurnBudget", { defaultTurnBudget: { maxTurns: 0 } }, /defaultTurnBudget\.maxTurns must be an integer >= 1/],
 			["defaultAcceptance", { defaultAcceptance: { level: "verified" } }, /defaultAcceptance\.verify must contain at least one runtime command/],
 			["runner", { runner: { type: "external-cli" } }, /external-cli runner requires a non-empty command string/],
 			["toolBudget", { toolBudget: { hard: 0 } }, /toolBudget\.hard must be an integer >= 1/],

package/dist/extensions/pi-subagents/test/unit/scheduled-runs.test.ts

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -56,6 +57,10 @@ afterEach(() => {
 	for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
 });
 
+function git(cwd: string, args: string[]): void {
+	execFileSync("git", args, { cwd, stdio: "ignore" });
+}
+
 function context(cwd: string, sessionId = "session-a"): ExtensionContext {
 	return {
 		cwd,
@@ -153,6 +158,28 @@ describe("project schedule management", () => {
 		assert.match(text(shown), /Night review/);
 	});
 
+	it("does not let completed one-shot schedules consume maxPending capacity", async () => {
+		const h = harness({ config: { scheduledRuns: { enabled: true, maxPending: 1 } } });
+		await h.manager.handleToolCall({ action: "schedule.create", id: "completed", at: "+1h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
+		h.clock.now += 3_600_000;
+		h.timers.fireAll();
+		await flush();
+		assert.equal(h.launches.length, 1);
+		const activeResult = await h.manager.handleToolCall({ action: "schedule.create", id: "active-blocked", at: "+2h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
+		assert.equal(activeResult.isError, true);
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "completed-async" } });
+		await flush();
+		h.manager.handleAsyncCompletion({ runId: "completed-async", success: true });
+
+		const result = await h.manager.handleToolCall({ action: "schedule.create", id: "replacement", at: "+2h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
+		assert.equal(result.isError, undefined);
+		const completedDir = path.join(scheduledRunStorePath(h.ctx.cwd, undefined, path.join(h.root, "stores")), "completed");
+		assert.equal(fs.existsSync(path.join(completedDir, "history.json")), true);
+		assert.equal(fs.existsSync(path.join(completedDir, "events.jsonl")), true);
+		const completedHistory = await h.manager.handleToolCall({ action: "schedule.history", id: "completed" }, h.ctx);
+		assert.match(text(completedHistory), /completed.*async completed-async/);
+	});
+
 	it("stores explicit cwd schedules in the target project", async () => {
 		const h = harness();
 		const target = path.join(h.root, "other-project");
@@ -360,6 +387,116 @@ describe("project schedule management", () => {
 		assert.match(text(result), /resolves outside the real project/);
 		assert.equal(fs.existsSync(path.join(outside, "schedules")), false);
 	});
+
+	it("allows a default project schedule root through a shared Git worktree .pi symlink", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-schedule-worktree-link-"));
+		roots.push(root);
+		const repository = path.join(root, "repository");
+		const worktree = path.join(repository, ".worktrees", "feature");
+		fs.mkdirSync(repository, { recursive: true });
+		git(repository, ["init"]);
+		git(repository, ["config", "user.email", "test@example.com"]);
+		git(repository, ["config", "user.name", "Test User"]);
+		fs.writeFileSync(path.join(repository, "tracked.txt"), "base\n", "utf-8");
+		git(repository, ["add", "tracked.txt"]);
+		git(repository, ["commit", "-m", "base"]);
+		fs.mkdirSync(path.dirname(worktree), { recursive: true });
+		git(repository, ["worktree", "add", "-b", "feature", worktree]);
+		fs.mkdirSync(path.join(repository, ".selesai"), { recursive: true });
+		fs.symlinkSync(path.join(repository, ".selesai"), path.join(worktree, ".selesai"), process.platform === "win32" ? "junction" : "dir");
+
+		const ctx = context(worktree);
+		const manager = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
+		});
+		manager.bindSession(ctx);
+		const result = await manager.handleToolCall({ action: "schedule.create", id: "shared", every: "1h", workflowScript: "return 1" }, ctx);
+		assert.equal(result.isError, undefined);
+		assert.equal(fs.existsSync(path.join(worktree, ".pi-subagents", "schedules", "shared", "schedule.json")), true);
+	});
+
+	it("rejects a Git worktree .pi symlink outside the shared config root", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-schedule-worktree-escape-"));
+		roots.push(root);
+		const repository = path.join(root, "repository");
+		const worktree = path.join(repository, ".worktrees", "feature");
+		const outside = path.join(root, "outside");
+		fs.mkdirSync(repository, { recursive: true });
+		git(repository, ["init"]);
+		git(repository, ["config", "user.email", "test@example.com"]);
+		git(repository, ["config", "user.name", "Test User"]);
+		fs.writeFileSync(path.join(repository, "tracked.txt"), "base\n", "utf-8");
+		git(repository, ["add", "tracked.txt"]);
+		git(repository, ["commit", "-m", "base"]);
+		fs.mkdirSync(path.dirname(worktree), { recursive: true });
+		git(repository, ["worktree", "add", "-b", "feature", worktree]);
+		fs.mkdirSync(path.join(repository, ".selesai"), { recursive: true });
+		fs.mkdirSync(outside);
+		fs.symlinkSync(outside, path.join(worktree, ".selesai"), process.platform === "win32" ? "junction" : "dir");
+
+		const manager = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
+		});
+		assert.doesNotThrow(() => manager.bindSession(context(worktree)));
+		assert.equal(fs.existsSync(path.join(outside, "subagents")), false);
+	});
+
+	it("rejects separate-git-dir primary checkout sharing without a registered root", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-schedule-separate-git-dir-"));
+		roots.push(root);
+		const repository = path.join(root, "repository");
+		const gitDir = path.join(root, "git-data", "metadata");
+		const worktree = path.join(root, "worktree");
+		fs.mkdirSync(repository, { recursive: true });
+		fs.mkdirSync(path.dirname(gitDir), { recursive: true });
+		git(repository, ["init", "--separate-git-dir", gitDir]);
+		git(repository, ["config", "user.email", "test@example.com"]);
+		git(repository, ["config", "user.name", "Test User"]);
+		fs.writeFileSync(path.join(repository, "tracked.txt"), "base\n", "utf-8");
+		git(repository, ["add", "tracked.txt"]);
+		git(repository, ["commit", "-m", "base"]);
+		git(repository, ["worktree", "add", "-b", "feature", worktree]);
+		const primaryConfig = path.join(repository, ".selesai");
+		fs.mkdirSync(primaryConfig, { recursive: true });
+		fs.symlinkSync(primaryConfig, path.join(worktree, ".selesai"), process.platform === "win32" ? "junction" : "dir");
+
+		const manager = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
+		});
+		assert.doesNotThrow(() => manager.bindSession(context(worktree)));
+		assert.equal(fs.existsSync(path.join(primaryConfig, "subagents")), false);
+	});
+
+	it("rejects an unregistered checkout ancestor with the same Git directory", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-schedule-unregistered-git-dir-"));
+		roots.push(root);
+		const repository = path.join(root, "repository");
+		const worktree = path.join(repository, ".worktrees", "feature");
+		const outside = path.join(root, "outside");
+		fs.mkdirSync(repository, { recursive: true });
+		git(repository, ["init"]);
+		git(repository, ["config", "user.email", "test@example.com"]);
+		git(repository, ["config", "user.name", "Test User"]);
+		fs.writeFileSync(path.join(repository, "tracked.txt"), "base\n", "utf-8");
+		git(repository, ["add", "tracked.txt"]);
+		git(repository, ["commit", "-m", "base"]);
+		fs.mkdirSync(path.dirname(worktree), { recursive: true });
+		git(repository, ["worktree", "add", "-b", "feature", worktree]);
+		const outsideConfig = path.join(outside, ".selesai");
+		fs.mkdirSync(outsideConfig, { recursive: true });
+		fs.writeFileSync(path.join(outside, ".git"), `gitdir: ${path.join(repository, ".git")}\n`, "utf-8");
+		fs.symlinkSync(outsideConfig, path.join(worktree, ".selesai"), process.platform === "win32" ? "junction" : "dir");
+
+		const manager = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
+		});
+		assert.doesNotThrow(() => manager.bindSession(context(worktree)));
+		assert.equal(fs.existsSync(path.join(outsideConfig, "subagents")), false);
+	});
 });
 
 describe("recurring schedule execution", () => {

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

@@ -29,6 +29,12 @@ interface SubagentParamsSchema {
 			minLength?: number;
 			description?: string;
 		};
+		workflowScriptPath?: {
+			type?: string;
+			minLength?: number;
+			description?: string;
+		};
+		preflight?: JsonSchemaNode;
 		chatProgress?: {
 			type?: string;
 			enum?: string[];
@@ -176,17 +182,33 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		assert.match(description, /else fresh/);
 	});
 
-	it("exposes a concise trusted inline workflow script mode", () => {
+	it("exposes trusted inline and file workflow script modes", () => {
 		const workflowScript = SubagentParams?.properties?.workflowScript;
 		assert.equal(workflowScript?.type, "string");
 		assert.equal(workflowScript?.minLength, 1);
 		assert.match(String(workflowScript?.description ?? ""), /runs\.run/);
+		assert.match(String(workflowScript?.description ?? ""), /runs\.lanes\(\[\{key,stages:/);
+		assert.match(String(workflowScript?.description ?? ""), /first stages run together.*later stages sequence per lane/i);
+		assert.match(String(workflowScript?.description ?? ""), /Each workflow key identifies one result lane.*new stable workflow key.*retained resume pass/i);
 		assert.match(String(workflowScript?.description ?? ""), /await runs\.all\(\[\{key, agent, task\}, \.\.\.\]\)/);
 		assert.match(String(workflowScript?.description ?? ""), /do not read \.output from unawaited runs\.run launches/i);
 		assert.match(String(workflowScript?.description ?? ""), /advanced rolling fanout/);
 		assert.match(String(workflowScript?.description ?? ""), /sequential and parallel phases dynamically/i);
 		assert.match(String(workflowScript?.description ?? ""), /worktree:true/i);
 		assert.match(String(workflowScript?.description ?? ""), /no filesystem, shell, Pi tools, or host globals/i);
+		const workflowScriptPath = SubagentParams?.properties?.workflowScriptPath;
+		assert.equal(workflowScriptPath?.type, "string");
+		assert.equal(workflowScriptPath?.minLength, 1);
+		assert.match(String(workflowScriptPath?.description ?? ""), /mutually exclusive with workflowScript/i);
+		assert.match(String(workflowScriptPath?.description ?? ""), /request cwd/i);
+		assert.match(String(workflowScriptPath?.description ?? ""), /host reads the file/i);
+		const preflight = SubagentParams?.properties?.preflight;
+		assert.equal(preflight?.type, "object");
+		assert.equal(preflight?.additionalProperties, false);
+		assert.match(String(preflight?.description ?? ""), /display-only/i);
+		assert.equal((preflight?.properties as JsonSchemaNode | undefined)?.version?.minimum, 1);
+		assert.equal((preflight?.properties as JsonSchemaNode | undefined)?.version?.maximum, 1);
+		assert.equal((preflight?.properties as JsonSchemaNode | undefined)?.lanes?.maxItems, 64);
 		const chatProgress = SubagentParams?.properties?.chatProgress;
 		assert.equal(chatProgress?.type, "string");
 		assert.deepEqual(chatProgress?.enum, ["auto", "off", "live-card"]);
@@ -209,14 +231,15 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		assert.match(String((properties?.agent as JsonSchemaNode | undefined)?.description ?? ""), /one-child/i);
 		assert.equal(properties?.clarify, undefined, "clarify should not be model-facing");
 		assert.ok(properties?.output, "output remains a workflow child default");
+		assert.match(String(properties?.output?.description ?? ""), /Relative workflow child paths use managed artifact routing/i);
+		assert.match(String(properties?.output?.description ?? ""), /Task filename prose is not an output declaration/i);
+		assert.match(String(properties?.output?.description ?? ""), /outputReference.*outputPathMapping.*artifactPaths/i);
 	});
 
 	it("omits removed legacy and workflow-child-only fields", () => {
 		for (const name of ["tasks", "chain", "concurrency", "chainDir", "step", "schedule", "scheduleName", "resume"]) {
 			assert.equal((SubagentParams?.properties as Record<string, unknown> | undefined)?.[name], undefined, `${name} should not be public`);
 		}
-
-		assert.doesNotMatch(JSON.stringify(SubagentParams), /append-step|approve-checkpoint|reject-checkpoint|scheduleName/);
 	});
 
 	it("allows runtime validation of management and control action strings", () => {
@@ -227,7 +250,7 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		assert.equal(actionSchema.enum, undefined);
 		const description = String(actionSchema.description ?? "");
 		assert.match(description, /Optional management\/control action/);
-		assert.match(description, /Omit this field for structured single-child or workflowScript execution/);
+		assert.match(description, /Omit this field for structured single-child or workflow execution/);
 		assert.match(description, /use it only for management\/control actions/);
 		assert.doesNotMatch(description, /orchestration\./);
 	});
@@ -243,7 +266,7 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		assert.equal(version.enum, undefined);
 	});
 
-	it("documents workflow timeout aliases and turn budget", () => {
+	it("documents workflow timeout aliases and omits removed turn budgets", () => {
 		const timeoutSchema = SubagentParams?.properties?.timeoutMs;
 		const maxRuntimeSchema = SubagentParams?.properties?.maxRuntimeMs;
 		const turnBudgetSchema = SubagentParams?.properties?.turnBudget;
@@ -260,8 +283,7 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		assert.match(String(maxRuntimeSchema.description ?? ""), /foreground and single async runs/i);
 		assert.match(String(maxRuntimeSchema.description ?? ""), /use config timeoutMs, else 30m/i);
 		assert.match(String(maxRuntimeSchema.description ?? ""), /async composites have no default parent deadline/i);
-		assert.equal(turnBudgetSchema?.properties?.maxTurns?.minimum, 1);
-		assert.equal(turnBudgetSchema?.properties?.graceTurns?.minimum, 0);
+		assert.equal(turnBudgetSchema, undefined);
 		assert.equal(toolBudgetSchema?.properties?.soft?.minimum, 1);
 		assert.equal(toolBudgetSchema?.properties?.hard?.minimum, 1);
 	});
@@ -328,9 +350,12 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 	it("exposes tolerant wait mode on subagent_wait", () => {
 		const properties = SubagentWaitParams?.properties as Record<string, JsonSchemaNode> | undefined;
 		const stopOnAttention = properties?.stopOnAttention;
+		const timeoutMs = properties?.timeoutMs;
 		assert.ok(stopOnAttention, "stopOnAttention schema should exist");
 		assert.equal(stopOnAttention.type, "boolean");
 		assert.match(String(stopOnAttention.description ?? ""), /idle or long-thinking attention/);
+		assert.match(String(timeoutMs?.description ?? ""), /waitTool\.defaultTimeoutMs/);
+		assert.match(String(timeoutMs?.description ?? ""), /non-error active-work result/);
 	});
 
 	it("does not emit description-only schema nodes", () => {
@@ -524,6 +549,7 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		const validValues = [
 			{ skill: "review" },
 			{ workflowScript: "return await runs.run(\"one\", {agent: \"reviewer\", task: \"check\"})" },
+			{ workflowScriptPath: "workflows/review.js" },
 			{ skill: false },
 			{ action: "get", agent: "worker" },
 			{ workflowScript: "return runs.run('main', { agent: 'worker', task: 'Fix', acceptance: false })", timeoutMs: 1000 },
@@ -544,11 +570,6 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 			{ agent: "worker", task: "Fix", acceptance: true },
 			{ config: [] },
 			{ config: null },
-			{ agent: "worker", task: "Fix", turnBudget: { maxTurns: 0 } },
-			{ agent: "worker", task: "Fix", turnBudget: { maxTurns: 5, graceTurns: -1 } },
-			{ agent: "worker", task: "Fix", turnBudget: { maxTurns: 1.5 } },
-			{ agent: "worker", task: "Fix", turnBudget: { graceTurns: 1 } },
-			{ agent: "worker", task: "Fix", turnBudget: { maxTurns: 5, graceTurns: 1, extra: true } },
 			{ agent: "worker", task: "Fix", toolBudget: { hard: 0 } },
 			{ agent: "worker", task: "Fix", toolBudget: { hard: 3, soft: 0 } },
 			{ agent: "worker", task: "Fix", toolBudget: { hard: 3, block: [123] } },