pi-subagents 0.50.0 → 0.52.0

package/src/runs/shared/orca-progress-tabs.ts

@@ -17,16 +17,29 @@ const MIRROR_FOOTER_RESERVE_BYTES = 16 * 1024;
 const COUNTER_LOCK_STALE_MS = 30_000;
 const COUNTER_LOCK_RETRIES = 200;
 const COUNTER_LOCK_RETRY_MS = 10;
+const ORCA_CREATE_WAIT_TIMEOUT_MS = ORCA_CREATE_TIMEOUT_MS + ORCA_KILL_GRACE_MS + 3_000;
 
 const ORCA_CREATE_WATCHDOG_SCRIPT = [
 	"const {spawn}=require('node:child_process');",
-	"const timeout=Number(process.argv[1]),grace=Number(process.argv[2]),command=process.argv[3],args=process.argv.slice(4);",
-	"const child=spawn(command,args,{stdio:'ignore',windowsHide:true});",
-	"let hardKill;",
-	"const timer=setTimeout(()=>{child.kill('SIGTERM');hardKill=setTimeout(()=>child.kill('SIGKILL'),grace)},timeout);",
-	"const clear=()=>{clearTimeout(timer);if(hardKill)clearTimeout(hardKill)};",
-	"child.once('error',()=>{clear();process.exitCode=1});",
-	"child.once('close',code=>{clear();process.exitCode=code===0?0:1});",
+	"const fs=require('node:fs');",
+	"const timeout=Number(process.argv[1]),grace=Number(process.argv[2]),waitTimeout=Number(process.argv[3]);",
+	"const previous=process.argv[4],done=process.argv[5],command=process.argv[6],args=process.argv.slice(7);",
+	"function mark(){try{fs.writeFileSync(done.replace(/\\.pending$/,'.ready'),'')}catch{}}",
+	"function exists(file){try{return fs.existsSync(file)}catch{return false}}",
+	"function keepQueued(){try{const now=new Date();fs.utimesSync(done,now,now)}catch{}}",
+	"function predecessorReady(){if(previous==='-')return true;if(exists(previous.replace(/\\.pending$/,'.ready')))return true;try{return Date.now()-fs.statSync(previous).mtimeMs>=waitTimeout}catch{return true}}",
+	"function start(){",
+	" try{",
+	"  const child=spawn(command,args,{stdio:'ignore',windowsHide:true});",
+	"  let hardKill;",
+	"  const timer=setTimeout(()=>{child.kill('SIGTERM');hardKill=setTimeout(()=>child.kill('SIGKILL'),grace)},timeout);",
+	"  const clear=()=>{clearTimeout(timer);if(hardKill)clearTimeout(hardKill);mark()};",
+	"  child.once('error',()=>{clear();process.exitCode=1});",
+	"  child.once('close',code=>{clear();process.exitCode=code===0?0:1});",
+	" }catch{mark();process.exitCode=1}",
+	"}",
+	"if(predecessorReady())start();",
+	"else{(function waitPrev(){keepQueued();if(predecessorReady())return start();setTimeout(waitPrev,20)})();}",
 ].join("");
 
 const ORCA_CLEANUP_WATCHDOG_SCRIPT = [
@@ -114,7 +127,7 @@ function progressRoot(): string {
 function pruneStaleProgressFiles(root: string, now = Date.now()): void {
 	try {
 		for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
-			if (!entry.isFile() || (!entry.name.endsWith(".log") && !entry.name.endsWith(".done"))) continue;
+			if (!entry.isFile() || (!entry.name.endsWith(".log") && !entry.name.endsWith(".done") && !entry.name.endsWith(".ready") && !entry.name.endsWith(".pending"))) continue;
 			const file = path.join(root, entry.name);
 			try {
 				if (now - fs.statSync(file).mtimeMs > STALE_PROGRESS_MAX_AGE_MS) fs.rmSync(file, { force: true });
@@ -148,10 +161,12 @@ function resolveSequenceScope(cwd: string): string {
 	}
 }
 
-function reserveTabSequence(root: string, cwd: string): number | undefined {
-	const key = createHash("sha256").update(resolveSequenceScope(cwd)).digest("hex").slice(0, 20);
-	const counterPath = path.join(root, `counter-${key}`);
-	const lockPath = `${counterPath}.lock`;
+function sequenceKey(cwd: string): string {
+	return createHash("sha256").update(resolveSequenceScope(cwd)).digest("hex").slice(0, 20);
+}
+
+function withSequenceLock<T>(root: string, key: string, fn: () => T): T | undefined {
+	const lockPath = path.join(root, `counter-${key}.lock`);
 	let locked = false;
 	for (let attempt = 0; attempt < COUNTER_LOCK_RETRIES; attempt++) {
 		try {
@@ -171,21 +186,44 @@ function reserveTabSequence(root: string, cwd: string): number | undefined {
 	}
 	if (!locked) return undefined;
 	try {
+		return fn();
+	} finally {
+		try { fs.rmSync(lockPath, { recursive: true, force: true }); } catch { /* stale lock cleanup handles crashes */ }
+	}
+}
+
+function predecessorMarker(pathValue: string | undefined): string | undefined {
+	if (!pathValue) return undefined;
+	const ready = pathValue.endsWith(".pending") ? pathValue.replace(/\.pending$/, ".ready") : pathValue;
+	const pending = ready.replace(/\.ready$/, ".pending");
+	if (fs.existsSync(ready) || fs.existsSync(pending)) return pending;
+	return undefined;
+}
+
+function reserveTabSequence(root: string, cwd: string): { sequence: number; previousCreateDone?: string; createDone: string } | undefined {
+	const key = sequenceKey(cwd);
+	const counterPath = path.join(root, `counter-${key}`);
+	const createDone = path.join(root, `create-${key}-${randomUUID()}.pending`);
+	return withSequenceLock(root, key, () => {
 		let current = 0;
+		let previousCreateDone: string | undefined;
 		try {
-			const parsed = Number.parseInt(fs.readFileSync(counterPath, "utf-8"), 10);
+			const raw = fs.readFileSync(counterPath, "utf-8");
+			const [countLine, previousLine] = raw.split("\n");
+			const parsed = Number.parseInt(countLine ?? "", 10);
 			if (Number.isSafeInteger(parsed) && parsed >= 0) current = parsed;
+			previousCreateDone = predecessorMarker(previousLine?.trim());
 		} catch { /* first tab for this worktree */ }
 		const next = current + 1;
 		try {
-			fs.writeFileSync(counterPath, `${next}\n`, { encoding: "utf-8", mode: 0o600 });
-			return next;
+			fs.writeFileSync(createDone, "", { encoding: "utf-8", mode: 0o600 });
+			fs.writeFileSync(counterPath, `${next}\n${createDone}\n`, { encoding: "utf-8", mode: 0o600 });
+			return { sequence: next, previousCreateDone, createDone };
 		} catch {
+			try { fs.rmSync(createDone, { force: true }); } catch { /* best effort */ }
 			return undefined;
 		}
-	} finally {
-		try { fs.rmSync(lockPath, { recursive: true, force: true }); } catch { /* stale lock cleanup handles crashes */ }
-	}
+	});
 }
 
 export function resolvePiSessionId(sessionFile: string | undefined): string | undefined {
@@ -263,16 +301,21 @@ export function createOrcaProgressTab(input: {
 	const agent = safeSegment(input.agent, "subagent");
 	const index = typeof input.index === "number" && Number.isInteger(input.index) && input.index >= 0 ? input.index : 0;
 	const cwd = typeof input.cwd === "string" && input.cwd ? input.cwd : process.cwd();
-	const tabSequence = reserveTabSequence(root, cwd);
-	if (tabSequence === undefined) return undefined;
+	const reservation = reserveTabSequence(root, cwd);
+	if (reservation === undefined) return undefined;
+	const tabSequence = reservation.sequence;
 	const stem = `${runId}-${index}-${randomUUID()}`;
 	const logPath = path.join(root, `${stem}.log`);
 	const donePath = path.join(root, `${stem}.done`);
 	const title = `subagent · ${agent} · ${tabSequence}`;
+	const markCreateReady = () => {
+		try { fs.writeFileSync(reservation.createDone.replace(/\.pending$/, ".ready"), ""); } catch { /* unblock later tabs */ }
+	};
 	try {
 		fs.writeFileSync(logPath, `pi-subagents / ${agent}\nrun ${runId} · child ${index + 1}\n${"─".repeat(48)}\n`, { encoding: "utf-8", mode: 0o600 });
 		fs.rmSync(donePath, { force: true });
 	} catch {
+		markCreateReady();
 		return undefined;
 	}
 
@@ -303,11 +346,21 @@ export function createOrcaProgressTab(input: {
 			failObserver();
 		}
 	};
+	let createSettled = false;
+	let cleanupPaths: string[] | undefined;
+	const scheduleDeferredCleanup = () => {
+		if (!createSettled || cleanupPaths === undefined) return;
+		scheduleCleanup(nodeExecutable, cleanupPaths);
+		cleanupPaths = undefined;
+	};
 	try {
 		const watchdog = spawn(nodeExecutable, [
 			"-e", ORCA_CREATE_WATCHDOG_SCRIPT,
 			String(ORCA_CREATE_TIMEOUT_MS),
 			String(ORCA_KILL_GRACE_MS),
+			String(ORCA_CREATE_WAIT_TIMEOUT_MS),
+			reservation.previousCreateDone ?? "-",
+			reservation.createDone,
 			command,
 			"terminal", "create",
 			"--worktree", `path:${path.resolve(cwd)}`,
@@ -322,11 +375,19 @@ export function createOrcaProgressTab(input: {
 			env: input.env ?? process.env,
 		});
 		watchdog.once("close", (code) => {
+			createSettled = true;
 			if (code !== 0) failObserver();
+			scheduleDeferredCleanup();
+		});
+		watchdog.once("error", () => {
+			markCreateReady();
+			createSettled = true;
+			failObserver();
+			scheduleDeferredCleanup();
 		});
-		watchdog.once("error", failObserver);
 		watchdog.unref();
 	} catch {
+		markCreateReady();
 		failObserver();
 		return undefined;
 	}
@@ -368,7 +429,8 @@ export function createOrcaProgressTab(input: {
 			logStream.end(footer, () => {
 				if (!available) return;
 				try { fs.writeFileSync(donePath, `${status}\n`, { encoding: "utf-8", mode: 0o600 }); } catch { /* best effort */ }
-				scheduleCleanup(nodeExecutable, [logPath, donePath]);
+				cleanupPaths = [logPath, donePath];
+				scheduleDeferredCleanup();
 			});
 		},
 	};

package/src/runs/shared/parallel-handoff.ts

@@ -34,6 +34,48 @@ function readManifest(manifestPath: string): ParallelHandoffManifest | undefined
 	return parsed;
 }
 
+function resolveExistingPath(candidate: string): string {
+	try {
+		return fs.realpathSync(candidate);
+	} catch {
+		return path.resolve(candidate);
+	}
+}
+
+function pathInside(root: string, candidate: string): boolean {
+	const relative = path.relative(root, candidate);
+	return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+
+export function resolveRetainedWorktreeCwd(manifestPath: string, runId: string, childIndex: number): string | undefined {
+	const manifest = readManifest(manifestPath);
+	if (!manifest) return undefined;
+	if (manifest.runId !== runId) throw new Error(`Managed worktree handoff belongs to run '${manifest.runId}', not '${runId}'.`);
+	const match = manifest.groups
+		.flatMap((group) => group.children.map((child) => ({ group, child })))
+		.find(({ child }) => child.index === childIndex);
+	if (!match) return undefined;
+	const cleanup = match.group.cleanup.tasks.find((task) => task.index === match.child.taskIndex);
+	if (!cleanup) throw new Error(`Async run '${runId}' child ${childIndex} has no managed worktree cleanup record.`);
+	const relativeCwd = path.relative(resolveExistingPath(match.group.repoRoot), resolveExistingPath(manifest.cwd));
+	if (path.isAbsolute(relativeCwd) || relativeCwd === ".." || relativeCwd.startsWith(`..${path.sep}`)) throw new Error(`Async run '${runId}' has an invalid managed worktree cwd.`);
+	const requiredCwd = path.join(cleanup.path, relativeCwd);
+	if (cleanup.worktreeRemoved || cleanup.branchRemoved) throw new Error(`Async run '${runId}' required managed worktree was removed: ${requiredCwd}`);
+	let worktreeRoot = "";
+	let resolvedRequiredCwd = "";
+	try {
+		const rootStat = fs.lstatSync(cleanup.path);
+		if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) throw new Error("worktree root is not a directory");
+		worktreeRoot = fs.realpathSync(cleanup.path);
+		if (!fs.statSync(requiredCwd).isDirectory()) throw new Error("path is not a directory");
+		resolvedRequiredCwd = fs.realpathSync(requiredCwd);
+	} catch (error) {
+		throw new Error(`Async run '${runId}' required managed worktree cwd is missing: ${requiredCwd}`, { cause: error instanceof Error ? error : undefined });
+	}
+	if (!pathInside(worktreeRoot, resolvedRequiredCwd)) throw new Error(`Async run '${runId}' has an invalid managed worktree cwd.`);
+	return requiredCwd;
+}
+
 function referenceFor(manifestPath: string, manifest: ParallelHandoffManifest): ParallelHandoffReference {
 	const children = manifest.groups.flatMap((group) => group.children);
 	return {
@@ -74,7 +116,7 @@ function missingDiff(input: { manifestPath: string; stepIndex: number; taskIndex
 export function writeParallelHandoffGroup(input: {
 	manifestPath: string;
 	runId: string;
-	mode: "parallel" | "chain";
+	mode: "single" | "parallel" | "chain";
 	source: "foreground" | "async";
 	cwd: string;
 	stepIndex: number;
@@ -162,7 +204,7 @@ export function parallelHandoffPath(baseDir: string, runId?: string): string {
 export function writePendingParallelHandoff(input: {
 	manifestPath: string;
 	runId: string;
-	mode: "parallel" | "chain";
+	mode: "single" | "parallel" | "chain";
 	source: "foreground" | "async";
 	cwd: string;
 	stepIndex: number;
@@ -173,11 +215,11 @@ export function writePendingParallelHandoff(input: {
 }
 
 export function formatParallelHandoffReference(reference: ParallelHandoffReference): string {
-	return `Parallel handoff: ${reference.path} (${reference.childCount} children, ${reference.changedPatches} changed patches, cleanup ${reference.cleanupState})`;
+	return `Worktree handoff: ${reference.path} (${reference.childCount} children, ${reference.changedPatches} changed patches, cleanup ${reference.cleanupState})`;
 }
 
 export function formatParallelHandoffError(error: unknown): string {
-	return `Parallel handoff unavailable: ${error instanceof Error ? error.message : String(error)}`;
+	return `Worktree handoff unavailable: ${error instanceof Error ? error.message : String(error)}`;
 }
 
 export function discardPreservedWorktrees(

package/src/runs/shared/parallel-utils.ts

@@ -65,13 +65,8 @@ export interface RunnerSubagentStep {
 	capabilityAudit?: import("./capability-ceiling.ts").SubagentCapabilityAudit;
 	/** Private stable logical-child path for inherited run fan-out accounting. */
 	runFanoutPath?: string;
-}
-
-export interface RunnerCheckpointStep {
-	checkpoint: string;
-	message?: string;
-	phase?: string;
-	label?: string;
+	/** Run this single child in one managed worktree. */
+	worktree?: boolean;
 }
 
 export interface ParallelStepGroup {
@@ -100,11 +95,7 @@ export interface DynamicRunnerGroup {
 	capabilityAudit?: import("./capability-ceiling.ts").SubagentCapabilityAudit;
 }
 
-export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup | RunnerCheckpointStep;
-
-export function isCheckpointRunnerStep(step: RunnerStep): step is RunnerCheckpointStep {
-	return "checkpoint" in step;
-}
+export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup;
 
 export function isParallelGroup(step: RunnerStep): step is ParallelStepGroup {
 	return "parallel" in step && Array.isArray(step.parallel);
@@ -117,9 +108,7 @@ export function isDynamicRunnerGroup(step: RunnerStep): step is DynamicRunnerGro
 export function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[] {
 	const flat: RunnerSubagentStep[] = [];
 	for (const step of steps) {
-		if (isCheckpointRunnerStep(step)) {
-			continue;
-		} else if (isParallelGroup(step)) {
+		if (isParallelGroup(step)) {
 			for (const task of step.parallel) flat.push(task);
 		} else if (isDynamicRunnerGroup(step)) {
 			continue;

package/src/runs/shared/permissions.ts

@@ -14,6 +14,10 @@ const MAX_PREVIEW_BYTES = 2048;
 const SECRET_KEY = /(?:authorization|cookie|credential|password|secret|token|api[-_]?key)/i;
 const SECRET_VALUE = /\b(?:Bearer\s+\S+|(?:sk|ghp|github_pat|xox[baprs])[-_A-Za-z0-9]{8,})\b/gi;
 
+export function redactSecretValues(value: string): string {
+	return value.replace(SECRET_VALUE, "[redacted]");
+}
+
 export function validatePermissionRules(value: unknown, label: string): PermissionRules | undefined {
 	if (value === undefined) return undefined;
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object mapping tool names to allow, ask, or deny.`);
@@ -66,7 +70,7 @@ function redact(value: unknown, key = "", depth = 0): unknown {
 	if (Array.isArray(value)) return value.slice(0, 10).map((item) => redact(item, "", depth + 1));
 	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value as Record<string, unknown>).slice(0, 20).map(([entryKey, entryValue]) => [entryKey, redact(entryValue, entryKey, depth + 1)]));
 	if (typeof value === "string") {
-		const redacted = value.replace(SECRET_VALUE, "[redacted]");
+		const redacted = redactSecretValues(value);
 		return redacted.length > 500 ? `${redacted.slice(0, 500)}…` : redacted;
 	}
 	return value;

package/src/runs/shared/pi-args.ts

@@ -433,13 +433,20 @@ export function resolvePiLaunchToolPlan(
 			...internalTools,
 		]),
 	];
+	// Supervisor-coordination names stay in the --tools allowlist but are never
+	// strict requirements: children register contact_supervisor at runtime through
+	// the native supervisor channel (or pi-intercom). The pre-0.50 bridge always
+	// appended intercom alongside contact_supervisor, so that exact pairing is
+	// legacy plumbing, not a user demand for an external intercom provider;
+	// a lone intercom entry stays strictly required (#1207).
+	const legacySupervisorPairing = declaredBuiltinTools.includes("contact_supervisor");
 	const requiredChildTools = explicitToolAllowlist
 		? [
 				...new Set([
 					...(input.tools !== undefined ? declaredBuiltinTools : []),
 					...(input.mcpDirectTools?.length ? effectiveMcpTools : []),
 					...internalTools,
-				]),
+				].filter((tool) => tool !== "contact_supervisor" && (!legacySupervisorPairing || tool !== "intercom"))),
 			]
 		: [];
 	const permSystemExt = capabilityCeiling?.denyExtensions

package/src/runs/shared/session-lease.ts

@@ -1,4 +1,3 @@
-import { spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -79,11 +78,6 @@ function getProcessStartIdentity(pid: number): string | undefined {
 			return undefined;
 		}
 	}
-	if (process.platform === "darwin" || process.platform === "freebsd") {
-		const result = spawnSync("/bin/ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf-8" });
-		const started = result.status === 0 ? result.stdout.trim() : "";
-		return started ? `${process.platform}:${started}` : undefined;
-	}
 	return undefined;
 }
 

package/src/runs/shared/subagent-control.ts

@@ -7,6 +7,8 @@ import {
 	type ResolvedControlConfig,
 } from "../../shared/types.ts";
 import { isToolTimeoutExempt } from "./tool-timeout.ts";
+import { createHash } from "node:crypto";
+import { previewDisplayText } from "../../shared/display-text.ts";
 
 const CONTROL_EVENT_TYPES: ControlEventType[] = ["active_long_running", "needs_attention"];
 const CONTROL_NOTIFICATION_CHANNELS: ControlNotificationChannel[] = ["event", "async", "intercom"];
@@ -116,6 +118,10 @@ export function buildControlEvent(input: {
 	currentPath?: string;
 	elapsedMs?: number;
 	recentFailureSummary?: string;
+	workflowKey?: string;
+	phase?: string;
+	label?: string;
+	taskPreview?: string;
 }): ControlEvent {
 	const ts = input.ts ?? Date.now();
 	const type = input.type ?? (input.to === "active_long_running" ? "active_long_running" : "needs_attention");
@@ -144,6 +150,10 @@ export function buildControlEvent(input: {
 		...(input.currentPath ? { currentPath: input.currentPath } : {}),
 		...(elapsedMs !== undefined ? { elapsedMs } : {}),
 		...(input.recentFailureSummary ? { recentFailureSummary: input.recentFailureSummary } : {}),
+		...(input.workflowKey ? { workflowKey: input.workflowKey } : {}),
+		...(input.phase ? { phase: input.phase } : {}),
+		...(input.label ? { label: input.label } : {}),
+		...(input.taskPreview ? { taskPreview: previewDisplayText(input.taskPreview, 160) } : {}),
 	};
 }
 
@@ -153,7 +163,8 @@ export function shouldNotifyControlEvent(config: ResolvedControlConfig, event: C
 
 export function controlNotificationKey(event: ControlEvent, childIntercomTarget?: string): string {
 	const childKey = childIntercomTarget ?? (event.index !== undefined ? `${event.runId}:${event.index}` : event.runId);
-	return `${childKey}:${event.type}:${event.reason ?? "idle"}`;
+	const contextHash = createHash("sha256").update(formatControlNudge(event)).digest("hex").slice(0, 8);
+	return `${childKey}:${event.type}:${event.reason ?? "idle"}:${contextHash}`;
 }
 
 export function claimControlNotification(config: ResolvedControlConfig, event: ControlEvent, seenKeys: Set<string>, childIntercomTarget?: string): boolean {
@@ -175,6 +186,17 @@ function formatLongRunningFacts(event: ControlEvent): string | undefined {
 	return facts.length > 0 ? facts.join(" | ") : undefined;
 }
 
+export function formatControlNudge(event: ControlEvent): string {
+	const scope = event.label ?? event.phase ?? event.workflowKey ?? event.taskPreview;
+	if (event.recentFailureSummary) return previewDisplayText(`Resolve the recent failure${scope ? ` for ${scope}` : ""}: ${event.recentFailureSummary}. Report the smallest next step or ask for a decision.`, 160);
+	if (event.currentTool || event.currentPath) {
+		const current = [event.currentTool ? `tool ${event.currentTool}` : undefined, event.currentPath ? `path ${event.currentPath}` : undefined].filter(Boolean).join(" at ");
+		return previewDisplayText(`Check ${current}${scope ? ` for ${scope}` : ""}. Report the smallest next step or ask for a decision.`, 160);
+	}
+	if (scope) return previewDisplayText(`Continue ${scope}. Report the smallest next step or ask for a decision.`, 160);
+	return "What are you blocked on? Reply with the smallest next step or ask for a decision.";
+}
+
 export function formatControlNoticeMessage(event: ControlEvent, childIntercomTarget?: string): string {
 	const runTarget = event.runId;
 	if (event.reason === "completion_guard") {
@@ -187,9 +209,9 @@ export function formatControlNoticeMessage(event: ControlEvent, childIntercomTar
 		].filter((line): line is string => Boolean(line)).join("\n");
 	}
 
-	const nudgeMessage = "What are you blocked on? Reply with the smallest next step or ask for a decision.";
-	const steerCommand = `subagent({ action: "steer", id: "${runTarget}", ${event.index !== undefined ? `index: ${event.index}, ` : ""}message: "${nudgeMessage}" })`;
-	const nestedResumeCommand = `subagent({ action: "resume", id: "${runTarget}", message: "${nudgeMessage}" })`;
+	const nudgeMessage = formatControlNudge(event);
+	const steerCommand = `subagent({ action: "steer", id: "${runTarget}", ${event.index !== undefined ? `index: ${event.index}, ` : ""}message: ${JSON.stringify(nudgeMessage)} })`;
+	const nestedResumeCommand = `subagent({ action: "resume", id: "${runTarget}", message: ${JSON.stringify(nudgeMessage)} })`;
 	if (event.type === "active_long_running") {
 		const facts = formatLongRunningFacts(event);
 		return [

package/src/runs/shared/subagent-prompt-runtime.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { registerNativeSupervisorClient } from "../../intercom/native-supervisor-channel.ts";
+import { shouldUseNativeFsWatch } from "../../shared/watch-strategy.ts";
 import { decodePermissionRules, permissionDecision, PERMISSION_AUDIT_PATH_ENV, PERMISSION_POLICY_ENV } from "./permissions.ts";
 import { consumeSteerRequestsFromDir, MAX_STEER_QUEUE_SIZE, steerAckPathFromDir, writeSteerAckAt, writeSteerCapabilityAt, writeSteerRequestToDir, type SteerDeliveryStatus, type SteerRequest } from "../background/control-channel.ts";
 import { SUBAGENT_CHILD_AGENT_ENV, SUBAGENT_CHILD_INDEX_ENV, SUBAGENT_FANOUT_CHILD_ENV, SUBAGENT_STEER_ACK_DIR_ENV, SUBAGENT_STEER_CAPABILITY_ENV, SUBAGENT_STEER_INBOX_ENV } from "./pi-args.ts";
@@ -337,6 +338,7 @@ export function registerSteeringInbox(
 		nativeRealpath?: (filePath: string) => string;
 		legacySettleFallbackMs?: number;
 		safetyPollIntervalMs?: number;
+		platform?: NodeJS.Platform;
 		timers?: Pick<typeof globalThis, "setInterval" | "clearInterval">;
 	} = {},
 ): void {
@@ -449,13 +451,17 @@ export function registerSteeringInbox(
 			safetyInterval = (deps.timers?.setInterval ?? setInterval)(flush, deps.safetyPollIntervalMs ?? STEERING_SAFETY_POLL_INTERVAL_MS) as NodeJS.Timeout;
 			safetyInterval.unref?.();
 		};
-		try {
-			watcher = (deps.watch ?? fs.watch)(resolveWatchPath(steerInbox, deps.nativeRealpath), () => flush());
-			watcher.on("error", startPolling);
-			startSafetyPolling();
-		} catch {
-			watcher = undefined;
+		if (!shouldUseNativeFsWatch("child-steering-inbox", deps.platform)) {
 			startPolling();
+		} else {
+			try {
+				watcher = (deps.watch ?? fs.watch)(resolveWatchPath(steerInbox, deps.nativeRealpath), () => flush());
+				watcher.on("error", startPolling);
+				startSafetyPolling();
+			} catch {
+				watcher = undefined;
+				startPolling();
+			}
 		}
 	};
 	const activate = (): undefined => {

package/src/runs/shared/workflow-graph.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 { SingleResult, SubagentRunMode, WorkflowGraphNode, WorkflowGraphSnapshot, WorkflowNodeStatus } from "../../shared/types.ts";
 
 export interface WorkflowGraphBuildInput {
@@ -81,28 +81,6 @@ export function buildWorkflowGraphSnapshot(input: WorkflowGraphBuildInput): Work
 
 	for (let stepIndex = 0; stepIndex < input.steps.length; stepIndex++) {
 		const step = input.steps[stepIndex]!;
-		if (isCheckpointStep(step)) {
-			const status = normalizeStatus(input.stepStatuses?.[flatIndex]?.status)
-				?? (input.currentStepIndex === stepIndex ? "paused" : "pending");
-			const checkpoint = { name: step.checkpoint, ...(step.message ? { message: step.message } : {}), status: status === "rejected" ? "rejected" as const : status === "completed" ? "approved" as const : "pending" as const, stepIndex };
-			const id = `step-${stepIndex}`;
-			nodes.push({
-				id,
-				kind: "checkpoint",
-				phase: step.phase,
-				label: step.label?.trim() || step.checkpoint,
-				status,
-				flatIndex,
-				stepIndex,
-				checkpoint,
-				error: input.stepStatuses?.[flatIndex]?.error,
-			});
-			pushPhase(phases, step.phase, id);
-			if (status === "paused" || input.currentStepIndex === stepIndex) currentNodeId = id;
-			flatIndex++;
-			continue;
-		}
-
 		if (isParallelStep(step)) {
 			const groupId = `step-${stepIndex}`;
 			const children: WorkflowGraphNode[] = [];

package/src/runs/shared/worktree.ts

@@ -46,7 +46,7 @@ export interface WorktreeCleanupTask {
 }
 
 export type WorktreeCleanupIntent =
-	| { kind: "preserve"; capturedDiffs?: WorktreeDiff[]; handoffManifestPath?: string }
+	| { kind: "preserve"; capturedDiffs?: WorktreeDiff[]; handoffManifestPath?: string; cleanupBlocker?: string }
 	| {
 		kind: "discard";
 		authorization:
@@ -115,7 +115,7 @@ interface RepoState {
 const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
 
 function runGit(cwd: string, args: string[]): GitResult {
-	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
+	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", windowsHide: true });
 	return {
 		stdout: result.stdout ?? "",
 		stderr: result.stderr ?? "",
@@ -338,6 +338,7 @@ function runWorktreeSetupHook(
 	input: WorktreeSetupHookInput,
 ): string[] {
 	const result = spawnSync(hook.hookPath, [], {
+		windowsHide: true,
 		cwd: input.worktreePath,
 		encoding: "utf-8",
 		input: JSON.stringify(input),
@@ -571,6 +572,17 @@ function cleanupSingleWorktree(
 	const errors: string[] = [];
 	let worktreeRemoved = false;
 	let branchRemoved = false;
+	if (intent.kind === "preserve" && intent.cleanupBlocker) {
+		return {
+			index: worktree.index,
+			path: worktree.path,
+			branch: worktree.branch,
+			worktreeRemoved: false,
+			branchRemoved: false,
+			preserved: true,
+			reason: intent.cleanupBlocker,
+		};
+	}
 	if (intent.kind !== "setup-rollback") {
 		try {
 			removeSyntheticPathsBeforeDiff(worktree);

package/src/shared/atomic-json.ts

@@ -1,9 +1,12 @@
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, runFileSystemOperationWithRetry, waitForFileSystemRetry } from "./file-system-retry.ts";
 
 type AtomicJsonFs = Pick<typeof fs, "mkdirSync" | "writeFileSync" | "renameSync" | "rmSync">;
 
+const MAX_PATH_COMPONENT_BYTES = 255;
+
 type AtomicJsonWriterOptions = {
 	fs?: AtomicJsonFs;
 	now?: () => number;
@@ -28,6 +31,13 @@ function renameWithRetry(
 	}, { retryDelaysMs, wait });
 }
 
+function tempBaseName(filePath: string, pid: number, nowMs: number, randomId: string): string {
+	const suffix = `.${pid}.${nowMs}.${randomId}.tmp`;
+	const preferred = `.${path.basename(filePath)}${suffix}`;
+	if (Buffer.byteLength(preferred, "utf-8") <= MAX_PATH_COMPONENT_BYTES) return preferred;
+	return `.${createHash("sha256").update(path.basename(filePath)).digest("hex")}${suffix}`;
+}
+
 export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (filePath: string, payload: object) => void {
 	const fsImpl = options.fs ?? fs;
 	const now = options.now ?? Date.now;
@@ -46,13 +56,23 @@ export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (
 		}, { retryDelaysMs: directoryRetryDelaysMs, wait });
 		const tempPath = path.join(
 			path.dirname(filePath),
-			`.${path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`,
+			tempBaseName(filePath, pid, now(), random().toString(36).slice(2)),
 		);
+		let writeError: unknown;
 		try {
 			fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), mode === undefined ? "utf-8" : { encoding: "utf-8", mode });
 			renameWithRetry(fsImpl, tempPath, filePath, renameRetryDelaysMs, wait);
+		} catch (error) {
+			writeError = error;
+			throw error;
 		} finally {
-			fsImpl.rmSync(tempPath, { force: true });
+			try {
+				fsImpl.rmSync(tempPath, { force: true });
+			} catch (cleanupError) {
+				// Preserve the write/rename failure: cleanup is best effort and must
+				// not hide the error callers need to classify or report.
+				if (writeError === undefined) throw cleanupError;
+			}
 		}
 	};
 }