@maxiaochao/pi-toolkit 0.10.21 → 0.10.23

package/packages/herdr-subagents/src/run-pane-allocator.ts

@@ -1,5 +1,5 @@
 import type { HerdrAutomation } from "./herdr.ts";
-import { writeJsonAtomic } from "./state.ts";
+import { withRunStateLock } from "./run-state.ts";
 import type { RunRecord } from "./records.ts";
 import { applyRunStatus } from "./run-status.ts";
 import { cleanupRunTab } from "./tab-cleanup.ts";
@@ -33,45 +33,47 @@ export class RunPaneAllocator {
 		this.allocation = this.allocation.then(async () => {
 			const { herdr, run, runFile, signal } = this.options;
 			const env = childEnvironment(taskDirectory);
-			let anchorExists = Boolean(run.tabId && this.lastPaneId);
-			if (anchorExists && this.options.validateExistingPane) {
-				const survivingPaneIds: string[] = [];
-				for (const existingPaneId of this.paneIds) {
-					if (await herdr.paneExists(existingPaneId, signal)) survivingPaneIds.push(existingPaneId);
+			const allocated = await withRunStateLock(runFile, signal, async (latest) => {
+				const currentPaneIds = [...(latest.paneIds ?? [])];
+				let lastPaneId = currentPaneIds.at(-1);
+				let anchorExists = Boolean(latest.tabId && lastPaneId);
+				if (anchorExists && this.options.validateExistingPane) {
+					const surviving: string[] = [];
+					for (const existingPaneId of currentPaneIds) if (await herdr.paneExists(existingPaneId, signal)) surviving.push(existingPaneId);
+					currentPaneIds.splice(0, currentPaneIds.length, ...surviving);
+					lastPaneId = currentPaneIds.at(-1);
+					anchorExists = Boolean(lastPaneId);
 				}
-				this.paneIds.splice(0, this.paneIds.length, ...survivingPaneIds);
-				this.lastPaneId = this.paneIds.at(-1);
-				anchorExists = Boolean(this.lastPaneId);
-			}
-			if (!anchorExists) {
-				const staleTabId = run.tabId;
-				const tab = await herdr.createTab({ workspaceId: process.env.HERDR_WORKSPACE_ID ?? "", cwd: run.cwd, label: `SA · ${run.label}`, env, focus: false, signal });
-				run.tabId = tab.tabId;
-				paneId = tab.paneId;
-				this.paneIds.splice(0);
-				if (staleTabId && staleTabId !== tab.tabId) {
-					run.staleTabIds = [...new Set([...(run.staleTabIds ?? []), staleTabId])];
-					await writeJsonAtomic(runFile, run);
-					await cleanupRunTab({
-						herdr, tabId: staleTabId, runFile, runRecord: run, signal, onError: this.options.onCleanupError,
-						errorPrefix: `Could not close stale Herdr tab ${staleTabId}`,
-							onClosed: (latest) => {
-							latest.staleTabIds = latest.staleTabIds?.filter((id) => id !== staleTabId);
-							if (!latest.staleTabIds?.length) delete latest.staleTabIds;
-						},
-					}).catch((error) => {
-						if (!this.options.onCleanupError) throw error;
-					});
+				let staleTabId: string | undefined;
+				if (!anchorExists) {
+					staleTabId = latest.tabId;
+					const tab = await herdr.createTab({ workspaceId: process.env.HERDR_WORKSPACE_ID ?? "", cwd: latest.cwd, label: `SA · ${latest.label}`, env, focus: false, signal });
+					latest.tabId = tab.tabId;
+					paneId = tab.paneId;
+					currentPaneIds.splice(0);
+					if (staleTabId && staleTabId !== tab.tabId) latest.staleTabIds = [...new Set([...(latest.staleTabIds ?? []), staleTabId])];
+				} else {
+					paneId = (await herdr.splitPane({ paneId: lastPaneId as string, cwd: latest.cwd, direction: currentPaneIds.length % 2 ? "right" : "down", focus: false, env, signal })).paneId;
 				}
-			} else {
-				const split = await herdr.splitPane({ paneId: this.lastPaneId as string, cwd: run.cwd, direction: this.paneIds.length % 2 ? "right" : "down", focus: false, env, signal });
-				paneId = split.paneId;
+				currentPaneIds.push(paneId);
+				applyRunStatus(latest, "running");
+				latest.paneIds = currentPaneIds;
+				return { latest, staleTabId: staleTabId && staleTabId !== latest.tabId ? staleTabId : undefined };
+			});
+			this.paneIds.splice(0, this.paneIds.length, ...(allocated.latest.paneIds ?? []));
+			this.lastPaneId = this.paneIds.at(-1);
+			Object.assign(run, allocated.latest);
+			if (allocated.staleTabId) {
+				const staleTabId = allocated.staleTabId;
+				await cleanupRunTab({
+					herdr, tabId: staleTabId, runFile, runRecord: run, signal, onError: this.options.onCleanupError,
+					errorPrefix: `Could not close stale Herdr tab ${staleTabId}`,
+					onClosed: (latest) => {
+						latest.staleTabIds = latest.staleTabIds?.filter((id) => id !== staleTabId);
+						if (!latest.staleTabIds?.length) delete latest.staleTabIds;
+					},
+				}).catch((error) => { if (!this.options.onCleanupError) throw error; });
 			}
-			this.lastPaneId = paneId;
-			this.paneIds.push(paneId);
-			applyRunStatus(run, "running");
-			run.paneIds = [...this.paneIds];
-			await writeJsonAtomic(runFile, run);
 		});
 		await this.allocation;
 		return paneId;

package/packages/herdr-subagents/src/run-state.ts

@@ -0,0 +1,120 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, readFile, rename, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { isProcessAlive } from "./ownership.ts";
+import { readRunRecord, type RunRecord } from "./records.ts";
+import { writeJsonAtomic } from "./state.ts";
+
+interface LockOwner {
+	token: string;
+	processId: number;
+	createdAt: string;
+}
+
+export interface DirectoryLock {
+	directory: string;
+	token: string;
+	release(): Promise<void>;
+}
+
+const INITIALIZATION_STALE_MS = 30_000;
+const delay = (milliseconds: number, signal?: AbortSignal) => new Promise<void>((resolve, reject) => {
+	const onAbort = () => { clearTimeout(timer); reject(signal?.reason ?? new Error("Lock wait aborted.")); };
+	const timer = setTimeout(() => { signal?.removeEventListener("abort", onAbort); resolve(); }, milliseconds);
+	if (signal?.aborted) onAbort();
+	else signal?.addEventListener("abort", onAbort, { once: true });
+});
+
+async function readOwner(directory: string): Promise<LockOwner | undefined> {
+	try {
+		const value = JSON.parse(await readFile(join(directory, "owner.json"), "utf8")) as Partial<LockOwner>;
+		if (typeof value.token === "string" && Number.isInteger(value.processId)) return { ...value, createdAt: typeof value.createdAt === "string" ? value.createdAt : new Date(0).toISOString() } as LockOwner;
+	} catch { /* An invalid/legacy lock is handled only after its initialization lease expires. */ }
+	return undefined;
+}
+
+async function reclaimIfStale(directory: string): Promise<boolean> {
+	const owner = await readOwner(directory);
+	if (owner && isProcessAlive(owner.processId)) return false;
+	let identity;
+	try { identity = await lstat(directory); }
+	catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return true; throw error; }
+	// A missing owner is an explicit initialization state. Atomic publication below does
+	// not create it, but retain a lease for old/crashed lock directories.
+	if (!owner && Date.now() - identity.mtimeMs < INITIALIZATION_STALE_MS) return false;
+	const stale = `${directory}.stale-${randomUUID()}`;
+	// Revalidate both ownership and directory identity immediately before reclamation.
+	const latestOwner = await readOwner(directory);
+	if (latestOwner && isProcessAlive(latestOwner.processId)) return false;
+	let latestIdentity;
+	try { latestIdentity = await lstat(directory); }
+	catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return true; throw error; }
+	if (latestIdentity.dev !== identity.dev || latestIdentity.ino !== identity.ino) return true;
+	try { await rename(directory, stale); }
+	catch (error) {
+		if (["ENOENT", "ENOTEMPTY", "EEXIST"].includes(String((error as NodeJS.ErrnoException).code))) return true;
+		throw error;
+	}
+	await rm(stale, { recursive: true, force: true });
+	return true;
+}
+
+export async function acquireDirectoryLock(directory: string, options: { wait: boolean; signal?: AbortSignal; contentionMessage?: string; beforePublish?: () => void | Promise<void> }): Promise<DirectoryLock> {
+	const token = randomUUID();
+	const owner: LockOwner = { token, processId: process.pid, createdAt: new Date().toISOString() };
+	for (;;) {
+		const prepared = `${directory}.initializing-${token}`;
+		await mkdir(prepared, { mode: 0o700 });
+		try {
+			await writeJsonAtomic(join(prepared, "owner.json"), owner);
+			await options.beforePublish?.();
+			try { await rename(prepared, directory); }
+			catch (error) {
+				if (!["EEXIST", "ENOTEMPTY"].includes(String((error as NodeJS.ErrnoException).code))) throw error;
+				await rm(prepared, { recursive: true, force: true });
+				if (await reclaimIfStale(directory)) continue;
+				if (!options.wait) throw new Error(options.contentionMessage ?? `Lock is already held: ${directory}`);
+				await delay(10, options.signal);
+				continue;
+			}
+			return {
+				directory,
+				token,
+				async release() {
+					if ((await readOwner(directory))?.token !== token) return;
+					const released = `${directory}.released-${token}`;
+					try { await rename(directory, released); }
+					catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return; throw error; }
+					// Delete only the detached inode; a contender may safely publish the next
+					// generation at the canonical path immediately after the rename.
+					await rm(released, { recursive: true, force: true });
+				}, 
+			};
+		} catch (error) {
+			await rm(prepared, { recursive: true, force: true });
+			throw error;
+		}
+	}
+}
+
+/** Only the holder of this lock may start a run's queued tasks. */
+export function queueLockPath(runDirectory: string): string { return join(runDirectory, ".queue.lock"); }
+
+/** Replaces a long-lived in-memory copy with the record observed under the lock, including removals. */
+export function adoptRecord<T extends object>(target: T, latest: T): T {
+	const mutable = target as unknown as Record<string, unknown>;
+	for (const key of Object.keys(mutable)) if (!(key in latest)) delete mutable[key];
+	return Object.assign(target, latest);
+}
+
+export async function withRunStateLock<T>(runFile: string, signal: AbortSignal | undefined, mutate: (run: RunRecord) => T | Promise<T>): Promise<T> {
+	const lock = await acquireDirectoryLock(join(dirname(runFile), ".state.lock"), { wait: true, signal });
+	try {
+		const run = await readRunRecord(runFile);
+		const result = await mutate(run);
+		await writeJsonAtomic(runFile, run);
+		return result;
+	} finally {
+		await lock.release();
+	}
+}

package/packages/herdr-subagents/src/status.ts

@@ -12,8 +12,6 @@ export interface RunStatusTask {
 	summary?: string;
 	question?: string;
 	error?: string;
-	failureKind?: "missing_input";
-	requiredInput?: string;
 }
 
 export interface RunStatusSnapshot {
@@ -46,8 +44,6 @@ async function loadDurableStatus(cwd: string, runId: string): Promise<RunStatusS
 		const report = reportIsCurrent && existsSync(reportFile) ? await readReport(reportFile) : undefined;
 		const question = report?.question ?? task.question;
 		const error = report?.error ?? task.error;
-		const failureKind = report?.failureKind ?? task.failureKind;
-		const requiredInput = report?.requiredInput ?? task.requiredInput;
 		tasks.push({
 			order: task.order,
 			name: task.name ?? task.agent ?? `Task ${task.order}`,
@@ -56,8 +52,6 @@ async function loadDurableStatus(cwd: string, runId: string): Promise<RunStatusS
 			...(report?.summary ? { summary: report.summary } : {}),
 			...(question ? { question } : {}),
 			...(error ? { error } : {}),
-			...(failureKind ? { failureKind } : {}),
-			...(requiredInput ? { requiredInput } : {}),
 		});
 	}
 	return {

package/packages/herdr-subagents/src/tab-cleanup.ts

@@ -1,6 +1,6 @@
 import type { HerdrAutomation } from "./herdr.ts";
-import { readRunRecord, type RunRecord } from "./records.ts";
-import { writeJsonAtomic } from "./state.ts";
+import { type RunRecord } from "./records.ts";
+import { adoptRecord, withRunStateLock } from "./run-state.ts";
 
 function isMissingTabError(error: unknown): boolean {
 	const detail = error instanceof Error ? `${error.message}\n${(error as { stderr?: unknown }).stderr ?? ""}` : String(error);
@@ -18,17 +18,16 @@ export async function cleanupRunTab(options: {
 	errorPrefix?: string;
 }): Promise<{ deferred: boolean }> {
 	const mergeLatest = async (update: (run: RunRecord) => void | Promise<void>, requirePending = false, clearPending = true) => {
-		const latest = await readRunRecord(options.runFile);
-		if (requirePending && !latest.cleanupPendingTabIds?.includes(options.tabId)) return;
-		if (clearPending) {
-			latest.cleanupPendingTabIds = latest.cleanupPendingTabIds?.filter((tabId) => tabId !== options.tabId);
-			if (!latest.cleanupPendingTabIds?.length) delete latest.cleanupPendingTabIds;
-		}
-		await update(latest);
-		await writeJsonAtomic(options.runFile, latest);
-		const mutableRecord = options.runRecord as unknown as Record<string, unknown>;
-		for (const key of Object.keys(mutableRecord)) if (!(key in latest)) delete mutableRecord[key];
-		Object.assign(options.runRecord, latest);
+		const latest = await withRunStateLock(options.runFile, options.signal, async (run) => {
+			if (requirePending && !run.cleanupPendingTabIds?.includes(options.tabId)) return run;
+			if (clearPending) {
+				run.cleanupPendingTabIds = run.cleanupPendingTabIds?.filter((tabId) => tabId !== options.tabId);
+				if (!run.cleanupPendingTabIds?.length) delete run.cleanupPendingTabIds;
+			}
+			await update(run);
+			return run;
+		});
+		adoptRecord(options.runRecord, latest);
 	};
 	const reportFailure = async (error: unknown, requirePending = false) => {
 		const detail = error instanceof Error ? error.message : String(error);
@@ -51,9 +50,10 @@ export async function cleanupRunTab(options: {
 			return { deferred: false };
 		}
 		if (await options.herdr.isTabFocused(options.tabId, options.signal)) {
-			const latest = await readRunRecord(options.runFile);
-			latest.cleanupPendingTabIds = [...new Set([...(latest.cleanupPendingTabIds ?? []), options.tabId])];
-			await writeJsonAtomic(options.runFile, latest);
+			const latest = await withRunStateLock(options.runFile, options.signal, (run) => {
+				run.cleanupPendingTabIds = [...new Set([...(run.cleanupPendingTabIds ?? []), options.tabId])];
+				return run;
+			});
 			Object.assign(options.runRecord, latest);
 			void options.herdr.waitForTabUnfocused(options.tabId, options.signal)
 				.then(() => options.herdr.closeTab(options.tabId, options.signal))

package/packages/herdr-subagents/src/tool.ts

@@ -1,6 +1,5 @@
 import { CliHerdrAutomation, type HerdrAutomation } from "./herdr.ts";
 import { loadSubagentConfiguration, type ConfigurationPaths, type SubagentConfiguration } from "./config.ts";
-import { runHerdrSubagents, type HerdrSubagentsResult } from "./runner.ts";
 import { runHerdrSubagentsBatch, type BatchResult, type BatchTask } from "./batch-runner.ts";
 import { respondToBlockedTask } from "./blocking.ts";
 import { cleanSubagentRun, historyText, listSubagentHistory, resumeHistoricalTask } from "./history.ts";
@@ -31,9 +30,7 @@ export interface HerdrSubagentsControlToolParams {
 export interface HerdrSubagentsToolParams {
 	action?: "list" | "status" | "respond" | "history" | "resume" | "cancel" | "cleanup";
 	prompt?: string;
-	agent?: string;
 	label?: string;
-	model?: string;
 	tasks?: HerdrSubagentsTaskParams[];
 	concurrency?: number;
 	background?: boolean;
@@ -57,13 +54,6 @@ export interface HerdrSubagentsToolDependencies {
 	cancelRun?: (runId: string) => Promise<{ cancelled: boolean; queued?: boolean; cleanupErrors?: string[] }>;
 }
 
-export type HerdrSubagentsDetails = HerdrSubagentsResult & {
-	agent: string;
-	description: string;
-	prompt: string;
-	personaPath: string;
-};
-
 export type HerdrSubagentsBatchDetails = BatchResult & { prompts: string[] };
 
 type ToolResponse = {
@@ -91,14 +81,6 @@ export function listText(discovery: SubagentConfiguration): string {
 	return lines.join("\n");
 }
 
-function summaryText(result: HerdrSubagentsResult): string {
-	if (result.ok) return result.output;
-	const lines = [result.summary];
-	if (result.errorMessage) lines.push(`Error: ${result.errorMessage}`);
-	if (result.recordDirectory) lines.push(`Task record: ${result.recordDirectory}`);
-	return lines.join("\n");
-}
-
 interface ToolExecutionContext {
 	params: HerdrSubagentsToolParams;
 	signal?: AbortSignal;
@@ -179,7 +161,7 @@ const actionHandlers = {
 	async respond({ params, signal, onUpdate, ctx, dependencies }: ToolExecutionContext) {
 		try {
 			const result = await respondToBlockedTask(ctx.cwd, (params.runId as string).trim(), (params.answer as string).trim(), {
-				herdr: dependencies.herdr, taskNumber: params.task, signal, owner: dependencies.owner,
+				herdr: dependencies.herdr, taskNumber: params.task as number, signal, owner: dependencies.owner,
 				onUpdate: (partial) => onUpdate?.({ content: [{ type: "text", text: partial.summary }], details: partial }),
 				onStalled: (text) => onUpdate?.({ content: [{ type: "text", text }], details: { action: "respond", runId: params.runId, stalled: true } }),
 				onWarning: (text) => onUpdate?.({ content: [{ type: "text", text }], details: { action: "respond", runId: params.runId, warning: text } }),
@@ -230,37 +212,6 @@ async function executeBatch({ params, signal, onUpdate, ctx, dependencies, disco
 	}
 }
 
-async function executeSingle({ params, signal, onUpdate, ctx, dependencies, discovery }: ToolExecutionContext): Promise<ToolResponse> {
-	const prompt = params.prompt as string;
-	const selectedName = params.agent?.trim() || "worker";
-	const persona = discovery.personas.find((agent) => agent.name === selectedName);
-	if (!persona) return errorResponse(`Unknown persona '${selectedName}'.\n\n${listText(discovery)}`);
-	const explicitModel = params.model?.trim();
-	const selectedModel = explicitModel || persona.model || modelId(ctx);
-	const selectedThinking = persona.thinking ?? (!explicitModel && persona.modelSource === "parent session" ? ctx.thinkingLevel : undefined);
-	const details = (result: HerdrSubagentsResult): HerdrSubagentsDetails => ({ ...result, agent: persona.name, description: persona.description, prompt, personaPath: persona.filePath });
-	const result = await runHerdrSubagents(prompt, {
-		agent: persona.name,
-		label: params.label,
-		...(selectedModel ? { model: selectedModel } : {}),
-		...(selectedThinking ? { thinking: selectedThinking } : {}),
-		...(persona.tools ? { tools: persona.tools } : {}),
-		skills: persona.skills,
-		access: persona.access,
-		owner: dependencies.owner,
-		systemPrompt: persona.systemPrompt,
-		cwd: ctx.cwd,
-		signal,
-		herdr: dependencies.herdr,
-		stalledWarningSeconds: discovery.settings.stalledWarningSeconds,
-		onStalled: (text) => onUpdate?.({ content: [{ type: "text", text }], details: { status: "running", stalled: true } }),
-		onCleanupError: (text) => onUpdate?.({ content: [{ type: "text", text }], details: { status: "warning", cleanupError: text } }),
-		onUpdate: (partial) => onUpdate?.({ content: [{ type: "text", text: partial.summary }], details: details(partial) }),
-	});
-	const isError = result.status === "failed" || result.status === "cancelled";
-	return { content: [{ type: "text", text: summaryText(result) }], details: details(result), ...(isError ? { isError: true } : {}) };
-}
-
 export async function executeHerdrSubagents(
 	params: HerdrSubagentsRunParams | HerdrSubagentsToolParams,
 	signal: AbortSignal | undefined,
@@ -269,10 +220,6 @@ export async function executeHerdrSubagents(
 	dependencies: HerdrSubagentsToolDependencies,
 ): Promise<ToolResponse> {
 	if (params.action) return executeHerdrSubagentsControl(params as HerdrSubagentsControlToolParams, signal, onUpdate, ctx, dependencies);
-	if (params.prompt && !params.tasks) {
-		const discovery = loadSubagentConfiguration(ctx.cwd, dependencies.agentsDirectory, modelId(ctx), dependencies.configurationPaths);
-		return executeSingle({ params, signal, onUpdate, ctx, dependencies, discovery });
-	}
 	const runParams = params as HerdrSubagentsRunParams;
 	const validationError = validateRunParams(runParams);
 	if (validationError) return { content: [{ type: "text", text: validationError }], details: { errorMessage: validationError }, isError: true };

package/packages/herdr-subagents/src/validation.ts

@@ -21,7 +21,7 @@ export function validateControlParams(params: HerdrSubagentsControlToolParams):
 	const extra = Object.keys(params).find((key) => !allowed.includes(key as keyof HerdrSubagentsControlToolParams));
 	if (extra) return `Field '${extra}' is not valid with action '${params.action}'.`;
 	if ((params.action === "status" || params.action === "cancel" || params.action === "cleanup") && !params.runId?.trim()) return `runId is required for action '${params.action}'.`;
-	if (params.action === "respond" && (!params.runId?.trim() || !params.answer?.trim())) return "runId and answer are required for action 'respond'.";
+	if (params.action === "respond" && (!params.runId?.trim() || !params.answer?.trim() || !params.task)) return "runId, answer, and task are required for action 'respond'.";
 	if (params.action === "resume" && (!params.runId?.trim() || !params.task || !params.prompt?.trim())) return "runId, task, and prompt are required for action 'resume'.";
 	return undefined;
 }

package/packages/herdr-subagents/tests/extension-contract.ts

@@ -311,7 +311,7 @@ async function verifyForegroundFailureHandoff() {
 		}
 		const queuedBehindBlocked = await blockedOwner.tool?.execute("blocked-background", { background: true, tasks: [{ name: "background", prompt: "later" }] }, undefined, undefined, { cwd: blockedOwnerRoot, ui: blockedOwner.ui });
 		if (queuedBehindBlocked.details?.status !== "queued" || blockedOwnerCalls !== 1) throw new Error("background run did not remain queued behind the blocked dispatcher owner");
-		await blockedOwner.controlTool?.execute("respond-prefix", { action: "respond", runId: ownerResult.details.runId.slice(0, 8), answer: "continue" }, undefined, undefined, { cwd: blockedOwnerRoot, ui: blockedOwner.ui });
+		await blockedOwner.controlTool?.execute("respond-prefix", { action: "respond", runId: ownerResult.details.runId.slice(0, 8), task: 1, answer: "continue" }, undefined, undefined, { cwd: blockedOwnerRoot, ui: blockedOwner.ui });
 		await waitUntil(() => blockedSuccessorStarted, "responding through a run ID prefix did not release the blocked dispatcher owner");
 		await blockedOwner.handlers.get("session_shutdown")?.({}, { cwd: blockedOwnerRoot, ui: blockedOwner.ui });
 
@@ -347,10 +347,10 @@ async function verifyPublicUiWiring() {
 		const responding = harness(async () => ({ content: [{ type: "text", text: "needs input" }], details: blockedDetails }));
 		await startHarness(responding, cwd);
 		if (!responding.tool) throw new Error("herdr_subagents was not registered for UI wiring test");
-		const renderedBlocked = responding.tool.renderResult({ content: [{ type: "text", text: "needs input" }], details: { agent: "explorer", status: "blocked", ok: false, summary: "Need input.", documents: [] } }, { isPartial: false }, { fg: (_color: string, text: string) => text, bold: (text: string) => text }).render(100).join("\n");
-		if (!renderedBlocked.includes("blocked") || renderedBlocked.includes("failed")) throw new Error("single-task blocked result did not render its authoritative status");
+		const renderedBlocked = responding.tool.renderResult({ content: [{ type: "text", text: "needs input" }], details: { label: "reviews", status: "blocked", effectiveConcurrency: 1, tasks: [{ index: 1, name: "second", status: "blocked", summary: "Need input." }] } }, { isPartial: false }, { fg: (_color: string, text: string) => text, bold: (text: string) => text }).render(100).join("\n");
+		if (!renderedBlocked.includes("blocked") || renderedBlocked.includes("failed")) throw new Error("blocked result did not render its authoritative status");
 		if (!responding.controlTool) throw new Error("herdr_subagents_control was not registered for UI wiring test");
-		await responding.controlTool.execute("call", { action: "respond", runId: "blocked-run", answer: "main" }, undefined, undefined, { cwd, ui: responding.ui });
+		await responding.controlTool.execute("call", { action: "respond", runId: "blocked-run", task: 2, answer: "main" }, undefined, undefined, { cwd, ui: responding.ui });
 		if (!responding.renderedLines.some((line) => line.includes("second") && line.includes("blocked"))) throw new Error("blocked response did not refresh Fleet rows");
 		if (!responding.terminalInput?.("\u001b[B")?.consume || !responding.terminalInput?.("\u001b[B")?.consume || !responding.terminalInput?.("\r")?.consume) throw new Error("Fleet terminal input was not consumed while selecting");
 		await new Promise((resolve) => setTimeout(resolve, 0));