@selesai/code 0.5.20 → 0.5.21

package/dist/extensions/pi-subagents/src/runs/background/result-watcher.ts

@@ -5,8 +5,8 @@ import { createFileCoalescer } from "../../shared/file-coalescer.ts";
 import {
 	SUBAGENT_ASYNC_COMPLETE_EVENT,
 	type IntercomEventBus,
-	type Usage,
 	type NestedRunSummary,
+	type ParallelHandoffReference,
 	type SubagentResultIntercomChild,
 	type SubagentState,
 } from "../../shared/types.ts";
@@ -18,9 +18,12 @@ import {
 	resolveSubagentResultStatus,
 } from "../../intercom/result-intercom.ts";
 import { projectNestedRegistryForRoot, sanitizeSummary } from "../shared/nested-events.ts";
+import { resolveWatchPath } from "../../shared/utils.ts";
+import type { CompletionNotifier, CompletionNotification } from "./notify.ts";
 
 const WATCHER_RESTART_DELAY_MS = 3000;
 const POLL_INTERVAL_MS = 3000;
+const RETRY_DELAY_MS = 100;
 
 type ResultWatcherFs = Pick<typeof fs, "existsSync" | "readFileSync" | "unlinkSync" | "readdirSync" | "mkdirSync" | "realpathSync" | "watch">;
 
@@ -34,6 +37,7 @@ type ResultWatcherTimers = {
 type ResultWatcherDeps = {
 	fs?: ResultWatcherFs;
 	timers?: ResultWatcherTimers;
+	notifier?: Pick<CompletionNotifier, "deliver">;
 };
 
 type ResultFileChild = {
@@ -41,28 +45,22 @@ type ResultFileChild = {
 	output?: string;
 	error?: string;
 	success?: boolean;
+	state?: string;
+	stopped?: boolean;
 	sessionFile?: string;
 	artifactPaths?: { outputPath?: string };
 	intercomTarget?: string;
 	children?: unknown;
 };
 
-type ResultFileData = {
-	id?: string;
+type ResultFileData = CompletionNotification & {
 	runId?: string;
-	agent?: string;
-	success?: boolean;
-	state?: string;
 	mode?: string;
-	summary?: string;
 	results?: ResultFileChild[];
 	nestedChildren?: unknown;
-	sessionId?: string;
-	cwd?: string;
-	sessionFile?: string;
 	asyncDir?: string;
 	intercomTarget?: string;
-	totalChildUsage?: Usage;
+	parallelHandoff?: ParallelHandoffReference;
 };
 
 function sanitizeNestedResultChildren(value: unknown, resultPath: string, label: string): NestedRunSummary[] | undefined {
@@ -78,29 +76,24 @@ function sanitizeNestedResultChildren(value: unknown, resultPath: string, label:
 	return children.length ? children : undefined;
 }
 
-function getErrorCode(error: unknown): string | undefined {
-	return typeof error === "object" && error !== null && "code" in error
-		? (error as NodeJS.ErrnoException).code
-		: undefined;
+function errorCode(error: unknown): string | undefined {
+	return typeof error === "object" && error !== null && "code" in error ? (error as NodeJS.ErrnoException).code : undefined;
 }
 
-function isNotFoundError(error: unknown): boolean {
-	return getErrorCode(error) === "ENOENT";
+function isNotFound(error: unknown): boolean {
+	return errorCode(error) === "ENOENT";
 }
 
-function shouldFallBackToPolling(error: unknown): boolean {
-	const code = getErrorCode(error);
+function shouldPoll(error: unknown): boolean {
+	const code = errorCode(error);
 	return code === "EMFILE" || code === "ENOSPC";
 }
 
-function resolveNativeWatchDir(fsApi: ResultWatcherFs, resultsDir: string): string {
-	try {
-		return fsApi.realpathSync.native(resultsDir);
-	} catch {
-		return resultsDir;
-	}
-}
-
+/**
+ * Watches persisted async results for the session currently owned by this
+ * runtime. `stopResultWatcher()` revokes ownership before closing resources,
+ * so old callbacks can never emit or delete after reload/session replacement.
+ */
 export function createResultWatcher(
 	pi: { events: IntercomEventBus },
 	state: SubagentState,
@@ -109,18 +102,41 @@ export function createResultWatcher(
 	deps: ResultWatcherDeps = {},
 ): {
 	startResultWatcher: () => void;
-	primeExistingResults: () => void;
+	primeExistingResults: (options?: { triggerTurn?: boolean }) => void;
 	stopResultWatcher: () => void;
 } {
 	const fsApi = deps.fs ?? fs;
 	const timers = deps.timers ?? { setTimeout, clearTimeout, setInterval, clearInterval };
+	const notifier = deps.notifier ?? { deliver: async () => true };
+	const pendingTriggerTurn = new Map<string, boolean>();
+	const processing = new Set<string>();
+	let deliveryActive = true;
+	let deliveryEpoch = 0;
+	// The sole in-memory ownership lease. It is acquired for one active session
+	// and revoked before the watcher, queues, or callbacks are torn down.
+	let activeSessionId: string | null = null;
 
-	const handleResult = async (file: string) => {
+	const ownsSession = (sessionId: string, epoch: number) => {
+		if (!deliveryActive || epoch !== deliveryEpoch) return false;
+		if (!activeSessionId && state.currentSessionId) activeSessionId = state.currentSessionId;
+		return activeSessionId === sessionId && state.currentSessionId === sessionId;
+	};
+
+	const scheduleResult = (file: string, triggerTurn: boolean, delayMs = 0) => {
+		const pendingMode = pendingTriggerTurn.get(file);
+		pendingTriggerTurn.set(file, pendingMode === false || !triggerTurn ? false : true);
+		state.resultFileCoalescer.schedule(file, delayMs);
+	};
+
+	const handleResult = async (file: string, triggerTurn: boolean) => {
 		const resultPath = path.join(resultsDir, file);
-		if (!fsApi.existsSync(resultPath)) return;
+		if (processing.has(file) || !fsApi.existsSync(resultPath)) return;
+		processing.add(file);
 		try {
 			const data = JSON.parse(fsApi.readFileSync(resultPath, "utf-8")) as ResultFileData;
-			if (typeof data.sessionId !== "string" || data.sessionId !== state.currentSessionId) return;
+			if (typeof data.sessionId !== "string" || !data.sessionId) return;
+			const epoch = deliveryEpoch;
+			if (!ownsSession(data.sessionId, epoch)) return;
 
 			const runId = data.runId ?? data.id ?? file.replace(/\.json$/i, "");
 			const hasExplicitNestedChildren = data.nestedChildren !== undefined;
@@ -130,24 +146,32 @@ export function createResultWatcher(
 					nestedChildren = compactNestedResultChildren(projectNestedRegistryForRoot(runId)?.children);
 				} catch (error) {
 					console.error(`Failed to enrich subagent result file '${resultPath}' with nested registry children; will retry later:`, error);
+					scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
 					return;
 				}
 			}
-			const now = Date.now();
+
 			const completionKey = buildCompletionKey(data, `result:${file}`);
-			if (markSeenWithTtl(state.completionSeen, completionKey, now, completionTtlMs)) {
-				fsApi.unlinkSync(resultPath);
+			const lastSeenAt = state.completionSeen.get(completionKey);
+			if (lastSeenAt !== undefined && Date.now() - lastSeenAt > completionTtlMs) {
+				state.completionSeen.delete(completionKey);
+			} else if (lastSeenAt !== undefined) {
+				if (!ownsSession(data.sessionId, epoch) || !fsApi.existsSync(resultPath)) return;
+				try {
+					fsApi.unlinkSync(resultPath);
+				} catch (error) {
+					if (!isNotFound(error)) {
+						console.error(`Failed to remove delivered subagent result '${resultPath}'; will retry:`, error);
+						scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
+					}
+				}
 				return;
 			}
 
 			const hasResultChildren = Array.isArray(data.results) && data.results.length > 0;
-			const resultChildren = hasResultChildren
+			const resultChildren: ResultFileChild[] = hasResultChildren
 				? data.results!
-				: [{
-					agent: data.agent,
-					output: data.summary,
-					success: data.success,
-				}];
+				: [{ agent: data.agent ?? undefined, output: data.summary, success: data.success }];
 			const normalizedChildren = attachNestedChildrenToResultChildren(runId, resultChildren.map((result = {}, index): SubagentResultIntercomChild => {
 				const baseOutput = result.output ?? data.summary;
 				const hasRealOutput = typeof baseOutput === "string" && baseOutput.trim().length > 0;
@@ -157,12 +181,16 @@ export function createResultWatcher(
 					: output;
 				const sessionPath = result.sessionFile ?? (resultChildren.length === 1 ? data.sessionFile : undefined);
 				const childNestedChildren = sanitizeNestedResultChildren(result.children, resultPath, `results[${index}].children`);
+				const childState = result.state === "paused" || result.state === "stopped"
+					? result.state
+					: result.stopped === true
+						? "stopped"
+						: data.state === "paused" || (!hasResultChildren && (data.state === "stopped" || typeof result.success !== "boolean"))
+							? data.state
+							: undefined;
 				return {
 					agent: result.agent ?? data.agent ?? `step-${index + 1}`,
-					status: resolveSubagentResultStatus({
-						success: result.success,
-						state: data.state === "paused" || typeof result.success !== "boolean" ? data.state : undefined,
-					}),
+					status: resolveSubagentResultStatus({ success: result.success, state: childState }),
 					summary,
 					index,
 					artifactPath: result.artifactPaths?.outputPath,
@@ -173,11 +201,11 @@ export function createResultWatcher(
 			}), nestedChildren);
 
 			const intercomTarget = data.intercomTarget?.trim();
-			if (intercomTarget) {
+			if (intercomTarget && triggerTurn) {
 				const mode = data.mode === "single" || data.mode === "parallel" || data.mode === "chain"
 					? data.mode
 					: resultChildren.length > 1 ? "chain" : "single";
-				const payload = buildSubagentResultIntercomPayload({
+				const delivered = await deliverSubagentResultIntercomEvent(pi.events, buildSubagentResultIntercomPayload({
 					to: intercomTarget,
 					runId,
 					mode,
@@ -185,20 +213,45 @@ export function createResultWatcher(
 					children: normalizedChildren,
 					asyncId: data.id,
 					asyncDir: data.asyncDir,
-				});
-				const delivered = await deliverSubagentResultIntercomEvent(pi.events, payload);
-				if (!delivered) {
-					console.error(`Subagent async grouped result intercom delivery was not acknowledged for '${resultPath}'.`);
-				}
+					...(data.parallelHandoff ? { parallelHandoff: data.parallelHandoff } : {}),
+				}));
+				if (!ownsSession(data.sessionId, epoch)) return;
+				if (!delivered) console.error(`Subagent async grouped result intercom delivery was not acknowledged for '${resultPath}'.`);
 			}
 
-			pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+			const accepted = await notifier.deliver({
 				...data,
+				id: data.id ?? runId,
 				runId,
+				triggerTurn,
 				...(nestedChildren?.length ? { nestedChildren } : {}),
 				...(Array.isArray(data.results) ? {
-					results: hasResultChildren
-						? normalizedChildren.map((child, index) => ({
+					results: hasResultChildren ? normalizedChildren.map((child, index) => ({
+						...data.results![index],
+						agent: child.agent,
+						status: child.status,
+						summary: child.summary,
+						index: child.index,
+						artifactPath: child.artifactPath,
+						sessionPath: child.sessionPath,
+						children: child.children,
+					})) : [],
+				} : {}),
+			});
+			if (!ownsSession(data.sessionId, epoch)) return;
+			if (!accepted) {
+				scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
+				return;
+			}
+			markSeenWithTtl(state.completionSeen, completionKey, Date.now(), completionTtlMs);
+			try {
+				pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+					...data,
+					runId,
+					triggerTurn,
+					...(nestedChildren?.length ? { nestedChildren } : {}),
+					...(Array.isArray(data.results) ? {
+						results: hasResultChildren ? normalizedChildren.map((child, index) => ({
 							...data.results![index],
 							agent: child.agent,
 							status: child.status,
@@ -207,40 +260,50 @@ export function createResultWatcher(
 							artifactPath: child.artifactPath,
 							sessionPath: child.sessionPath,
 							children: child.children,
-						}))
-						: [],
-				} : {}),
-			});
-			fsApi.unlinkSync(resultPath);
+						})) : [],
+					} : {}),
+				});
+			} catch (error) {
+				console.error(`Completion observer failed for '${resultPath}':`, error);
+			}
+			if (!ownsSession(data.sessionId, epoch) || !fsApi.existsSync(resultPath)) return;
+			try {
+				fsApi.unlinkSync(resultPath);
+			} catch (error) {
+				if (!isNotFound(error)) {
+					console.error(`Failed to remove delivered subagent result '${resultPath}'; will retry:`, error);
+					scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
+				}
+			}
 		} catch (error) {
-			if (isNotFoundError(error)) return;
-			console.error(`Failed to process subagent result file '${resultPath}':`, error);
+			if (!isNotFound(error)) console.error(`Failed to process subagent result file '${resultPath}':`, error);
+		} finally {
+			processing.delete(file);
 		}
 	};
 
 	state.resultFileCoalescer = createFileCoalescer((file) => {
-		void handleResult(file);
+		const triggerTurn = pendingTriggerTurn.get(file) !== false;
+		pendingTriggerTurn.delete(file);
+		void handleResult(file, triggerTurn);
 	}, 50);
 
-	const primeExistingResults = () => {
+	const primeExistingResults = (options: { triggerTurn?: boolean } = {}) => {
 		try {
+			const triggerTurn = options.triggerTurn !== false;
 			fsApi.readdirSync(resultsDir)
 				.filter((f) => f.endsWith(".json"))
-				.forEach((file) => state.resultFileCoalescer.schedule(file, 0));
+				.forEach((file) => scheduleResult(file, triggerTurn));
 		} catch (error) {
-			if (isNotFoundError(error)) return;
-			console.error(`Failed to scan subagent result directory '${resultsDir}':`, error);
+			if (!isNotFound(error)) console.error(`Failed to scan subagent result directory '${resultsDir}':`, error);
 		}
 	};
 
-	const startPollingFallback = (reason: unknown) => {
+	const startPolling = (reason: unknown) => {
 		state.watcher?.close();
 		state.watcher = null;
 		if (state.watcherRestartTimer) return;
-
-		console.error(
-			`Subagent result watcher for '${resultsDir}' fell back to polling because native fs.watch is unavailable (${getErrorCode(reason) ?? "unknown error"}).`,
-		);
+		console.error(`Subagent result watcher for '${resultsDir}' fell back to polling because native fs.watch is unavailable (${errorCode(reason) ?? "unknown error"}).`);
 		primeExistingResults();
 		state.watcherRestartTimer = timers.setInterval(primeExistingResults, POLL_INTERVAL_MS);
 		state.watcherRestartTimer.unref?.();
@@ -254,10 +317,7 @@ export function createResultWatcher(
 				fsApi.mkdirSync(resultsDir, { recursive: true });
 				startResultWatcher();
 			} catch (error) {
-				if (shouldFallBackToPolling(error)) {
-					startPollingFallback(error);
-					return;
-				}
+				if (shouldPoll(error)) return startPolling(error);
 				console.error(`Failed to restart subagent result watcher for '${resultsDir}':`, error);
 				scheduleRestart();
 			}
@@ -267,24 +327,23 @@ export function createResultWatcher(
 
 	const startResultWatcher = () => {
 		if (state.watcher) return;
+		activeSessionId = state.currentSessionId;
+		deliveryActive = true;
+		deliveryEpoch += 1;
 		if (state.watcherRestartTimer) {
 			timers.clearTimeout(state.watcherRestartTimer);
 			timers.clearInterval(state.watcherRestartTimer);
 			state.watcherRestartTimer = null;
 		}
 		try {
-			const watchDir = resolveNativeWatchDir(fsApi, resultsDir);
-			state.watcher = fsApi.watch(watchDir, (ev, file) => {
-				if (ev !== "rename" || !file) return;
+			const watchDir = resolveWatchPath(resultsDir, fsApi.realpathSync.native);
+			state.watcher = fsApi.watch(watchDir, (event, file) => {
+				if (event !== "rename" || !file) return;
 				const fileName = file.toString();
-				if (!fileName.endsWith(".json")) return;
-				state.resultFileCoalescer.schedule(fileName);
+				if (fileName.endsWith(".json")) scheduleResult(fileName, true);
 			});
 			state.watcher.on("error", (error) => {
-				if (shouldFallBackToPolling(error)) {
-					startPollingFallback(error);
-					return;
-				}
+				if (shouldPoll(error)) return startPolling(error);
 				console.error(`Subagent result watcher failed for '${resultsDir}':`, error);
 				state.watcher?.close();
 				state.watcher = null;
@@ -292,10 +351,7 @@ export function createResultWatcher(
 			});
 			state.watcher.unref?.();
 		} catch (error) {
-			if (shouldFallBackToPolling(error)) {
-				startPollingFallback(error);
-				return;
-			}
+			if (shouldPoll(error)) return startPolling(error);
 			console.error(`Failed to start subagent result watcher for '${resultsDir}':`, error);
 			state.watcher = null;
 			scheduleRestart();
@@ -303,6 +359,9 @@ export function createResultWatcher(
 	};
 
 	const stopResultWatcher = () => {
+		deliveryActive = false;
+		activeSessionId = null;
+		deliveryEpoch += 1;
 		state.watcher?.close();
 		state.watcher = null;
 		if (state.watcherRestartTimer) {
@@ -311,6 +370,8 @@ export function createResultWatcher(
 		}
 		state.watcherRestartTimer = null;
 		state.resultFileCoalescer.clear();
+		pendingTriggerTurn.clear();
+		processing.clear();
 	};
 
 	return { startResultWatcher, primeExistingResults, stopResultWatcher };

package/dist/extensions/pi-subagents/src/runs/background/run-id-resolver.ts

@@ -29,7 +29,19 @@ function exactAsyncLocation(id: string, asyncDirRoot: string, resultsDir: string
 
 function foregroundIds(state: SubagentState | undefined): string[] {
 	if (!state) return [];
-	return [...new Set([...state.foregroundControls.keys(), ...(state.foregroundRuns?.keys() ?? [])])];
+	const remembered = state.currentSessionId
+		? [...(state.foregroundRuns?.values() ?? [])]
+			.filter((run) => run.sessionId === state.currentSessionId)
+			.map((run) => run.runId)
+		: [];
+	return [...new Set([...state.foregroundControls.keys(), ...remembered])];
+}
+
+function hasExactForegroundId(state: SubagentState | undefined, id: string): boolean {
+	if (!state) return false;
+	if (state.foregroundControls.has(id)) return true;
+	const remembered = state.foregroundRuns?.get(id);
+	return Boolean(remembered && state.currentSessionId && remembered.sessionId === state.currentSessionId);
 }
 
 function nestedScopeFromState(state: SubagentState | undefined): NestedRunResolutionScope | undefined {
@@ -58,7 +70,7 @@ export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps
 	const resultsDir = deps.resultsDir ?? RESULTS_DIR;
 
 	const nestedScope = deps.nested ?? nestedScopeFromState(deps.state);
-	if (deps.state?.foregroundControls.has(id) || deps.state?.foregroundRuns?.has(id)) return { kind: "foreground", id };
+	if (hasExactForegroundId(deps.state, id)) return { kind: "foreground", id };
 	const exactAsync = exactAsyncLocation(id, asyncDirRoot, resultsDir);
 	if (exactAsync) return { kind: "async", id, location: exactAsync };
 	const exactNested = findNestedRunMatchesById(id, nestedScope ? { scope: nestedScope } : {});

package/dist/extensions/pi-subagents/src/runs/background/run-status.ts

@@ -6,8 +6,9 @@ import { formatAsyncResultTranscript, formatAsyncRunTranscript, formatNestedRunT
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { formatModelThinking } from "../../shared/formatters.ts";
 import { formatActivityLabel } from "../../shared/status-format.ts";
-import { ASYNC_DIR, RESULTS_DIR, type AsyncStatus, type Details, type ForegroundResumeRun, type NestedRunSummary, type SubagentState } from "../../shared/types.ts";
+import { ASYNC_DIR, RESULTS_DIR, type AsyncStatus, type Details, type ForegroundResumeRun, type NestedRunSummary, type SteeringStatus, type SubagentState } from "../../shared/types.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
+import { readProcessTerminal, sanitizeProcessTerminal } from "./process-terminal.ts";
 import { resolveAsyncRunLocation } from "./async-resume.ts";
 import { resolveSubagentRunId } from "./run-id-resolver.ts";
 import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
@@ -38,7 +39,8 @@ function hasExistingSessionFile(value: unknown): value is string {
 	return typeof value === "string" && fs.existsSync(value);
 }
 
-function formatResumeGuidance(runId: string | undefined, children: Array<{ agent?: unknown; sessionFile?: unknown }>, fallbackSessionFile?: unknown): string {
+function formatResumeGuidance(runId: string | undefined, children: Array<{ agent?: unknown; sessionFile?: unknown }>, fallbackSessionFile?: unknown, options: { stopped?: boolean } = {}): string {
+	if (options.stopped) return "Resume: unavailable; stopped runs are not resumable. Start a new run instead.";
 	const knownChildren = children
 		.map((child, index) => ({ child, index }))
 		.filter(({ child }) => typeof child.agent === "string");
@@ -73,15 +75,15 @@ function nestedRunDisplayName(run: NestedRunSummary): string {
 	return run.id;
 }
 
-function formatSteeringSummary(input: { steerCount?: number; lastSteerAt?: number }): string | undefined {
-	const parts: string[] = [];
-	if (input.steerCount !== undefined) parts.push(`${input.steerCount} steer${input.steerCount === 1 ? "" : "s"}`);
-	if (typeof input.lastSteerAt === "number" && Number.isFinite(input.lastSteerAt)) parts.push(`last ${new Date(input.lastSteerAt).toISOString()}`);
-	return parts.length ? parts.join(", ") : undefined;
+function formatSteeringSummary(input: { steering?: SteeringStatus }): string | undefined {
+	const steering = input.steering;
+	if (!steering || steering.requested === 0) return undefined;
+	const lateAcknowledgments = steering.recent.reduce((count, request) => count + request.targets.filter((target) => target.lateDeliveredAt !== undefined).length, 0);
+	return `${steering.requested} requested, ${steering.scheduled} scheduled, ${steering.pending} pending, ${steering.delivered} delivered, ${steering.failed} failed, ${steering.recovered} recovered${lateAcknowledgments ? `, ${lateAcknowledgments} late acknowledged` : ""}`;
 }
 
 function rememberedForegroundChildOutput(child: ForegroundResumeRun["children"][number]): string {
-	const outputPath = child.artifactPaths?.outputPath;
+	const outputPath = child.artifactPaths?.outputPath ?? child.savedOutputPath;
 	if (outputPath && fs.existsSync(outputPath)) {
 		try {
 			const artifactOutput = fs.readFileSync(outputPath, "utf-8").trim();
@@ -107,24 +109,29 @@ function formatRememberedForegroundStatus(run: ForegroundResumeRun): string {
 			`${child.index + 1}. ${child.agent} ${child.status}`,
 			child.exitCode !== undefined ? `exit ${child.exitCode}` : undefined,
 			child.detachedReason ? `detached: ${child.detachedReason}` : undefined,
+			child.acceptance ? `acceptance: ${child.acceptance.status}` : undefined,
+			child.error ? `error: ${child.error}` : undefined,
 			output ? `output: ${output.slice(0, 160)}` : undefined,
 		].filter(Boolean);
 		lines.push(parts.join(", "));
 		if (child.sessionFile) lines.push(`  Session: ${child.sessionFile}`);
 		if (child.transcriptPath) lines.push(`  Transcript: ${child.transcriptPath}`);
 		if (child.artifactPaths?.outputPath) lines.push(`  Output: ${child.artifactPaths.outputPath}`);
+		if (child.savedOutputPath && child.savedOutputPath !== child.artifactPaths?.outputPath) lines.push(`  Saved output: ${child.savedOutputPath}`);
+		if (child.outputSaveError) lines.push(`  Output warning: ${child.outputSaveError}`);
 		if (child.transcriptError) lines.push(`  Transcript warning: ${child.transcriptError}`);
 	}
 	lines.push("", `Status: subagent({ action: "status", id: "${run.runId}" })`);
 	if (run.children.length === 1) lines.push(`Transcript: subagent({ action: "status", id: "${run.runId}", view: "transcript" })`);
 	else lines.push(`Transcript: subagent({ action: "status", id: "${run.runId}", index: 0, view: "transcript" })`);
-	const resumable = run.children.find((child) => child.status !== "detached" && hasExistingSessionFile(child.sessionFile));
-	if (resumable) {
+	const detached = run.children.some((child) => child.status === "detached");
+	const resumable = run.children.find((child) => hasExistingSessionFile(child.sessionFile));
+	if (detached) {
+		lines.push(`Recovery: reply to the supervisor request first, then wait with subagent_wait({ id: "${run.runId}" }); do not resume or launch a replacement while any child remains detached.`);
+	} else if (resumable) {
 		lines.push(run.children.length === 1
 			? `Revive: subagent({ action: "resume", id: "${run.runId}", message: "..." })`
 			: `Revive child: subagent({ action: "resume", id: "${run.runId}", index: ${resumable.index}, message: "..." })`);
-	} else if (run.children.some((child) => child.status === "detached")) {
-		lines.push("Recovery: child detached for intercom coordination; status will show recovered output after the child exits when Pi can observe it.");
 	} else {
 		lines.push("Resume: unavailable; no child session file was persisted.");
 	}
@@ -147,6 +154,8 @@ function formatRememberedForegroundTranscript(run: ForegroundResumeRun, options:
 		child.sessionFile ? `Session: ${child.sessionFile}` : undefined,
 		child.transcriptPath ? `Transcript: ${child.transcriptPath}` : undefined,
 		child.artifactPaths?.outputPath ? `Output: ${child.artifactPaths.outputPath}` : undefined,
+		child.savedOutputPath && child.savedOutputPath !== child.artifactPaths?.outputPath ? `Saved output: ${child.savedOutputPath}` : undefined,
+		child.outputSaveError ? `Output warning: ${child.outputSaveError}` : undefined,
 	].filter((line): line is string => Boolean(line));
 	lines.push("Result transcript tail:");
 	if (outputLines.length === 0) lines.push("  (no recovered final output available yet)");
@@ -343,10 +352,15 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			const updated = status.lastUpdate ? new Date(status.lastUpdate).toISOString() : "n/a";
 			const statusActivityText = status.state === "running" ? formatActivityLabel(status.lastActivityAt, status.activityState) : undefined;
 			const steeringText = formatSteeringSummary(status);
+			const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId })
+				?? sanitizeProcessTerminal(status.processTerminal, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }, path.join(asyncDir, "status.json"));
 
 			const lines = [
 				`Run: ${status.runId}`,
 				`State: ${status.state}`,
+				processTerminal ? `Process terminal: ${processTerminal.state}${processTerminal.reason ? ` (${processTerminal.reason})` : ""}` : undefined,
+				status.capabilityCeiling ? `Capability ceiling: ${status.capabilityCeiling.allowedTools === undefined ? "names unrestricted" : status.capabilityCeiling.allowedTools.length === 0 ? "none" : status.capabilityCeiling.allowedTools.join(", ")}\nExtensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (sources: ${status.capabilityCeiling.sources.join(", ")})` : undefined,
+				status.capabilityAudit ? `Capability audit: ${status.capabilityAudit.removedTools.length} tools removed, ${status.capabilityAudit.removedExtensionCount} extension entries removed` : undefined,
 				status.error ? `Error: ${status.error}` : undefined,
 				statusActivityText ? `Activity: ${statusActivityText}` : undefined,
 				steeringText ? `Steering: ${steeringText}` : undefined,
@@ -358,6 +372,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				status.turnBudget ? `Turn budget: ${status.turnBudget.turnCount}/${status.turnBudget.maxTurns}+${status.turnBudget.graceTurns} (${status.turnBudget.outcome})` : undefined,
 				`Dir: ${asyncDir}`,
 				outputPath ? `Output: ${outputPath}` : undefined,
+				status.parallelHandoff ? `Parallel handoff: ${status.parallelHandoff.path}` : undefined,
 				reconciliation.message ? `Diagnosis: ${reconciliation.message}` : undefined,
 				reconciliation.resultPath && fs.existsSync(reconciliation.resultPath) ? `Result: ${reconciliation.resultPath}` : undefined,
 			].filter((line): line is string => Boolean(line));
@@ -388,19 +403,19 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			if (status.sessionFile) lines.push(`Session: ${status.sessionFile}`);
 			if (status.state === "running") lines.push(`Steer running child: subagent({ action: "steer", id: "${status.runId}", message: "..." })`);
 			if (status.state !== "running") {
-				lines.push(formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile));
+				lines.push(formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile, { stopped: status.state === "stopped" || status.stopped === true }));
 			}
 			if (fs.existsSync(logPath)) lines.push(`Log: ${logPath}`);
 			if (fs.existsSync(eventsPath)) lines.push(`Events: ${eventsPath}`);
 
-			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [] } };
+			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
 		}
 	}
 
 	if (resultPath) {
 		try {
 			const raw = fs.readFileSync(resultPath, "utf-8");
-			const data = JSON.parse(raw) as { id?: string; runId?: string; agent?: string; success?: boolean; summary?: string; output?: string; exitCode?: number; state?: string; sessionFile?: string; results?: Array<{ agent?: string; output?: string; summary?: string; sessionFile?: string; state?: string; success?: boolean; exitCode?: number | null }> };
+			const data = JSON.parse(raw) as { id?: string; runId?: string; agent?: string; success?: boolean; summary?: string; output?: string; exitCode?: number; state?: string; sessionFile?: string; parallelHandoff?: { path?: string }; results?: Array<{ agent?: string; output?: string; summary?: string; sessionFile?: string; state?: string; success?: boolean; exitCode?: number | null }> };
 			if (params.view === "transcript") {
 				try {
 					return { content: [{ type: "text", text: formatAsyncResultTranscript(data, resultPath, { index: params.index, lines: params.lines }) }], details: { mode: "single", results: [] } };
@@ -409,11 +424,12 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 					return { content: [{ type: "text", text: message }], isError: true, details: { mode: "single", results: [] } };
 				}
 			}
-			const status = data.success ? "complete" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
+			const status = data.state === "stopped" ? "stopped" : data.success ? "complete" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
 			const runId = data.runId ?? data.id ?? resolvedId;
 			const lines = [`Run: ${runId}`, `State: ${status}`, `Result: ${resultPath}`];
+			if (data.parallelHandoff?.path) lines.push(`Parallel handoff: ${data.parallelHandoff.path}`);
 			const children = Array.isArray(data.results) ? data.results : data.agent ? [{ agent: data.agent, sessionFile: data.sessionFile }] : [];
-			lines.push(formatResumeGuidance(runId, children, data.sessionFile));
+			lines.push(formatResumeGuidance(runId, children, data.sessionFile, { stopped: status === "stopped" }));
 			if (data.summary) lines.push("", data.summary);
 			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [] } };
 		} catch (error) {

package/dist/extensions/pi-subagents/src/runs/background/scheduled-runs.ts

@@ -12,6 +12,8 @@ import {
 	type ExtensionConfig,
 } from "../../shared/types.ts";
 import type { SubagentParamsLike } from "../foreground/subagent-executor.ts";
+import { validateExecutionAcceptance } from "../shared/acceptance.ts";
+import type { ResolvedSubagentCapabilityCeiling } from "../shared/capability-ceiling.ts";
 
 export const SCHEDULED_RUNS_DIR = path.join(TEMP_ROOT_DIR, "scheduled-subagent-runs");
 export const SCHEDULED_RUN_ACTIONS = ["schedule", "schedule-list", "schedule-status", "schedule-cancel"] as const;
@@ -56,6 +58,7 @@ type ScheduledRunManagerDeps = {
 	storeRoot?: string;
 	now?: () => number;
 	randomId?: () => string;
+	resolveCapabilityCeiling?: (sessionId: string) => ResolvedSubagentCapabilityCeiling | undefined;
 	timers?: ScheduledRunTimers;
 };
 
@@ -228,6 +231,8 @@ function sanitizeScheduledParams(params: SubagentParamsLike): { params?: Subagen
 	if (params.context === "fork") return { error: "Scheduled subagent runs require fresh context. Forked parent-session context is not safe at fire time." };
 	if (params.async === false) return { error: "Scheduled subagent runs are always async; omit async or set async: true." };
 	if (params.clarify === true) return { error: "Scheduled subagent runs cannot open clarify UI; omit clarify or set clarify: false." };
+	const acceptanceErrors = validateExecutionAcceptance(params);
+	if (acceptanceErrors.length > 0) return { error: acceptanceErrors.join(" ") };
 
 	const {
 		action: _action,
@@ -307,12 +312,15 @@ export class ScheduledRunManager {
 		const sanitized = sanitizeScheduledParams(params);
 		if (sanitized.error) return textResult(sanitized.error, true);
 		const scheduleInput = params.schedule!.trim();
+		const sessionId = resolveCurrentSessionId(ctx.sessionManager);
+		if (this.deps.resolveCapabilityCeiling?.(sessionId)) {
+			return textResult("Cannot schedule a capability-ceiling-restricted run because this store does not yet persist ceilings. Remove the active parent restriction or run it immediately.", true);
+		}
 		const runAt = parseScheduledRunTime(scheduleInput, this.now());
 		const pendingCount = store.list().filter((job) => job.state === "scheduled" || job.state === "running").length;
 		const maxPending = resolveMaxPending(this.deps.config);
 		if (pendingCount >= maxPending) return textResult(`Scheduled subagent limit reached (${pendingCount}/${maxPending} pending or running). Cancel an existing scheduled run before adding another.`, true);
 		const id = this.randomId();
-		const sessionId = resolveCurrentSessionId(ctx.sessionManager);
 		const scheduleName = params.scheduleName?.trim();
 		const executionParams = sanitized.params!;
 		const now = this.now();