@maxiaochao/pi-toolkit 0.10.20 → 0.10.21

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2026-10-10 - v0.10.21
+
+- bundle herdr-subagents v0.4.7: fix blocked-run scheduling and limit interactive blocking to serial runs
+- bundle the Herdr Subagents blocked-dispatch deadlock fix, serial-only interactive blocking, structured concurrent `missing_input` failures, and flexible run ID controls
+
 ## 2026-10-10 - v0.10.20
 
 - bundle herdr-subagents v0.4.6: reduce global prompt noise by keeping Subagent workflow guidance in tool descriptions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxiaochao/pi-toolkit",
-  "version": "0.10.20",
+  "version": "0.10.21",
   "description": "Personal pi coding agent toolkit: scheduler, /btw, /cache_export, apply_patch, browser automation, and bundled theme/skills.",
   "type": "module",
   "workspaces": [

package/packages/herdr-subagents/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 2026-10-10 - v0.4.7
+
+- fix blocked-run scheduling and limit interactive blocking to serial runs
+- prevent foreground runs from hanging behind a blocked dispatcher owner, return the blocking run ID immediately, and remove cancelled foreground calls from the queue while preserving background queuing
+- limit interactive blocking to effectively serial runs; concurrent input requests become structured `missing_input` failures while independent siblings continue
+- accept full run UUIDs, saved run-directory names, and unique UUID prefixes in run controls
+
 ## 2026-10-10 - v0.4.6
 
 - reduce global prompt noise by keeping Subagent workflow guidance in tool descriptions

package/packages/herdr-subagents/README.md

@@ -64,7 +64,7 @@ herdr_subagents({
 })
 ```
 
-`tasks` is always a non-empty array: one item is a single task and multiple items form a batch. Set `background: true` for either form to return a stable run ID immediately while the queue continues. The dispatcher starts batches FIFO, with one batch holding its active slot at a time; a failed foreground handoff releases that slot as described below. Each background run sends one compact parent notification only when the whole run completes, partially fails, fails, or blocks. Individual successful tasks do not wake the parent model.
+`tasks` is always a non-empty array: one item is a single task and multiple items form a batch. Set `background: true` for either form to return a stable run ID immediately while the queue continues. The dispatcher starts batches FIFO, with one batch holding its active slot at a time; a failed foreground handoff releases that slot as described below. A blocked run retains the slot so its queued siblings can continue after an answer. While that slot is blocked, a new foreground submission fails immediately with the blocking run ID instead of waiting indefinitely; a background submission remains queued. Cancelling a foreground tool call while it is queued removes it from the queue immediately. Each background run sends one compact parent notification only when the whole run completes, partially fails, fails, or blocks. Individual successful tasks do not wake the parent model.
 
 A foreground concurrent batch normally waits for the whole batch. If any task fails while siblings are still running, the call immediately returns the stable `runId` and that failure's details, then durably continues the same batch in the background without cancelling its siblings. The handed-off batch releases its dispatcher slot immediately, so a later submission can start while its surviving tasks are still running. The detached batch remains cancellable and is still joined during session shutdown. Its final aggregate is delivered exactly once through the same follow-up notification used by an explicit background run.
 
@@ -76,6 +76,8 @@ herdr_subagents_control({ action: "status", runId: "<run-id>" })
 
 The snapshot reports the aggregate run state and every task's state, including a blocked question when present. It checks durable run state before queued state, never returns unrelated runs, and does not wait or trigger a parent turn. Do not poll full `history` for progress.
 
+Run controls accept the complete run UUID, the saved run-directory name, or any unique UUID prefix. Results always return the canonical complete UUID.
+
 A child missing required information reports `needs-input` with an exact question. The run becomes blocked, keeps its Herdr tab, pane, partial report, and Pi session, and returns control to the parent. Answer through the control tool to continue the original session:
 
 ```text
@@ -84,6 +86,10 @@ herdr_subagents_control({ action: "respond", runId: "<run-id>", answer: "Use the
 
 Blocked is a normal control state, not a failed tool call. Only terminal failure, cancellation, or a partial aggregate is returned as a tool error.
 
+Blocking is limited to effectively serial runs (`effectiveConcurrency: 1`), where task order can depend on the answer. In a concurrent read-only run, tasks must be independent: a task that requests input is recorded as `failed` with `failureKind: "missing_input"` and `requiredInput`, while its independent siblings continue. This prevents a blocked concurrent task from holding the parent tool call behind unrelated long-running siblings.
+
+Only work owned by the current parent session's main dispatcher can remain blocked. Historical follow-ups that need more input settle as `missing_input` failures, and startup reconciliation cancels blocked work whose parent session disappeared; neither path creates an unowned blocked run.
+
 Cancel one active or queued run with `herdr_subagents_control({ action: "cancel", runId: "<run-id>" })`. Cancellation aborts its live child prompts, archives active or queued tasks as cancelled, closes its run tab, and leaves unrelated runs alone.
 
 While a batch is active, a compact Fleet monitor stays below the editor. Its divider/title row summarizes the run, and each task row shows a hollow or filled status circle, the real persona and task name, status, live active duration, and cumulative child Pi token usage in one compact shared metrics column after the longest row rather than at the terminal edge. Running work uses Pi's warning/yellow semantic color and completed work uses success/green. Token totals use the child session's persisted assistant, tool-result, standalone usage, compaction, and branch-summary usage; they are never estimated. Queued tasks show neither fabricated time nor tokens. The monitor follows Pi theme semantics, truncates by visible terminal columns, and refreshes session usage from both file events and the running one-second timer.

package/packages/herdr-subagents/TESTING.md

@@ -17,6 +17,9 @@
 - Let a detached run later block or be explicitly cancelled and verify the newer dispatcher owner remains intact and each detached run emits exactly one final notification.
 - Shut down the parent while a handed-off sibling is active and verify it is cancelled and joined, durable queue state is removed, and no stale follow-up is sent.
 - Verify all-success foreground batches still wait for every task and explicit `background: true` submissions still return immediately.
+- Verify a blocked dispatcher owner immediately rejects both newly submitted and already-queued foreground runs with its full run ID, keeps explicit background runs queued, and removes queued foreground runs when their caller cancels.
+- Verify only effectively serial runs can block; concurrent input requests settle as structured `missing_input` failures, including owner-loss reconciliation, while independent siblings continue.
+- Verify historical follow-ups cannot create unowned blocked work and owner-loss reconciliation cancels serial blocked work instead of reconstructing hidden dispatcher ownership.
 - Verify all paths use interactive Agent start/prompt without print mode, shell injection, markers, or pane reuse.
 - Force write-capable batches to serial execution while allowing bounded read-only parallelism, including three concurrent `analyst` tasks with independent task-level models.
 - Preserve compact reports, full results, Pi sessions, blocked questions, and historical follow-ups.
@@ -32,4 +35,4 @@
 
 ## Latest baseline
 
-All 194 deterministic scheduler, recovery, process-boundary, schema-validation, navigation, metrics, responsive-formatting, lifecycle, attempt-isolation, and persona cases plus the extension-contract lifecycle simulations must pass. Release validation also requires extension loading and a real Herdr read-only batch smoke with distinct task panes and final tab cleanup. The latest smoke completed a read-only package inspection with matching durable attempt/report IDs and automatic tab cleanup.
+All 198 deterministic scheduler, recovery, process-boundary, schema-validation, navigation, metrics, responsive-formatting, lifecycle, attempt-isolation, and persona cases plus the extension-contract lifecycle simulations must pass. Release validation also requires extension loading and a real Herdr read-only batch smoke with distinct task panes and final tab cleanup. The latest smoke completed a read-only package inspection with matching durable attempt/report IDs and automatic tab cleanup.

package/packages/herdr-subagents/extensions/herdr-subagents.ts

@@ -195,12 +195,18 @@ export function registerHerdrSubagents(pi: ExtensionAPI, dependencies: HerdrSuba
 	pi.registerTool({
 		name: "herdr_subagents",
 		label: "Herdr Subagents",
-		description: "Run one or more ordered tasks in visible interactive Herdr Pi Agents. Use one tasks item for a single task. Independent read-only tasks may run concurrently; write-capable runs are serialized. Foreground calls wait for the batch unless a task fails, when the run continues in the background and returns its run ID immediately. Explicit background calls always return a run ID immediately. Complete results and Pi sessions stay in project-local records.",
+		description: "Run one or more ordered tasks in visible interactive Herdr Pi Agents. Use one tasks item for a single task. Independent read-only tasks may run concurrently; write-capable runs are serialized. Only effectively serial runs can pause for input; concurrent input requests become missing_input failures while independent siblings continue. Foreground calls wait for the batch unless a task fails, when the run continues in the background and returns its run ID immediately. Explicit background calls always return a run ID immediately. Complete results and Pi sessions stay in project-local records.",
 		promptSnippet: "Run focused work in visible Herdr subagents",
 		parameters: HerdrSubagentsParams,
 		prepareArguments: normalizeHerdrSubagentsArguments,
 
 		async execute(_toolCallId, params: HerdrSubagentsRunParams, signal, onUpdate, ctx) {
+			const blockedForegroundResponse = (blockingRunId: string) => {
+				const text = `Cannot start a foreground Subagent run while blocked run ${blockingRunId} is waiting for input. Respond to or cancel that run first, or submit this run with background: true.`;
+				return { content: [{ type: "text" as const, text }], details: { errorMessage: text, blockingRunId }, isError: true };
+			};
+			const blockingRunId = dispatcher.snapshot().retainedRunId;
+			if (!params.background && blockingRunId) return blockedForegroundResponse(blockingRunId);
 			const generation = sessionGeneration;
 			const runId = randomUUID();
 			const controller = new AbortController();
@@ -249,7 +255,7 @@ export function registerHerdrSubagents(pi: ExtensionAPI, dependencies: HerdrSuba
 					dispatcher.retain(runId);
 				}
 				return result;
-			});
+			}, params.background ? undefined : { ...(signal ? { signal } : {}), onRetained: blockedForegroundResponse });
 			runPromises.set(runId, promise);
 			inFlight.add(promise);
 			void promise.finally(() => {
@@ -369,11 +375,12 @@ export function registerHerdrSubagents(pi: ExtensionAPI, dependencies: HerdrSuba
 			const result = await promise.finally(() => { inFlight.delete(promise); runControllers.delete(executionId); });
 			fleet.sync(result.details);
 			if (params.action === "respond") {
-				const details = result.details as { status?: string };
+				const details = result.details as { runId?: string; status?: string };
 				if (details.status === "blocked") fleet.sync(result.details);
 				else if (isSettledRunStatus(details.status)) {
-					fleet.clearRun(params.runId);
-					if (params.runId) dispatcher.release(params.runId);
+					const canonicalRunId = details.runId ?? params.runId;
+					fleet.clearRun(canonicalRunId);
+					if (canonicalRunId) dispatcher.release(canonicalRunId);
 				}
 			}
 			return result;

package/packages/herdr-subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxiaochao/pi-herdr-subagents",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "Run inspectable interactive Pi subagent batches through Herdr.",
   "type": "module",
   "keywords": [

package/packages/herdr-subagents/src/batch-runner.ts

@@ -10,11 +10,12 @@ import { writeJsonAtomic } from "./state.ts";
 import type { OwnerIdentity } from "./ownership.ts";
 import { ownerRecord } from "./ownership.ts";
 import { RunPaneAllocator } from "./run-pane-allocator.ts";
-import { applyReport, applyTaskStatus, projectTaskActivity, settleAttemptFailure, type PersistedReport, type RunRecord, type TaskActivity, type TaskRecord, type TaskStatus } from "./records.ts";
+import { applyReport, applyTaskStatus, normalizeNeedsInputReport, projectTaskActivity, settleAttemptFailure, type PersistedReport, type RunRecord, type TaskActivity, type TaskRecord, type TaskStatus } from "./records.ts";
 import { reportProtocolPrompt } from "./protocol.ts";
 import { cleanupRunTab } from "./tab-cleanup.ts";
 import { aggregateTaskStatus, applyRunStatus } from "./run-status.ts";
 import { isAbortError } from "./errors.ts";
+import { attemptReportPath } from "./attempts.ts";
 
 export interface BatchTask {
 	name: string;
@@ -51,6 +52,8 @@ export interface BatchTaskResult {
 	documents: HerdrSubagentsDocument[];
 	error?: string;
 	question?: string;
+	failureKind?: "missing_input";
+	requiredInput?: string;
 	paneId: string;
 	recordDirectory: string;
 	sessionFile: string;
@@ -68,6 +71,8 @@ export interface BatchResult {
 	documents: HerdrSubagentsDocument[];
 	recordDirectory: string;
 	tabId?: string;
+	question?: string;
+	allowedActions?: Array<"respond" | "cancel">;
 }
 
 type TaskContext = {
@@ -151,7 +156,8 @@ export async function runHerdrSubagentsBatch(tasks: BatchTask[], options: BatchO
 				const prompted = await promptLiveAgent({ herdr, task: { ...task, id: context.taskId, sessionFile: context.sessionFile }, paneId, prompt: task.prompt, systemPromptFile: context.systemPromptFile, agentName, signal: options.signal, stalledWarningMs: options.stalledWarningSeconds ? options.stalledWarningSeconds * 1000 : undefined, onStalled: () => emit("running", `${task.name} appears stalled; it is still running.`) });
 				agentName = prompted.agentName;
 				context.taskRecord.currentAttemptId = prompted.attemptId;
-				report = prompted.report;
+				report = normalizeNeedsInputReport(prompted.report, effectiveConcurrency);
+				if (report !== prompted.report) await Promise.all([writeJsonAtomic(context.reportFile, report), writeJsonAtomic(attemptReportPath(context.taskDirectory, prompted.attemptId), report)]);
 				status = applyReport(context.taskRecord, report);
 			} catch (error) {
 				const settled = await settleAttemptFailure(context.taskRecord, context.reportFile, {
@@ -164,7 +170,7 @@ export async function runHerdrSubagentsBatch(tasks: BatchTask[], options: BatchO
 			}
 			Object.assign(context.taskRecord, { paneId, agentName });
 			await writeJsonAtomic(context.taskFile, context.taskRecord);
-			results[index] = { index, name: task.name, status, summary: report.summary, documents: report.documents, ...(report.error ? { error: report.error } : {}), ...(report.question ? { question: report.question } : {}), paneId, recordDirectory: context.taskDirectory, sessionFile: context.sessionFile };
+			results[index] = { index, name: task.name, status, summary: report.summary, documents: report.documents, ...(report.error ? { error: report.error } : {}), ...(report.question ? { question: report.question } : {}), ...(report.failureKind ? { failureKind: report.failureKind } : {}), ...(report.requiredInput ? { requiredInput: report.requiredInput } : {}), paneId, recordDirectory: context.taskDirectory, sessionFile: context.sessionFile };
 			activity[index] = projectTaskActivity(context.taskRecord, index);
 			settled += 1;
 			emit("running", `${settled}/${tasks.length} tasks settled.`);
@@ -197,7 +203,7 @@ export async function runHerdrSubagentsBatch(tasks: BatchTask[], options: BatchO
 		const summary = status === "cancelled" ? "Subagent batch cancelled." : blocked ? `${blocked.name} needs input: ${blocked.question}` : status === "partial" ? `${completed}/${tasks.length} tasks completed; ${failed} failed; ${cancelled} cancelled.` : failed ? `${completed}/${tasks.length} tasks completed; ${failed} failed.` : `${tasks.length}/${tasks.length} tasks completed.`;
 		applyRunStatus(runRecord, status, { question: blocked?.question });
 		await writeJsonAtomic(runFile, runRecord);
-		return { ok: status === "completed", status, runId, label: options.label, requestedConcurrency, effectiveConcurrency, tasks: settledResults, activity, summary, documents: settledResults.flatMap((result) => result.documents), recordDirectory: runDirectory, tabId };
+		return { ok: status === "completed", status, runId, label: options.label, requestedConcurrency, effectiveConcurrency, tasks: settledResults, activity, summary, documents: settledResults.flatMap((result) => result.documents), recordDirectory: runDirectory, tabId, ...(blocked?.question ? { question: blocked.question, allowedActions: ["respond", "cancel"] } : {}) };
 	} catch (error) {
 		applyRunStatus(runRecord, options.signal?.aborted ? "cancelled" : "failed", { error: error instanceof Error ? error.message : String(error) });
 		await writeJsonAtomic(runFile, runRecord);

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

@@ -199,7 +199,7 @@ async function respondToBlockedTaskLocked(cwd: string, runId: string, answer: st
 			}
 			await Promise.all([writeJsonAtomic(join(taskDirectory, "task.json"), task), writeJsonAtomic(runFile, run), writeJsonAtomic(turnFile, turn)]);
 			if (run.tabId) await cleanupRunTab({ herdr, tabId: run.tabId, runFile, runRecord: run, signal, onError: onCleanupError });
-			return { ok: false, runId, label: String(run.label ?? "batch"), status: "cancelled", summary: "Subagent response cancelled.", documents: [], recordDirectory: runDirectory, requestedConcurrency: Number(run.requestedConcurrency ?? 1), effectiveConcurrency: Number(run.effectiveConcurrency ?? 1), ...(run.tabId ? { tabId: String(run.tabId) } : {}) };
+			return { ok: false, runId: run.id, label: String(run.label ?? "batch"), status: "cancelled", summary: "Subagent response cancelled.", documents: [], recordDirectory: runDirectory, requestedConcurrency: Number(run.requestedConcurrency ?? 1), effectiveConcurrency: Number(run.effectiveConcurrency ?? 1), ...(run.tabId ? { tabId: String(run.tabId) } : {}) };
 	}
 	turn.events.push({ type: "report", status, summary: report.summary, question: report.question, error: report.error, at: new Date().toISOString() });
 	Object.assign(turn, { summary: report.summary, documents: report.documents ?? [] });

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

@@ -6,8 +6,9 @@ import { writeJsonAtomic } from "./state.ts";
 import { cleanupRunTab } from "./tab-cleanup.ts";
 import { RunPaneAllocator } from "./run-pane-allocator.ts";
 import { aggregateTaskStatus, applyRunStatus } from "./run-status.ts";
-import { applyReport, applyTaskStatus, readRunRecord, readTaskRecord, settleAttemptFailure } from "./records.ts";
+import { applyReport, applyTaskStatus, normalizeNeedsInputReport, readRunRecord, readTaskRecord, settleAttemptFailure } from "./records.ts";
 import { isAbortError } from "./errors.ts";
+import { attemptReportPath } from "./attempts.ts";
 
 export interface ContinueQueuedRunOptions {
 	cleanup?: boolean;
@@ -50,7 +51,8 @@ export async function continueQueuedRun(runDirectory: string, herdr: HerdrAutoma
 			await options.onUpdate?.();
 			const prompted = await promptLiveAgent({ herdr, task: { ...task, id: task.id, sessionFile: task.sessionFile }, paneId, prompt: task.prompt, systemPromptFile: join(directory, "system-prompt.md"), agentName, signal: options.signal, stalledWarningMs: run.stalledWarningSeconds ? Number(run.stalledWarningSeconds) * 1000 : undefined, onStalled: () => options.onStalled?.(`${task.name ?? task.agent} appears stalled; it is still running.`) });
 			task.currentAttemptId = prompted.attemptId;
-			const report = prompted.report;
+			const report = normalizeNeedsInputReport(prompted.report, Number(run.effectiveConcurrency) || 1);
+			if (report !== prompted.report) await Promise.all([writeJsonAtomic(reportFile, report), writeJsonAtomic(attemptReportPath(directory, prompted.attemptId), report)]);
 			applyReport(task, report);
 		} catch (error) {
 			await settleAttemptFailure(task, reportFile, {

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

@@ -3,10 +3,19 @@ interface QueuedRun<T> {
 	execute: () => Promise<T>;
 	resolve: (value: T) => void;
 	reject: (error: unknown) => void;
+	signal?: AbortSignal;
+	onAbort?: () => void;
+	onRetained?: (retainedRunId: string) => T;
+}
+
+interface SubmitOptions<T> {
+	signal?: AbortSignal;
+	onRetained?: (retainedRunId: string) => T;
 }
 
 export interface DispatcherSnapshot {
 	activeRunId?: string;
+	retainedRunId?: string;
 	queuedRunIds: string[];
 }
 
@@ -19,15 +28,33 @@ export class RunDispatcher {
 
 	constructor(onChange?: (snapshot: DispatcherSnapshot) => void) { this.onChange = onChange; }
 
-	submit<T>(id: string, execute: () => Promise<T>): Promise<T> {
-		const promise = new Promise<T>((resolve, reject) => this.queue.push({ id, execute, resolve: resolve as (value: unknown) => void, reject }));
+	submit<T>(id: string, execute: () => Promise<T>, options: SubmitOptions<T> = {}): Promise<T> {
+		const { signal, onRetained } = options;
+		if (signal?.aborted) return Promise.reject(signal.reason ?? new Error(`Queued run '${id}' was cancelled.`));
+		if (this.retainedRunId && onRetained) return Promise.resolve(onRetained(this.retainedRunId));
+		const promise = new Promise<T>((resolve, reject) => {
+			const queued: QueuedRun<T> = { id, execute, resolve, reject, signal, onRetained };
+			queued.onAbort = () => {
+				const index = this.queue.indexOf(queued as QueuedRun<unknown>);
+				if (index < 0) return;
+				this.queue.splice(index, 1);
+				reject(signal?.reason ?? new Error(`Queued run '${id}' was cancelled.`));
+				this.changed();
+			};
+			signal?.addEventListener("abort", queued.onAbort, { once: true });
+			this.queue.push(queued as QueuedRun<unknown>);
+		});
 		this.changed();
 		void this.drain();
 		return promise;
 	}
 
 	snapshot(): DispatcherSnapshot {
-		return { ...(this.activeRunId ? { activeRunId: this.activeRunId } : {}), queuedRunIds: this.queue.map((run) => run.id) };
+		return {
+			...(this.activeRunId ? { activeRunId: this.activeRunId } : {}),
+			...(this.retainedRunId ? { retainedRunId: this.retainedRunId } : {}),
+			queuedRunIds: this.queue.map((run) => run.id),
+		};
 	}
 
 	pause(): void { this.paused = true; this.changed(); }
@@ -35,6 +62,14 @@ export class RunDispatcher {
 	retain(id: string): void {
 		if (this.activeRunId !== id) throw new Error(`Cannot retain inactive run '${id}'.`);
 		this.retainedRunId = id;
+		for (let index = this.queue.length - 1; index >= 0; index -= 1) {
+			const queued = this.queue[index];
+			if (!queued.onRetained) continue;
+			this.queue.splice(index, 1);
+			if (queued.onAbort) queued.signal?.removeEventListener("abort", queued.onAbort);
+			try { queued.resolve(queued.onRetained(id)); }
+			catch (error) { queued.reject(error); }
+		}
 		this.changed();
 	}
 	detach(id: string): boolean {
@@ -54,7 +89,10 @@ export class RunDispatcher {
 	}
 	cancelQueued(reason: Error): string[] {
 		const cancelled = this.queue.splice(0);
-		for (const run of cancelled) run.reject(reason);
+		for (const run of cancelled) {
+			if (run.onAbort) run.signal?.removeEventListener("abort", run.onAbort);
+			run.reject(reason);
+		}
 		this.changed();
 		return cancelled.map((run) => run.id);
 	}
@@ -62,6 +100,7 @@ export class RunDispatcher {
 		const index = this.queue.findIndex((run) => run.id === id);
 		if (index < 0) return false;
 		const [cancelled] = this.queue.splice(index, 1);
+		if (cancelled.onAbort) cancelled.signal?.removeEventListener("abort", cancelled.onAbort);
 		cancelled.reject(reason);
 		this.changed();
 		return true;
@@ -73,6 +112,7 @@ export class RunDispatcher {
 		if (this.activeRunId || this.paused) return;
 		const run = this.queue.shift();
 		if (!run) { this.changed(); return; }
+		if (run.onAbort) run.signal?.removeEventListener("abort", run.onAbort);
 		this.activeRunId = run.id;
 		this.changed();
 		try { run.resolve(await run.execute()); }

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

@@ -8,7 +8,8 @@ import { cleanupRunTab } from "./tab-cleanup.ts";
 import type { OwnerIdentity } from "./ownership.ts";
 import { ownerRecord } from "./ownership.ts";
 import { aggregateTaskStatus, applyRunStatus } from "./run-status.ts";
-import { applyReport, applyTaskStatus, isActiveStatus, projectTaskActivity, readReport, readRunRecord, readTaskRecord, settleAttemptFailure, type PersistedDocument, type PersistedReport, type RunRecord, type RunStatus, type TaskActivity, type TaskRecord, type TaskStatus } from "./records.ts";
+import { applyReport, applyTaskStatus, isActiveStatus, normalizeNeedsInputReport, projectTaskActivity, readReport, readRunRecord, readTaskRecord, settleAttemptFailure, type PersistedDocument, type PersistedReport, type RunRecord, type RunStatus, type TaskActivity, type TaskRecord, type TaskStatus } from "./records.ts";
+import { attemptReportPath } from "./attempts.ts";
 import { continuationSystemPrompt } from "./protocol.ts";
 import { isAbortError } from "./errors.ts";
 import { findRunDirectory } from "./run-locator.ts";
@@ -88,10 +89,13 @@ export function historyText(history: HistoricalRun[]): string {
 }
 
 export async function cleanSubagentRun(cwd: string, runId: string): Promise<boolean> {
-	const run = (await listSubagentHistory(cwd)).find((candidate) => candidate.id === runId);
+	const runDirectory = await findRunDirectory(join(cwd, ".pi", "herdr-subagents", "runs"), runId);
+	if (!runDirectory) return false;
+	const canonicalRunId = (await readRunRecord(join(runDirectory, "run.json"))).id;
+	const run = (await listSubagentHistory(cwd)).find((candidate) => candidate.id === canonicalRunId);
 	if (!run) return false;
-	if (isActiveStatus(run.status)) throw new Error(`Subagent run '${runId}' is still active and cannot be cleaned.`);
-	if (run.cleanupPendingTabIds?.length) throw new Error(`Subagent run '${runId}' is still waiting to clean up Herdr tabs ${run.cleanupPendingTabIds.join(", ")}.`);
+	if (isActiveStatus(run.status)) throw new Error(`Subagent run '${canonicalRunId}' is still active and cannot be cleaned.`);
+	if (run.cleanupPendingTabIds?.length) throw new Error(`Subagent run '${canonicalRunId}' is still waiting to clean up Herdr tabs ${run.cleanupPendingTabIds.join(", ")}.`);
 	await rm(run.recordDirectory, { recursive: true, force: false });
 	return true;
 }
@@ -102,13 +106,14 @@ export interface ResumeHistoricalTaskResult { runId: string; label: string; stat
 export async function resumeHistoricalTask(cwd: string, runId: string, taskNumber: number, prompt: string, options: ResumeHistoricalTaskOptions = {}): Promise<ResumeHistoricalTaskResult> {
 	const runDirectory = await findRunDirectory(join(cwd, ".pi", "herdr-subagents", "runs"), runId);
 	if (!runDirectory) throw new Error(`Unknown Subagent run '${runId}'.`);
+	const canonicalRunId = (await readRunRecord(join(runDirectory, "run.json"))).id;
 	const lockDirectory = join(runDirectory, ".resume.lock");
 	try { await mkdir(lockDirectory); }
 	catch (error) {
 		if ((error as NodeJS.ErrnoException).code === "EEXIST") throw new Error(`Subagent run '${runId}' already has a historical resume in progress (lock: ${lockDirectory}).`);
 		throw error;
 	}
-	try { return await resumeHistoricalTaskLocked(cwd, runId, taskNumber, prompt, options); }
+	try { return await resumeHistoricalTaskLocked(cwd, canonicalRunId, taskNumber, prompt, options); }
 	finally { await rmdir(lockDirectory); }
 }
 
@@ -163,7 +168,11 @@ async function resumeHistoricalTaskLocked(cwd: string, runId: string, taskNumber
 			options.onUpdate?.({ runId, label: run.label, status: "running", summary: `${historical.name} is continuing.`, documents: [], tabId: tab.tabId, paneId: tab.paneId, sessionFile: historical.sessionFile, activity: runningActivity });
 			const prompted = await promptLiveAgent({ herdr, task: { ...task, id: historical.id, sessionFile: historical.sessionFile }, paneId: tab.paneId, prompt, systemPromptFile: followupPrompt, agentName, signal, stalledWarningMs: options.stalledWarningSeconds ? options.stalledWarningSeconds * 1000 : undefined, onStalled: () => options.onStalled?.(`${historical.name} appears stalled; it is still running.`) });
 			task.currentAttemptId = prompted.attemptId;
-			report = prompted.report;
+			report = normalizeNeedsInputReport(prompted.report, Number.POSITIVE_INFINITY);
+			if (report !== prompted.report) await Promise.all([
+				writeJsonAtomic(join(historical.recordDirectory, "report.json"), report),
+				writeJsonAtomic(attemptReportPath(historical.recordDirectory, prompted.attemptId), report),
+			]);
 			status = applyReport(task, report);
 		} catch (error) {
 			const settled = await settleAttemptFailure(task, join(historical.recordDirectory, "report.json"), {

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

@@ -4,7 +4,7 @@ import type { HerdrAutomation } from "./herdr.ts";
 import { isProcessAlive, type OwnerIdentity } from "./ownership.ts";
 import { writeJsonAtomic } from "./state.ts";
 import { aggregateTaskStatus, applyRunStatus } from "./run-status.ts";
-import { applyReport, applyTaskStatus, isActiveStatus, persistFailureReport, readReport, readRunRecord, readTaskRecord, type RunRecord, type TaskStatus } from "./records.ts";
+import { applyReport, applyTaskStatus, isActiveStatus, normalizeNeedsInputReport, persistFailureReport, readReport, readRunRecord, readTaskRecord, type RunRecord, type TaskStatus } from "./records.ts";
 import { cleanupRunTab } from "./tab-cleanup.ts";
 import { attemptReportPath } from "./attempts.ts";
 
@@ -110,7 +110,6 @@ export async function reconcileSubagentRuns(cwd: string, herdr: HerdrAutomation,
 				continue;
 			}
 			if (isActiveStatus(task.status)) {
-				let recoveredCurrentReport = false;
 				const canonicalReportFile = join(tasksDirectory, taskEntry, "report.json");
 				let currentAttemptReport: string | undefined;
 				if (task.currentAttemptId) {
@@ -122,11 +121,12 @@ export async function reconcileSubagentRuns(cwd: string, herdr: HerdrAutomation,
 				const reportFile = task.currentAttemptId ? currentAttemptReport : canonicalReportFile;
 				if (reportFile && existsSync(reportFile) && (task.status === "running" || task.status === "starting")) {
 					try {
-						const report = await readReport(reportFile);
+						const submittedReport = await readReport(reportFile);
+						const report = normalizeNeedsInputReport(submittedReport, Number(run.effectiveConcurrency) || 1);
 						if (task.currentAttemptId && report.attemptId !== task.currentAttemptId) throw new Error(`Report attempt '${report.attemptId ?? "unknown"}' does not match current attempt '${task.currentAttemptId}'.`);
 						applyReport(task, report, report.reportedAt ?? new Date().toISOString());
-						recoveredCurrentReport = reportFile !== canonicalReportFile;
-						if (reportFile !== canonicalReportFile) await writeJsonAtomic(canonicalReportFile, report);
+						if (report !== submittedReport) await writeJsonAtomic(reportFile, report);
+						if (reportFile !== canonicalReportFile || report !== submittedReport) await writeJsonAtomic(canonicalReportFile, report);
 						result.settledTasks += 1;
 					} catch (error) {
 						const detail = error instanceof Error ? error.message : String(error);
@@ -137,7 +137,19 @@ export async function reconcileSubagentRuns(cwd: string, herdr: HerdrAutomation,
 						result.interruptedTasks += 1;
 					}
 				}
-				if (differentOwner && isActiveStatus(task.status) && !(recoveredCurrentReport && task.status === "blocked")) {
+				if (differentOwner && isActiveStatus(task.status)) {
+					if (task.status === "blocked") {
+						const cancelledReport = {
+							status: "failed",
+							summary: "Blocked task was cancelled because its parent Pi session is no longer active.",
+							documents: [],
+							error: "Owning parent Pi session is no longer active.",
+							...(task.currentAttemptId ? { attemptId: task.currentAttemptId } : {}),
+							reportedAt: new Date().toISOString(),
+						} as const;
+						await persistFailureReport(canonicalReportFile, cancelledReport, true);
+						if (currentAttemptReport) await writeJsonAtomic(currentAttemptReport, cancelledReport);
+					}
 					applyTaskStatus(task, "cancelled", { error: "Owning parent Pi session is no longer active." });
 					result.cancelledTasks += 1;
 					result.interruptedTasks += 1;

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

@@ -22,6 +22,8 @@ export interface PersistedReport {
 	attemptId?: string;
 	error?: string;
 	question?: string;
+	failureKind?: "missing_input";
+	requiredInput?: string;
 	reportedAt?: string;
 }
 
@@ -45,6 +47,8 @@ export interface RunRecord {
 	staleTabIds?: string[];
 	question?: string;
 	error?: string;
+	failureKind?: "missing_input";
+	requiredInput?: string;
 	cleanupError?: string;
 	cleanupPendingTabIds?: string[];
 }
@@ -178,6 +182,10 @@ export function parseReport(value: unknown, source = "structured report"): Persi
 	if (report.status === "needs-input" && (typeof report.question !== "string" || !report.question.trim())) throw new Error(`Missing report question in ${source}.`);
 	if (report.error !== undefined && typeof report.error !== "string") throw new Error(`Invalid report error in ${source}.`);
 	if (report.question !== undefined && typeof report.question !== "string") throw new Error(`Invalid report question in ${source}.`);
+	if (report.failureKind !== undefined && report.failureKind !== "missing_input") throw new Error(`Invalid report failureKind in ${source}.`);
+	if (report.requiredInput !== undefined && (typeof report.requiredInput !== "string" || !report.requiredInput.trim())) throw new Error(`Invalid report requiredInput in ${source}.`);
+	if (report.failureKind === "missing_input" && report.status !== "failed") throw new Error(`missing_input must be a failed report in ${source}.`);
+	if (report.failureKind === "missing_input" && (typeof report.requiredInput !== "string" || !report.requiredInput.trim())) throw new Error(`Missing report requiredInput in ${source}.`);
 	if (report.attemptId !== undefined && (typeof report.attemptId !== "string" || !report.attemptId.trim())) throw new Error(`Invalid report attemptId in ${source}.`);
 	return report as unknown as PersistedReport;
 }
@@ -186,6 +194,18 @@ export async function readReport(path: string): Promise<PersistedReport> {
 	return parseReport(await readObject(path), path);
 }
 
+export function normalizeNeedsInputReport(report: PersistedReport, effectiveConcurrency: number): PersistedReport {
+	if (report.status !== "needs-input" || effectiveConcurrency <= 1) return report;
+	return parseReport({
+		...report,
+		status: "failed",
+		error: `Missing required input: ${report.question}`,
+		failureKind: "missing_input",
+		requiredInput: report.question,
+		question: undefined,
+	}, "normalized concurrent input request");
+}
+
 export async function persistFailureReport(path: string, report: PersistedReport, replaceExisting = false): Promise<string | undefined> {
 	if (replaceExisting) {
 		await writeJsonAtomic(path, parseReport(report, "generated failure report"));
@@ -264,5 +284,11 @@ export async function settleAttemptFailure<T extends TaskRecord | TurnRecord>(
 export function applyReport(record: TaskRecord | TurnRecord, report: PersistedReport, completedAt = new Date().toISOString()): "blocked" | "completed" | "failed" {
 	const status = report.status === "needs-input" ? "blocked" : report.status;
 	applyTaskStatus(record, status, { at: completedAt, question: report.question, error: report.error });
+	if ("order" in record) {
+		if (report.failureKind) record.failureKind = report.failureKind;
+		else delete record.failureKind;
+		if (report.requiredInput) record.requiredInput = report.requiredInput;
+		else delete record.requiredInput;
+	}
 	return status;
 }

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

@@ -1,19 +1,34 @@
 import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { readRunRecord } from "./records.ts";
 
 export async function findRunDirectory(runsDirectory: string, runId: string): Promise<string | undefined> {
 	if (!existsSync(runsDirectory)) return undefined;
+	const reference = basename(runId.trim());
 	const errors: string[] = [];
+	const matches: Array<{ id: string; directory: string }> = [];
 	for (const entry of readdirSync(runsDirectory)) {
 		const directory = join(runsDirectory, entry);
 		const runFile = join(directory, "run.json");
 		try {
-			if ((await readRunRecord(runFile)).id === runId) return directory;
+			const id = (await readRunRecord(runFile)).id;
+			if (id === reference || entry === reference) return directory;
+			if (id.startsWith(reference) || entry.endsWith(`-${reference}`)) matches.push({ id, directory });
 		} catch (error) {
 			errors.push(`${runFile}: ${error instanceof Error ? error.message : String(error)}`);
 		}
 	}
+	if (matches.length === 1) return matches[0].directory;
+	if (matches.length > 1) throw new Error(`Ambiguous Subagent run reference '${runId}': ${matches.map((match) => match.id).join(", ")}.`);
 	if (errors.length) throw new Error(`Could not inspect Subagent runs while looking for '${runId}': ${errors.join("; ")}`);
 	return undefined;
 }
+
+export function resolveRunIdReference(reference: string, candidates: readonly string[]): string | undefined {
+	const trimmed = basename(reference.trim());
+	const exact = candidates.find((candidate) => candidate === trimmed);
+	if (exact) return exact;
+	const matches = [...new Set(candidates.filter((candidate) => candidate.startsWith(trimmed)))];
+	if (matches.length > 1) throw new Error(`Ambiguous Subagent run reference '${reference}': ${matches.join(", ")}.`);
+	return matches[0];
+}

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

@@ -2,7 +2,7 @@ import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { loadQueuedRuns } from "./queued-runs.ts";
 import { isSettledRunStatus, readReport, readRunRecord, readTaskRecord, type RunStatus, type TaskStatus } from "./records.ts";
-import { findRunDirectory } from "./run-locator.ts";
+import { findRunDirectory, resolveRunIdReference } from "./run-locator.ts";
 
 export interface RunStatusTask {
 	order: number;
@@ -12,6 +12,8 @@ export interface RunStatusTask {
 	summary?: string;
 	question?: string;
 	error?: string;
+	failureKind?: "missing_input";
+	requiredInput?: string;
 }
 
 export interface RunStatusSnapshot {
@@ -44,6 +46,8 @@ 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}`,
@@ -52,6 +56,8 @@ async function loadDurableStatus(cwd: string, runId: string): Promise<RunStatusS
 			...(report?.summary ? { summary: report.summary } : {}),
 			...(question ? { question } : {}),
 			...(error ? { error } : {}),
+			...(failureKind ? { failureKind } : {}),
+			...(requiredInput ? { requiredInput } : {}),
 		});
 	}
 	return {
@@ -70,9 +76,14 @@ async function loadDurableStatus(cwd: string, runId: string): Promise<RunStatusS
 }
 
 export async function getSubagentRunStatus(cwd: string, runId: string): Promise<RunStatusSnapshot | undefined> {
+	const queuedRuns = await loadQueuedRuns(cwd);
 	const durable = await loadDurableStatus(cwd, runId);
-	if (durable) return durable;
-	const queued = (await loadQueuedRuns(cwd)).find((candidate) => candidate.runId === runId);
+	if (durable) {
+		resolveRunIdReference(runId, [durable.runId, ...queuedRuns.map((candidate) => candidate.runId)]);
+		return durable;
+	}
+	const queuedId = resolveRunIdReference(runId, queuedRuns.map((candidate) => candidate.runId));
+	const queued = queuedRuns.find((candidate) => candidate.runId === queuedId);
 	if (!queued) return undefined;
 	return {
 		runId: queued.runId,

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

@@ -131,17 +131,20 @@ const actionHandlers = {
 	},
 	async cleanup({ params, ctx }: ToolExecutionContext) {
 		try {
-			const cleaned = await cleanSubagentRun(ctx.cwd, params.runId as string);
-			const text = cleaned ? `Removed Subagent run ${params.runId}.` : `Unknown Subagent run '${params.runId}'.`;
-			return { content: [{ type: "text", text }], details: { action: "cleanup", runId: params.runId, cleaned }, ...(cleaned ? {} : { isError: true }) };
+			const requestedRunId = params.runId as string;
+			const runId = (await getSubagentRunStatus(ctx.cwd, requestedRunId))?.runId ?? requestedRunId;
+			const cleaned = await cleanSubagentRun(ctx.cwd, runId);
+			const text = cleaned ? `Removed Subagent run ${runId}.` : `Unknown Subagent run '${requestedRunId}'.`;
+			return { content: [{ type: "text", text }], details: { action: "cleanup", runId, cleaned }, ...(cleaned ? {} : { isError: true }) };
 		} catch (error) {
 			const text = error instanceof Error ? error.message : String(error);
 			return errorResponse(text, { action: "cleanup", runId: params.runId, cleaned: false });
 		}
 	},
 	async cancel({ params, ctx, dependencies }: ToolExecutionContext) {
-		const runId = (params.runId as string).trim();
+		const requestedRunId = (params.runId as string).trim();
 		try {
+			const runId = (await getSubagentRunStatus(ctx.cwd, requestedRunId))?.runId ?? requestedRunId;
 			let result: { cancelled: boolean; queued?: boolean; cleanupErrors?: string[] };
 			if (dependencies.cancelRun) result = await dependencies.cancelRun(runId);
 			else {
@@ -159,7 +162,7 @@ const actionHandlers = {
 			const text = result.cancelled ? `Cancelled Subagent run ${runId}.${suffix}` : `Subagent run '${runId}' is not active or queued.`;
 			return { content: [{ type: "text", text }], details: { action: "cancel", runId, ...result }, ...(result.cancelled ? {} : { isError: true }) };
 		} catch (error) {
-			return errorResponse(error instanceof Error ? error.message : String(error), { action: "cancel", runId, cancelled: false });
+			return errorResponse(error instanceof Error ? error.message : String(error), { action: "cancel", runId: requestedRunId, cancelled: false });
 		}
 	},
 	async resume({ params, signal, onUpdate, ctx, dependencies, discovery }: ToolExecutionContext) {
@@ -182,8 +185,9 @@ const actionHandlers = {
 				onWarning: (text) => onUpdate?.({ content: [{ type: "text", text }], details: { action: "respond", runId: params.runId, warning: text } }),
 				onCleanupError: (text) => onUpdate?.({ content: [{ type: "text", text }], details: { action: "respond", runId: params.runId, cleanupError: text } }),
 			});
-			const text = [result.summary, ...(result.question ? [`Question: ${result.question}`] : []), ...result.documents.map((document) => `${document.description}: ${document.path}`)].join("\n");
-			return { content: [{ type: "text", text }], details: result, ...(result.status === "failed" || result.status === "partial" || result.status === "cancelled" ? { isError: true } : {}) };
+			const blockedControl = result.status === "blocked" ? { allowedActions: ["respond", "cancel"] as const } : {};
+			const text = [result.summary, ...(result.question ? [`Question: ${result.question}`] : []), ...(result.status === "blocked" ? [`Run ID: ${result.runId}`, `Answer with herdr_subagents_control({ action: "respond", runId: "${result.runId}", answer: "..." }) or cancel this run.`] : []), ...result.documents.map((document) => `${document.description}: ${document.path}`)].join("\n");
+			return { content: [{ type: "text", text }], details: { ...result, ...blockedControl }, ...(result.status === "failed" || result.status === "partial" || result.status === "cancelled" ? { isError: true } : {}) };
 		} catch (error) { return errorResponse(error instanceof Error ? error.message : String(error)); }
 	},
 	async list({ discovery }: ToolExecutionContext) {
@@ -215,9 +219,10 @@ async function executeBatch({ params, signal, onUpdate, ctx, dependencies, disco
 			onUpdate: (partial) => onUpdate?.({ content: [{ type: "text", text: partial.summary }], details: { ...partial, prompts: tasks.map((task) => task.prompt) } }),
 		});
 		const lines = [result.summary, ...result.tasks.map((task) => `- ${task.name}: ${task.status} — ${task.summary}`)];
+		if (result.status === "blocked") lines.push("", `Run ID: ${result.runId}`, `Answer with herdr_subagents_control({ action: "respond", runId: "${result.runId}", answer: "..." }) or cancel this run before starting another foreground run.`);
 		if (result.documents.length) lines.push("", "Documents:", ...result.documents.map((document) => `- ${document.description}: ${document.path}`));
 		const isError = result.status === "failed" || result.status === "partial" || result.status === "cancelled";
-		return { content: [{ type: "text", text: lines.join("\n") }], details: { ...result, prompts: tasks.map((task) => task.prompt) }, ...(isError ? { isError: true } : {}) };
+		return { content: [{ type: "text", text: lines.join("\n") }], details: { ...result, prompts: tasks.map((task) => task.prompt), ...(result.status === "blocked" ? { allowedActions: ["respond", "cancel"] } : {}) }, ...(isError ? { isError: true } : {}) };
 	} catch (error) {
 		const text = error instanceof Error ? error.message : String(error);
 		const diagnostic = error as { recordDirectory?: string; runId?: string };

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

@@ -240,6 +240,81 @@ async function verifyForegroundFailureHandoff() {
 		await successPromise;
 
 		const backgroundGate = deferred<void>();
+		const queuedCancellationRoot = join(cwd, "queued-cancellation");
+		mkdirSync(queuedCancellationRoot, { recursive: true });
+		const activeGate = deferred<void>();
+		let queuedCancellationCalls = 0;
+		const queuedCancellation = harness(async (_params, _signal, _onUpdate, _ctx, dependencies) => {
+			queuedCancellationCalls += 1;
+			await activeGate.promise;
+			return { content: [{ type: "text", text: "done" }], details: { runId: dependencies.runId, label: "active", status: "completed", summary: "done", documents: [], tasks: [], activity: [], effectiveConcurrency: 1, requestedConcurrency: 1 } };
+		});
+		await startHarness(queuedCancellation, queuedCancellationRoot);
+		const activeBackground = await queuedCancellation.tool?.execute("active", { background: true, tasks: [{ name: "active", prompt: "wait" }] }, undefined, undefined, { cwd: queuedCancellationRoot, ui: queuedCancellation.ui });
+		await waitUntil(() => queuedCancellationCalls === 1, "active background run did not start");
+		const queuedCaller = new AbortController();
+		const queuedForeground = queuedCancellation.tool?.execute("queued", { tasks: [{ name: "queued", prompt: "later" }] }, queuedCaller.signal, undefined, { cwd: queuedCancellationRoot, ui: queuedCancellation.ui });
+		await new Promise<void>((resolve) => setImmediate(resolve));
+		queuedCaller.abort(new Error("foreground tool call cancelled"));
+		const queuedCancellationError = await Promise.race([
+			queuedForeground.then(() => "resolved", (error: Error) => error.message),
+			new Promise<string>((_, reject) => setTimeout(() => reject(new Error("queued foreground call ignored cancellation")), 100)),
+		]);
+		if (queuedCancellationError !== "foreground tool call cancelled" || queuedCancellationCalls !== 1) throw new Error("extension did not remove a cancelled foreground run from the dispatcher queue");
+		const activeNotification = queuedCancellation.waitForMessage((message) => message.details?.runId === activeBackground.details.runId);
+		activeGate.resolve();
+		await activeNotification;
+
+		const blockedOwnerRoot = join(cwd, "blocked-owner");
+		mkdirSync(blockedOwnerRoot, { recursive: true });
+		let blockedOwnerCalls = 0;
+		let blockedOwnerRunId = "";
+		let blockedSuccessorStarted = false;
+		const becomeRetained = deferred<void>();
+		const blockedOwner = harness(async (params, _signal, _onUpdate, _ctx, dependencies) => {
+			if (params.action === "respond") {
+				return { content: [{ type: "text", text: "answered" }], details: { runId: blockedOwnerRunId, label: "blocked owner", status: "completed", summary: "answered", documents: [], tasks: [], activity: [], effectiveConcurrency: 1, requestedConcurrency: 1 } };
+			}
+			blockedOwnerCalls += 1;
+			if (blockedOwnerCalls > 1) {
+				blockedSuccessorStarted = true;
+				return { content: [{ type: "text", text: "successor done" }], details: { runId: dependencies.runId, label: "successor", status: "completed", summary: "done", documents: [], tasks: [], activity: [], effectiveConcurrency: 1, requestedConcurrency: 1 } };
+			}
+			blockedOwnerRunId = dependencies.runId;
+			if (blockedOwnerCalls === 1) await becomeRetained.promise;
+			return {
+				content: [{ type: "text", text: "waiting for input" }],
+				details: {
+					runId: dependencies.runId, label: "blocked owner", status: "blocked", summary: "waiting for input", question: "Continue?", documents: [],
+					tasks: [blockedTask], activity: [{ index: 1, name: blockedTask.name, status: "blocked" }], effectiveConcurrency: 1, requestedConcurrency: 1,
+				},
+			};
+		});
+		await startHarness(blockedOwner, blockedOwnerRoot);
+		const ownerPromise = blockedOwner.tool?.execute("blocked-owner", { tasks: [{ name: blockedTask.name, prompt: "block" }] }, undefined, undefined, { cwd: blockedOwnerRoot, ui: blockedOwner.ui });
+		await waitUntil(() => blockedOwnerCalls === 1, "blocked owner did not start");
+		const queuedBeforeBlocked = blockedOwner.tool?.execute("queued-before-blocked", { tasks: [{ name: "queued", prompt: "later" }] }, undefined, undefined, { cwd: blockedOwnerRoot, ui: blockedOwner.ui });
+		await new Promise<void>((resolve) => setImmediate(resolve));
+		becomeRetained.resolve();
+		const ownerResult = await ownerPromise;
+		const retainedForeground = await Promise.race([
+			queuedBeforeBlocked,
+			new Promise((_, reject) => setTimeout(() => reject(new Error("foreground run queued before blocked transition remained stuck")), 100)),
+		]);
+		if (!retainedForeground.isError || retainedForeground.details?.blockingRunId !== ownerResult.details.runId || blockedOwnerCalls !== 1) throw new Error("blocked transition did not reject an already-queued foreground run");
+		const blockedForeground = await Promise.race([
+			blockedOwner.tool?.execute("blocked-successor", { tasks: [{ name: "successor", prompt: "later" }] }, undefined, undefined, { cwd: blockedOwnerRoot, ui: blockedOwner.ui }),
+			new Promise((_, reject) => setTimeout(() => reject(new Error("foreground run waited behind a blocked dispatcher owner")), 100)),
+		]);
+		if (!blockedForeground.isError || blockedForeground.details?.blockingRunId !== ownerResult.details.runId || !blockedForeground.content?.[0]?.text.includes(ownerResult.details.runId)) {
+			throw new Error("foreground run blocked by dispatcher omitted the blocking run ID");
+		}
+		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 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 });
+
 		const explicitBackground = harness(async (_params, _signal, _onUpdate, _ctx, dependencies) => {
 			await backgroundGate.promise;
 			return { content: [{ type: "text", text: "background done" }], details: { runId: dependencies.runId, label: "background", status: "completed", summary: "done", documents: [], tasks: [], activity: [], effectiveConcurrency: 1, requestedConcurrency: 1 } };

package/packages/herdr-subagents/tests/run-tests.mjs

@@ -1,5 +1,5 @@
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { tmpdir } from "node:os";
 import { getEventListeners } from "node:events";
 import { visibleWidth } from "@earendil-works/pi-tui";
@@ -81,7 +81,7 @@ function fakeHerdr(mode = "completed") {
 			calls.push(["promptAgent", request]);
 			const current = agents.get(request.target) ?? { directory: taskDirectory };
 			const directory = current.directory;
-			taskRuns += 1;
+			const runNumber = ++taskRuns;
 			active += 1;
 			maxActive = Math.max(maxActive, active);
 			await new Promise((resolve) => setTimeout(resolve, request.prompt.includes("slow") ? 15 : 2));
@@ -115,7 +115,7 @@ function fakeHerdr(mode = "completed") {
 				active -= 1;
 				throw new Error("connection lost after authoritative report");
 			}
-			if (mode === "post-fail" || (mode === "blocked-then-post-fail" && taskRuns > 1)) { active -= 1; throw new Error("connection lost after prompt submission"); }
+			if (mode === "post-fail" || (mode === "blocked-then-post-fail" && runNumber > 1)) { active -= 1; throw new Error("connection lost after prompt submission"); }
 			writeFileSync(join(directory, "session.jsonl"), `${JSON.stringify({ type: "session", version: 3, id: request.target, cwd: root })}\n`);
 			if (mode === "completed" || mode === "close-failed") {
 				const failed = request.prompt.includes("FAIL");
@@ -137,9 +137,9 @@ function fakeHerdr(mode = "completed") {
 			} else if (mode === "malformed") {
 				writeAttemptReport(directory, "{truncated");
 			} else if (mode === "blocked" || mode === "blocked-twice" || mode === "blocked-then-post-fail") {
-				const needsInput = ((mode === "blocked" || mode === "blocked-then-post-fail") && taskRuns === 1) || (mode === "blocked-twice" && (taskRuns === 1 || taskRuns === 3));
+				const needsInput = ((mode === "blocked" || mode === "blocked-then-post-fail") && runNumber === 1) || (mode === "blocked-twice" && (runNumber === 1 || runNumber === 3));
 				const failed = request.prompt.includes("FAIL");
-				const question = taskRuns === 3 ? "Which environment should I inspect?" : "Which branch should I inspect?";
+				const question = runNumber === 3 ? "Which environment should I inspect?" : "Which branch should I inspect?";
 				writeFileSync(join(directory, "result.md"), `FULL ${request.prompt}`);
 				writeAttemptReport(directory, { status: needsInput ? "needs-input" : failed ? "failed" : "completed", summary: needsInput ? "Need more input." : failed ? `${request.prompt} failed.` : `${request.prompt} completed.`, ...(needsInput ? { question } : {}), ...(failed ? { error: "expected failure" } : {}), documents: [] });
 			}
@@ -533,6 +533,15 @@ try {
 	check("read-only batch uses bounded concurrency", batchDetails.effectiveConcurrency === 2 && batchHerdr.maxActive === 2 && batchHerdr.calls.filter(([name]) => name === "splitPane").length === 3);
 	check("batch is FIFO with a dedicated pane per task", batchPrompts.join(",") === "one slow,two,three FAIL,four" && new Set(batchStarts.map((request) => request.paneId)).size === 4);
 	check("failed sibling does not cancel batch", batch.isError && batchDetails.status === "partial" && batchDetails.tasks.map((task) => task.name).join(",") === "one,two,three,four" && batchDetails.tasks[2].status === "failed" && batchDetails.tasks[3].status === "completed");
+	const parallelQuestionHerdr = fakeHerdr("blocked");
+	const parallelQuestion = await executeHerdrSubagents({ concurrency: 2, tasks: [
+		{ name: "missing-input", prompt: "question", agent: "explorer" },
+		{ name: "independent", prompt: "continue", agent: "reviewer" },
+	] }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: parallelQuestionHerdr });
+	const parallelQuestionTask = JSON.parse(readFileSync(join(parallelQuestion.details.tasks[0].recordDirectory, "task.json"), "utf8"));
+	const parallelQuestionReport = JSON.parse(readFileSync(join(parallelQuestion.details.tasks[0].recordDirectory, "report.json"), "utf8"));
+	const parallelQuestionAttemptReport = JSON.parse(readFileSync(join(parallelQuestion.details.tasks[0].recordDirectory, "reports", `${parallelQuestionTask.currentAttemptId}.json`), "utf8"));
+	check("parallel needs-input becomes a structured failure while independent siblings finish", parallelQuestion.isError && parallelQuestion.details.status === "partial" && parallelQuestion.details.tasks[0].status === "failed" && parallelQuestion.details.tasks[0].failureKind === "missing_input" && parallelQuestion.details.tasks[0].requiredInput === "Which branch should I inspect?" && parallelQuestion.details.tasks[1].status === "completed" && parallelQuestionTask.status === "failed" && parallelQuestionReport.status === "failed" && parallelQuestionReport.failureKind === "missing_input" && parallelQuestionAttemptReport.status === "failed" && parallelQuestionAttemptReport.failureKind === "missing_input" && parallelQuestionHerdr.calls.some(([name]) => name === "closeTab"));
 	const mixedCancelHerdr = fakeHerdr();
 	const mixedCancelPrompt = mixedCancelHerdr.promptAgent.bind(mixedCancelHerdr);
 	mixedCancelHerdr.promptAgent = async (request) => request.prompt.includes("WAIT") ? await new Promise((_resolve, reject) => request.signal?.addEventListener("abort", () => reject(request.signal.reason), { once: true })) : mixedCancelPrompt(request);
@@ -677,6 +686,20 @@ try {
 	check("dispatcher cancels only the selected queued run", cancellingDispatcher.cancelQueuedRun("remove-me", new Error("cancelled by user")) && await removedQueued === "cancelled by user" && cancellingDispatcher.snapshot().queuedRunIds.join(",") === "keep-me");
 	cancellingDispatcher.resume();
 	check("dispatcher still executes uncancelled queued siblings", await keptQueued === "kept");
+	const abortingDispatcher = new RunDispatcher();
+	abortingDispatcher.pause();
+	const queuedAbort = new AbortController();
+	let abortedQueuedStarted = false;
+	const abortedQueued = abortingDispatcher.submit("abort-me", async () => { abortedQueuedStarted = true; return "unexpected"; }, { signal: queuedAbort.signal }).catch((error) => error.message);
+	queuedAbort.abort(new Error("foreground tool call cancelled"));
+	check("queued foreground dispatch responds to caller cancellation", await abortedQueued === "foreground tool call cancelled" && !abortedQueuedStarted && abortingDispatcher.snapshot().queuedRunIds.length === 0);
+	const retainingDispatcher = new RunDispatcher();
+	let settleRetainingOwner;
+	let retainedWaiterStarted = false;
+	const retainingOwner = retainingDispatcher.submit("retaining-owner", async () => { await new Promise((resolve) => { settleRetainingOwner = resolve; }); retainingDispatcher.retain("retaining-owner"); return "blocked"; });
+	const retainedWaiter = retainingDispatcher.submit("foreground-waiter", async () => { retainedWaiterStarted = true; return "unexpected"; }, { onRetained: (runId) => `blocked by ${runId}` });
+	settleRetainingOwner();
+	check("retaining an active run rejects already-queued foreground waiters", await retainingOwner === "blocked" && await retainedWaiter === "blocked by retaining-owner" && !retainedWaiterStarted && retainingDispatcher.snapshot().queuedRunIds.length === 0);
 	const retainedDispatcher = new RunDispatcher();
 	const retainedStarts = [];
 	const retainedFirst = retainedDispatcher.submit("blocked-run", async () => { retainedStarts.push("blocked-run"); retainedDispatcher.retain("blocked-run"); return "blocked"; });
@@ -735,8 +758,8 @@ try {
 
 	const blockedHerdr = fakeHerdr("blocked");
 	const blocked = await executeHerdrSubagents({ concurrency: 1, tasks: [{ name: "question", prompt: "inspect branch", agent: "explorer" }, { name: "after-answer", prompt: "continue queued", agent: "reviewer" }] }, undefined, undefined, { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: blockedHerdr });
-	check("needs-input returns foreground control without a tool error and preserves tab", !blocked.isError && blocked.details.status === "blocked" && blocked.details.tasks[0].question === "Which branch should I inspect?" && !blockedHerdr.calls.some(([name]) => name === "closeTab"));
-	const blockedStatus = await executeHerdrSubagents({ action: "status", runId: blocked.details.runId }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents") });
+	check("needs-input returns foreground control with its full run ID and allowed actions", !blocked.isError && blocked.details.status === "blocked" && blocked.details.question === "Which branch should I inspect?" && blocked.details.tasks[0].question === blocked.details.question && blocked.details.allowedActions?.join(",") === "respond,cancel" && blocked.content[0].text.includes(blocked.details.runId) && !blockedHerdr.calls.some(([name]) => name === "closeTab"));
+	const blockedStatus = await executeHerdrSubagents({ action: "status", runId: basename(blocked.details.recordDirectory) }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents") });
 	check("status exposes blocked task questions for respond", blockedStatus.details.status === "blocked" && blockedStatus.details.settled === false && blockedStatus.details.tasks[0].question === "Which branch should I inspect?" && blockedStatus.content[0].text.includes("Which branch should I inspect?"));
 	const activeCleanup = await executeHerdrSubagents({ action: "cleanup", runId: blocked.details.runId }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: blockedHerdr });
 	check("cleanup refuses to delete an active blocked run", activeCleanup.isError && activeCleanup.content[0].text.includes("still active") && existsSync(blocked.details.recordDirectory));
@@ -751,7 +774,7 @@ try {
 	check("blocked response diagnoses a lock owned by a dead process without unsafe reclamation", diagnosedStaleResponse.isError && diagnosedStaleResponse.content[0].text.includes("stale blocked-response lock"));
 	rmSync(join(staleLockBlocked.details.recordDirectory, ".respond.lock"));
 	const resumeUpdates = [];
-	const resumed = await executeHerdrSubagents({ action: "respond", runId: blocked.details.runId, answer: "Inspect main." }, undefined, (update) => resumeUpdates.push(update.details), { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: blockedHerdr });
+	const resumed = await executeHerdrSubagents({ action: "respond", runId: blocked.details.runId.slice(0, 8), answer: "Inspect main." }, undefined, (update) => resumeUpdates.push(update.details), { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: blockedHerdr });
 	const blockedStarts = blockedHerdr.calls.filter(([name]) => name === "startAgent").map(([, request]) => request);
 	const blockedPrompts = blockedHerdr.calls.filter(([name]) => name === "promptAgent").map(([, request]) => request);
 	check("answer resumes original live Agent and queued sibling gets a new pane", !resumed.isError && resumed.details.status === "completed" && blockedPrompts.length === 3 && blockedPrompts[1].target === blockedPrompts[0].target && blockedStarts.length === 2 && new Set(blockedStarts.map((request) => request.paneId)).size === 2);
@@ -765,7 +788,7 @@ try {
 	const twiceBlockedHerdr = fakeHerdr("blocked-twice");
 	const twiceBlocked = await executeHerdrSubagents({ concurrency: 1, tasks: [{ name: "first-question", prompt: "first", agent: "explorer" }, { name: "second-question", prompt: "second", agent: "reviewer" }] }, undefined, undefined, { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: twiceBlockedHerdr });
 	const secondQuestion = await executeHerdrSubagents({ action: "respond", runId: twiceBlocked.details.runId, answer: "main" }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: twiceBlockedHerdr });
-	check("queued sibling blocking returns its current question and Fleet pane", secondQuestion.details.status === "blocked" && secondQuestion.details.question === "Which environment should I inspect?" && secondQuestion.content[0].text.includes("environment") && secondQuestion.details.activity[1].status === "blocked" && Boolean(secondQuestion.details.activity[1].paneId));
+	check("queued sibling blocking returns its current question, actions, and Fleet pane", secondQuestion.details.status === "blocked" && secondQuestion.details.question === "Which environment should I inspect?" && secondQuestion.details.allowedActions?.join(",") === "respond,cancel" && secondQuestion.content[0].text.includes(secondQuestion.details.runId) && secondQuestion.details.activity[1].status === "blocked" && Boolean(secondQuestion.details.activity[1].paneId));
 	const failedAfterBlockHerdr = fakeHerdr("blocked");
 	const failedAfterBlock = await executeHerdrSubagents({ concurrency: 1, tasks: [{ name: "question-first", prompt: "question", agent: "explorer" }, { name: "fails-later", prompt: "FAIL sibling", agent: "reviewer" }] }, undefined, undefined, { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: failedAfterBlockHerdr });
 	const failedAnswer = await executeHerdrSubagents({ action: "respond", runId: failedAfterBlock.details.runId, answer: "main" }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: failedAfterBlockHerdr });
@@ -865,7 +888,7 @@ try {
 	check("history lists compact project-local runs and tasks", Boolean(stableHistory?.tasks.length) && historyText(history).includes("stable") && !historyText(history).includes("FULL stable"));
 	const historyHerdr = fakeHerdr();
 	const historicalUpdates = [];
-	const historicalResume = await executeHerdrSubagents({ action: "resume", runId: backgroundId, task: 1, prompt: "follow up" }, undefined, (update) => historicalUpdates.push(update.details), { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: historyHerdr });
+	const historicalResume = await executeHerdrSubagents({ action: "resume", runId: backgroundId.slice(0, 8), task: 1, prompt: "follow up" }, undefined, (update) => historicalUpdates.push(update.details), { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: historyHerdr });
 	const historyStartRequest = historyHerdr.calls.find(([name]) => name === "startAgent")[1];
 	check("historical resume preserves the saved Pi session and persona prompt", !historicalResume.isError && historyHerdr.calls[0][0] === "createTab" && historyStartRequest.args.includes(stableHistory.tasks[0].sessionFile) && historyStartRequest.args.includes(stableHistory.tasks[0].model) && historyStartRequest.args.some((value) => String(value).includes("subagent_report")) && existsSync(join(stableHistory.tasks[0].recordDirectory, "turns", "02.json")) && readFileSync(join(stableHistory.tasks[0].recordDirectory, "followup-system-prompt.md"), "utf8").includes("Investigate the assigned question without modifying files"));
 	check("historical resume streams authoritative Fleet activity", historicalUpdates.some((update) => update.status === "running" && update.activity?.[0]?.agent === "explorer" && update.activity[0].sessionFile === stableHistory.tasks[0].sessionFile));
@@ -917,13 +940,11 @@ try {
 	check("parent shutdown marks a historical follow-up run cancelled despite completed siblings", historicalCancelledRun.status === "cancelled" && historicalCancelledRun.error.includes("Parent Pi session closed"));
 	const followupBlockedHerdr = fakeHerdr("blocked");
 	const blockedFollowup = await executeHerdrSubagents({ action: "resume", runId: backgroundId, task: 1, prompt: "ask a follow-up" }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: followupBlockedHerdr });
-	const duplicateResumeHerdr = fakeHerdr();
-	const duplicateResume = await executeHerdrSubagents({ action: "resume", runId: backgroundId, task: 1, prompt: "duplicate live follow-up" }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: duplicateResumeHerdr });
-	check("historical resume rejects an active run without starting a second Agent", duplicateResume.isError && duplicateResume.content[0].text.includes("still active") && duplicateResumeHerdr.calls.length === 0);
-	const answeredFollowup = await executeHerdrSubagents({ action: "respond", runId: backgroundId, answer: "follow-up answer" }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: followupBlockedHerdr });
 	const historicalTurns = join(stableHistory.tasks[0].recordDirectory, "turns");
-	const answeredTurn = JSON.parse(readFileSync(join(historicalTurns, "03.json"), "utf8"));
-	check("blocked historical follow-up remains publicly resumable with durable turns", blockedFollowup.details.status === "blocked" && !answeredFollowup.isError && answeredFollowup.details.status === "completed" && existsSync(join(historicalTurns, "01.json")) && answeredTurn.status === "completed" && answeredTurn.events.some((event) => event.type === "answer"));
+	const failedInputTurn = JSON.parse(readFileSync(join(historicalTurns, "03.json"), "utf8"));
+	const failedInputTask = JSON.parse(readFileSync(join(stableHistory.tasks[0].recordDirectory, "task.json"), "utf8"));
+	const failedInputAttempt = JSON.parse(readFileSync(join(stableHistory.tasks[0].recordDirectory, "reports", `${failedInputTask.currentAttemptId}.json`), "utf8"));
+	check("historical input requests fail instead of creating unowned blocked work", blockedFollowup.isError && blockedFollowup.details.status === "failed" && failedInputTurn.status === "failed" && failedInputAttempt.failureKind === "missing_input" && followupBlockedHerdr.calls.at(-1)[0] === "closeTab");
 	const prePromptFailureTaskFile = join(stableHistory.tasks[0].recordDirectory, "task.json");
 	const prePromptStaleTask = JSON.parse(readFileSync(prePromptFailureTaskFile, "utf8"));
 	Object.assign(prePromptStaleTask, { question: "stale question", error: "stale error", completedAt: "2000-01-01T00:00:00.000Z" });
@@ -952,7 +973,7 @@ try {
 	const ignoreText = readFileSync(ignoreFile, "utf8");
 	check("runtime archive is ignored without hiding personas or overwriting unrelated rules", ignoreText.includes("herdr-subagents/runs/") && !ignoreText.split(/\r?\n/).includes("herdr-subagents/") && ignoreText.includes("unrelated-state/") && ignoreText.match(/herdr-subagents\/runs\//g)?.length === 1);
 	const remainingRunId = history.find((run) => run.id !== backgroundId)?.id;
-	const cleaned = await executeHerdrSubagents({ action: "cleanup", runId: backgroundId }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: fakeHerdr() });
+	const cleaned = await executeHerdrSubagents({ action: "cleanup", runId: basename(stableHistory.recordDirectory) }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: fakeHerdr() });
 	const afterCleanup = await listSubagentHistory(root);
 	check("explicit cleanup removes only the selected run", !cleaned.isError && !afterCleanup.some((run) => run.id === backgroundId) && (!remainingRunId || afterCleanup.some((run) => run.id === remainingRunId)));
 
@@ -1079,6 +1100,33 @@ try {
 	writeFileSync(join(ownerLossTask, "reports", `${ownerLossAttempt}.json`), JSON.stringify({ attemptId: ownerLossAttempt, status: "completed", summary: "Completed before owner loss.", documents: [] }));
 	await reconcileSubagentRuns(ownerLossRoot, fakeHerdr(), { sessionId: "new-owner", processId: process.pid });
 	check("matching attempt report survives prior owner loss", JSON.parse(readFileSync(join(ownerLossTask, "task.json"), "utf8")).status === "completed" && JSON.parse(readFileSync(join(ownerLossRun, "run.json"), "utf8")).status === "completed" && JSON.parse(readFileSync(join(ownerLossTask, "report.json"), "utf8")).attemptId === ownerLossAttempt);
+	const blockedOwnerLossRoot = join(root, "blocked-owner-loss-recovery");
+	const blockedOwnerLossRun = join(blockedOwnerLossRoot, ".pi", "herdr-subagents", "runs", "run");
+	const blockedOwnerLossTask = join(blockedOwnerLossRun, "tasks", "01-task");
+	const blockedOwnerLossAttempt = "66666666-6666-4666-8666-666666666666";
+	mkdirSync(join(blockedOwnerLossTask, "reports"), { recursive: true });
+	writeFileSync(join(blockedOwnerLossRun, "run.json"), JSON.stringify({ id: "blocked-owner-loss", label: "blocked-owner-loss", status: "running", effectiveConcurrency: 1, ownerSessionId: "dead-owner", ownerProcessId: 99999999, tabId: "w1:t-blocked-owner-loss", startedAt: new Date().toISOString() }));
+	writeFileSync(join(blockedOwnerLossTask, "task.json"), JSON.stringify({ id: "blocked-owner-loss-task", runId: "blocked-owner-loss", order: 1, status: "running", paneId: "w1:p-blocked-owner-loss", currentAttemptId: blockedOwnerLossAttempt, sessionFile: join(blockedOwnerLossTask, "session.jsonl") }));
+	writeFileSync(join(blockedOwnerLossTask, "reports", `${blockedOwnerLossAttempt}.json`), JSON.stringify({ attemptId: blockedOwnerLossAttempt, status: "needs-input", summary: "Need input before owner loss.", question: "Which branch?", documents: [] }));
+	const blockedOwnerLossHerdr = fakeHerdr();
+	await reconcileSubagentRuns(blockedOwnerLossRoot, blockedOwnerLossHerdr, { sessionId: "new-owner", processId: process.pid });
+	const cancelledBlockedOwnerTask = JSON.parse(readFileSync(join(blockedOwnerLossTask, "task.json"), "utf8"));
+	const cancelledBlockedOwnerReport = JSON.parse(readFileSync(join(blockedOwnerLossTask, "report.json"), "utf8"));
+	const cancelledBlockedOwnerAttempt = JSON.parse(readFileSync(join(blockedOwnerLossTask, "reports", `${blockedOwnerLossAttempt}.json`), "utf8"));
+	check("owner-loss reconciliation never leaves blocked work without dispatcher ownership", cancelledBlockedOwnerTask.status === "cancelled" && cancelledBlockedOwnerReport.status === "failed" && !cancelledBlockedOwnerReport.question && cancelledBlockedOwnerAttempt.status === "failed" && !cancelledBlockedOwnerAttempt.question && JSON.parse(readFileSync(join(blockedOwnerLossRun, "run.json"), "utf8")).status === "cancelled" && blockedOwnerLossHerdr.calls.some(([name]) => name === "closeTab"));
+	const parallelInputRecoveryRoot = join(root, "parallel-input-recovery");
+	const parallelInputRecoveryRun = join(parallelInputRecoveryRoot, ".pi", "herdr-subagents", "runs", "run");
+	const parallelInputRecoveryTask = join(parallelInputRecoveryRun, "tasks", "01-task");
+	const parallelInputRecoveryAttempt = "55555555-5555-4555-8555-555555555555";
+	mkdirSync(join(parallelInputRecoveryTask, "reports"), { recursive: true });
+	writeFileSync(join(parallelInputRecoveryRun, "run.json"), JSON.stringify({ id: "parallel-input-recovery", label: "parallel-input-recovery", status: "running", effectiveConcurrency: 2, ownerSessionId: "dead-owner", ownerProcessId: 99999999, tabId: "w1:t-parallel-input", startedAt: new Date().toISOString() }));
+	writeFileSync(join(parallelInputRecoveryTask, "task.json"), JSON.stringify({ id: "parallel-input-task", runId: "parallel-input-recovery", order: 1, status: "running", paneId: "w1:p-parallel-input", currentAttemptId: parallelInputRecoveryAttempt, sessionFile: join(parallelInputRecoveryTask, "session.jsonl") }));
+	writeFileSync(join(parallelInputRecoveryTask, "reports", `${parallelInputRecoveryAttempt}.json`), JSON.stringify({ attemptId: parallelInputRecoveryAttempt, status: "needs-input", summary: "Need a branch.", question: "Which branch?", documents: [] }));
+	await reconcileSubagentRuns(parallelInputRecoveryRoot, fakeHerdr(), { sessionId: "new-owner", processId: process.pid });
+	const recoveredParallelInputTask = JSON.parse(readFileSync(join(parallelInputRecoveryTask, "task.json"), "utf8"));
+	const recoveredParallelInputReport = JSON.parse(readFileSync(join(parallelInputRecoveryTask, "report.json"), "utf8"));
+	const recoveredParallelInputAttempt = JSON.parse(readFileSync(join(parallelInputRecoveryTask, "reports", `${parallelInputRecoveryAttempt}.json`), "utf8"));
+	check("reconciliation keeps concurrent input requests out of blocked state", recoveredParallelInputTask.status === "failed" && recoveredParallelInputTask.failureKind === "missing_input" && recoveredParallelInputReport.status === "failed" && recoveredParallelInputReport.requiredInput === "Which branch?" && recoveredParallelInputAttempt.status === "failed" && recoveredParallelInputAttempt.failureKind === "missing_input" && JSON.parse(readFileSync(join(parallelInputRecoveryRun, "run.json"), "utf8")).status === "failed");
 	const malformedRoot = join(root, "malformed-recovery");
 	const malformedRun = join(malformedRoot, ".pi", "herdr-subagents", "runs", "run");
 	const malformedTask = join(malformedRun, "tasks", "01-task");