@selesai/code 0.9.10 → 0.9.12

package/dist/extensions/pi-subagents/src/runs/foreground/workflow-detach-reconcile.ts

@@ -0,0 +1,274 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { getSingleResultOutput, readStatus } from "../../shared/utils.ts";
+import {
+	DIRS,
+	SUBAGENT_ASYNC_COMPLETE_EVENT,
+	type AsyncStatus,
+	type IntercomEventBus,
+	type SingleResult,
+	type SubagentState,
+} from "../../shared/types.ts";
+import { updateActiveRunIndex } from "../background/active-run-index.ts";
+import { resultFilePath, writeAsyncResultFile } from "../background/result-files.ts";
+import { resolveAsyncResumeTarget } from "../background/async-resume.ts";
+import { readWorkflowReceipt, workflowReceiptPath, writeWorkflowReceipt, type WorkflowReceipt } from "../../workflows/workflow-receipt.ts";
+
+function cloneWorkflowStatus(status: AsyncStatus): AsyncStatus {
+	return {
+		...status,
+		steps: status.steps?.map((step) => ({ ...step })),
+		workflow: status.workflow ? { ...status.workflow, trace: [...(status.workflow.trace ?? [])] } : status.workflow,
+	};
+}
+
+function childSucceeded(result: Pick<SingleResult, "exitCode" | "error" | "interrupted">): boolean {
+	return result.exitCode === 0 && !result.error && !result.interrupted;
+}
+
+const UNSUPPORTED_DETACHED_WORKFLOW_CONTINUATION = "unsupported-continuation: detached workflow child settled, but JavaScript workflow continuation was not persisted. Resume the workflow explicitly instead of treating the completed child as top-level workflow completion.";
+const INTERRUPTED_DETACHED_CHILD = "Interrupted. Waiting for explicit next action.";
+
+export function applyDetachedChildToPausedWorkflow(
+	status: AsyncStatus,
+	input: { childRunId: string; result: Pick<SingleResult, "exitCode" | "error" | "interrupted" | "sessionFile">; workflowKey?: string },
+): AsyncStatus | undefined {
+	if (status.mode !== "workflow" || status.state !== "paused") return undefined;
+	const next = cloneWorkflowStatus(status);
+	const step = next.steps?.find((candidate) => candidate.runId === input.childRunId)
+		?? (input.workflowKey ? next.steps?.find((candidate) => candidate.workflowKey === input.workflowKey) : undefined);
+	if (!step) return undefined;
+	const succeeded = childSucceeded(input.result);
+	const failedSiblingError = next.steps?.find((candidate) => candidate !== step && candidate.status === "failed" && candidate.error)?.error;
+	const updatedAt = Date.now();
+	step.status = succeeded ? "completed" : "failed";
+	step.endedAt = updatedAt;
+	delete step.activityState;
+	delete step.currentTool;
+	delete step.currentToolStartedAt;
+	if (input.result.sessionFile) step.sessionFile = input.result.sessionFile;
+	if (succeeded) delete step.error;
+	else if (input.result.interrupted) step.error = input.result.error ?? INTERRUPTED_DETACHED_CHILD;
+	else if (input.result.error) step.error = input.result.error;
+	next.lastUpdate = updatedAt;
+	const promoted = promotePausedWorkflowIfSettled(next);
+	if (promoted?.state === "failed" && input.result.interrupted && !failedSiblingError) promoted.error = input.result.error ?? INTERRUPTED_DETACHED_CHILD;
+	else if (promoted?.state === "failed" && input.result.error) promoted.error = input.result.error;
+	return promoted ?? next;
+}
+
+export function promotePausedWorkflowIfSettled(status: AsyncStatus): AsyncStatus | undefined {
+	if (status.mode !== "workflow" || status.state !== "paused") return undefined;
+	const next = cloneWorkflowStatus(status);
+	const stillOpen = next.steps?.some((candidate) =>
+		candidate.status === "running"
+		|| (candidate.status === "paused" && candidate.activityState === "needs_attention")
+	) === true;
+	if (stillOpen || !next.steps?.length) return undefined;
+	const failed = next.steps.some((candidate) => candidate.status === "failed");
+	const updatedAt = Date.now();
+	next.lastUpdate = updatedAt;
+	next.state = "failed";
+	next.endedAt = updatedAt;
+	delete next.activityState;
+	if (failed) return next;
+	next.error = UNSUPPORTED_DETACHED_WORKFLOW_CONTINUATION;
+	return next;
+}
+
+function workflowResultChildren(status: AsyncStatus, childRunId: string, result: SingleResult, existingResults: unknown): unknown {
+	const output = getSingleResultOutput(result);
+	if (Array.isArray(existingResults)) {
+		return existingResults.map((entry) => {
+			if (!entry || typeof entry !== "object" || Array.isArray(entry)) return entry;
+			const child = entry as Record<string, unknown>;
+			if (child.runId !== childRunId) return child;
+			return {
+				...child,
+				success: childSucceeded(result),
+				output,
+				outputState: output.trim() ? "present" : "absent",
+				detached: undefined,
+				...(result.interrupted ? { interrupted: true } : {}),
+				...(result.error ? { error: result.error } : {}),
+			};
+		});
+	}
+	return status.steps?.map((step) => ({
+		workflowKey: step.workflowKey,
+		agent: step.agent,
+		runId: step.runId,
+		success: step.status === "completed" || step.status === "complete",
+		output: step.runId === childRunId ? output : "",
+		outputState: step.runId === childRunId && output.trim() ? "present" : "absent",
+		...(step.runId === childRunId && result.interrupted ? { interrupted: true } : {}),
+		...(step.error ? { error: step.error } : {}),
+	}));
+}
+
+function publishedWorkflowResult(status: AsyncStatus, childRunId: string, result: SingleResult, asyncDir: string, existing?: Record<string, unknown>, receipt?: WorkflowReceipt): Record<string, unknown> {
+	const sessionId = status.sessionId ?? (typeof existing?.sessionId === "string" ? existing.sessionId : undefined);
+	const summary = status.state === "complete"
+		? `Workflow completed after detached child ${childRunId} finished.`
+		: status.error ?? (typeof existing?.summary === "string" ? existing.summary : undefined);
+	return {
+		...(existing ?? {}),
+		id: status.runId,
+		runId: status.runId,
+		toolCallId: status.toolCallId,
+		agent: "workflow",
+		mode: "workflow",
+		success: status.state === "complete",
+		state: status.state,
+		summary,
+		error: status.error,
+		activityState: status.activityState,
+		endedAt: status.endedAt,
+		timestamp: Date.now(),
+		results: workflowResultChildren(status, childRunId, result, existing?.results),
+		workflow: status.workflow,
+		reconciledFromDetachedChild: childRunId,
+		...(receipt ? { workflowReceipt: { path: path.join(asyncDir, "workflow-receipt.json"), receipt } } : {}),
+		asyncDir,
+		cwd: status.cwd,
+		sessionId,
+		completionOwnerId: status.completionOwnerId,
+	};
+}
+
+function reconcileWorkflowReceipt(status: AsyncStatus, childRunId: string, result: SingleResult, asyncDir: string): WorkflowReceipt | undefined {
+	const receiptPath = workflowReceiptPath(DIRS.async, status.runId);
+	if (!fs.existsSync(receiptPath)) return undefined;
+	const receipt = readWorkflowReceipt(DIRS.async, status.runId);
+	const step = status.steps?.find((candidate) => candidate.runId === childRunId);
+	const key = step?.workflowKey;
+	if (!key) throw new Error(`Workflow receipt '${status.runId}' cannot identify detached child '${childRunId}' by stable key.`);
+	const entry = receipt.entries[key];
+	if (!entry) throw new Error(`Workflow receipt '${status.runId}' has no detached child key '${key}'.`);
+	let resumability: typeof entry.resumability;
+	try {
+		const target = resolveAsyncResumeTarget({ id: childRunId, dir: path.join(DIRS.async, childRunId) }, {}, { requireSessionFile: true, sessionId: status.sessionId });
+		resumability = target.kind === "revive" ? { state: "resumable" } : { state: "not-resumable", reason: "child is still running" };
+	} catch (error) {
+		resumability = { state: "not-resumable", reason: error instanceof Error ? error.message : String(error) };
+	}
+	const outputReference = result.savedOutputPath ?? result.outputReference?.path ?? entry.outputReference;
+	const updatedEntry: WorkflowReceipt["entries"][string] = resumability.state === "resumable"
+		? {
+			...entry,
+			...(step.agent ? { agent: step.agent } : {}),
+			...(step.context ? { resolvedContext: step.context } : {}),
+			latestRunId: entry.latestRunId ?? childRunId,
+			resumability,
+			...(outputReference ? { outputReference } : {}),
+		}
+		: {
+			...entry,
+			...(step.agent ? { agent: step.agent } : {}),
+			...(step.context ? { resolvedContext: step.context } : {}),
+			resumability,
+			...(outputReference ? { outputReference } : {}),
+		};
+	const next: WorkflowReceipt = {
+		...receipt,
+		state: status.state === "complete" ? "complete" : status.state === "stopped" ? "stopped" : status.state === "paused" ? "paused" : "failed",
+		entries: {
+			...receipt.entries,
+			[key]: updatedEntry,
+		},
+	};
+	writeWorkflowReceipt(asyncDir, next);
+	return next;
+}
+
+function appendDetachedWorkflowEvent(asyncDir: string, event: Record<string, unknown>): void {
+	const eventsPath = path.join(asyncDir, "events.jsonl");
+	try {
+		fs.appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, "utf-8");
+	} catch (error) {
+		console.error(`Failed to append detached workflow event '${eventsPath}':`, error);
+	}
+}
+
+export function reconcileDetachedWorkflowChildCompletion(input: {
+	state: SubagentState;
+	workflowRunId: string;
+	childRunId: string;
+	result: SingleResult;
+	events?: IntercomEventBus;
+	workflowKey?: string;
+}): boolean {
+	const job = input.state.asyncJobs.get(input.workflowRunId);
+	const asyncDir = job?.asyncDir ?? path.join(DIRS.async, input.workflowRunId);
+	const status = readStatus(asyncDir);
+	if (!status) return false;
+	const next = applyDetachedChildToPausedWorkflow(status, {
+		childRunId: input.childRunId,
+		result: input.result,
+		workflowKey: input.workflowKey,
+	});
+	if (!next) return false;
+	writeAtomicJson(path.join(asyncDir, "status.json"), next);
+	updateActiveRunIndex(asyncDir, next.state, next.toolCallId);
+	if (job) {
+		job.status = next.state;
+		job.updatedAt = next.lastUpdate;
+		job.activityState = next.activityState;
+		job.steps = next.steps?.map((step, index) => ({ ...step, index }));
+		job.workflow = next.workflow;
+	}
+	const resultPath = resultFilePath(DIRS.results, input.workflowRunId);
+	let existing: Record<string, unknown> | undefined;
+	try {
+		const parsed: unknown = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) existing = parsed as Record<string, unknown>;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	let receipt: WorkflowReceipt | undefined;
+	let receiptError: string | undefined;
+	try {
+		receipt = reconcileWorkflowReceipt(next, input.childRunId, input.result, asyncDir);
+	} catch (error) {
+		receiptError = `Failed to reconcile async workflow receipt: ${error instanceof Error ? error.message : String(error)}`;
+	}
+	const published = publishedWorkflowResult(next, input.childRunId, input.result, asyncDir, existing, receipt);
+	writeAsyncResultFile(resultPath, published);
+	if (receiptError) {
+		appendDetachedWorkflowEvent(asyncDir, {
+			ts: Date.now(),
+			runId: input.workflowRunId,
+			type: "subagent.workflow.receipt_write_failed",
+			error: receiptError,
+			reconciledFromDetachedChild: input.childRunId,
+		});
+	}
+	if (next.state === "complete" || next.state === "failed") {
+		appendDetachedWorkflowEvent(asyncDir, {
+			ts: Date.now(),
+			runId: input.workflowRunId,
+			type: "subagent.workflow.completed",
+			state: next.state,
+			...(next.error ? { error: next.error } : {}),
+			reconciledFromDetachedChild: input.childRunId,
+		});
+		input.events?.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+			id: input.workflowRunId,
+			runId: input.workflowRunId,
+			source: "async",
+			mode: "workflow",
+			agent: "workflow",
+			success: next.state === "complete",
+			state: next.state,
+			summary: typeof published.summary === "string" ? published.summary : (next.state === "complete" ? "Workflow completed." : next.error),
+			reconciledFromDetachedChild: input.childRunId,
+			...(Array.isArray(published.results) ? { results: published.results } : {}),
+			sessionId: next.sessionId,
+			completionOwnerId: next.completionOwnerId,
+			timestamp: Date.now(),
+			triggerTurn: true,
+		});
+	}
+	return true;
+}

package/dist/extensions/pi-subagents/src/runs/foreground/workflow-foreground-steering.ts

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Details, ForegroundRunControl, SubagentState } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
+import { steeringReceipt } from "../background/steering.ts";
 import {
 	consumeSteerAckFromDir,
 	readSteerCapability,
@@ -146,18 +147,18 @@ export async function steerWorkflowForegroundTarget(input: {
 		targets: [target],
 	};
 	if (input.signal?.aborted) {
-		return { content: [{ type: "text", text: `Steering pending for foreground run ${control.runId} (request ${request.id}); caller aborted before acknowledgment.` }], details: { mode: "management", results: [], steering } };
+		return { content: [{ type: "text", text: steeringReceipt(request.message, `Steering pending for foreground run ${control.runId} (request ${request.id}); caller aborted before acknowledgment.`) }], details: { mode: "management", results: [], steering } };
 	}
 	if (ack?.state === "delivered") {
-		return { content: [{ type: "text", text: `Steering delivered for foreground run ${control.runId} (request ${request.id}).` }], details: { mode: "management", results: [], steering } };
+		return { content: [{ type: "text", text: steeringReceipt(request.message, `Steering delivered for foreground run ${control.runId} (request ${request.id}).`) }], details: { mode: "management", results: [], steering } };
 	}
 	if (ack?.state === "queued") {
-		return { content: [{ type: "text", text: `Steering queued for foreground run ${control.runId} (request ${request.id}).` }], details: { mode: "management", results: [], steering } };
+		return { content: [{ type: "text", text: steeringReceipt(request.message, `Steering queued for foreground run ${control.runId} (request ${request.id}).`) }], details: { mode: "management", results: [], steering } };
 	}
 	if (ack?.state === "failed") {
-		return { content: [{ type: "text", text: `Steering failed for foreground run ${control.runId} (request ${request.id}): ${ack.message}` }], isError: true, details: { mode: "management", results: [], steering } };
+		return { content: [{ type: "text", text: steeringReceipt(request.message, `Steering failed for foreground run ${control.runId} (request ${request.id}): ${ack.message}`) }], isError: true, details: { mode: "management", results: [], steering } };
 	}
-	return { content: [{ type: "text", text: `Steering pending for foreground run ${control.runId} (request ${request.id}); no acknowledgment was received.` }], details: { mode: "management", results: [], steering } };
+	return { content: [{ type: "text", text: steeringReceipt(request.message, `Steering pending for foreground run ${control.runId} (request ${request.id}); no acknowledgment was received.`) }], details: { mode: "management", results: [], steering } };
 }
 
 export function workflowForegroundSteeringDir(asyncDirRoot: string, workflowRunId: string, childRunId: string): string {

package/dist/extensions/pi-subagents/src/runs/shared/acceptance.ts

@@ -404,7 +404,7 @@ function acceptanceRequiresChildReport(acceptance: ResolvedAcceptanceConfig): bo
 	return acceptance.criteria.length > 0 || acceptance.evidence.length > 0;
 }
 
-export function formatAcceptancePrompt(acceptance: ResolvedAcceptanceConfig, options: { reportOptional?: boolean } = {}): string {
+export function formatAcceptancePrompt(acceptance: ResolvedAcceptanceConfig, options: { reportOptional?: boolean; structuredOutput?: boolean } = {}): string {
 	if (acceptance.level === "none") return "";
 	if (options.reportOptional && !acceptanceRequiresChildReport(acceptance)) return "";
 	const lines = [
@@ -431,13 +431,15 @@ export function formatAcceptancePrompt(acceptance: ResolvedAcceptanceConfig, opt
 	}
 	lines.push(
 		"",
-		"Finish with a fenced JSON block tagged `acceptance-report` in this shape:",
+		options.structuredOutput
+			? "Include an `acceptanceReport` object in your final `structured_output` tool call in this shape:"
+			: "Finish with a fenced JSON block tagged `acceptance-report` in this shape:",
 		"Use empty arrays when no items apply; array fields contain strings unless object entries are shown.",
 		"Empty-string entries (`[\"\"]`) are ignored; use `[]` when nothing applies.",
 		"`criteriaSatisfied[].status` must be exactly one of: satisfied, not-satisfied, not-applicable.",
 		"`commandsRun[].result` must be exactly one of: passed, failed, not-run.",
 		"`manualNotes` and `notes` are optional strings; an empty string means no note and does not satisfy `manual-notes` evidence.",
-		"```acceptance-report",
+		...(options.structuredOutput ? [] : ["```acceptance-report"]),
 		JSON.stringify({
 			criteriaSatisfied: acceptance.criteria
 				.filter((criterion) => criterion.severity !== "recommended")
@@ -452,7 +454,7 @@ export function formatAcceptancePrompt(acceptance: ResolvedAcceptanceConfig, opt
 			reviewFindings: ["blocker: file.ts:12 - issue found, or no blockers"],
 			manualNotes: "anything else the parent should know",
 		}, null, 2),
-		"```",
+		...(options.structuredOutput ? [] : ["```"]),
 	);
 	return lines.join("\n");
 }
@@ -946,7 +948,7 @@ function reportEvidenceStatus(report: AcceptanceReport, kind: AcceptanceEvidence
 }
 
 function checkNoStagedFiles(cwd: string): AcceptanceRuntimeCheck {
-	const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8" });
+	const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8", windowsHide: true });
 	if (result.status !== 0) {
 		return { id: "no-staged-files", status: "not-applicable", message: "git status unavailable; no staged-files check skipped" };
 	}
@@ -959,6 +961,7 @@ function checkNoStagedFiles(cwd: string): AcceptanceRuntimeCheck {
 function runStructuralChecks(acceptance: ResolvedAcceptanceConfig, report: AcceptanceReport, cwd: string): AcceptanceRuntimeCheck[] {
 	const checks: AcceptanceRuntimeCheck[] = [];
 	for (const kind of acceptance.evidence) {
+		if (kind === "no-staged-files" && report.noStagedFiles === undefined) continue;
 		const status = reportEvidenceStatus(report, kind);
 		checks.push({
 			id: `evidence:${kind}`,
@@ -1053,11 +1056,11 @@ interface VerifyWorkspaceState {
 }
 
 function readVerifyWorkspaceState(cwd: string): VerifyWorkspaceState | undefined {
-	const repo = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf-8" });
+	const repo = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf-8", windowsHide: true });
 	if (repo.status !== 0 || !repo.stdout.trim()) return undefined;
 	const repoRoot = fs.realpathSync(repo.stdout.trim());
-	const head = spawnSync("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf-8" });
-	const diff = spawnSync("git", ["diff", "--binary", "--full-index", "HEAD", "--"], { cwd: repoRoot, encoding: "utf-8", maxBuffer: 50 * 1024 * 1024 });
+	const head = spawnSync("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf-8", windowsHide: true });
+	const diff = spawnSync("git", ["diff", "--binary", "--full-index", "HEAD", "--"], { cwd: repoRoot, encoding: "utf-8", maxBuffer: 50 * 1024 * 1024, windowsHide: true });
 	if (head.status !== 0 || diff.status !== 0 || !head.stdout.trim()) return undefined;
 	return {
 		kind: "git-tracked",
@@ -1140,6 +1143,49 @@ async function runMemoizedVerifyCommand(command: AcceptanceVerifyCommand, defaul
 	return evidenced;
 }
 
+/**
+ * On Windows with `shell: true`, cmd.exe parses the command line itself and an
+ * unquoted executable path containing spaces (e.g. `C:\Program Files\...\tool.exe`)
+ * is split at the first space, so cmd tries to run `C:\Program` and fails.
+ *
+ * The command line is ambiguous, so only an unquoted absolute drive path with
+ * a space in a directory component is safe to identify as an executable. That
+ * path is quoted; everything after it is preserved as arguments.
+ *
+ * Commands that already start with a quote, single-token commands, and commands
+ * whose first token already ends in an executable extension are returned
+ * unchanged. Non-Windows platforms pass the command through untouched.
+ */
+export function quoteExecutableForShell(command: string, platform: string = process.platform): string {
+	if (platform !== "win32") return command;
+	const trimmed = command.trimStart();
+	if (trimmed.startsWith("\"")) return command;
+	const firstToken = trimmed.match(/^\S+/)?.[0];
+	if (/\.(?:exe|bat|cmd|com|ps1)$/i.test(firstToken ?? "")) return command;
+	const match = trimmed.match(/^([A-Za-z]:\\[^"<>|&*?\r\n]*?\s[^"<>|&*?\r\n]*?\\[^"<>|&*?\r\n]*?\.(?:exe|bat|cmd|com|ps1))(?=\s|$)/i);
+	const executable = match?.[1];
+	if (executable && /\s/.test(executable) && !/[A-Za-z]:\\/.test(executable.slice(3))) {
+		const rest = trimmed.slice(executable.length);
+		const leading = command.slice(0, command.length - trimmed.length);
+		return `${leading}"${executable}"${rest}`;
+	}
+	const extensionlessSpacedFilenameMatch = trimmed.match(/^([A-Za-z]:\\[^"<>|&*?\r\n]*?\s[^"<>|&*?\r\n]*?)(?=\s+--|$)/i);
+	const extensionlessSpacedFilename = extensionlessSpacedFilenameMatch?.[1];
+	if (extensionlessSpacedFilename && /\s/.test(extensionlessSpacedFilename.slice(0, extensionlessSpacedFilename.lastIndexOf("\\"))) && !/[A-Za-z]:\\/.test(extensionlessSpacedFilename.slice(3))) {
+		const rest = trimmed.slice(extensionlessSpacedFilename.length);
+		const leading = command.slice(0, command.length - trimmed.length);
+		return `${leading}"${extensionlessSpacedFilename}"${rest}`;
+	}
+	const extensionlessMatch = trimmed.match(/^([A-Za-z]:\\[^"<>|&*?\r\n]*?\s[^"<>|&*?\r\n]*?\\[^"<>|&*?\s\r\n]+)(?=\s|$)/i);
+	const extensionlessExecutable = extensionlessMatch?.[1];
+	if (extensionlessExecutable && /\s/.test(extensionlessExecutable) && !/[A-Za-z]:\\/.test(extensionlessExecutable.slice(3)) && !/\s/.test(extensionlessExecutable.slice(extensionlessExecutable.lastIndexOf("\\") + 1))) {
+		const rest = trimmed.slice(extensionlessExecutable.length);
+		const leading = command.slice(0, command.length - trimmed.length);
+		return `${leading}"${extensionlessExecutable}"${rest}`;
+	}
+	return command;
+}
+
 function runVerifyCommand(command: AcceptanceVerifyCommand, defaultCwd: string, options: { signal?: AbortSignal; abortMessage?: string } = {}): Promise<AcceptanceVerifyResult> {
 	return new Promise((resolve) => {
 		const startedAt = Date.now();
@@ -1149,7 +1195,7 @@ function runVerifyCommand(command: AcceptanceVerifyCommand, defaultCwd: string,
 		let timedOut = false;
 		let settled = false;
 		let hardKill: NodeJS.Timeout | undefined;
-		const child = spawn(command.command, {
+		const child = spawn(quoteExecutableForShell(command.command), {
 			cwd,
 			env: effectiveVerifyEnv(command.env),
 			shell: true,
@@ -1228,6 +1274,7 @@ export async function evaluateAcceptance(input: {
 	 */
 	fileOutput?: { content: string; path: string; authoritative?: boolean };
 	report?: AcceptanceReport;
+	reportError?: string;
 	reviewResult?: AcceptanceReviewResult;
 	signal?: AbortSignal;
 	abortMessage?: string;
@@ -1249,7 +1296,9 @@ export async function evaluateAcceptance(input: {
 	};
 	if (acceptance.level === "none") return ledger;
 
-	const parsed = input.report
+	const parsed = input.reportError
+		? { error: input.reportError }
+		: input.report
 		? (() => {
 			const validation = validateAcceptanceReport(input.report);
 			return validation.report

package/dist/extensions/pi-subagents/src/runs/shared/agent-contract.ts

@@ -12,7 +12,7 @@ export function buildExecutionProjection(result: Pick<SingleResult, "exitCode" |
 		return { status: "stopped", success: false, exitCode: result.exitCode, stopped: true, ...(result.error ? { error: result.error } : {}) };
 	}
 	if (result.interrupted) {
-		return { status: "paused", success: true, exitCode: result.exitCode, interrupted: true, ...(result.error ? { error: result.error } : {}) };
+		return { status: "paused", success: false, exitCode: result.exitCode, interrupted: true, ...(result.error ? { error: result.error } : {}) };
 	}
 	const success = result.exitCode === 0 && !result.error && !result.timedOut;
 	return {

package/dist/extensions/pi-subagents/src/runs/shared/chain-outputs.ts

@@ -1,4 +1,4 @@
-import { isCheckpointStep, isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
+import { isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
 import type { ChainOutputMap, ChainOutputMapEntry, SingleResult } from "../../shared/types.ts";
 import { getSingleResultOutput } from "../../shared/utils.ts";
 import { DynamicFanoutError, hasDynamicFanoutFields, type DynamicFanoutConfig, validateDynamicStepShape } from "./dynamic-fanout.ts";
@@ -14,7 +14,6 @@ export interface ChainOutputValidationContext {
 }
 
 function outputNamesForStep(step: ChainStep): string[] {
-	if (isCheckpointStep(step)) return [];
 	if (isParallelStep(step)) return step.parallel.map((task) => task.as).filter((name): name is string => Boolean(name));
 	if (isDynamicParallelStep(step)) return [step.collect.as];
 	const name = (step as SequentialStep).as;
@@ -22,7 +21,6 @@ function outputNamesForStep(step: ChainStep): string[] {
 }
 
 function taskTemplatesForStep(step: ChainStep): string[] {
-	if (isCheckpointStep(step)) return [];
 	if (isParallelStep(step)) return step.parallel.map((task) => task.task ?? "{previous}");
 	if (isDynamicParallelStep(step)) return [step.parallel.task ?? "{previous}", step.parallel.label ?? ""].filter(Boolean);
 	return [(step as SequentialStep).task ?? "{previous}"];

package/dist/extensions/pi-subagents/src/runs/shared/child-identity.ts

@@ -0,0 +1,36 @@
+import type { AsyncStatus } from "../../shared/types.ts";
+
+export type AsyncStatusStep = NonNullable<AsyncStatus["steps"]>[number];
+
+export interface ResolvedAsyncStatusChild {
+	index: number;
+	step: AsyncStatusStep;
+	id: string;
+}
+
+export type AsyncStatusChildResolution =
+	| { ok: true; child: ResolvedAsyncStatusChild }
+	| { ok: false; code: "not_found" | "ambiguous"; message: string };
+
+export function asyncStatusChildIdentity(step: AsyncStatusStep, index: number): string {
+	return step.workflowKey ?? step.runId ?? `step:${index}`;
+}
+
+export function asyncStatusChildIdentityCandidates(step: AsyncStatusStep, index: number): string[] {
+	return [...new Set([step.workflowKey, step.runId, `step:${index}`].filter((value): value is string => typeof value === "string" && value.length > 0))];
+}
+
+export function resolveAsyncStatusChild(status: Pick<AsyncStatus, "runId" | "steps">, childId: string): AsyncStatusChildResolution {
+	const matches: ResolvedAsyncStatusChild[] = [];
+	for (const [index, step] of (status.steps ?? []).entries()) {
+		if (!asyncStatusChildIdentityCandidates(step, index).includes(childId)) continue;
+		matches.push({ index, step, id: asyncStatusChildIdentity(step, index) });
+	}
+	if (matches.length === 1) return { ok: true, child: matches[0]! };
+	if (matches.length > 1) return { ok: false, code: "ambiguous", message: `Child '${childId}' is ambiguous under async run '${status.runId}'.` };
+	return { ok: false, code: "not_found", message: `Child '${childId}' was not found under async run '${status.runId}'.` };
+}
+
+export function isStoppableAsyncStatusStep(step: AsyncStatusStep): boolean {
+	return step.status === "pending" || step.status === "running";
+}

package/dist/extensions/pi-subagents/src/runs/shared/completion-guard.ts

@@ -1,6 +1,7 @@
 import type { Message } from "@earendil-works/pi-ai";
+import type { AcceptanceRole, TrackedMutationEvidence } from "../../shared/types.ts";
 import { isMutatingTool } from "./long-running-guard.ts";
-import { expectsImplementationMutation } from "./task-intent.ts";
+import { classifyTaskMutationIntent, expectsImplementationMutation, taskMayMutate } from "./task-intent.ts";
 
 export { expectsImplementationMutation };
 
@@ -14,6 +15,7 @@ const READ_ONLY_BUILTIN_TOOLS = new Set([
 	"get_search_content",
 	"intercom",
 	"contact_supervisor",
+	"structured_output",
 ]);
 
 // Cursor native edit/write often land as thinking traces (inactive_trace /
@@ -45,12 +47,16 @@ interface CompletionMutationGuardInput {
 	messages: Message[];
 	tools?: string[];
 	mcpDirectTools?: string[];
+	toolAvailabilityError?: string;
+	mutationEvidence?: TrackedMutationEvidence;
 }
 
 interface CompletionMutationGuardResult {
 	expectedMutation: boolean;
 	attemptedMutation: boolean;
 	triggered: boolean;
+	blocked: boolean;
+	message?: string;
 }
 
 interface ReportSentence {
@@ -64,6 +70,40 @@ export function hasMutationToolCapability(tools: string[] | undefined, mcpDirect
 	return !tools.every((tool) => READ_ONLY_BUILTIN_TOOLS.has(tool));
 }
 
+function hasBuiltinMutationTool(tools: string[] | undefined): boolean {
+	return tools === undefined || tools.some((tool) => !READ_ONLY_BUILTIN_TOOLS.has(tool));
+}
+
+function isWriterRole(agent: string, acceptanceRole: AcceptanceRole | undefined): boolean {
+	return acceptanceRole === "writer"
+		|| (acceptanceRole === undefined && /\bworker\b/i.test(agent));
+}
+
+const WRITER_DELIVERY_PATTERN = /\b(?:address|resolve|work)\s+(?:backlog\s+)?(?:item|issue)\b|\b(?:land|ship)\s+(?:the\s+)?(?:change|changes|fix|feature|implementation)\b/i;
+
+export function validateImplementationToolContract(input: {
+	agent: string;
+	task: string;
+	tools?: string[];
+	mcpDirectTools?: string[];
+	configuredExtensions?: string[];
+	requestedTools?: string[];
+	acceptanceRole?: AcceptanceRole;
+	completionGuard?: boolean;
+}): string | undefined {
+	if (input.completionGuard === false) return undefined;
+	const requestedMutationTools = input.requestedTools?.filter((tool) => !READ_ONLY_BUILTIN_TOOLS.has(tool)) ?? [];
+	const declaredMutationToolsWereRemoved = requestedMutationTools.length > 0 && !hasBuiltinMutationTool(input.tools);
+	const configuredExtensionCapability = (input.configuredExtensions?.length ?? 0) > 0 && !declaredMutationToolsWereRemoved;
+	if (hasMutationToolCapability(input.tools, input.mcpDirectTools) || configuredExtensionCapability) return undefined;
+	const intent = classifyTaskMutationIntent(input.agent, input.task);
+	if (intent.kind === "read-only") return undefined;
+	const writerTaskMayMutate = isWriterRole(input.agent, input.acceptanceRole)
+		&& (taskMayMutate(input.task) || WRITER_DELIVERY_PATTERN.test(input.task));
+	if (intent.kind !== "implementation" && !writerTaskMayMutate && !declaredMutationToolsWereRemoved) return undefined;
+	return `Agent '${input.agent}' was given an implementation task, but its tool allowlist has no mutation-capable tools. Add bash, edit, write, or another mutation-capable tool to the agent, or use a read-only task/agent.`;
+}
+
 function hasCheckpointMutationEvidence(message: Message): boolean {
 	const record = message as unknown as {
 		role?: string;
@@ -187,15 +227,25 @@ function reportsNoBetterChallengeChange(messages: Message[]): boolean {
 }
 
 export function evaluateCompletionMutationGuard(input: CompletionMutationGuardInput): CompletionMutationGuardResult {
+	if (input.toolAvailabilityError && expectsImplementationMutation(input.agent, input.task)) {
+		return {
+			expectedMutation: true,
+			attemptedMutation: false,
+			triggered: false,
+			blocked: true,
+			message: input.toolAvailabilityError,
+		};
+	}
 	const expectedMutation = hasMutationToolCapability(input.tools, input.mcpDirectTools)
 		? expectsImplementationMutation(input.agent, input.task)
 		: false;
-	const attemptedMutation = hasMutationToolCall(input.messages);
+	const attemptedMutation = hasMutationToolCall(input.messages) || input.mutationEvidence?.attemptedMutation === true;
 	const noEditChallengeComplete = isImplementationChallengeTask(input.task)
 		&& reportsNoBetterChallengeChange(input.messages);
 	return {
 		expectedMutation,
 		attemptedMutation,
 		triggered: expectedMutation && !attemptedMutation && !noEditChallengeComplete,
+		blocked: false,
 	};
 }

package/dist/extensions/pi-subagents/src/runs/shared/dynamic-fanout.ts

@@ -46,7 +46,7 @@ const DYNAMIC_STEP_KEYS = new Set(["expand", "parallel", "collect", "concurrency
 const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "sessionFiles", "thinkingOverrides"]);
 const DYNAMIC_EXPAND_KEYS = new Set(["from", "item", "key", "maxItems", "onEmpty"]);
 const DYNAMIC_EXPAND_FROM_KEYS = new Set(["output", "path"]);
-const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "toolBudget", "acceptance", "agentContract", "gateOn"]);
+const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "fast", "toolBudget", "acceptance", "agentContract", "gateOn"]);
 const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
 	...DYNAMIC_PARALLEL_KEYS,
 	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "namespaceOutputPath", "maxSubagentDepth", "timeoutMs", "waitToolEnabled",