@selesai/code 0.13.6 → 0.13.7

package/dist/extensions/pi-subagents/src/agents/builtin-names.ts

@@ -17,4 +17,4 @@ export const BUILTIN_AGENT_NAMES = [
 	"reviewer",
 	"scout",
 	"worker",
-] as const;
+] as const;

package/dist/extensions/pi-subagents/src/agents/chain-serializer.ts

@@ -277,4 +277,4 @@ export function serializeChain(config: ChainConfig): string {
 	}
 
 	return `${lines.join("\n")}\n`;
-}
+}

package/dist/extensions/pi-subagents/src/agents/frontmatter.ts

@@ -150,4 +150,4 @@ export function parseFrontmatter(content: string): { frontmatter: Record<string,
 	}
 
 	return { frontmatter, body };
-}
+}

package/dist/extensions/pi-subagents/src/agents/identity.ts

@@ -27,4 +27,4 @@ export function frontmatterNameForConfig(config: Pick<AgentConfig | ChainConfig,
 		return config.name.slice(config.packageName.length + 1);
 	}
 	return config.name;
-}
+}

package/dist/extensions/pi-subagents/src/agents/proactive-skills.ts

@@ -191,4 +191,4 @@ export function buildProactiveSkillSubagentRecommendationLines(input: {
 		availableSkills,
 		...(input.config !== undefined ? { config: input.config } : {}),
 	}));
-}
+}

package/dist/extensions/pi-subagents/src/agents/runtime-agent-events.ts

@@ -67,4 +67,4 @@ export function registerRuntimeAgentEventListener(pi: ExtensionAPI): () => void
 			request.result = { ok: false, error: errorFrom(error) } satisfies RuntimeAgentRegistrationResult;
 		}
 	});
-}
+}

package/dist/extensions/pi-subagents/src/agents/runtime-agent-registry.ts

@@ -422,4 +422,4 @@ export function mergeRuntimeAgents<T extends { agents: AgentConfig[]; agentDiagn
 	assertNoIdentityCollisions(runtimeAgents, "Runtime agent registration");
 	assertNoConfiguredCollision(configuredAgents, runtimeAgents);
 	return { ...discovered, agents: [...discovered.agents, ...runtimeAgents] };
-}
+}

package/dist/extensions/pi-subagents/src/agents/skills.ts

@@ -751,4 +751,4 @@ export function discoverAvailableSkills(cwd: string): Array<{
 export function clearSkillCache(): void {
 	skillCache.clear();
 	loadSkillsCache = null;
-}
+}

package/dist/extensions/pi-subagents/src/api/agents.ts

@@ -9,4 +9,4 @@ export {
 	type RuntimeAgentRegistrationResult,
 } from "../agents/runtime-agent-events.ts";
 
-export type { RegisterRuntimeAgentInput, RuntimeAgentDefinition, RuntimeAgentRegistration };
+export type { RegisterRuntimeAgentInput, RuntimeAgentDefinition, RuntimeAgentRegistration };

package/dist/extensions/pi-subagents/src/api/background-work.ts

@@ -22,9 +22,14 @@ export interface BackgroundWorkReconcileContext {
 	nowMs: number;
 }
 
+export interface BackgroundWorkListContext {
+	sessionId: string;
+	nowMs: number;
+}
+
 export interface BackgroundWorkProvider {
 	name: string;
-	listActiveWork(): readonly BackgroundWorkItem[];
+	listActiveWork(context?: BackgroundWorkListContext): readonly BackgroundWorkItem[];
 	wakeChannels?: readonly string[];
 	reconcile?(context: BackgroundWorkReconcileContext): void;
 }
@@ -171,7 +176,7 @@ export function snapshotBackgroundWork(sessionId: string, nowMs = Date.now()): B
 		}
 		let active: readonly BackgroundWorkItem[];
 		try {
-			active = provider.listActiveWork();
+			active = provider.listActiveWork({ sessionId, nowMs });
 		} catch (error) {
 			throw new Error(
 				`Background-work provider '${provider.name}' listActiveWork failed: ${error instanceof Error ? error.message : String(error)}`,
@@ -198,4 +203,4 @@ export function snapshotBackgroundWork(sessionId: string, nowMs = Date.now()): B
 		providers: providers.map((provider) => provider.name),
 		items,
 	};
-}
+}

package/dist/extensions/pi-subagents/src/api/capability-ceiling.ts

@@ -14,4 +14,4 @@ export {
 	type SubagentCapabilityCeiling,
 	type SubagentCapabilityCeilingHandle,
 	type SubagentCapabilityAudit,
-} from "../runs/shared/capability-ceiling.ts";
+} from "../runs/shared/capability-ceiling.ts";

package/dist/extensions/pi-subagents/src/api/control-channel.ts

@@ -1,4 +1,4 @@
 export {
 	requestAsyncStop,
 	type StopRequest,
-} from "../runs/background/control-channel.ts";
+} from "../runs/background/control-channel.ts";

package/dist/extensions/pi-subagents/src/api/delegation.ts

@@ -109,4 +109,4 @@ export interface SubagentDelegationInvalidResponse {
 
 export type SubagentDelegationResponse = SubagentDelegationTerminalResponse | SubagentDelegationInvalidResponse;
 
-export interface SubagentDelegationCancel extends SubagentDelegationStarted {}
+export interface SubagentDelegationCancel extends SubagentDelegationStarted {}

package/dist/extensions/pi-subagents/src/api/external-job-provider.ts

@@ -192,4 +192,4 @@ export function listExternalJobProviders(): readonly ExternalJobProvider[] {
 export function getExternalJobProvider(name: string): ExternalJobProvider | undefined {
 	const safeName = validateString(name, "External-job provider name", MAX_PROVIDER_NAME_LENGTH);
 	return listExternalJobProviders().find((provider) => provider.name === safeName);
-}
+}

package/dist/extensions/pi-subagents/src/api/external-runs.ts

@@ -48,7 +48,16 @@ interface ExternalRunRegistry {
 	runs: Map<string, ExternalRun>;
 }
 
-const RUN_FIELDS = new Set([
+interface TrustedExternalRunRecord {
+	value: unknown;
+	normalized: ExternalRun;
+	keys: readonly string[];
+	values: readonly unknown[];
+}
+
+const trustedRecordsByRegistry = new WeakMap<object, Map<string, TrustedExternalRunRecord>>();
+
+const RUN_FIELD_NAMES = [
 	"id",
 	"sessionId",
 	"source",
@@ -61,7 +70,8 @@ const RUN_FIELDS = new Set([
 	"preview",
 	"reportPath",
 	"transcriptPath",
-]);
+] as const satisfies readonly (keyof ExternalRun)[];
+const RUN_FIELDS = new Set<string>(RUN_FIELD_NAMES);
 const UPDATE_FIELDS = new Set([...RUN_FIELDS].filter((field) => field !== "id" && field !== "sessionId" && field !== "source"));
 
 function registry(): ExternalRunRegistry {
@@ -79,6 +89,14 @@ function registry(): ExternalRunRegistry {
 	return candidate as ExternalRunRegistry;
 }
 
+function trustedRecords(current: ExternalRunRegistry): Map<string, TrustedExternalRunRecord> {
+	const cached = trustedRecordsByRegistry.get(current);
+	if (cached) return cached;
+	const records = new Map<string, TrustedExternalRunRecord>();
+	trustedRecordsByRegistry.set(current, records);
+	return records;
+}
+
 function inputObject(value: unknown, field: string, allowed: Set<string>): Record<string, unknown> {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${field} must be an object.`);
 	const input = value as Record<string, unknown>;
@@ -150,6 +168,41 @@ function clone(run: ExternalRun): ExternalRun {
 	return { ...run };
 }
 
+function trustedRecord(value: unknown, normalized: ExternalRun): TrustedExternalRunRecord {
+	const candidate = value as ExternalRun;
+	return {
+		value,
+		normalized,
+		keys: Object.keys(candidate),
+		values: RUN_FIELD_NAMES.map((field) => candidate[field]),
+	};
+}
+
+function trustedRecordValue(value: unknown, record: TrustedExternalRunRecord | undefined): ExternalRun | undefined {
+	if (!record || record.value !== value || !value || typeof value !== "object") return undefined;
+	try {
+		const candidate = value as ExternalRun;
+		const keys = Object.keys(candidate);
+		if (keys.length !== record.keys.length || keys.some((key, index) => key !== record.keys[index])) return undefined;
+		for (const [index, field] of RUN_FIELD_NAMES.entries()) {
+			if (candidate[field] !== record.values[index]) return undefined;
+		}
+		return record.normalized;
+	} catch {
+		return undefined;
+	}
+}
+
+function rememberTrustedRecord(current: ExternalRunRegistry, cacheKey: string, value: unknown, normalized: ExternalRun): void {
+	trustedRecords(current).set(cacheKey, trustedRecord(value, normalized));
+}
+
+function normalizeCachedRecord(current: ExternalRunRegistry, cacheKey: string, value: unknown): ExternalRun {
+	const run = validateRun(value);
+	rememberTrustedRecord(current, cacheKey, value, run);
+	return run;
+}
+
 /** Register one current-session external job. pi-subagents never controls the job. */
 export function registerExternalRun(input: ExternalRun): ExternalRun {
 	const run = validateRun(input);
@@ -158,6 +211,7 @@ export function registerExternalRun(input: ExternalRun): ExternalRun {
 	if (current.runs.has(runKey)) throw new Error(`External run '${run.id}' is already registered for session '${run.sessionId}'.`);
 	if (current.runs.size >= EXTERNAL_RUN_LIMITS.maxCachedRuns) throw new Error(`External-run registry supports at most ${EXTERNAL_RUN_LIMITS.maxCachedRuns} cached runs.`);
 	current.runs.set(runKey, run);
+	rememberTrustedRecord(current, runKey, run, run);
 	return clone(run);
 }
 
@@ -172,12 +226,17 @@ export function updateExternalRun(sessionId: string, id: string, update: Externa
 	if (!previous) throw new Error(`External run '${safeId}' is not registered for session '${safeSessionId}'.`);
 	const next = validateRun({ ...previous, ...patch });
 	current.runs.set(runKey, next);
+	rememberTrustedRecord(current, runKey, next, next);
 	return clone(next);
 }
 
 /** Remove a cached external job. The caller remains responsible for its process and artifacts. */
 export function unregisterExternalRun(sessionId: string, id: string): boolean {
-	return registry().runs.delete(key(identity(sessionId, "External run sessionId", EXTERNAL_RUN_LIMITS.maxSessionIdLength), identity(id, "External run id")));
+	const current = registry();
+	const runKey = key(identity(sessionId, "External run sessionId", EXTERNAL_RUN_LIMITS.maxSessionIdLength), identity(id, "External run id"));
+	const deleted = current.runs.delete(runKey);
+	if (deleted) trustedRecords(current).delete(runKey);
+	return deleted;
 }
 
 function snapshotBytes(runs: readonly ExternalRun[]): number {
@@ -192,15 +251,19 @@ function getErrorMessage(error: unknown): string {
 export function snapshotExternalRuns(sessionId: string, options: ExternalRunSnapshotOptions = {}): readonly ExternalRun[] {
 	const safeSessionId = identity(sessionId, "External-run snapshot sessionId", EXTERNAL_RUN_LIMITS.maxSessionIdLength);
 	const current = registry();
+	const trusted = trustedRecords(current);
+	const sessionPrefix = `${safeSessionId}\0`;
 	const runs: ExternalRun[] = [];
 	for (const [cacheKey, value] of current.runs.entries()) {
+		if (typeof cacheKey !== "string" || !cacheKey.startsWith(sessionPrefix)) continue;
 		try {
-			const run = validateRun(value);
+			const run = trustedRecordValue(value, trusted.get(cacheKey)) ?? normalizeCachedRecord(current, cacheKey, value);
 			if (run.sessionId === safeSessionId) runs.push(run);
 		} catch (error) {
 			const message = `Malformed cached external run '${cacheKey}': ${getErrorMessage(error)}`;
 			if (!options.ignoreMalformed) throw new Error(message, { cause: error instanceof Error ? error : undefined });
 			current.runs.delete(cacheKey);
+			trusted.delete(cacheKey);
 			options.onMalformedRecord?.(message);
 		}
 	}
@@ -216,4 +279,4 @@ export function snapshotExternalRuns(sessionId: string, options: ExternalRunSnap
 }
 
 /** Alias for callers that prefer list terminology. */
-export const listExternalRuns = snapshotExternalRuns;
+export const listExternalRuns = snapshotExternalRuns;

package/dist/extensions/pi-subagents/src/api/intercom-bridge.ts

@@ -1,3 +1,3 @@
 export {
 	resolveIntercomSessionTarget,
-} from "../intercom/intercom-bridge.ts";
+} from "../intercom/intercom-bridge.ts";

package/dist/extensions/pi-subagents/src/api/pi-args.ts

@@ -2,4 +2,4 @@ export {
 	resolvePiLaunchToolPlan,
 	type PiLaunchToolPlan,
 	type ResolvePiLaunchToolPlanInput,
-} from "../runs/shared/pi-args.ts";
+} from "../runs/shared/pi-args.ts";

package/dist/extensions/pi-subagents/src/api/preflight.ts

@@ -1,11 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { discoverAgents, discoverAgentsAll, findBlockingAgentDiagnostic, formatUnknownAgentError, resolveAgentName, unknownAgentDiagnosticContext, type AgentConfig, type AgentScope, type AgentSource } from "../agents/agents.ts";
+import { discoverAgentSnapshot, findBlockingAgentDiagnostic, formatUnknownAgentError, resolveAgentName, unknownAgentDiagnosticContext, type AgentConfig, type AgentDiscoveryAllResult, type AgentScope, type AgentSource } from "../agents/agents.ts";
 import { resolveExecutionAgentScope } from "../agents/agent-scope.ts";
 import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../agents/skills.ts";
 import { buildAgentMemoryInjection } from "../agents/agent-memory.ts";
-import { buildModelCandidates, inheritsParentModel, resolveEffectiveSubagentModel, type AvailableModelInfo, type ParentModel } from "../runs/shared/model-fallback.ts";
+import { buildModelCandidates, inheritsParentModel, resolveEffectiveSubagentModel, resolveModelOrigin, type AvailableModelInfo, type ParentModel } from "../runs/shared/model-fallback.ts";
 import { resolveModelScopesForAgent } from "../runs/shared/model-scope.ts";
 import { applyThinkingSuffix, resolvePiLaunchToolPlan, type PiLaunchToolPlan } from "../runs/shared/pi-args.ts";
 import { injectOutputPathSystemPrompt, normalizeSingleOutputOverride, resolveSingleOutputPath } from "../runs/shared/single-output.ts";
@@ -222,8 +222,7 @@ function taskWorkspaceScopeAuthorityDiagnostic(task: string | undefined): Subage
 	};
 }
 
-function candidateList(inputAgent: string, selected: AgentConfig | undefined, cwd: string, provider?: string): SubagentLaunchContractAgentCandidate[] {
-	const all = discoverAgentsAll(cwd, provider);
+function candidateList(inputAgent: string, selected: AgentConfig | undefined, all: AgentDiscoveryAllResult): SubagentLaunchContractAgentCandidate[] {
 	return [...all.builtin, ...all.package, ...all.user, ...all.project]
 		.filter((agent) => Boolean(resolveAgentName(inputAgent, [agent]).agent))
 		.map((agent) => ({
@@ -258,7 +257,8 @@ export async function resolveSubagentLaunchContract(input: SubagentLaunchContrac
 	}
 	const scope = resolveExecutionAgentScope(input.agentScope);
 	const parentProvider = input.preferredProvider ?? input.parentModel?.provider;
-	const discovered = discoverAgents(effectiveCwd, scope, parentProvider);
+	const discovery = discoverAgentSnapshot(effectiveCwd, scope, parentProvider, { includeChains: false });
+	const discovered = discovery.effective;
 	const resolvedAgent = resolveAgentName(input.agent, discovered.agents);
 	const ambiguousCandidates = resolvedAgent.error
 		? discovered.agents.filter((agent) => resolveAgentName(input.agent, [agent]).agent)
@@ -317,9 +317,13 @@ export async function resolveSubagentLaunchContract(input: SubagentLaunchContrac
 	const availableModels = normalizeAvailableModels(input.availableModels);
 	const preferredProvider = agent.modelProvider ?? input.preferredProvider ?? input.parentModel?.provider;
 	const modelScopes = resolveModelScopesForAgent(discovered.modelScope, agent.name, input.parentModel);
+	const modelOrigin = resolveModelOrigin({ explicitModel: input.model, agentModel: agent.model, parentModel: input.parentModel });
 	const primaryModel = externalRunner
 		? undefined
-		: resolveEffectiveSubagentModel(input.model, agent.model, input.parentModel, availableModels, preferredProvider, { scope: modelScopes });
+		: resolveEffectiveSubagentModel(input.model, agent.model, input.parentModel, availableModels, preferredProvider, {
+			scope: modelScopes,
+			source: modelOrigin === "explicit" ? "explicit" : "inherited",
+		});
 	const effectiveThinkingConfig = input.thinking !== undefined ? input.thinking : agent.thinking;
 	const thinkingCeiling = externalRunner ? undefined : intersectThinkingCeilings(
 		discovered.maxThinking,
@@ -332,7 +336,8 @@ export async function resolveSubagentLaunchContract(input: SubagentLaunchContrac
 		? []
 		: buildModelCandidates(primaryModel, agent.fallbackModels, availableModels, preferredProvider, {
 			scope: modelScopes,
-			primaryModelFromParent: inheritsParentModel(input.model, agent.model, input.parentModel),
+			primaryModelFromParent: modelOrigin === "inherited" || inheritsParentModel(input.model, agent.model, input.parentModel),
+			origin: modelOrigin,
 		})
 			.map((candidate) => applyThinkingSuffix(candidate, effectiveThinkingConfig, input.thinking !== undefined) ?? candidate);
 	if (!externalRunner) {
@@ -397,7 +402,7 @@ export async function resolveSubagentLaunchContract(input: SubagentLaunchContrac
 	const memoryInjection = buildAgentMemoryInjection(agent, effectiveCwd);
 	if (memoryInjection) effectiveSystemPrompt = effectiveSystemPrompt ? `${effectiveSystemPrompt}\n\n${memoryInjection}` : memoryInjection;
 	effectiveSystemPrompt = injectOutputPathSystemPrompt(effectiveSystemPrompt, outputPath, agent);
-	const candidates = candidateList(input.agent, agent, effectiveCwd, parentProvider);
+	const candidates = candidateList(input.agent, agent, discovery.all);
 	const shadowedCandidates = candidates.filter((candidate) => !candidate.selected);
 	const definitionDigest = agentDefinitionDigest(agent);
 	const contractBase: Omit<SubagentLaunchContract, "digest"> = {
@@ -489,4 +494,4 @@ export async function resolveSubagentLaunchContract(input: SubagentLaunchContrac
 		}),
 	};
 	return { ok: true, contract: { ...contractBase, digest: digestContract(contractBase) } };
-}
+}

package/dist/extensions/pi-subagents/src/api/project-panes.ts

@@ -29,4 +29,4 @@ export {
 	type ProjectPaneErrorCode,
 	type ProjectPaneResult,
 	type HerdrProjectPaneBinding,
-} from "../inspectors/herdr/project-panes.ts";
+} from "../inspectors/herdr/project-panes.ts";

package/dist/extensions/pi-subagents/src/api/shared-types.ts

@@ -20,4 +20,5 @@ export {
 	type SubagentResultStatus,
 	type SubagentRunMode,
 	type Usage,
-} from "../shared/types.ts";
+	type WorkflowResourceProvenanceV1,
+} from "../shared/types.ts";

package/dist/extensions/pi-subagents/src/extension/config.ts

@@ -232,4 +232,4 @@ export function loadConfig(): ExtensionConfig {
 		console.error(`Failed to load subagent config from '${configPath}':`, error);
 	}
 	return {};
-}
+}

package/dist/extensions/pi-subagents/src/extension/control-notices.ts

@@ -55,4 +55,4 @@ export function handleSubagentControlNotice(input: {
 		return;
 	}
 	deliverControlNotice(input);
-}
+}

package/dist/extensions/pi-subagents/src/extension/doctor.ts

@@ -275,4 +275,4 @@ export function buildDoctorReport(input: DoctorReportInput): string {
 		}), input.context).join("\n")).split("\n"),
 	];
 	return lines.join("\n");
-}
+}

package/dist/extensions/pi-subagents/src/extension/fanout-child.ts

@@ -202,4 +202,4 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI):
 	previous?.cleanup();
 	const inboxState = previous?.state ?? createNestedControlInboxState();
 	listenerCleanups.set(routeKey, { state: inboxState, cleanup: startNestedControlInboxListener(pi, state, route, inboxState) });
-}
+}

package/dist/extensions/pi-subagents/src/extension/index.ts

@@ -19,7 +19,7 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { keyText, type ExtensionAPI, type ExtensionContext, type ToolDefinition } from "@selesai/code";
 import { Box, Container, Spacer, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component } from "@earendil-works/pi-tui";
-import { discoverAgents, discoverAgentsAll, type AgentConfig, type AgentScope } from "../agents/agents.ts";
+import { discoverAgentSnapshot, discoverAgents, type AgentConfig, type AgentScope } from "../agents/agents.ts";
 import { clearRuntimeAgentsForPi, listRuntimeAgentConfigs, mergeRuntimeAgents } from "../agents/runtime-agent-registry.ts";
 import { registerRuntimeAgentEventListener } from "../agents/runtime-agent-events.ts";
 import { ensureAccessibleDir } from "../shared/accessible-dir.ts";
@@ -438,6 +438,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	const state: SubagentState = {
 		baseCwd: "",
 		currentSessionId: null,
+		statusProjectionSessionId: null,
 		completionOwnerId: currentCompletionOwnerId(),
 		artifactDirPreference: config.artifactDir ?? DEFAULT_ARTIFACT_CONFIG.dir,
 		...(config.authorityPolicy ? { authorityPolicy: config.authorityPolicy } : {}),
@@ -525,9 +526,10 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		return missionObserverResultCandidateFiles(DIRS.results).length > 0;
 	};
 	const discoverAgentsForRuntime = (cwd: string, scope: AgentScope, preferredModelProvider?: string) => {
-		const discovered = discoverAgents(cwd, scope, preferredModelProvider);
-		if (listRuntimeAgentConfigs(pi).length === 0) return discovered;
-		const all = discoverAgentsAll(cwd, preferredModelProvider);
+		if (listRuntimeAgentConfigs(pi).length === 0) return discoverAgents(cwd, scope, preferredModelProvider);
+		const snapshot = discoverAgentSnapshot(cwd, scope, preferredModelProvider, { includeChains: false });
+		const discovered = snapshot.effective;
+		const all = snapshot.all;
 		const configuredAgents: AgentConfig[] = [
 			...all.builtin,
 			...all.package,
@@ -996,6 +998,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			promptTemplateBridge.dispose();
 			state.widgetsSuspended = false;
 			state.currentSessionId = null;
+			state.statusProjectionSessionId = null;
 			state.parentSessionFile = null;
 			parentSessionEnvValue = null;
 			if (shuttingDownParentSession && process.env[SUBAGENT_PARENT_SESSION_ENV] === shuttingDownParentSession) {
@@ -1087,4 +1090,4 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		runtimeEntry.cleanup();
 		await herdrStatusBridge.flush();
 	});
-}
+}

package/dist/extensions/pi-subagents/src/extension/public-execution.ts

@@ -18,8 +18,12 @@ export interface PublicSubagentExecutionParams {
 	chainDir?: unknown;
 	chainName?: unknown;
 	config?: unknown;
+	workflow?: unknown;
+	args?: unknown;
 	workflowScript?: unknown;
 	workflowScriptPath?: unknown;
+	globalConcurrencyLimit?: unknown;
+	maxSubagentSpawnsPerRun?: unknown;
 	preflight?: unknown;
 	isolation?: unknown;
 	worktree?: unknown;
@@ -45,20 +49,56 @@ export type PublicSubagentExecutionNormalization<T> =
 	| { ok: true; params: T }
 	| { ok: false; error: string; mode: PublicSubagentExecutionMode };
 
+export function validateWorkflowCapacityOverrides(params: PublicSubagentExecutionParams): string | undefined {
+	for (const [name, value] of [
+		["globalConcurrencyLimit", params.globalConcurrencyLimit],
+		["maxSubagentSpawnsPerRun", params.maxSubagentSpawnsPerRun],
+	] as const) {
+		if (value !== undefined && (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)) return `${name} must be a positive safe integer.`;
+	}
+}
+
 /**
  * Enforce the public execution cutover before requests reach the executor.
  * Internal runs.run children and structured owned delegation bypass this boundary.
  */
 export function normalizePublicSubagentExecution<T extends PublicSubagentExecutionParams>(params: T): PublicSubagentExecutionNormalization<T> {
+	for (const field of ["resource", "resourceProvenance", "workflowResource", "workflowResourceProvenance", "workflowResourcePermit", "resourcePermit", "permit"] as const) {
+		if (Object.hasOwn(params, field) && (params as Record<string, unknown>)[field] !== undefined) {
+			return { ok: false, error: "Public execution does not accept workflow resource provenance or permit fields.", mode: params.action === undefined ? "workflow" : "management" };
+		}
+	}
 	if (params.workflowScript !== undefined && params.workflowScriptPath !== undefined) {
 		return { ok: false, error: "workflowScript and workflowScriptPath are mutually exclusive.", mode: "workflow" };
 	}
-	const hasWorkflowInput = params.workflowScript !== undefined || params.workflowScriptPath !== undefined;
+	const hasNamedWorkflow = params.workflow !== undefined;
+	if (hasNamedWorkflow && (typeof params.workflow !== "string" || !params.workflow.trim())) {
+		return { ok: false, error: "workflow must be a non-empty named workflow resource.", mode: "workflow" };
+	}
+	if (hasNamedWorkflow && (params.workflowScript !== undefined || params.workflowScriptPath !== undefined)) {
+		return { ok: false, error: "workflow is mutually exclusive with workflowScript and workflowScriptPath.", mode: "workflow" };
+	}
+	if (!hasNamedWorkflow && params.args !== undefined) {
+		return { ok: false, error: "args requires a named workflow resource.", mode: "workflow" };
+	}
+	const hasWorkflowInput = params.workflowScript !== undefined || params.workflowScriptPath !== undefined || hasNamedWorkflow;
+	const hasCapacityOverride = params.globalConcurrencyLimit !== undefined || params.maxSubagentSpawnsPerRun !== undefined;
+	if (hasCapacityOverride) {
+		const capacityOverrideError = validateWorkflowCapacityOverrides(params);
+		if (capacityOverrideError) return { ok: false, error: capacityOverrideError, mode: params.action === undefined ? "workflow" : "management" };
+		if (params.action !== undefined || hasNamedWorkflow || (params.workflowScript === undefined && params.workflowScriptPath === undefined)) {
+			return { ok: false, error: "Workflow capacity overrides are only supported on top-level workflowScript or workflowScriptPath calls.", mode: params.action === undefined ? "workflow" : "management" };
+		}
+	}
 	if (params.preflight !== undefined && !hasWorkflowInput) {
 		return { ok: false, error: "preflight requires workflowScript or workflowScriptPath.", mode: params.action === undefined ? "workflow" : "management" };
 	}
+	if (params.preflight !== undefined && hasNamedWorkflow && params.workflowScript === undefined && params.workflowScriptPath === undefined) {
+		return { ok: false, error: "preflight is not supported with named workflow resources.", mode: "workflow" };
+	}
 	const hasValidWorkflowInput = (typeof params.workflowScript === "string" && Boolean(params.workflowScript.trim()))
-		|| (typeof params.workflowScriptPath === "string" && Boolean(params.workflowScriptPath.trim()));
+		|| (typeof params.workflowScriptPath === "string" && Boolean(params.workflowScriptPath.trim()))
+		|| (typeof params.workflow === "string" && Boolean(params.workflow.trim()));
 	if (params.isolation !== undefined) {
 		if (params.isolation !== "none" && params.isolation !== "worktree") {
 			return { ok: false, error: "isolation must be 'none' or 'worktree'.", mode: hasWorkflowInput ? "workflow" : "management" };
@@ -81,6 +121,9 @@ export function normalizePublicSubagentExecution<T extends PublicSubagentExecuti
 		return { ok: false, error: "action must be a non-empty management/control action, or omit action and use workflowScript.", mode: "management" };
 	}
 	const normalizedAction = typeof action === "string" ? action.trim() : undefined;
+	if (normalizedAction !== undefined && hasNamedWorkflow) {
+		return { ok: false, error: "Named workflow resource execution must omit action.", mode: "management" };
+	}
 	if (params.clarify !== undefined) {
 		return { ok: false, error: "Public workflowScript execution does not support clarify UI.", mode: "workflow" };
 	}
@@ -141,7 +184,7 @@ export function normalizePublicSubagentExecution<T extends PublicSubagentExecuti
 		return { ok: false, error: "step is not a public execution field; use workflowScript for orchestration.", mode: "workflow" };
 	}
 	if (hasWorkflowInput && (params.agent !== undefined || params.task !== undefined)) {
-		return { ok: false, error: "Structured single-child execution cannot be combined with workflowScript or workflowScriptPath.", mode: "workflow" };
+		return { ok: false, error: "Structured single-child execution cannot be combined with workflow, workflowScript, or workflowScriptPath.", mode: "workflow" };
 	}
 	if (params.agent !== undefined || params.task !== undefined) {
 		if (typeof params.agent !== "string" || !params.agent.trim()) {
@@ -160,7 +203,7 @@ export function normalizePublicSubagentExecution<T extends PublicSubagentExecuti
 		};
 	}
 	if (!hasValidWorkflowInput) {
-		return { ok: false, error: "Execution requires either { agent, task? } for one child or a non-empty workflowScript or workflowScriptPath for orchestration.", mode: "workflow" };
+		return { ok: false, error: "Execution requires either { agent, task? } for one child, a named workflow resource, or a non-empty workflowScript or workflowScriptPath for orchestration.", mode: "workflow" };
 	}
 	return { ok: true, params };
-}
+}