pi-ui-extend 1.0.42 → 1.0.45

package/external/pi-tools-suite/src/async-subagents/core/config.ts

@@ -3,13 +3,14 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse as parseJsonc } from "jsonc-parser";
 import { projectAgentsDir, readAgentDefinitionsFromDir, readProjectAgentDefinitions, type AgentDefinition } from "./agents-dir.js";
+import { LEGACY_BROWSER_QA_TYPE, UI_QA_TYPE } from "./browser-qa.js";
 import type { AgentTask, RetryConfig } from "./types.js";
 
 export interface ModelByParentEntry {
 	/** Model ref to use when the parent model matches the entry's pattern. */
 	model: string;
 	/** Ordered fallbacks used when this entry's model hits quota/rate limits; replaces the normal fallback chain. */
-	fallbackModels?: string[];
+	fallbackModels: string[];
 }
 
 export interface SubagentTypeConfig {
@@ -29,7 +30,8 @@ export interface SubagentTypeConfig {
 	/**
 	 * Parent-model-aware model selection. Keys are glob model refs (e.g. "zai/*")
 	 * matched against the current parent model; the first matching key wins.
-	 * Values may be a model ref string or { model, fallbackModels? }.
+	 * Raw values may be a model ref string or { model, fallbackModels? };
+	 * normalized entries always carry an explicit fallbackModels array.
 	 * Ordinary roles: explicit task/forced model and preset models take priority.
 	 * Oracle alone keeps parent-aware selection ahead of presets.
 	 */
@@ -46,8 +48,6 @@ export interface SubagentTypeConfig {
 	notForParentModels?: string[];
 	thinking?: string;
 	tools?: string[];
-	/** Explicit skill files loaded after disabling normal skill discovery. */
-	isolatedSkills?: string[];
 	extraArgs?: string[];
 	/** Extra prompt text appended after the generated or overridden prompt. */
 	promptAppend?: string;
@@ -136,8 +136,6 @@ export interface SubagentConfig {
 export interface ResolvedAgentTaskConfig {
 	task: AgentTask;
 	extraArgs: string[];
-	/** Explicit skill files loaded with normal skill discovery disabled. */
-	isolatedSkills: string[];
 	/** Ordered model fallbacks for the resolved model. Current-process exhausted models are skipped before spawning. */
 	fallbackModels: string[];
 	profile?: SubagentTypeConfig;
@@ -243,6 +241,11 @@ export function getProjectSubagentPresetsPath(cwd: string): string {
 /** Normalize `.pi/agents/*.md` definitions through the shared type-profile path. */
 function projectAgentTypes(cwd: string): Partial<SubagentConfig> {
 	const definitions = readProjectAgentDefinitions(cwd);
+	const legacyUiQa = definitions[LEGACY_BROWSER_QA_TYPE];
+	if (legacyUiQa) {
+		if (!definitions[UI_QA_TYPE]) definitions[UI_QA_TYPE] = legacyUiQa;
+		delete definitions[LEGACY_BROWSER_QA_TYPE];
+	}
 	const types = normalizeAgentDefinitions(definitions);
 	if (Object.keys(types).length === 0) return {};
 	return { types };
@@ -336,7 +339,6 @@ export function resolveAgentTaskConfig(
 	return {
 		profile,
 		extraArgs,
-		isolatedSkills: arrayOfStrings(profile?.isolatedSkills) ?? [],
 		fallbackModels,
 		retry: resolveRetryConfig(config.retry, profile?.retry),
 		maxResultBytes: profile?.maxResultBytes ?? config.maxResultBytes,
@@ -359,7 +361,7 @@ export function resolveSubagentRoutingConfig(config: SubagentConfig): ResolvedSu
 }
 
 export function defaultSubagentType(config: SubagentConfig): string | undefined {
-	const configured = trimString(config.defaultType);
+	const configured = normalizeSubagentType(config.defaultType, config);
 	if (configured) return Object.prototype.hasOwnProperty.call(config.types, configured) ? configured : undefined;
 	return Object.keys(config.types).find((name) => trimString(name));
 }
@@ -429,11 +431,20 @@ export function filterSubagentConfigForParentModel(
 }
 
 export function selectSubagentType(task: AgentTask, config: SubagentConfig): string | undefined {
-	const explicit = trimString(task.subagentType);
+	const explicit = normalizeSubagentType(task.subagentType, config);
 	if (explicit) return explicit;
 	return defaultSubagentType(config);
 }
 
+/** Preserve explicit legacy browser-qa calls after the built-in role was broadened to ui-qa. */
+export function normalizeSubagentType(value: string | undefined, config: SubagentConfig): string | undefined {
+	const requested = trimString(value);
+	if (!requested) return undefined;
+	if (Object.prototype.hasOwnProperty.call(config.types, requested)) return requested;
+	if (requested === LEGACY_BROWSER_QA_TYPE && Object.prototype.hasOwnProperty.call(config.types, UI_QA_TYPE)) return UI_QA_TYPE;
+	return requested;
+}
+
 function readPresetConfigFile(file: string): Partial<SubagentConfig> {
 	const raw = fs.readFileSync(file, "utf-8");
 	const parsed = parseJsonc(raw) as unknown;
@@ -467,18 +478,19 @@ export function normalizeSubagentTypeProfile(
 	file: string,
 ): SubagentTypeConfig {
 	const models = normalizeModels(rawProfile.models, `type "${name}"`, file);
+	const model = models === undefined ? trimString(rawProfile.model) : undefined;
+	const fallbackModels = models === undefined ? modelList(rawProfile.fallbackModels, rawProfile.fallbackModel) : undefined;
 	return {
 		description: trimString(rawProfile.description),
 		icon: trimString(rawProfile.icon),
 		models,
-		model: models === undefined ? trimString(rawProfile.model) : undefined,
-		fallbackModels: models === undefined ? modelList(rawProfile.fallbackModels, rawProfile.fallbackModel) : undefined,
-		modelByParent: models === undefined ? normalizeModelByParent(rawProfile.modelByParent, name, file) : undefined,
+		model,
+		fallbackModels: models === undefined && (model || fallbackModels !== undefined) ? fallbackModels ?? [] : undefined,
+		modelByParent: models === undefined ? normalizeModelByParent(rawProfile.modelByParent, name, file, fallbackModels ?? []) : undefined,
 		forParentModels: normalizeParentModelPatterns(rawProfile.forParentModels, "forParentModels", name, file),
 		notForParentModels: normalizeParentModelPatterns(rawProfile.notForParentModels, "notForParentModels", name, file),
 		thinking: trimString(rawProfile.thinking),
 		tools: arrayOfStrings(rawProfile.tools),
-		isolatedSkills: arrayOfStrings(rawProfile.isolatedSkills),
 		extraArgs: arrayOfStrings(rawProfile.extraArgs),
 		promptAppend: textBlock(rawProfile.promptAppend),
 		promptOverride: textBlock(rawProfile.promptOverride),
@@ -545,7 +557,6 @@ function compactProfile(profile: SubagentTypeConfig): SubagentTypeConfig {
 	if (profile.notForParentModels !== undefined) compact.notForParentModels = profile.notForParentModels;
 	if (profile.thinking) compact.thinking = profile.thinking;
 	if (profile.tools && profile.tools.length > 0) compact.tools = profile.tools;
-	if (profile.isolatedSkills && profile.isolatedSkills.length > 0) compact.isolatedSkills = profile.isolatedSkills;
 	if (profile.extraArgs && profile.extraArgs.length > 0) compact.extraArgs = profile.extraArgs;
 	if (profile.promptAppend) compact.promptAppend = profile.promptAppend;
 	if (profile.promptOverride) compact.promptOverride = profile.promptOverride;
@@ -589,7 +600,12 @@ function normalizeParentModelPatterns(
 	return [...new Set(value.map((pattern: string) => pattern.trim()))];
 }
 
-function normalizeModelByParent(value: unknown, typeName: string, file: string): Record<string, ModelByParentEntry> | undefined {
+function normalizeModelByParent(
+	value: unknown,
+	typeName: string,
+	file: string,
+	defaultFallbackModels: string[] = [],
+): Record<string, ModelByParentEntry> | undefined {
 	if (value === undefined || value === null) return undefined;
 	if (!isRecord(value)) throw new Error(`Subagent type "${typeName}" modelByParent must be an object: ${file}`);
 	const out: Record<string, ModelByParentEntry> = {};
@@ -598,13 +614,20 @@ function normalizeModelByParent(value: unknown, typeName: string, file: string):
 		if (!pat) continue;
 		if (typeof raw === "string") {
 			const model = trimString(raw);
-			if (model) out[pat] = { model };
+			if (model) out[pat] = { model, fallbackModels: [...defaultFallbackModels] };
 			continue;
 		}
 		if (isRecord(raw)) {
 			const model = trimString(raw.model);
 			if (!model) throw new Error(`Subagent type "${typeName}" modelByParent["${pat}"].model must be a non-empty string: ${file}`);
-			out[pat] = { model, fallbackModels: modelList(raw.fallbackModels, raw.fallbackModel) };
+			const hasFallbackOverride = Object.prototype.hasOwnProperty.call(raw, "fallbackModels")
+				|| Object.prototype.hasOwnProperty.call(raw, "fallbackModel");
+			out[pat] = {
+				model,
+				fallbackModels: hasFallbackOverride
+					? modelList(raw.fallbackModels, raw.fallbackModel) ?? []
+					: [...defaultFallbackModels],
+			};
 			continue;
 		}
 		throw new Error(`Subagent type "${typeName}" modelByParent["${pat}"] must be a string or object: ${file}`);

package/external/pi-tools-suite/src/async-subagents/core/model-selection.ts

@@ -1,5 +1,6 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { isBlindModelRef, SubagentModelSelectionError, type ResolvedAgentTaskConfig, type SubagentConfig } from "./config.js";
+import { isUiQaType } from "./browser-qa.js";
 import { isSessionModelUnavailable } from "./model-fallback.js";
 
 export interface SubagentModelRegistry {
@@ -17,7 +18,7 @@ export async function selectAvailableAgentModels(
 	signal?: AbortSignal,
 ): Promise<ResolvedAgentTaskConfig> {
 	if (signal?.aborted) throw new Error("Aborted");
-	const needsImages = Boolean(resolved.task.imagePaths?.length) || resolved.task.subagentType === "browser-qa";
+	const needsImages = Boolean(resolved.task.imagePaths?.length) || isUiQaType(resolved.task.subagentType);
 	if (!registry && !needsImages) return resolved; // Narrow offline/test callers.
 	const candidates = [resolved.task.model, ...resolved.fallbackModels].filter((ref): ref is string => Boolean(ref));
 	let registeredAvailable: Set<string> | undefined;

package/external/pi-tools-suite/src/async-subagents/core/registry.ts

@@ -4,6 +4,15 @@ import { getRunRoot, hasAgentPrompt, hasLaunchedAgentPrompt, isDir, resolveRunDi
 
 export const SUBAGENT_REGISTRY_FILE = "registry.json";
 
+const REGISTRY_LOCK_RETRY_MS = 10;
+const REGISTRY_LOCK_TIMEOUT_MS = 2_000;
+const REGISTRY_LOCK_STALE_MS = 30_000;
+
+interface RegistryLockOwner {
+	pid: number;
+	token: string;
+}
+
 export interface SubagentRegistryRun {
 	runId: string;
 	runDir: string;
@@ -62,45 +71,44 @@ export function loadSubagentRegistry(cwd: string): SubagentRegistry {
 
 export function saveSubagentRegistry(cwd: string, registry: SubagentRegistry): void {
 	const registryPath = getSubagentRegistryPath(cwd);
-	fs.mkdirSync(path.dirname(registryPath), { recursive: true });
-	fs.writeFileSync(registryPath, `${JSON.stringify(registry, null, 2)}\n`, "utf-8");
+	withRegistryLock(registryPath, () => writeRegistryAtomically(registryPath, registry));
 }
 
 export function recordSubagentRun(cwd: string, runDir: string, agentIds: string[]): SubagentRegistry {
-	const registry = loadSubagentRegistry(cwd);
-	const resolvedRunDir = path.resolve(runDir);
-	const runId = path.basename(resolvedRunDir);
-	const now = new Date().toISOString();
-	const uniqueAgentIds = [...new Set(agentIds.filter((id) => id.trim().length > 0))];
-	const previous = registry.runs[runId];
-	registry.runs[runId] = {
-		runId,
-		runDir: resolvedRunDir,
-		agentIds: uniqueAgentIds,
-		createdAt: previous?.createdAt ?? now,
-		updatedAt: now,
-	};
-	registry.latestRunId = runId;
-	registry.latestRunDir = resolvedRunDir;
-	for (const agentId of uniqueAgentIds) {
-		registry.agents[agentId] = { agentId, runId, runDir: resolvedRunDir, updatedAt: now };
-	}
-	saveSubagentRegistry(cwd, registry);
-	return registry;
+	return updateSubagentRegistry(cwd, (registry) => {
+		const resolvedRunDir = path.resolve(runDir);
+		const runId = path.basename(resolvedRunDir);
+		const now = new Date().toISOString();
+		const uniqueAgentIds = [...new Set(agentIds.filter((id) => id.trim().length > 0))];
+		const previous = registry.runs[runId];
+		registry.runs[runId] = {
+			runId,
+			runDir: resolvedRunDir,
+			agentIds: uniqueAgentIds,
+			createdAt: previous?.createdAt ?? now,
+			updatedAt: now,
+		};
+		registry.latestRunId = runId;
+		registry.latestRunDir = resolvedRunDir;
+		for (const agentId of uniqueAgentIds) {
+			registry.agents[agentId] = { agentId, runId, runDir: resolvedRunDir, updatedAt: now };
+		}
+		return registry;
+	});
 }
 
 export function removeSubagentRunsFromRegistry(cwd: string, runDirs: string[]): SubagentRegistry {
-	const registry = loadSubagentRegistry(cwd);
-	const removed = new Set(runDirs.map((runDir) => normalizePath(runDir)));
-	for (const [runId, run] of Object.entries(registry.runs)) {
-		if (removed.has(normalizePath(run.runDir))) delete registry.runs[runId];
-	}
-	for (const [agentId, agent] of Object.entries(registry.agents)) {
-		if (removed.has(normalizePath(agent.runDir))) delete registry.agents[agentId];
-	}
-	refreshLatestRun(registry);
-	saveSubagentRegistry(cwd, registry);
-	return registry;
+	return updateSubagentRegistry(cwd, (registry) => {
+		const removed = new Set(runDirs.map((runDir) => normalizePath(runDir)));
+		for (const [runId, run] of Object.entries(registry.runs)) {
+			if (removed.has(normalizePath(run.runDir))) delete registry.runs[runId];
+		}
+		for (const [agentId, agent] of Object.entries(registry.agents)) {
+			if (removed.has(normalizePath(agent.runDir))) delete registry.agents[agentId];
+		}
+		refreshLatestRun(registry);
+		return registry;
+	});
 }
 
 export function resolveSubagentRunDir(cwd: string, runDir?: string): string {
@@ -157,6 +165,123 @@ function refreshLatestRun(registry: SubagentRegistry): void {
 	delete registry.latestRunDir;
 }
 
+function updateSubagentRegistry(cwd: string, update: (registry: SubagentRegistry) => SubagentRegistry): SubagentRegistry {
+	const registryPath = getSubagentRegistryPath(cwd);
+	return withRegistryLock(registryPath, () => {
+		const registry = loadSubagentRegistry(cwd);
+		const updated = update(registry);
+		writeRegistryAtomically(registryPath, updated);
+		return updated;
+	});
+}
+
+function withRegistryLock<T>(registryPath: string, operation: () => T): T {
+	fs.mkdirSync(path.dirname(registryPath), { recursive: true });
+	const lockPath = `${registryPath}.lock`;
+	const owner = registryLockOwner();
+	const deadline = Date.now() + REGISTRY_LOCK_TIMEOUT_MS;
+	while (!createRegistryLock(lockPath, owner)) {
+		recoverStaleRegistryLock(lockPath, owner);
+		if (Date.now() >= deadline) {
+			throw new Error(`Timed out waiting for sub-agent registry lock at ${lockPath}.`);
+		}
+		sleep(REGISTRY_LOCK_RETRY_MS);
+	}
+	try {
+		return operation();
+	} finally {
+		releaseRegistryLock(lockPath, owner);
+	}
+}
+
+function writeRegistryAtomically(registryPath: string, registry: SubagentRegistry): void {
+	const temporaryPath = `${registryPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	try {
+		fs.writeFileSync(temporaryPath, `${JSON.stringify(registry, null, 2)}\n`, { encoding: "utf-8", mode: 0o600, flag: "wx" });
+		fs.renameSync(temporaryPath, registryPath);
+	} finally {
+		fs.rmSync(temporaryPath, { force: true });
+	}
+}
+
+function registryLockOwner(): RegistryLockOwner {
+	return { pid: process.pid, token: `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}` };
+}
+
+function createRegistryLock(lockPath: string, owner: RegistryLockOwner): boolean {
+	try {
+		fs.writeFileSync(lockPath, JSON.stringify(owner), { encoding: "utf-8", mode: 0o600, flag: "wx" });
+		return true;
+	} catch (error) {
+		if (errorCode(error) === "EEXIST") return false;
+		throw error;
+	}
+}
+
+function recoverStaleRegistryLock(lockPath: string, owner: RegistryLockOwner): void {
+	let lockStat: fs.Stats;
+	try {
+		lockStat = fs.statSync(lockPath);
+	} catch (error) {
+		if (errorCode(error) === "ENOENT") return;
+		throw error;
+	}
+	const existingOwner = readRegistryLockOwner(lockPath);
+	const lockAgeMs = Date.now() - lockStat.mtimeMs;
+	if (existingOwner && isProcessAlive(existingOwner.pid)) return;
+	if (!existingOwner && lockAgeMs <= REGISTRY_LOCK_STALE_MS) return;
+
+	const quarantinePath = `${lockPath}.stale-${owner.token}`;
+	try {
+		fs.renameSync(lockPath, quarantinePath);
+	} catch (error) {
+		if (errorCode(error) === "ENOENT") return;
+		throw error;
+	}
+	try {
+		const movedStat = fs.statSync(quarantinePath);
+		if (movedStat.dev !== lockStat.dev || movedStat.ino !== lockStat.ino) return;
+		fs.rmSync(quarantinePath, { force: true });
+	} finally {
+		if (fs.existsSync(quarantinePath) && !fs.existsSync(lockPath)) {
+			fs.renameSync(quarantinePath, lockPath);
+		}
+	}
+}
+
+function releaseRegistryLock(lockPath: string, owner: RegistryLockOwner): void {
+	if (readRegistryLockOwner(lockPath)?.token === owner.token) fs.rmSync(lockPath, { force: true });
+}
+
+function readRegistryLockOwner(lockPath: string): RegistryLockOwner | undefined {
+	try {
+		const parsed: unknown = JSON.parse(fs.readFileSync(lockPath, "utf-8"));
+		if (!isRecord(parsed) || typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0 || typeof parsed.token !== "string") return undefined;
+		return { pid: parsed.pid, token: parsed.token };
+	} catch {
+		return undefined;
+	}
+}
+
+function isProcessAlive(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return errorCode(error) !== "ESRCH";
+	}
+}
+
+function errorCode(error: unknown): string | undefined {
+	return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string"
+		? error.code
+		: undefined;
+}
+
+function sleep(ms: number): void {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
 function looksLikeRunDir(runDir: string): boolean {
 	if (isDir(path.join(runDir, "prompts"))) return true;
 	try {

package/external/pi-tools-suite/src/async-subagents/core/routing.ts

@@ -5,6 +5,7 @@ import {
 	currentModelRef,
 	defaultSubagentType,
 	filterSubagentConfigForParentModel,
+	normalizeSubagentType,
 	resolveSubagentRoutingConfig,
 	type ResolvedSubagentRoutingConfig,
 	type SubagentConfig,
@@ -46,7 +47,7 @@ export class SubagentRoutingError extends Error {
 const ROUTER_SYSTEM_PROMPT = [
 	"You route Pi async sub-agent tasks to the best configured subagentType.",
 	"Choose exactly one allowed type for each task. Use the allowed type descriptions as the source of truth.",
-	"Prefer a matching project specialist. Otherwise use research for reading/evidence or focused review questions, implement for code/docs/tests/UI changes, verify for running checks, browser-qa for real-browser testing, and frontier-review for an independent post-implementation code review when that type is allowed. Oracle is a deliberate strong second opinion, not routine code review or the default for difficult work.",
+	"Prefer a matching project specialist. Otherwise use research for reading/evidence or focused review questions, implement for code/docs/tests/UI changes, verify for running checks, ui-qa for real user-interface testing across browsers, TUIs, and desktop GUIs, and frontier-review for an independent post-implementation code review when that type is allowed. Oracle is a deliberate strong second opinion, not routine code review or the default for difficult work.",
 	"Return only strict JSON with this shape: {\"routes\":[{\"id\":\"task-id\",\"subagentType\":\"type\"}]}",
 	"Do not include markdown, comments, explanations, or unknown types.",
 ].join("\n");
@@ -59,9 +60,11 @@ export async function routeSubagentTasks(
 ): Promise<RoutedSubagentTasks> {
 	if (signal?.aborted) throw new Error("Aborted");
 	// Validate even the fast path: an explicit typo must not bypass profiles.
-	tasks = tasks.map((task) => hasText(task.subagentType) && task.subagentType !== task.subagentType.trim()
-		? { ...task, subagentType: task.subagentType.trim() }
-		: task);
+	tasks = tasks.map((task) => {
+		if (!hasText(task.subagentType)) return task;
+		const subagentType = normalizeSubagentType(task.subagentType, config);
+		return subagentType !== task.subagentType ? { ...task, subagentType } : task;
+	});
 	const parentModel = currentModelRef(ctx.model);
 	const effectiveConfig = filterSubagentConfigForParentModel(config, parentModel);
 	const invalidTasks = tasks.filter((task) => hasText(task.subagentType)

package/external/pi-tools-suite/src/async-subagents/core/spawn.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { selectSuitableToolsForModel } from "../../lib/tool-args.js";
-import { BROWSER_QA_RUNNER_ENV, getBrowserQaRunnerPath } from "./browser-qa.js";
+import { BROWSER_QA_RUNNER_ENV, getBrowserQaRunnerPath, getUiQaRunnerPath, isUiQaType, UI_QA_RUNNER_ENV } from "./browser-qa.js";
 import { validateBasename } from "./paths.js";
 import { getPiInvocation } from "./pi-invocation.js";
 import { writePromptFile } from "./prompt.js";
@@ -20,12 +20,11 @@ export interface SpawnAgentOptions {
 	parentSession?: string;
 	timeoutMs?: number;
 	maxResultBytes?: number;
-	/** Explicit skills to load after disabling normal skill discovery. */
-	isolatedSkills?: string[];
 }
 
 export const DEFAULT_AGENT_TIMEOUT_MS = 30 * 60 * 1000;
 const BROWSER_QA_WORKSPACE_DIR = "browser-qa";
+const UI_QA_WORKSPACE_DIR = "ui-qa";
 const SUBAGENT_AGENT_DIR_ENV = "PI_SUBAGENT_AGENT_DIR";
 const AGENT_TIMEOUT_EXIT_CODE = 124;
 const AGENT_TIMEOUT_KILL_GRACE_MS = 5_000;
@@ -50,7 +49,7 @@ export function spawnAgent(
 	validateBasename(task.id, "task.id");
 	const agentDir = path.join(runDir, task.id);
 	fs.mkdirSync(agentDir, { recursive: true });
-	prepareBrowserQaWorkspace(agentDir, task.subagentType);
+	prepareUiQaWorkspace(agentDir, task.subagentType);
 
 	// Clean previous state when reusing a run directory/agent id.
 	for (const f of [
@@ -89,10 +88,9 @@ export function spawnAgent(
 	// detached subprocesses do not depend on persisted local pi settings.
 	const persistSessions = shouldPersistSubagentSessions();
 	const sessionDir = persistSessions ? getAgentSessionDir(agentDir) : undefined;
-	// QA instructions now live in the agent prompt, but normal skill discovery
-	// must stay disabled even when no additional skill is configured.
-	const isolateSkills = task.subagentType === "browser-qa" || Boolean(options.isolatedSkills?.length);
-	const forwardedExtraArgs = isolateSkills ? withoutSkillArgs(extraArgs) : extraArgs;
+	// Sub-agent roles are self-contained. Never inherit/discover skills, and do
+	// not allow profile/user extra args to re-enable or inject them.
+	const forwardedExtraArgs = withoutSkillArgs(extraArgs);
 	if (sessionDir) fs.mkdirSync(sessionDir, { recursive: true });
 	const piArgs: string[] = ["--mode", "rpc"];
 	if (sessionDir) piArgs.push("--session-dir", sessionDir);
@@ -101,16 +99,15 @@ export function spawnAgent(
 	piArgs.push("--extension", getModelToolsExtensionPath());
 	// Preserve `--no-extensions` unless this invocation explicitly selects an
 	// Antigravity model. Environment/default models do not opt the provider in.
-	if (usesAntigravityModel(task.model, forwardedExtraArgs)) {
+	const configuredModel = task.model || getEnvModel();
+	const selectedModel = resolveSelectedModel(configuredModel, forwardedExtraArgs);
+	const explicitModel = resolveSelectedModel(task.model, forwardedExtraArgs);
+	if (explicitModel?.startsWith("antigravity/") && explicitModel.length > "antigravity/".length) {
 		piArgs.push("--extension", getAntigravityAuthExtensionPath());
 	}
-	if (isolateSkills) {
-		piArgs.push("--no-skills");
-		for (const skillPath of options.isolatedSkills ?? []) piArgs.push("--skill", skillPath);
-	}
-	const envModel = task.model || getEnvModel();
-	if (envModel) piArgs.push("--model", envModel);
-	const selectedTools = task.tools ? filterSubagentTools(selectSuitableToolsForModel(envModel, task.tools)) : undefined;
+	piArgs.push("--no-skills");
+	if (configuredModel) piArgs.push("--model", configuredModel);
+	const selectedTools = task.tools ? filterSubagentTools(selectSuitableToolsForModel(selectedModel, task.tools)) : undefined;
 	if (selectedTools) {
 		if (selectedTools.length > 0) piArgs.push("--tools", selectedTools.join(","));
 		else piArgs.push("--no-tools");
@@ -119,6 +116,10 @@ export function spawnAgent(
 
 	// User-supplied extra args (e.g. --thinking high)
 	piArgs.push(...forwardedExtraArgs);
+	// The child always runs one explicitly selected model. Override persisted
+	// enabledModels (and any extra --models value) so isolated children do not
+	// resolve unrelated provider patterns before their limited extensions load.
+	if (selectedModel) piArgs.push("--models", selectedModel);
 	// Keep recursive/interactive parent-only tools disabled even if explicit
 	// sub-agent extraArgs load additional extensions or override --tools.
 	piArgs.push("--extension", getSubagentToolGuardExtensionPath());
@@ -151,7 +152,7 @@ export function spawnAgent(
 
 	const proc = spawn(invocation.command, invocation.args, {
 		cwd,
-		env: subagentEnvironment(process.env, task.subagentType === "browser-qa" ? agentDir : undefined),
+		env: subagentEnvironment(process.env, isUiQaType(task.subagentType) ? agentDir : undefined),
 		stdio: ["pipe", "pipe", "pipe"],
 		detached: process.platform !== "win32",
 	});
@@ -477,8 +478,8 @@ function withoutSkillArgs(args: string[]): string[] {
 	return filtered;
 }
 
-function usesAntigravityModel(taskModel: string | undefined, extraArgs: string[]): boolean {
-	let model = taskModel?.trim() || undefined;
+function resolveSelectedModel(configuredModel: string | undefined, extraArgs: string[]): string | undefined {
+	let model = configuredModel?.trim() || undefined;
 	for (let index = 0; index < extraArgs.length; index += 1) {
 		const arg = extraArgs[index];
 		if (arg === "--model" || arg === "-m") {
@@ -490,7 +491,7 @@ function usesAntigravityModel(taskModel: string | undefined, extraArgs: string[]
 			model = arg.slice("--model=".length).trim() || undefined;
 		}
 	}
-	return Boolean(model?.startsWith("antigravity/") && model.length > "antigravity/".length);
+	return model;
 }
 
 function getModelToolsExtensionPath(): string {
@@ -821,21 +822,30 @@ function subagentEnvironment(env: NodeJS.ProcessEnv, agentDir?: string): NodeJS.
 	};
 	delete result[SUBAGENT_AGENT_DIR_ENV];
 	delete result[BROWSER_QA_RUNNER_ENV];
+	delete result[UI_QA_RUNNER_ENV];
 	if (agentDir) {
 		result[SUBAGENT_AGENT_DIR_ENV] = fs.realpathSync(agentDir);
 		result[BROWSER_QA_RUNNER_ENV] = getBrowserQaRunnerPath();
+		result[UI_QA_RUNNER_ENV] = getUiQaRunnerPath();
 	}
 	return result;
 }
 
-function prepareBrowserQaWorkspace(agentDir: string, subagentType: string | undefined): void {
-	const workspace = path.join(agentDir, BROWSER_QA_WORKSPACE_DIR);
+function prepareUiQaWorkspace(agentDir: string, subagentType: string | undefined): void {
+	const workspace = path.join(agentDir, UI_QA_WORKSPACE_DIR);
+	const browserWorkspace = path.join(agentDir, BROWSER_QA_WORKSPACE_DIR);
 	fs.rmSync(workspace, { recursive: true, force: true });
-	if (subagentType !== "browser-qa") return;
-	const flows = path.join(workspace, "flows");
+	fs.rmSync(browserWorkspace, { recursive: true, force: true });
+	if (!isUiQaType(subagentType)) return;
+	const flows = path.join(browserWorkspace, "flows");
+	const uiFlows = path.join(workspace, "flows");
+	fs.mkdirSync(workspace, { recursive: true, mode: 0o700 });
+	fs.mkdirSync(uiFlows, { recursive: true, mode: 0o700 });
 	fs.mkdirSync(flows, { recursive: true, mode: 0o700 });
 	if (process.platform !== "win32") {
 		fs.chmodSync(workspace, 0o700);
+		fs.chmodSync(uiFlows, 0o700);
+		fs.chmodSync(browserWorkspace, 0o700);
 		fs.chmodSync(flows, 0o700);
 	}
 }