pi-ui-extend 1.0.41 → 1.0.45

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

@@ -4,6 +4,8 @@ import type { AgentTask } from "./types.js";
 import {
 	currentModelRef,
 	defaultSubagentType,
+	filterSubagentConfigForParentModel,
+	normalizeSubagentType,
 	resolveSubagentRoutingConfig,
 	type ResolvedSubagentRoutingConfig,
 	type SubagentConfig,
@@ -45,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/review and evidence, implement for code/docs/tests/UI changes, verify for running checks, browser-qa for real-browser testing. Oracle is a deliberate strong second opinion, not 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");
@@ -58,14 +60,28 @@ 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)
 		&& !Object.prototype.hasOwnProperty.call(config.types, task.subagentType));
 	if (invalidTasks.length > 0) {
-		throw routingError(`Unknown subagentType: ${invalidTasks.map((task) => `${task.id}=${JSON.stringify(task.subagentType)}`).join(", ")}.`, invalidTasks, config);
+		throw routingError(`Unknown subagentType: ${invalidTasks.map((task) => `${task.id}=${JSON.stringify(task.subagentType)}`).join(", ")}.`, invalidTasks, effectiveConfig);
+	}
+	const unavailableTasks = tasks.filter((task) => hasText(task.subagentType)
+		&& !Object.prototype.hasOwnProperty.call(effectiveConfig.types, task.subagentType));
+	if (unavailableTasks.length > 0) {
+		throw routingError(
+			`subagentType unavailable for parent model ${parentModel ?? "(unknown)"}: ${unavailableTasks.map((task) => `${task.id}=${JSON.stringify(task.subagentType)}`).join(", ")}.`,
+			unavailableTasks,
+			effectiveConfig,
+		);
 	}
+	config = effectiveConfig;
 	const autoTasks = tasks.filter((task) => !hasText(task.subagentType));
 	if (autoTasks.length === 0) return { tasks, usedLlm: false, routes: {}, warnings: [] };
 

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 {
@@ -696,10 +697,14 @@ function compactRpcEventForProgress(event: RpcEventRecord): Record<string, unkno
 			toolName: typeof event.toolName === "string" ? event.toolName : undefined,
 		});
 	}
-	if (event.type === "message_end") {
+	if (event.type === "message_start" || event.type === "message_end") {
 		return stripUndefined({
 			type: event.type,
-			role: isRecord(event.message) && typeof event.message.role === "string" ? event.message.role : undefined,
+			role: typeof event.role === "string"
+				? event.role
+				: isRecord(event.message) && typeof event.message.role === "string"
+					? event.message.role
+					: undefined,
 			stopReason: isRecord(event.message) && typeof event.message.stopReason === "string" ? event.message.stopReason : undefined,
 		});
 	}
@@ -817,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);
 	}
 }

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

@@ -1,10 +1,12 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { activityFromProgressRecord } from "./activity.js";
 import { hasLaunchedAgentPrompt, isDir } from "./paths.js";
 import { readStructuredResult } from "./structured-result.js";
 import type { AgentResult, AgentState, RpcEventRecord, RunState } from "./types.js";
 
 const MAX_RPC_EVENT_LINE_CHARS = 1024 * 1024;
+const LAST_ACTIVITY_TAIL_BYTES = 64 * 1024;
 
 interface AgentStateReadOptions {
 	includeLineCounts?: boolean;
@@ -67,6 +69,9 @@ export function getAgentState(
 		state.finishedAt = fs.readFileSync(finishedAtFile, "utf-8").trim();
 	}
 
+	const lastActivity = readLastActivity(path.join(agentDir, "progress.jsonl"));
+	if (lastActivity) state.lastActivity = lastActivity;
+
 	const retryPendingFile = path.join(agentDir, "retry_pending");
 	const stopRequestedFile = path.join(agentDir, "stop_requested");
 	if (fs.existsSync(retryPendingFile) && !fs.existsSync(stopRequestedFile) && state.status !== "running" && state.status !== "done") {
@@ -109,6 +114,41 @@ function readPid(pidFile: string): number | undefined {
 	return isNaN(pid) ? undefined : pid;
 }
 
+function readLastActivity(filePath: string): AgentState["lastActivity"] | undefined {
+	if (!fs.existsSync(filePath)) return undefined;
+	let fd: number | undefined;
+	try {
+		fd = fs.openSync(filePath, "r");
+		const size = fs.fstatSync(fd).size;
+		if (size <= 0) return undefined;
+		const start = Math.max(0, size - LAST_ACTIVITY_TAIL_BYTES);
+		const buffer = Buffer.allocUnsafe(size - start);
+		const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, start);
+		if (bytesRead <= 0) return undefined;
+		const lines = buffer.toString("utf-8", 0, bytesRead).split(/\r?\n/);
+		if (start > 0) {
+			const previousByte = Buffer.allocUnsafe(1);
+			const previousBytesRead = fs.readSync(fd, previousByte, 0, 1, start - 1);
+			if (previousBytesRead === 1 && previousByte[0] !== 0x0a) lines.shift();
+		}
+		for (let index = lines.length - 1; index >= 0; index--) {
+			const line = lines[index]?.trim();
+			if (!line) continue;
+			try {
+				const activity = activityFromProgressRecord(JSON.parse(line) as unknown);
+				if (activity) return activity;
+			} catch {
+				// Ignore malformed or partially written tail lines and keep scanning.
+			}
+		}
+	} catch {
+		return undefined;
+	} finally {
+		if (fd !== undefined) fs.closeSync(fd);
+	}
+	return undefined;
+}
+
 function hasRpcPromptFailure(eventsFile: string): boolean {
 	if (!fs.existsSync(eventsFile)) return false;
 	let fd: number | undefined;

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

@@ -39,6 +39,13 @@ export interface AgentState {
 	eventLines?: number;
 	/** How many times this agent has been retried (0 = first attempt). */
 	retryCount?: number;
+	/** Most recent user-visible activity observed from the sub-agent RPC stream. */
+	lastActivity?: AgentActivity;
+}
+
+export interface AgentActivity {
+	label: string;
+	at: string;
 }
 
 /** Retry configuration for failed agents. */

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

@@ -59,40 +59,58 @@ export async function decideUltraworkAuto(
 	if (!routing.enabled) return "none";
 	if (signal?.aborted) throw new Error("Aborted");
 
-	try {
-		const resolved = await resolveClassifierModel(ctx, routing.model);
-		if (!resolved) return "none";
-
-		const response = await completeWithModelRegistry(
-			ctx.modelRegistry,
-			resolved.model,
-			{
-				systemPrompt: CLASSIFIER_SYSTEM_PROMPT,
-				messages: [
-					{
-						role: "user" as const,
-						content: [{ type: "text" as const, text: buildClassifierPrompt(userText) }],
-						timestamp: Date.now(),
-					},
-				],
-			},
-			{
-				apiKey: resolved.apiKey,
-				headers: resolved.headers,
-				env: resolved.env,
-				cacheRetention: "none",
-				maxRetries: routing.maxRetries,
-				maxTokens: Math.min(routing.maxTokens, 32),
-				signal,
-				timeoutMs: routing.timeoutMs,
-			},
-		);
-
-		return parseUltraworkAutoDecision(responseText(response));
-	} catch (error) {
-		if (signal?.aborted || isAbortError(error)) throw error;
-		return "none";
+	const refs = [routing.model, ...routing.fallbackModels];
+	const parentModel = currentModelRef(ctx.model);
+	if (parentModel) refs.push(parentModel);
+	const seen = new Set<string>();
+
+	for (const ref of refs) {
+		const modelRef = ref?.trim();
+		if (!modelRef || seen.has(modelRef)) continue;
+		seen.add(modelRef);
+
+		let resolved: Awaited<ReturnType<typeof resolveModelRef>>;
+		try {
+			resolved = await resolveModelRef(ctx, modelRef);
+		} catch (error) {
+			if (signal?.aborted || isAbortError(error)) throw error;
+			continue;
+		}
+		if (!resolved) continue;
+
+		try {
+			const response = await completeWithModelRegistry(
+				ctx.modelRegistry,
+				resolved.model,
+				{
+					systemPrompt: CLASSIFIER_SYSTEM_PROMPT,
+					messages: [
+						{
+							role: "user" as const,
+							content: [{ type: "text" as const, text: buildClassifierPrompt(userText) }],
+							timestamp: Date.now(),
+						},
+					],
+				},
+				{
+					apiKey: resolved.apiKey,
+					headers: resolved.headers,
+					env: resolved.env,
+					cacheRetention: "none",
+					maxRetries: routing.maxRetries,
+					maxTokens: Math.min(routing.maxTokens, 32),
+					signal,
+					timeoutMs: routing.timeoutMs,
+				},
+			);
+			if (signal?.aborted || response.stopReason === "aborted") throw new Error("Aborted");
+			if (response.stopReason === "error") continue;
+			return parseUltraworkAutoDecision(responseText(response));
+		} catch (error) {
+			if (signal?.aborted || isAbortError(error)) throw error;
+		}
 	}
+	return "none";
 }
 
 export function parseUltraworkAutoDecision(raw: string): UltraworkAutoDecision {
@@ -128,18 +146,6 @@ function buildClassifierPrompt(userText: string): string {
 	].join("\n");
 }
 
-async function resolveClassifierModel(ctx: UltraworkAutoContext, modelRef: string): Promise<{
-	model: Model<Api>;
-	apiKey?: string;
-	headers?: ProviderHeaders;
-	env?: Record<string, string>;
-} | undefined> {
-	const configured = await resolveModelRef(ctx, modelRef);
-	if (configured) return configured;
-	const parentModel = currentModelRef(ctx.model);
-	return parentModel && parentModel !== modelRef ? resolveModelRef(ctx, parentModel) : undefined;
-}
-
 async function resolveModelRef(ctx: UltraworkAutoContext, modelRef: string): Promise<{
 	model: Model<Api>;
 	apiKey?: string;