@maxiaochao/pi-toolkit 0.10.15 → 0.10.17

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2026-10-10 - v0.10.17
+
+- bundle herdr-subagents v0.4.5: fix transient retry lifecycle, attempt isolation, and recovery semantics
+- bundle Herdr Subagents lifecycle and attempt-isolation fixes so provider retries cannot create false failed tasks or overwrite newer attempts
+
+## 2026-10-10 - v0.10.16
+
+- tapd skill: handle large attachment timeouts without misdiagnosing download failures
+
 ## 2026-10-09 - v0.10.15
 
 - redesign the TAPD skill around executable workflows, explicit workspace and JSON contracts, and safe attachment handling

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxiaochao/pi-toolkit",
-  "version": "0.10.15",
+  "version": "0.10.17",
   "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,11 @@
+## 2026-10-10 - v0.4.5
+
+- fix transient retry lifecycle, attempt isolation, and recovery semantics
+- prevent transient Herdr states from finalizing live child attempts
+- Report authoritative child Pi lifecycle state even under `--no-extensions`, wait through provider retry/fallback until the matching structured report arrives, and bind every report to a unique attempt ID.
+- Reconcile matching attempt reports after interruption, serialize blocked responses, keep blocked results non-error, and preserve business outcomes when tab cleanup fails.
+- Aggregate mixed failed/cancelled task sets as partial instead of hiding one terminal outcome.
+
 ## 2026-10-09 - v0.4.4
 
 - return failed foreground batches early while surviving subagents continue in background

package/packages/herdr-subagents/README.md

@@ -82,6 +82,8 @@ A child missing required information reports `needs-input` with an exact questio
 herdr_subagents_control({ action: "respond", runId: "<run-id>", answer: "Use the main branch." })
 ```
 
+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.
+
 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.
@@ -96,13 +98,13 @@ Continue a saved conversation in a new Herdr tab with `herdr_subagents_control({
 
 Read-only tasks start FIFO up to the configured concurrency limit. A pane is created only when its task starts, belongs exclusively to that task, and is never reused. Completed panes remain inspectable while another task in the batch is unsettled. Results remain in input order, and one failed task does not cancel its siblings. Any batch containing a write-capable persona is forced to concurrency one.
 
-The widget shows one row per queued, running, blocked, failed, or completed task. Answering a blocked task or resuming saved history refreshes authoritative persona, timing, session, status, and pane projections as work advances. Active duration accumulates only while the task is running, excluding time spent queued or waiting for an answer. Completed rows remain selectable until the whole batch settles. `/herdr-subagents active` shows the same compact state. Native labels stay short: `SA · <batch>` for the tab and `<order> · <task>` for each pane. When all tasks settle, the tab closes immediately if unfocused or after the user leaves it; a deferred close failure is persisted and shown as a warning. An already-missing tab is treated as successfully cleaned, so retries are idempotent.
+The widget shows one row per queued, running, blocked, failed, or completed task. Answering a blocked task or resuming saved history refreshes authoritative persona, timing, session, status, and pane projections as work advances. Active duration accumulates only while the task is running, excluding time spent queued or waiting for an answer. Completed rows remain selectable until the whole batch settles. `/herdr-subagents active` shows the same compact state. Native labels stay short: `SA · <batch>` for the tab and `<order> · <task>` for each pane. When all tasks settle, the tab closes immediately if unfocused or after the user leaves it; a deferred close failure is persisted and shown as a warning without changing the completed/failed business result. An already-missing tab is treated as successfully cleaned, so retries are idempotent.
 
-Foreground calls wait until all children report completion or a request for input when no task fails. On the first task failure, they return early as described above while the surviving children continue. Every child is started with Herdr's Agent lifecycle as a normal Pi TUI and prompted with wait semantics; no print-mode command or completion marker is injected into the pane.
+Foreground calls wait until all children report completion or a request for input when no task fails. On the first task failure, they return early as described above while the surviving children continue. Every child is started with Herdr's Agent lifecycle as a normal Pi TUI and prompted with wait semantics; no print-mode command or completion marker is injected into the pane. The child extension reports Pi's authoritative `agent_start`/`agent_settled` lifecycle to Herdr, so provider retry and fallback screens cannot end a task early through screen detection alone.
 
 ## Reports and records
 
-The child must finish through the package's structured `subagent_report` tool. The parent receives only:
+The child must finish through the package's structured `subagent_report` tool. Every prompt gets a unique attempt ID; the child commits to an attempt-specific report, and the parent accepts only the matching report before updating the canonical task result. A late report from an older retry, response, or historical follow-up cannot settle a newer attempt. The parent receives only:
 
 - completion or failure status
 - a concise summary
@@ -115,7 +117,7 @@ The complete result is not copied into the parent model context. Each run is ret
 .pi/herdr-subagents/runs/<run>/tasks/<task>/
 ```
 
-The task directory contains the full result, structured report, task metadata, system prompt, and persistent Pi session. Run-level metadata is stored in the parent run directory.
+The task directory contains the full result, canonical structured report, attempt-scoped reports and lifecycle markers, task metadata, system prompt, and persistent Pi session. Run-level metadata is stored in the parent run directory.
 
 ## Configuration and personas
 

package/packages/herdr-subagents/TESTING.md

@@ -27,7 +27,9 @@
 - Verify selected active/queued run cancellation, blocked-response live Fleet updates, authoritative stale-field replacement, parent-shutdown cancellation, idempotent missing-tab cleanup, cleanup notifications, atomic state replacement, non-retried uncertain startup operations, and stalled warnings.
 - Verify `status(runId)` isolates one run, projects queue-only state, prefers durable state over a stale queue record, exposes blocked questions, marks terminal states settled, rejects unknown IDs, and leaves full `history` semantics unchanged.
 - Verify resumed batches retain newly allocated pane IDs and historical follow-ups exclude simultaneous session writers.
+- Simulate a false screen-settled return while the authoritative Pi lifecycle remains working, then write the report later and verify the task completes without a transient failed state.
+- Verify reports are bound to unique attempt IDs, blocked results are not tool errors, duplicate blocked responses are serialized, mixed failed/cancelled aggregates remain partial, and cleanup failures never overwrite business outcomes.
 
 ## Latest baseline
 
-All 179 deterministic scheduler, recovery, process-boundary, schema-validation, navigation, metrics, responsive-formatting, 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 two concurrent tasks, retained its focused run tab through settlement, and closed it automatically after focus moved away.
+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.

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

@@ -1,10 +1,12 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
+import net from "node:net";
+import { dirname, resolve } from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { resultPathForAttempt } from "../src/result-path.ts";
+import { resultPathForAttemptId } from "../src/result-path.ts";
 import { PARENT_PANE_ENV } from "../src/live-agent.ts";
+import { attemptReportPath, attemptStatePath, requireAttemptId, type AttemptState } from "../src/attempts.ts";
 
 const RETURN_SHORTCUT = "alt+p";
 
@@ -33,12 +35,52 @@ const ReportParams = Type.Object({
 });
 
 function writeAtomic(path: string, content: string): void {
+	mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
 	const temporary = `${path}.tmp-${process.pid}`;
 	writeFileSync(temporary, content, { encoding: "utf8", mode: 0o600 });
 	renameSync(temporary, path);
 }
 
+function currentAttemptId(taskDirectory: string): string {
+	const task = JSON.parse(readFileSync(resolve(taskDirectory, "task.json"), "utf8")) as { currentAttemptId?: unknown };
+	return requireAttemptId(task.currentAttemptId);
+}
+
+function writeAttemptState(taskDirectory: string, attemptId: string, state: AttemptState): void {
+	writeAtomic(attemptStatePath(taskDirectory, attemptId), `${JSON.stringify({ attemptId, state, at: new Date().toISOString() }, null, 2)}\n`);
+}
+
+let herdrReportSeq = Date.now() * 1000;
+
+function reportHerdrState(state: "working" | "blocked" | "idle", message?: string): void {
+	const socketPath = process.env.HERDR_SOCKET_PATH;
+	const paneId = process.env.HERDR_PANE_ID;
+	if (process.env.HERDR_ENV !== "1" || !socketPath || !paneId) return;
+	const endpoint = process.platform === "win32" ? `\\\\.\\pipe\\${socketPath}` : socketPath;
+	const socket = net.createConnection(endpoint);
+	socket.on("error", () => undefined);
+	socket.on("connect", () => socket.end(`${JSON.stringify({ id: `herdr:subagent:${Date.now()}:${Math.random().toString(36).slice(2)}`, method: "pane.report_agent", params: { pane_id: paneId, source: "herdr:pi", agent: "pi", state, message, seq: ++herdrReportSeq } })}\n`));
+}
+
 export default function (pi: ExtensionAPI) {
+	let activeAttemptId: string | undefined;
+	let blockedCount = 0;
+	pi.on("before_agent_start", async () => {
+		const taskDirectory = process.env.PI_HERDR_SUBAGENTS_TASK_DIR?.trim();
+		if (!taskDirectory) return;
+		activeAttemptId = currentAttemptId(taskDirectory);
+		writeAttemptState(taskDirectory, activeAttemptId, "working");
+	});
+	pi.on("agent_start", () => reportHerdrState("working"));
+	pi.on("agent_settled", (_event, ctx) => {
+		const taskDirectory = process.env.PI_HERDR_SUBAGENTS_TASK_DIR?.trim();
+		if (taskDirectory && activeAttemptId) writeAttemptState(taskDirectory, activeAttemptId, "settled");
+		if (ctx?.isIdle?.() === true) reportHerdrState("idle");
+	});
+	pi.events.on("herdr:blocked", (data: { active?: boolean; label?: string }) => {
+		blockedCount = Math.max(0, blockedCount + (data?.active ? 1 : -1));
+		reportHerdrState(blockedCount > 0 ? "blocked" : "working", blockedCount > 0 ? data?.label : undefined);
+	});
 	pi.registerCommand("parent", {
 		description: "Return focus to the parent Agent pane",
 		async handler(_args, ctx) { await returnToParent(pi, ctx); },
@@ -58,12 +100,9 @@ export default function (pi: ExtensionAPI) {
 		async execute(_toolCallId, params) {
 			const taskDirectory = process.env.PI_HERDR_SUBAGENTS_TASK_DIR?.trim();
 			if (!taskDirectory) throw new Error("PI_HERDR_SUBAGENTS_TASK_DIR is not set");
+			const attemptId = activeAttemptId ?? currentAttemptId(taskDirectory);
 			mkdirSync(taskDirectory, { recursive: true, mode: 0o700 });
-			let attempt = 1;
-			const task = JSON.parse(readFileSync(resolve(taskDirectory, "task.json"), "utf8")) as { attempt?: unknown };
-			if (Number.isInteger(task.attempt) && Number(task.attempt) > 1) attempt = Number(task.attempt);
-			const resultPath = resultPathForAttempt(taskDirectory, attempt);
-			if (attempt > 1) mkdirSync(resolve(taskDirectory, "turns"), { recursive: true, mode: 0o700 });
+			const resultPath = resultPathForAttemptId(taskDirectory, attemptId);
 			writeAtomic(resultPath, params.result);
 			const documents = (params.documents ?? []).map((document) => ({
 				path: resolve(process.cwd(), document.path),
@@ -73,6 +112,7 @@ export default function (pi: ExtensionAPI) {
 				documents.unshift({ path: resultPath, description: "Complete task result" });
 			}
 			const report = {
+				attemptId,
 				status: params.status,
 				summary: params.summary,
 				documents,
@@ -80,7 +120,7 @@ export default function (pi: ExtensionAPI) {
 				...(params.question ? { question: params.question } : {}),
 				reportedAt: new Date().toISOString(),
 			};
-			writeAtomic(resolve(taskDirectory, "report.json"), `${JSON.stringify(report, null, 2)}\n`);
+			writeAtomic(attemptReportPath(taskDirectory, attemptId), `${JSON.stringify(report, null, 2)}\n`);
 			return {
 				content: [{ type: "text" as const, text: `${params.status}: ${params.summary}` }],
 				details: report,

package/packages/herdr-subagents/package.json

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

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

@@ -0,0 +1,21 @@
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+
+const ATTEMPT_ID = /^[a-f0-9-]{36}$/i;
+
+export type AttemptState = "working" | "settled";
+
+export function createAttemptId(): string { return randomUUID(); }
+
+export function requireAttemptId(value: unknown): string {
+	if (typeof value !== "string" || !ATTEMPT_ID.test(value)) throw new Error("Subagent attempt has no valid attempt ID.");
+	return value;
+}
+
+export function attemptReportPath(taskDirectory: string, attemptId: string): string {
+	return join(taskDirectory, "reports", `${requireAttemptId(attemptId)}.json`);
+}
+
+export function attemptStatePath(taskDirectory: string, attemptId: string): string {
+	return join(taskDirectory, "attempts", `${requireAttemptId(attemptId)}.json`);
+}

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

@@ -13,7 +13,7 @@ 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 { reportProtocolPrompt } from "./protocol.ts";
 import { cleanupRunTab } from "./tab-cleanup.ts";
-import { applyRunStatus } from "./run-status.ts";
+import { aggregateTaskStatus, applyRunStatus } from "./run-status.ts";
 import { isAbortError } from "./errors.ts";
 
 export interface BatchTask {
@@ -150,6 +150,7 @@ export async function runHerdrSubagentsBatch(tasks: BatchTask[], options: BatchO
 				emit("running", `${settled}/${tasks.length} tasks settled.`);
 				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;
 				status = applyReport(context.taskRecord, report);
 			} catch (error) {
@@ -190,9 +191,10 @@ export async function runHerdrSubagentsBatch(tasks: BatchTask[], options: BatchO
 		const settledResults = results.filter(Boolean);
 		const blocked = settledResults.find((result) => result.status === "blocked");
 		const failed = settledResults.filter((result) => result.status === "failed").length;
-		const cancelled = options.signal?.aborted || activity.some((entry) => entry.status === "cancelled");
-		const status: BatchResult["status"] = cancelled ? "cancelled" : blocked || activity.some((entry) => entry.status === "queued") ? "blocked" : failed === 0 ? "completed" : failed === tasks.length ? "failed" : "partial";
-		const summary = status === "cancelled" ? "Subagent batch cancelled." : blocked ? `${blocked.name} needs input: ${blocked.question}` : failed ? `${tasks.length - failed}/${tasks.length} tasks completed; ${failed} failed.` : `${tasks.length}/${tasks.length} tasks completed.`;
+		const completed = settledResults.filter((result) => result.status === "completed").length;
+		const cancelled = settledResults.filter((result) => result.status === "cancelled").length;
+		const status = aggregateTaskStatus(activity.map((entry) => entry.status)) as BatchResult["status"];
+		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 };
@@ -203,19 +205,11 @@ export async function runHerdrSubagentsBatch(tasks: BatchTask[], options: BatchO
 	} finally {
 		const keepTab = !options.signal?.aborted && activity.some((entry) => entry.status === "blocked" || entry.status === "queued" || entry.status === "running");
 		if (tabId && !keepTab) {
-			try {
-				await cleanupRunTab({
-					herdr, tabId, runFile, runRecord, signal: options.signal, failureStatus: "failed",
-					errorPrefix: "Task results settled, but Herdr tab cleanup failed",
-					onError: (message) => options.onCleanupError?.(message),
-				});
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				const cleanupError = new Error(`Task results settled, but Herdr tab cleanup failed: ${message}`) as Error & { recordDirectory: string; runId: string };
-				cleanupError.recordDirectory = runDirectory;
-				cleanupError.runId = runId;
-				throw cleanupError;
-			}
+			await cleanupRunTab({
+				herdr, tabId, runFile, runRecord, signal: options.signal,
+				errorPrefix: "Task results settled, but Herdr tab cleanup failed",
+				onError: (message) => options.onCleanupError?.(message),
+			});
 		}
 	}
 }

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

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync } from "node:fs";
-import { mkdir, rename } from "node:fs/promises";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { CliHerdrAutomation, type HerdrAutomation } from "./herdr.ts";
 import { continueQueuedRun } from "./continue-run.ts";
@@ -7,7 +8,7 @@ import { liveAgentName, promptLiveAgent } from "./live-agent.ts";
 import { writeJsonAtomic, writeTextAtomic } from "./state.ts";
 import { cleanupRunTab } from "./tab-cleanup.ts";
 import type { OwnerIdentity } from "./ownership.ts";
-import { ownerRecord } from "./ownership.ts";
+import { isProcessAlive, ownerRecord } from "./ownership.ts";
 import { aggregateTaskStatus, applyRunStatus } from "./run-status.ts";
 import { applyReport, applyTaskStatus, isActiveStatus, persistFailureReport, projectTaskActivity, readReport, readRunRecord, readTaskRecord, readTurnRecord, settleAttemptFailure, type PersistedDocument, type PersistedReport, type RunRecord, type TaskActivity, type TaskRecord, type TaskStatus, type TurnRecord } from "./records.ts";
 import { isAbortError } from "./errors.ts";
@@ -32,6 +33,36 @@ export interface ResumeBlockedResult {
 	tabId?: string;
 }
 
+interface ResponseLock { token?: string; processId?: unknown; sessionId?: unknown; createdAt?: unknown; }
+
+async function readResponseLock(lockFile: string): Promise<ResponseLock | undefined> {
+	try {
+		const lock = JSON.parse(await readFile(lockFile, "utf8")) as unknown;
+		return lock && typeof lock === "object" ? lock as ResponseLock : undefined;
+	} catch { return undefined; }
+}
+
+async function releaseResponseLock(lockFile: string, token: string): Promise<void> {
+	if ((await readResponseLock(lockFile))?.token !== token) return;
+	try { await unlink(lockFile); }
+	catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
+}
+
+async function acquireResponseLock(lockFile: string, runId: string, owner?: OwnerIdentity): Promise<string> {
+	const token = randomUUID();
+	try {
+		await writeFile(lockFile, `${JSON.stringify({ token, processId: process.pid, sessionId: owner?.sessionId, createdAt: new Date().toISOString() })}\n`, { flag: "wx", mode: 0o600 });
+		return token;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+		const lock = await readResponseLock(lockFile);
+		if (lock && Number.isInteger(lock.processId) && !isProcessAlive(lock.processId)) {
+			throw new Error(`Subagent run '${runId}' has a stale blocked-response lock from process ${lock.processId}; remove ${lockFile} and retry.`);
+		}
+		throw new Error(`Subagent run '${runId}' already has a blocked response in progress (lock: ${lockFile}).`);
+	}
+}
+
 async function emitProgress(options: RespondToBlockedTaskOptions, runDirectory: string, run: RunRecord, taskDirectories: string[], summary: string): Promise<void> {
 	if (!options.onUpdate) return;
 	const tasks = await Promise.all(taskDirectories.map((directory) => readTaskRecord(join(directory, "task.json"))));
@@ -71,7 +102,7 @@ async function projectSettledRun(runDirectory: string, runFile: string, run: Run
 	run = await readRunRecord(runFile);
 	applyRunStatus(run, runStatus, { question: blockedReport?.question });
 	await writeJsonAtomic(runFile, run);
-	if (runStatus !== "blocked" && run.tabId) await cleanupRunTab({ herdr, tabId: run.tabId, runFile, runRecord: run, onError: onCleanupError, failureStatus: "failed" });
+	if (runStatus !== "blocked" && run.tabId) await cleanupRunTab({ herdr, tabId: run.tabId, runFile, runRecord: run, onError: onCleanupError });
 	const summary = runStatus === "completed" ? "All tasks completed after the answer." : runStatus === "blocked" ? `${finalTasks[blockedIndex]?.name ?? "Task"} needs input: ${blockedReport?.question ?? "Input required."}` : finalReports.map((entry, index) => `${finalTasks[index].name}: ${entry.summary}`).join("\n");
 	const activity = finalTasks.map((entry, index) => projectTaskActivity(entry, index));
 	const tasks = finalTasks.map((entry, index) => ({ index, name: activity[index].name, status: entry.status, summary: String(finalReports[index].summary ?? "Task has no report."), documents: finalReports[index].documents ?? [], ...(entry.error ? { error: String(entry.error) } : {}), ...(entry.question ? { question: String(entry.question) } : {}), paneId: String(entry.paneId ?? ""), recordDirectory: taskDirectories[index], sessionFile: String(entry.sessionFile ?? "") }));
@@ -79,11 +110,18 @@ async function projectSettledRun(runDirectory: string, runFile: string, run: Run
 }
 
 export async function respondToBlockedTask(cwd: string, runId: string, answer: string, options: RespondToBlockedTaskOptions = {}): Promise<ResumeBlockedResult> {
-	const herdr = options.herdr ?? new CliHerdrAutomation();
-	const { taskNumber, signal, onCleanupError } = options;
 	const runsDirectory = join(cwd, ".pi", "herdr-subagents", "runs");
 	const runDirectory = await findRunDirectory(runsDirectory, runId);
 	if (!runDirectory) throw new Error(`Unknown Subagent run '${runId}'.`);
+	const lockFile = join(runDirectory, ".respond.lock");
+	const lockToken = await acquireResponseLock(lockFile, runId, options.owner);
+	try { return await respondToBlockedTaskLocked(cwd, runId, answer, runDirectory, options); }
+	finally { await releaseResponseLock(lockFile, lockToken); }
+}
+
+async function respondToBlockedTaskLocked(cwd: string, runId: string, answer: string, runDirectory: string, options: RespondToBlockedTaskOptions): Promise<ResumeBlockedResult> {
+	const herdr = options.herdr ?? new CliHerdrAutomation();
+	const { taskNumber, signal, onCleanupError } = options;
 	const runFile = join(runDirectory, "run.json");
 	const run = await readRunRecord(runFile);
 	const taskDirectories = readdirSync(join(runDirectory, "tasks")).sort().map((entry) => join(runDirectory, "tasks", entry));
@@ -131,7 +169,9 @@ export async function respondToBlockedTask(cwd: string, runId: string, answer: s
 	let status: "blocked" | "completed" | "failed" | "cancelled";
 	let attemptError: unknown;
 	try {
-		report = (await promptLiveAgent({ herdr, task: { ...task, id: task.id, sessionFile: task.sessionFile }, paneId, prompt: answer, systemPromptFile: resumePrompt, agentName, start: !live, signal, stalledWarningMs: run.stalledWarningSeconds ? Number(run.stalledWarningSeconds) * 1000 : undefined, onStalled: () => options.onStalled?.(`${task.name ?? task.agent} appears stalled; it is still running.`) })).report;
+		const prompted = await promptLiveAgent({ herdr, task: { ...task, id: task.id, sessionFile: task.sessionFile }, paneId, prompt: answer, systemPromptFile: resumePrompt, agentName, start: !live, 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;
+		report = prompted.report;
 		status = applyReport(task, report);
 	} catch (error) {
 		attemptError = error;
@@ -158,7 +198,7 @@ export async function respondToBlockedTask(cwd: string, runId: string, answer: s
 				await writeJsonAtomic(siblingFile, sibling);
 			}
 			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, failureStatus: "failed" });
+			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) } : {}) };
 	}
 	turn.events.push({ type: "report", status, summary: report.summary, question: report.question, error: report.error, at: new Date().toISOString() });

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

@@ -48,7 +48,9 @@ export async function continueQueuedRun(runDirectory: string, herdr: HerdrAutoma
 			Object.assign(task, { tabId: run.tabId, paneId, paneLabel, agentName, attempt: Number(task.attempt ?? 0) + 1, startedAt: new Date().toISOString() });
 			await writeJsonAtomic(taskFile, task);
 			await options.onUpdate?.();
-			const report = (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.`) })).report;
+			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;
 			applyReport(task, report);
 		} catch (error) {
 			await settleAttemptFailure(task, reportFile, {
@@ -79,9 +81,9 @@ export async function continueQueuedRun(runDirectory: string, herdr: HerdrAutoma
 		}
 	}
 	const statuses = await Promise.all(taskDirectories.map(async (directory) => (await readTaskRecord(join(directory, "task.json"))).status));
-	applyRunStatus(run, options.signal?.aborted ? "cancelled" : aggregateTaskStatus(statuses));
+	applyRunStatus(run, aggregateTaskStatus(statuses));
 	await writeJsonAtomic(runFile, run);
 	if (options.cleanup !== false && run.status !== "blocked" && run.tabId) {
-		await cleanupRunTab({ herdr, tabId: run.tabId, runFile, runRecord: run, signal: options.signal, onError: options.onCleanupError, failureStatus: "failed" });
+		await cleanupRunTab({ herdr, tabId: run.tabId, runFile, runRecord: run, signal: options.signal, onError: options.onCleanupError });
 	}
 }

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

@@ -161,7 +161,9 @@ async function resumeHistoricalTaskLocked(cwd: string, runId: string, taskNumber
 			]);
 			const runningActivity = await Promise.all(run.tasks.map(async (entry, index) => projectTaskActivity(await readTaskRecord(join(entry.recordDirectory, "task.json")), index)));
 			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 });
-			report = (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.`) })).report;
+			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;
 			status = applyReport(task, report);
 		} catch (error) {
 			const settled = await settleAttemptFailure(task, join(historical.recordDirectory, "report.json"), {
@@ -183,7 +185,7 @@ async function resumeHistoricalTaskLocked(cwd: string, runId: string, taskNumber
 		Object.assign(runRecord, { ...ownerRecord(options.owner), tabId: tab.tabId });
 		await writeJsonAtomic(join(run.recordDirectory, "run.json"), runRecord);
 		if (status !== "blocked") {
-			await cleanupRunTab({ herdr, tabId: tab.tabId, runFile: join(run.recordDirectory, "run.json"), runRecord, signal, onError: onCleanupError, failureStatus: "failed" });
+			await cleanupRunTab({ herdr, tabId: tab.tabId, runFile: join(run.recordDirectory, "run.json"), runRecord, signal, onError: onCleanupError });
 		}
 		const activity = await Promise.all(run.tasks.map(async (entry, index) => projectTaskActivity(await readTaskRecord(join(entry.recordDirectory, "task.json")), index)));
 		return { runId, label: run.label, status, summary: report.summary, documents: report.documents ?? [], tabId: tab.tabId, paneId: tab.paneId, sessionFile: historical.sessionFile, activity };
@@ -210,7 +212,7 @@ async function resumeHistoricalTaskLocked(cwd: string, runId: string, taskNumber
 		]);
 		const activity = await Promise.all(run.tasks.map(async (entry, index) => projectTaskActivity(await readTaskRecord(join(entry.recordDirectory, "task.json")), index)));
 		options.onUpdate?.({ runId, label: run.label, status, summary: report.summary, documents: report.documents, tabId: tab?.tabId ?? "", paneId: tab?.paneId ?? "", sessionFile: historical.sessionFile, activity });
-		if (tab) await cleanupRunTab({ herdr, tabId: tab.tabId, runFile: join(run.recordDirectory, "run.json"), runRecord, signal, onError: onCleanupError, failureStatus: "failed" });
+		if (tab) await cleanupRunTab({ herdr, tabId: tab.tabId, runFile: join(run.recordDirectory, "run.json"), runRecord, signal, onError: onCleanupError });
 		throw error;
 	}
 }

package/packages/herdr-subagents/src/live-agent.ts

@@ -1,10 +1,12 @@
 import { existsSync } from "node:fs";
-import { readFile, rm } from "node:fs/promises";
+import { mkdir, readFile, rename } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { HerdrAutomation } from "./herdr.ts";
 import type { HerdrSubagentsReport } from "./runner.ts";
 import { parseReport } from "./records.ts";
+import { attemptReportPath, attemptStatePath, createAttemptId, type AttemptState } from "./attempts.ts";
+import { writeJsonAtomic } from "./state.ts";
 
 export interface LiveTaskRecord {
 	id: string;
@@ -15,6 +17,7 @@ export interface LiveTaskRecord {
 	thinking?: string;
 	tools?: string[];
 	skills?: string[];
+	currentAttemptId?: string;
 }
 
 export const PARENT_PANE_ENV = "PI_HERDR_SUBAGENTS_PARENT_PANE_ID";
@@ -61,10 +64,17 @@ export async function promptLiveAgent(options: {
 	start?: boolean;
 	stalledWarningMs?: number;
 	onStalled?: () => void;
-}): Promise<{ report: HerdrSubagentsReport; agentName: string }> {
+}): Promise<{ report: HerdrSubagentsReport; agentName: string; attemptId: string }> {
 	const taskDirectory = dirname(options.task.sessionFile);
 	const reportFile = join(taskDirectory, "report.json");
-	await rm(reportFile, { force: true });
+	const taskFile = join(taskDirectory, "task.json");
+	const attemptId = createAttemptId();
+	const attemptReportFile = attemptReportPath(taskDirectory, attemptId);
+	const attemptStateFile = attemptStatePath(taskDirectory, attemptId);
+	await Promise.all([mkdir(dirname(attemptReportFile), { recursive: true, mode: 0o700 }), mkdir(dirname(attemptStateFile), { recursive: true, mode: 0o700 })]);
+	const durableTask = JSON.parse(await readFile(taskFile, "utf8")) as Record<string, unknown>;
+	durableTask.currentAttemptId = attemptId;
+	await writeJsonAtomic(taskFile, durableTask);
 	const agentName = options.agentName ?? liveAgentName(options.task.id, options.attempt);
 	if (options.start !== false) {
 		await options.herdr.startAgent({
@@ -80,18 +90,50 @@ export async function promptLiveAgent(options: {
 	try { await options.herdr.promptAgent({ target: agentName, prompt: options.prompt, signal: options.signal }); }
 	catch (error) { promptError = error; }
 	finally { if (stalledTimer) clearTimeout(stalledTimer); }
-	if (!existsSync(reportFile)) {
+	while (!existsSync(attemptReportFile)) {
+		let state: AttemptState | undefined;
+		if (existsSync(attemptStateFile)) {
+			try {
+				const value = JSON.parse(await readFile(attemptStateFile, "utf8")) as { attemptId?: unknown; state?: unknown };
+				if (value.attemptId === attemptId && (value.state === "working" || value.state === "settled")) state = value.state;
+			} catch { /* a concurrent atomic replacement will be retried */ }
+		}
+		if (state === "working") {
+			try {
+				if (!(await options.herdr.isTaskRunning(options.paneId, options.signal))) {
+					if (promptError) throw promptError;
+					throw new Error("Child Pi stopped while its authoritative attempt state was still working and did not submit a subagent_report.");
+				}
+			} catch (error) {
+				if (error === promptError || (error instanceof Error && error.message.startsWith("Child Pi stopped while"))) throw error;
+				// A transient liveness query is not evidence that the child stopped.
+			}
+			await new Promise<void>((resolve, reject) => {
+				const onAbort = () => { clearTimeout(timer); reject(options.signal?.reason ?? new Error("Subagent attempt aborted.")); };
+				const timer = setTimeout(() => { options.signal?.removeEventListener("abort", onAbort); resolve(); }, 100);
+				if (options.signal?.aborted) onAbort();
+				else options.signal?.addEventListener("abort", onAbort, { once: true });
+			});
+			continue;
+		}
 		if (promptError) throw promptError;
-		throw new Error("Child Pi settled but did not submit a subagent_report.");
+		throw new Error(state === "settled" ? "Child Pi settled but did not submit a subagent_report." : "Child Pi stopped without an authoritative lifecycle state and did not submit a subagent_report.");
 	}
 	let value: unknown;
-	try { value = JSON.parse(await readFile(reportFile, "utf8")); }
+	try { value = JSON.parse(await readFile(attemptReportFile, "utf8")); }
 	catch {
+		await rename(attemptReportFile, `${reportFile}.invalid-${Date.now()}`).catch(() => undefined);
 		if (promptError) throw new Error(`${promptError instanceof Error ? promptError.message : String(promptError)}; Child Pi also submitted an invalid subagent_report.`);
 		throw new Error("Child Pi submitted an invalid subagent_report.");
 	}
-	try { return { report: parseReport(value, "child subagent_report") as HerdrSubagentsReport, agentName }; }
+	try {
+		const report = parseReport(value, "child subagent_report") as HerdrSubagentsReport;
+		if (report.attemptId !== attemptId) throw new Error(`Report belongs to attempt '${report.attemptId ?? "unknown"}', expected '${attemptId}'.`);
+		await writeJsonAtomic(reportFile, report);
+		return { report, agentName, attemptId };
+	}
 	catch (error) {
+		await rename(attemptReportFile, `${reportFile}.invalid-${Date.now()}`).catch(() => undefined);
 		const detail = `Child Pi submitted an invalid subagent_report: ${error instanceof Error ? error.message : String(error)}`;
 		throw new Error(promptError ? `${promptError instanceof Error ? promptError.message : String(promptError)}; ${detail}` : detail);
 	}

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

@@ -6,6 +6,7 @@ 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 { cleanupRunTab } from "./tab-cleanup.ts";
+import { attemptReportPath } from "./attempts.ts";
 
 
 export interface CancellationResult { cancelledRuns: number; cleanupErrors: string[]; }
@@ -109,24 +110,34 @@ export async function reconcileSubagentRuns(cwd: string, herdr: HerdrAutomation,
 				continue;
 			}
 			if (isActiveStatus(task.status)) {
-				const reportFile = join(tasksDirectory, taskEntry, "report.json");
-				if (existsSync(reportFile) && (task.status === "running" || task.status === "starting")) {
+				let recoveredCurrentReport = false;
+				const canonicalReportFile = join(tasksDirectory, taskEntry, "report.json");
+				let currentAttemptReport: string | undefined;
+				if (task.currentAttemptId) {
+					try { currentAttemptReport = attemptReportPath(join(tasksDirectory, taskEntry), task.currentAttemptId); }
+					catch (error) { result.cleanupErrors.push(`Invalid current attempt for Subagent task ${taskFile}: ${error instanceof Error ? error.message : String(error)}`); }
+				}
+				// Once an attempt is identified, the canonical report is only history from
+				// an earlier attempt until this attempt publishes its scoped report.
+				const reportFile = task.currentAttemptId ? currentAttemptReport : canonicalReportFile;
+				if (reportFile && existsSync(reportFile) && (task.status === "running" || task.status === "starting")) {
 					try {
 						const report = await readReport(reportFile);
+						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);
 						result.settledTasks += 1;
 					} catch (error) {
 						const detail = error instanceof Error ? error.message : String(error);
 						result.cleanupErrors.push(`Invalid Subagent report ${reportFile}: ${detail}`);
-						await persistFailureReport(reportFile, { status: "failed", summary: "Recovered task had an invalid structured report.", documents: [], error: detail, reportedAt: new Date().toISOString() });
-						if (!differentOwner) {
-							applyTaskStatus(task, "failed", { error: `Invalid structured report: ${detail}` });
-							result.settledTasks += 1;
-							result.interruptedTasks += 1;
-						}
+						await persistFailureReport(canonicalReportFile, { status: "failed", summary: "Recovered task had an invalid structured report.", documents: [], error: detail, reportedAt: new Date().toISOString() }, reportFile !== canonicalReportFile);
+						applyTaskStatus(task, "failed", { error: `Invalid structured report: ${detail}` });
+						result.settledTasks += 1;
+						result.interruptedTasks += 1;
 					}
 				}
-				if (differentOwner && isActiveStatus(task.status)) {
+				if (differentOwner && isActiveStatus(task.status) && !(recoveredCurrentReport && task.status === "blocked")) {
 					applyTaskStatus(task, "cancelled", { error: "Owning parent Pi session is no longer active." });
 					result.cancelledTasks += 1;
 					result.interruptedTasks += 1;
@@ -158,8 +169,8 @@ export async function reconcileSubagentRuns(cwd: string, herdr: HerdrAutomation,
 			result.interruptedTasks += unreadableTasks;
 			continue;
 		}
-		if (differentOwner || !statuses.some((status) => status === "running" || status === "starting")) {
-			applyRunStatus(run, differentOwner ? "cancelled" : aggregateTaskStatus(statuses), { error: differentOwner ? "Owning parent Pi session is no longer active." : undefined });
+		if (!statuses.some((status) => status === "running" || status === "starting")) {
+			applyRunStatus(run, aggregateTaskStatus(statuses));
 			await writeJsonAtomic(runFile, run);
 			if (differentOwner || run.status === "cancelled") await closeRunTab(run, runFile, herdr, result.cleanupErrors);
 		}

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

@@ -19,6 +19,7 @@ export interface PersistedReport {
 	status: "completed" | "needs-input" | "failed";
 	summary: string;
 	documents: PersistedDocument[];
+	attemptId?: string;
 	error?: string;
 	question?: string;
 	reportedAt?: string;
@@ -74,6 +75,7 @@ export interface TaskRecord {
 	agentName?: string;
 	attempt?: number;
 	currentTurnFile?: string;
+	currentAttemptId?: string;
 	question?: string;
 	error?: string;
 }
@@ -176,6 +178,7 @@ 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.attemptId !== undefined && (typeof report.attemptId !== "string" || !report.attemptId.trim())) throw new Error(`Invalid report attemptId in ${source}.`);
 	return report as unknown as PersistedReport;
 }
 

package/packages/herdr-subagents/src/result-path.ts

@@ -5,3 +5,7 @@ export function resultPathForAttempt(taskDirectory: string, attempt: number): st
 		? resolve(taskDirectory, "turns", `${String(attempt).padStart(2, "0")}-result.md`)
 		: resolve(taskDirectory, "result.md");
 }
+
+export function resultPathForAttemptId(taskDirectory: string, attemptId: string): string {
+	return resolve(taskDirectory, "attempt-results", `${attemptId}.md`);
+}

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

@@ -7,9 +7,9 @@ export function aggregateTaskStatus(statuses: readonly TaskStatus[]): AggregateR
 	if (statuses.length === 0) return "failed";
 	if (statuses.some((status) => status === "running" || status === "starting")) return "running";
 	if (statuses.some((status) => status === "blocked" || status === "queued")) return "blocked";
-	const completed = statuses.some((status) => status === "completed");
-	if (statuses.some((status) => status === "cancelled")) return completed ? "partial" : "cancelled";
-	if (statuses.some((status) => status === "failed")) return completed ? "partial" : "failed";
+	if (statuses.every((status) => status === "cancelled")) return "cancelled";
+	if (statuses.every((status) => status === "failed")) return "failed";
+	if (statuses.some((status) => status === "cancelled" || status === "failed")) return "partial";
 	if (statuses.every((status) => status === "completed")) return "completed";
 	throw new Error(`Cannot aggregate unknown task status: ${statuses.join(", ")}`);
 }

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

@@ -184,7 +184,9 @@ export async function runHerdrSubagents(prompt: string, options: HerdrSubagentsO
 		await writeJson(taskFile, taskRecord);
 		update("starting", "Starting child Pi in Herdr...");
 		update("running", "Child Pi is working...");
-		const report = (await promptLiveAgent({ herdr, task: { ...taskRecord, id: taskId, sessionFile }, paneId, prompt, systemPromptFile, agentName: name, signal: options.signal, stalledWarningMs: options.stalledWarningSeconds ? options.stalledWarningSeconds * 1000 : undefined, onStalled: () => options.onStalled?.(`${label} appears stalled; it is still running.`) })).report;
+		const prompted = await promptLiveAgent({ herdr, task: { ...taskRecord, id: taskId, sessionFile }, paneId, prompt, systemPromptFile, agentName: name, signal: options.signal, stalledWarningMs: options.stalledWarningSeconds ? options.stalledWarningSeconds * 1000 : undefined, onStalled: () => options.onStalled?.(`${label} appears stalled; it is still running.`) });
+		taskRecord.currentAttemptId = prompted.attemptId;
+		const report = prompted.report;
 		attempt = { status: applyReport(taskRecord, report), report };
 	} catch (error) {
 		const settled = await settleAttemptFailure(taskRecord, reportFile, {
@@ -224,19 +226,7 @@ export async function runHerdrSubagents(prompt: string, options: HerdrSubagentsO
 		}
 	} finally {
 		if (tabId && result?.status !== "blocked") {
-			try {
-				await cleanupRunTab({ herdr, tabId, runFile, runRecord, signal: options.signal, onError: options.onCleanupError, failureStatus: "failed" });
-			} catch (error) {
-				const cleanupError = error instanceof Error ? error.message : String(error);
-				if (result?.ok) {
-					const errorMessage = `Task completed but Herdr tab cleanup failed: ${cleanupError}`;
-					const completedAt = new Date().toISOString();
-					applyRunStatus(runRecord, "failed", { at: completedAt, error: errorMessage });
-					applyTaskStatus(taskRecord, "failed", { at: completedAt, error: errorMessage });
-					await Promise.all([writeJson(runFile, runRecord), writeJson(taskFile, taskRecord)]);
-					result = failure(cwd, startedAt, errorMessage, common());
-				}
-			}
+			await cleanupRunTab({ herdr, tabId, runFile, runRecord, signal: options.signal, onError: options.onCleanupError });
 		}
 	}
 

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

@@ -15,7 +15,6 @@ export async function cleanupRunTab(options: {
 	signal?: AbortSignal;
 	onError?: (message: string) => void;
 	onClosed?: (runRecord: RunRecord) => void | Promise<void>;
-	failureStatus?: "failed";
 	errorPrefix?: string;
 }): Promise<{ deferred: boolean }> {
 	const mergeLatest = async (update: (run: RunRecord) => void | Promise<void>, requirePending = false, clearPending = true) => {
@@ -34,14 +33,17 @@ export async function cleanupRunTab(options: {
 	const reportFailure = async (error: unknown, requirePending = false) => {
 		const detail = error instanceof Error ? error.message : String(error);
 		try {
-			await mergeLatest((latest) => Object.assign(latest, { cleanupPendingTabIds: [...new Set([...(latest.cleanupPendingTabIds ?? []), options.tabId])], cleanupError: detail, ...(options.failureStatus ? { status: options.failureStatus } : {}) }), requirePending, false);
+			await mergeLatest((latest) => Object.assign(latest, { cleanupPendingTabIds: [...new Set([...(latest.cleanupPendingTabIds ?? []), options.tabId])], cleanupError: detail }), requirePending, false);
 		} catch (persistError) {
 			options.onError?.(`${options.errorPrefix ?? "Herdr tab cleanup failed"}: ${detail}; could not persist cleanup state: ${persistError instanceof Error ? persistError.message : String(persistError)}`);
 			return;
 		}
 		options.onError?.(`${options.errorPrefix ?? "Herdr tab cleanup failed"}: ${detail}`);
 	};
-	const finishClosed = async (requirePending = false) => mergeLatest(async (latest) => options.onClosed?.(latest), requirePending);
+	const finishClosed = async (requirePending = false) => mergeLatest(async (latest) => {
+		await options.onClosed?.(latest);
+		if (!latest.cleanupPendingTabIds?.length) delete latest.cleanupError;
+	}, requirePending);
 	try {
 		if (options.signal?.aborted) {
 			await options.herdr.closeTab(options.tabId);
@@ -78,7 +80,7 @@ export async function cleanupRunTab(options: {
 			return { deferred: false };
 		}
 		await reportFailure(error);
-		throw error;
+		return { deferred: false };
 	}
 	return { deferred: false };
 }

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

@@ -216,7 +216,8 @@ async function executeBatch({ params, signal, onUpdate, ctx, dependencies, disco
 		});
 		const lines = [result.summary, ...result.tasks.map((task) => `- ${task.name}: ${task.status} — ${task.summary}`)];
 		if (result.documents.length) lines.push("", "Documents:", ...result.documents.map((document) => `- ${document.description}: ${document.path}`));
-		return { content: [{ type: "text", text: lines.join("\n") }], details: { ...result, prompts: tasks.map((task) => task.prompt) }, ...(result.ok ? {} : { isError: true }) };
+		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 } : {}) };
 	} catch (error) {
 		const text = error instanceof Error ? error.message : String(error);
 		const diagnostic = error as { recordDirectory?: string; runId?: string };
@@ -248,10 +249,11 @@ async function executeSingle({ params, signal, onUpdate, ctx, dependencies, disc
 		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: "failed", cleanupError: text } }),
+		onCleanupError: (text) => onUpdate?.({ content: [{ type: "text", text }], details: { status: "warning", cleanupError: text } }),
 		onUpdate: (partial) => onUpdate?.({ content: [{ type: "text", text: partial.summary }], details: details(partial) }),
 	});
-	return { content: [{ type: "text", text: summaryText(result) }], details: details(result), ...(result.ok ? {} : { isError: true }) };
+	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(

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

@@ -56,6 +56,14 @@ function fakeHerdr(mode = "completed") {
 	let maxActive = 0;
 	let taskRuns = 0;
 	const agents = new Map();
+	const writeAttemptReport = (directory, report) => {
+		const task = JSON.parse(readFileSync(join(directory, "task.json"), "utf8"));
+		const attemptId = task.currentAttemptId;
+		if (!attemptId) throw new Error("test task has no currentAttemptId");
+		const reports = join(directory, "reports");
+		mkdirSync(reports, { recursive: true });
+		writeFileSync(join(reports, `${attemptId}.json`), typeof report === "string" ? report : JSON.stringify({ attemptId, ...report }));
+	};
 	return {
 		calls,
 		get maxActive() { return maxActive; },
@@ -77,8 +85,33 @@ function fakeHerdr(mode = "completed") {
 			active += 1;
 			maxActive = Math.max(maxActive, active);
 			await new Promise((resolve) => setTimeout(resolve, request.prompt.includes("slow") ? 15 : 2));
+			if (mode === "delayed-report") {
+				const task = JSON.parse(readFileSync(join(directory, "task.json"), "utf8"));
+				const attempts = join(directory, "attempts");
+				mkdirSync(attempts, { recursive: true });
+				writeFileSync(join(attempts, `${task.currentAttemptId}.json`), JSON.stringify({ attemptId: task.currentAttemptId, state: "working" }));
+				setTimeout(() => writeAttemptReport(directory, { status: "completed", summary: "Retry eventually completed.", documents: [] }), 25);
+				active -= 1;
+				return { status: "idle" };
+			}
+			if (mode === "working-state-crash") {
+				const task = JSON.parse(readFileSync(join(directory, "task.json"), "utf8"));
+				const attempts = join(directory, "attempts");
+				mkdirSync(attempts, { recursive: true });
+				writeFileSync(join(attempts, `${task.currentAttemptId}.json`), JSON.stringify({ attemptId: task.currentAttemptId, state: "working" }));
+				active -= 1;
+				throw new Error("child process exited");
+			}
+			if (mode === "working-state-dead-return") {
+				const task = JSON.parse(readFileSync(join(directory, "task.json"), "utf8"));
+				const attempts = join(directory, "attempts");
+				mkdirSync(attempts, { recursive: true });
+				writeFileSync(join(attempts, `${task.currentAttemptId}.json`), JSON.stringify({ attemptId: task.currentAttemptId, state: "working" }));
+				active -= 1;
+				return { status: "idle" };
+			}
 			if (mode === "report-then-post-fail") {
-				writeFileSync(join(directory, "report.json"), JSON.stringify({ status: "completed", summary: "Authoritative report completed before transport failed.", documents: [] }));
+				writeAttemptReport(directory, { status: "completed", summary: "Authoritative report completed before transport failed.", documents: [] });
 				active -= 1;
 				throw new Error("connection lost after authoritative report");
 			}
@@ -87,28 +120,28 @@ function fakeHerdr(mode = "completed") {
 			if (mode === "completed" || mode === "close-failed") {
 				const failed = request.prompt.includes("FAIL");
 				writeFileSync(join(directory, "result.md"), request.prompt.startsWith("Review") ? "FULL RESULT THAT STAYS OUT OF PARENT CONTEXT" : `FULL ${request.prompt}`);
-				writeFileSync(join(directory, "report.json"), JSON.stringify({
+				writeAttemptReport(directory, {
 					status: failed ? "failed" : "completed",
 					summary: request.prompt.startsWith("Review") ? "Authentication review completed." : failed ? `${request.prompt} failed.` : `${request.prompt} completed.`,
 					...(failed ? { error: "expected failure" } : {}),
 					documents: [{ path: join(directory, "result.md"), description: "Full result" }],
-				}));
+				});
 			} else if (mode === "failed") {
 				writeFileSync(join(directory, "result.md"), "Provider stopped before completing the review.");
-				writeFileSync(join(directory, "report.json"), JSON.stringify({
+				writeAttemptReport(directory, {
 					status: "failed",
 					summary: "Authentication review failed.",
 					error: "provider unavailable",
 					documents: [],
-				}));
+				});
 			} else if (mode === "malformed") {
-				writeFileSync(join(directory, "report.json"), "{truncated");
+				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 failed = request.prompt.includes("FAIL");
 				const question = taskRuns === 3 ? "Which environment should I inspect?" : "Which branch should I inspect?";
 				writeFileSync(join(directory, "result.md"), `FULL ${request.prompt}`);
-				writeFileSync(join(directory, "report.json"), JSON.stringify({ 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: [] }));
+				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: [] });
 			}
 			active -= 1;
 			return { status: mode === "failed" ? "done" : "idle" };
@@ -124,7 +157,7 @@ function fakeHerdr(mode = "completed") {
 		async isTabFocused(tabId) { calls.push(["isTabFocused", { tabId }]); return mode === "focused"; },
 		async waitForTabUnfocused(tabId) { calls.push(["waitForTabUnfocused", { tabId }]); },
 		async paneExists(paneId) { calls.push(["paneExists", { paneId }]); return mode !== "missing-pane"; },
-		async isTaskRunning(paneId) { calls.push(["isTaskRunning", { paneId }]); return mode !== "missing-pane" && mode !== "shell-only"; },
+		async isTaskRunning(paneId) { calls.push(["isTaskRunning", { paneId }]); return mode !== "missing-pane" && mode !== "shell-only" && mode !== "working-state-crash" && mode !== "working-state-dead-return"; },
 		async closeTab(tabId) {
 			calls.push(["closeTab", { tabId }]);
 			if (mode === "close-failed") throw new Error("tab still busy");
@@ -308,6 +341,7 @@ try {
 	let unknownStatusRejected = false;
 	try { aggregateTaskStatus(["unknown"]); } catch { unknownStatusRejected = true; }
 	check("task status aggregation rejects unknown states", unknownStatusRejected);
+	check("mixed failed and cancelled tasks remain partial", aggregateTaskStatus(["failed", "cancelled"]) === "partial" && aggregateTaskStatus(["failed", "failed"]) === "failed" && aggregateTaskStatus(["cancelled", "cancelled"]) === "cancelled");
 	check("all execution paths share abort classification", isAbortError(Object.assign(new Error("stopped"), { name: "AbortError" })) && isAbortError(new Error("operation aborted")) && !isAbortError(new Error("provider unavailable")));
 	check("respond releases ownership only for explicit terminal statuses", ["completed", "partial", "failed", "cancelled"].every(isSettledRunStatus) && !isSettledRunStatus("blocked") && !isSettledRunStatus(undefined));
 
@@ -322,11 +356,13 @@ try {
 	const childEvents = new Map();
 	const childExecCalls = [];
 	const childStatuses = [];
+	let childReportTool;
 	registerSubagentReport({
-		registerTool() {},
+		registerTool(definition) { childReportTool = definition; },
 		registerCommand(name, options) { childCommands.set(name, options); },
 		registerShortcut(key, options) { childShortcuts.set(key, options); },
 		on(name, handler) { childEvents.set(name, handler); },
+		events: { on() {} },
 		async exec(command, args) { childExecCalls.push([command, args]); return { stdout: "", stderr: "", code: 0, killed: false }; },
 	});
 	process.env.PI_HERDR_SUBAGENTS_PARENT_PANE_ID = "w1:p-parent";
@@ -335,6 +371,23 @@ try {
 	await childCommands.get("parent")?.handler("", childContext);
 	await childShortcuts.get("alt+p")?.handler(childContext);
 	check("child command and shortcut return to the exact parent Agent pane", childExecCalls.length === 2 && childExecCalls.every(([command, args]) => command === "herdr" && args.join(",") === "agent,focus,w1:p-parent") && childStatuses.some(([, value]) => value.includes("alt+p")));
+	const reportToolDirectory = join(root, "child-report-tool");
+	const reportAttemptId = "11111111-1111-4111-8111-111111111111";
+	mkdirSync(reportToolDirectory, { recursive: true });
+	writeFileSync(join(reportToolDirectory, "task.json"), JSON.stringify({ id: "report-task", runId: "report-run", order: 1, status: "running", currentAttemptId: reportAttemptId }));
+	process.env.PI_HERDR_SUBAGENTS_TASK_DIR = reportToolDirectory;
+	await childEvents.get("before_agent_start")?.({}, childContext);
+	await childReportTool.execute("report", { status: "completed", summary: "Attempt completed.", result: "Full attempt result.", documents: [] });
+	const scopedReport = JSON.parse(readFileSync(join(reportToolDirectory, "reports", `${reportAttemptId}.json`), "utf8"));
+	check("child report commits only to its captured attempt identity", scopedReport.attemptId === reportAttemptId && scopedReport.status === "completed" && !existsSync(join(reportToolDirectory, "report.json")) && JSON.parse(readFileSync(join(reportToolDirectory, "attempts", `${reportAttemptId}.json`), "utf8")).state === "working");
+	const firstAttemptResult = scopedReport.documents[0].path;
+	const nextReportAttemptId = "33333333-3333-4333-8333-333333333333";
+	writeFileSync(join(reportToolDirectory, "task.json"), JSON.stringify({ id: "report-task", runId: "report-run", order: 1, status: "running", currentAttemptId: nextReportAttemptId }));
+	await childEvents.get("before_agent_start")?.({}, childContext);
+	await childReportTool.execute("report", { status: "completed", summary: "New attempt completed.", result: "New full result.", documents: [] });
+	const nextScopedReport = JSON.parse(readFileSync(join(reportToolDirectory, "reports", `${nextReportAttemptId}.json`), "utf8"));
+	check("full results are isolated by attempt identity", nextScopedReport.documents[0].path !== firstAttemptResult && readFileSync(firstAttemptResult, "utf8") === "Full attempt result." && readFileSync(nextScopedReport.documents[0].path, "utf8") === "New full result.");
+	delete process.env.PI_HERDR_SUBAGENTS_TASK_DIR;
 	const herdr = fakeHerdr();
 	const success = await runHerdrSubagents("Review authentication", {
 		cwd: root,
@@ -381,6 +434,12 @@ try {
 	const silentHerdr = fakeHerdr("silent");
 	const silent = await runHerdrSubagents("Forget report", { cwd: root, herdr: silentHerdr });
 	check("missing report is visible failure", !silent.ok && silent.errorMessage?.includes("did not submit") && silentHerdr.calls.at(-1)[0] === "closeTab");
+	const delayedReport = await runHerdrSubagents("Retry after a transient provider error", { cwd: root, herdr: fakeHerdr("delayed-report") });
+	check("authoritative lifecycle waits for a report after a false screen-settled state", delayedReport.ok && delayedReport.status === "completed" && delayedReport.summary === "Retry eventually completed.");
+	const crashedAttempt = await runHerdrSubagents("Crash after reporting working", { cwd: root, herdr: fakeHerdr("working-state-crash") });
+	check("a dead child cannot leave an authoritative working attempt waiting forever", !crashedAttempt.ok && crashedAttempt.errorMessage?.includes("child process exited"));
+	const deadWorkingReturn = await runHerdrSubagents("Return idle then exit", { cwd: root, herdr: fakeHerdr("working-state-dead-return") });
+	check("a normal wait return cannot leave a dead working attempt waiting forever", !deadWorkingReturn.ok && deadWorkingReturn.errorMessage?.includes("Child Pi stopped while"));
 	const malformedExecutionHerdr = fakeHerdr("malformed");
 	const malformedExecution = await runHerdrSubagents("Write malformed report", { cwd: root, herdr: malformedExecutionHerdr });
 	const malformedExecutionTaskDirectory = malformedExecution.recordDirectory;
@@ -396,7 +455,7 @@ try {
 	const cleanupRunRecord = JSON.parse(readFileSync(join(cleanupRunDirectory, "run.json"), "utf8"));
 	const cleanupTaskDirectory = join(cleanupRunDirectory, "tasks", readdirSync(join(cleanupRunDirectory, "tasks"))[0]);
 	const cleanupTaskRecord = JSON.parse(readFileSync(join(cleanupTaskDirectory, "task.json"), "utf8"));
-	check("tab cleanup failure settles records as failed", !cleanupFailure.ok && cleanupFailure.errorMessage?.includes("cleanup failed") && cleanupRunRecord.status === "failed" && cleanupTaskRecord.status === "failed");
+	check("tab cleanup failure preserves completed business records", cleanupFailure.ok && cleanupRunRecord.status === "completed" && cleanupTaskRecord.status === "completed" && cleanupRunRecord.cleanupError.includes("tab still busy"));
 
 	const definition = parseAgentMarkdown(`---\nname: reviewer\ndescription: Review code\nmodel: fake/model\ntools: read, grep\n---\nReview carefully.`, "reviewer.md");
 	check("persona frontmatter parsing", definition.name === "reviewer" && definition.model === "fake/model" && definition.tools?.join(",") === "read,grep" && definition.systemPrompt === "Review carefully.");
@@ -474,16 +533,25 @@ 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 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);
+	const mixedCancelController = new AbortController();
+	const mixedCancelPromise = executeHerdrSubagents({ concurrency: 2, tasks: [{ name: "fail-first", prompt: "FAIL", agent: "explorer" }, { name: "cancel-second", prompt: "WAIT", agent: "reviewer" }] }, mixedCancelController.signal, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: mixedCancelHerdr });
+	await new Promise((resolve) => setTimeout(resolve, 10));
+	mixedCancelController.abort(new Error("Parent Pi session closed."));
+	const mixedCancel = await mixedCancelPromise;
+	check("failed and cancelled production tasks aggregate to partial", mixedCancel.details.status === "partial" && mixedCancel.details.tasks.some((task) => task.status === "failed") && mixedCancel.details.tasks.some((task) => task.status === "cancelled"));
 	const batchCleanupHerdr = fakeHerdr("close-failed");
 	const batchCleanupUpdates = [];
 	const batchCleanup = await executeHerdrSubagents({ tasks: [{ name: "cleanup", prompt: "cleanup", agent: "explorer" }] }, undefined, (update) => batchCleanupUpdates.push(update), { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: batchCleanupHerdr });
 	const batchCleanupRecord = JSON.parse(readFileSync(join(batchCleanup.details.recordDirectory, "run.json"), "utf8"));
-	check("batch cleanup failure is persisted and surfaced once", batchCleanup.isError && batchCleanup.content[0].text.includes("cleanup failed") && batchCleanupRecord.status === "failed" && batchCleanupRecord.cleanupError.includes("tab still busy") && batchCleanupUpdates.filter((update) => update.content[0]?.text.includes("cleanup failed")).length === 1);
+	check("batch cleanup failure is persisted without changing the business result", !batchCleanup.isError && batchCleanupRecord.status === "completed" && batchCleanupRecord.cleanupError.includes("tab still busy") && batchCleanupUpdates.filter((update) => update.content[0]?.text.includes("cleanup failed")).length === 1);
 	const cleanupProbeHerdr = fakeHerdr();
 	cleanupProbeHerdr.isTabFocused = async () => { throw new Error("tab lookup failed"); };
 	const cleanupProbe = await executeHerdrSubagents({ tasks: [{ name: "cleanup-probe", prompt: "cleanup probe", agent: "explorer" }] }, undefined, undefined, { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: cleanupProbeHerdr });
 	const cleanupProbeRecord = JSON.parse(readFileSync(join(cleanupProbe.details.recordDirectory, "run.json"), "utf8"));
-	check("cleanup focus-probe failure is persisted and surfaced", cleanupProbe.isError && cleanupProbe.content[0].text.includes("tab lookup failed") && cleanupProbeRecord.status === "failed" && cleanupProbeRecord.cleanupError === "tab lookup failed");
+	check("cleanup focus-probe failure is persisted without changing the business result", !cleanupProbe.isError && cleanupProbeRecord.status === "completed" && cleanupProbeRecord.cleanupError === "tab lookup failed");
 	const missingTabHerdr = fakeHerdr();
 	missingTabHerdr.isTabFocused = async () => { throw new Error('{"error":{"code":"tab_not_found","message":"tab w1:t2 not found"}}'); };
 	const missingTabCleanup = await executeHerdrSubagents({ tasks: [{ name: "already-closed", prompt: "already closed", agent: "explorer" }] }, undefined, undefined, { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: missingTabHerdr });
@@ -549,7 +617,7 @@ try {
 	const deferredSingle = await executeHerdrSubagents({ prompt: "single deferred cleanup", agent: "explorer" }, undefined, (update) => deferredSingleUpdates.push(update), { cwd: root, model: { provider: "fake", id: "model" } }, { agentsDirectory: join(process.cwd(), "agents"), herdr: deferredSingleHerdr });
 	await new Promise((resolve) => setTimeout(resolve, 10));
 	const deferredSingleRun = JSON.parse(readFileSync(join(deferredSingle.details.recordDirectory, "..", "..", "run.json"), "utf8"));
-	check("deferred single-task cleanup failure is persisted and surfaced", deferredSingleRun.status === "failed" && deferredSingleRun.cleanupError === "single deferred close failed" && deferredSingleUpdates.some((update) => update.content[0].text.includes("cleanup failed")));
+	check("deferred single-task cleanup failure is persisted and surfaced without changing completion", deferredSingleRun.status === "completed" && deferredSingleRun.cleanupError === "single deferred close failed" && deferredSingleUpdates.some((update) => update.content[0].text.includes("cleanup failed") && update.details.status === "warning"));
 	const cancelledHerdr = fakeHerdr();
 	cancelledHerdr.isTabFocused = async (tabId) => { cancelledHerdr.calls.push(["isTabFocused", { tabId }]); return true; };
 	cancelledHerdr.waitForTabUnfocused = async () => { throw new Error("shutdown cleanup must not wait for focus"); };
@@ -667,11 +735,21 @@ 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 and preserves tab", blocked.details.status === "blocked" && blocked.details.tasks[0].question === "Which branch should I inspect?" && !blockedHerdr.calls.some(([name]) => name === "closeTab"));
+	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("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));
+	mkdirSync(join(blocked.details.recordDirectory, ".respond.lock"));
+	const concurrentResponse = await executeHerdrSubagents({ action: "respond", runId: blocked.details.runId, answer: "duplicate" }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: blockedHerdr });
+	rmSync(join(blocked.details.recordDirectory, ".respond.lock"), { recursive: true });
+	check("concurrent blocked responses are rejected before a second prompt", concurrentResponse.isError && concurrentResponse.content[0].text.includes("already has a blocked response in progress"));
+	const staleLockHerdr = fakeHerdr("blocked");
+	const staleLockBlocked = await executeHerdrSubagents({ tasks: [{ name: "stale-lock-question", prompt: "question", agent: "explorer" }] }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: staleLockHerdr });
+	writeFileSync(join(staleLockBlocked.details.recordDirectory, ".respond.lock"), JSON.stringify({ processId: 99999999, createdAt: "2000-01-01T00:00:00.000Z" }));
+	const diagnosedStaleResponse = await executeHerdrSubagents({ action: "respond", runId: staleLockBlocked.details.runId, answer: "Inspect main." }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: staleLockHerdr });
+	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 blockedStarts = blockedHerdr.calls.filter(([name]) => name === "startAgent").map(([, request]) => request);
@@ -714,7 +792,7 @@ try {
 	const cancelledContinuationTask = JSON.parse(readFileSync(join(abortedTaskDirectories[1], "task.json"), "utf8"));
 	const cancelledContinuationRun = JSON.parse(readFileSync(join(abortedContinuationRun.details.recordDirectory, "run.json"), "utf8"));
 	const cancelledContinuationReport = JSON.parse(readFileSync(join(abortedTaskDirectories[1], "report.json"), "utf8"));
-	check("aborted queued continuation is persisted as cancelled", cancelledContinuationTask.status === "cancelled" && cancelledContinuationRun.status === "cancelled" && cancelledContinuationReport.summary.includes("cancelled"));
+	check("aborted queued continuation preserves a partial completed/cancelled run", cancelledContinuationTask.status === "cancelled" && cancelledContinuationRun.status === "partial" && cancelledContinuationReport.summary.includes("cancelled"));
 	const deadPaneHerdr = fakeHerdr("blocked");
 	const deadPaneRun = await executeHerdrSubagents({ tasks: [{ name: "dead-pane", prompt: "question", agent: "explorer" }] }, undefined, undefined, { cwd: root }, { agentsDirectory: join(process.cwd(), "agents"), herdr: deadPaneHerdr });
 	deadPaneHerdr.paneExists = async () => false;
@@ -980,6 +1058,27 @@ try {
 	writeFileSync(join(recoveryTask, "task.json"), JSON.stringify({ id: "task", runId: "recover", order: 1, name: "lost", status: "running", paneId: "w1:missing", sessionFile: join(recoveryTask, "session.jsonl") }));
 	const reconciliation = await reconcileSubagentRuns(recoveryRoot, fakeHerdr("missing-pane"), { sessionId: "new-owner" });
 	check("reconciliation marks stale child cancelled", reconciliation.cancelledTasks === 1 && JSON.parse(readFileSync(join(recoveryTask, "task.json"), "utf8")).status === "cancelled");
+	const isolatedAttemptRoot = join(root, "isolated-attempt-recovery");
+	const isolatedAttemptRun = join(isolatedAttemptRoot, ".pi", "herdr-subagents", "runs", "run");
+	const isolatedAttemptTask = join(isolatedAttemptRun, "tasks", "01-task");
+	mkdirSync(isolatedAttemptTask, { recursive: true });
+	const currentAttemptId = "22222222-2222-4222-8222-222222222222";
+	writeFileSync(join(isolatedAttemptRun, "run.json"), JSON.stringify({ id: "isolated-attempt", label: "isolated-attempt", status: "running", startedAt: new Date().toISOString() }));
+	writeFileSync(join(isolatedAttemptTask, "task.json"), JSON.stringify({ id: "isolated-attempt-task", runId: "isolated-attempt", order: 1, status: "running", paneId: "w1:p-live", currentAttemptId, sessionFile: join(isolatedAttemptTask, "session.jsonl") }));
+	writeFileSync(join(isolatedAttemptTask, "report.json"), JSON.stringify({ attemptId: "11111111-1111-4111-8111-111111111111", status: "needs-input", summary: "Prior attempt blocked.", question: "Old question?", documents: [] }));
+	const isolatedReconciliation = await reconcileSubagentRuns(isolatedAttemptRoot, fakeHerdr());
+	const isolatedTaskRecord = JSON.parse(readFileSync(join(isolatedAttemptTask, "task.json"), "utf8"));
+	check("reconciliation ignores a prior canonical report while the current attempt is live", isolatedReconciliation.liveTasks === 1 && isolatedTaskRecord.status === "running" && isolatedTaskRecord.currentAttemptId === currentAttemptId && JSON.parse(readFileSync(join(isolatedAttemptTask, "report.json"), "utf8")).summary === "Prior attempt blocked.");
+	const ownerLossRoot = join(root, "owner-loss-report-recovery");
+	const ownerLossRun = join(ownerLossRoot, ".pi", "herdr-subagents", "runs", "run");
+	const ownerLossTask = join(ownerLossRun, "tasks", "01-task");
+	const ownerLossAttempt = "44444444-4444-4444-8444-444444444444";
+	mkdirSync(join(ownerLossTask, "reports"), { recursive: true });
+	writeFileSync(join(ownerLossRun, "run.json"), JSON.stringify({ id: "owner-loss", label: "owner-loss", status: "running", ownerSessionId: "dead-owner", ownerProcessId: 99999999, tabId: "w1:t-owner-loss", startedAt: new Date().toISOString() }));
+	writeFileSync(join(ownerLossTask, "task.json"), JSON.stringify({ id: "owner-loss-task", runId: "owner-loss", order: 1, status: "running", paneId: "w1:p-owner-loss", currentAttemptId: ownerLossAttempt, sessionFile: join(ownerLossTask, "session.jsonl") }));
+	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 malformedRoot = join(root, "malformed-recovery");
 	const malformedRun = join(malformedRoot, ".pi", "herdr-subagents", "runs", "run");
 	const malformedTask = join(malformedRun, "tasks", "01-task");
@@ -989,7 +1088,7 @@ try {
 	writeFileSync(join(malformedTask, "report.json"), "{truncated");
 	const malformedHerdr = fakeHerdr();
 	const malformedReconciliation = await reconcileSubagentRuns(malformedRoot, malformedHerdr, { sessionId: "new-owner", processId: process.pid });
-	check("malformed report cannot abort orphan reconciliation", malformedReconciliation.cancelledTasks === 1 && malformedReconciliation.cleanupErrors.some((message) => message.includes("Invalid Subagent report")) && JSON.parse(readFileSync(join(malformedTask, "task.json"), "utf8")).status === "cancelled" && malformedHerdr.calls.some(([name]) => name === "closeTab"));
+	check("malformed report cannot abort orphan reconciliation", malformedReconciliation.settledTasks === 1 && malformedReconciliation.cleanupErrors.some((message) => message.includes("Invalid Subagent report")) && JSON.parse(readFileSync(join(malformedTask, "task.json"), "utf8")).status === "failed" && malformedHerdr.calls.some(([name]) => name === "closeTab"));
 	const invalidReportRoot = join(root, "invalid-report-recovery");
 	const invalidReportRun = join(invalidReportRoot, ".pi", "herdr-subagents", "runs", "run");
 	const invalidReportTask = join(invalidReportRun, "tasks", "01-task");

package/skills/tapd/references/attachment-download.md

@@ -22,6 +22,8 @@ URL="$(
 设置来自附件列表的目标文件名，并完整执行下载命令：
 
 ```bash
+set -euo pipefail
+
 OUTPUT='<附件文件名>'
 PART="${OUTPUT}.part"
 if [ -e "$OUTPUT" ] || [ -e "$PART" ]; then
@@ -43,4 +45,4 @@ test -s "$PART"
 5. 按格式做完整性检查：ZIP 使用 `unzip -t "$PART"`，图片使用环境可用的格式识别/解码能力，其他格式使用对应检查。
 6. 全部检查通过后执行 `mv -- "$PART" "$OUTPUT"`。目标文件或 `.part` 已存在时必须在下载前失败，避免把旧文件误认为本次结果；任何检查失败都不得创建最终文件。
 
-本流程不续传失败的 `.part`；始终用新 URL 从头下载。临时 URL 过期仅表示需要重新获取链接，不能据此判断 TAPD 原附件损坏。
+本流程不续传失败的 `.part`。附件大小未知或大于 50 MB 时，工具超时至少设为 600 秒；timeout 仅表示本地执行被终止。删除残留 `.part`，重新获取临时 URL 后从头下载；临时 URL 过期不能说明原附件损坏。