@selesai/code 0.13.40 → 0.14.3

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

@@ -6,8 +6,10 @@
  * observation channel, not a delivery acknowledgement.
  */
 
+import { statSync } from "node:fs";
 import { debuglog } from "node:util";
-import type { ExtensionAPI } from "@selesai/code";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
 import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.ts";
 import {
 	type CompletionBatchConfig,
@@ -17,6 +19,7 @@ import {
 } from "./completion-batcher.ts";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT, type ChildWatchdogProgress, type ChildWatchdogWarningSummary, type ParallelHandoffReference, type ScheduleOrigin, type SubagentState } from "../../shared/types.ts";
 import { safeTerminalText } from "../../shared/display-text.ts";
+import type { ParentWake } from "../../shared/parent-wake.ts";
 import { resolveSubagentResultStatus } from "../../intercom/result-intercom.ts";
 import { isUnexplainedProcessSignal } from "../shared/process-signal.ts";
 import type { ResultDeliveryOwnership } from "./result-delivery-ownership.ts";
@@ -26,7 +29,13 @@ export interface SubagentNotifyChildOutput {
 	runId?: string;
 	agent?: string;
 	status: string;
+	/** Latest detached revival of this failed child, e.g. `Revived → <run>: completed`. */
+	revival?: string;
 	savedOutputPath?: string;
+	outputArtifactPath?: string;
+	structuredOutputPath?: string;
+	outputArtifactError?: RetainedPathError;
+	structuredOutputError?: RetainedPathError;
 	preview: string;
 	previewTruncated?: boolean;
 	previewUnavailableReason?: string;
@@ -36,6 +45,7 @@ export type SubagentNotifyWatchdogBlocker = Pick<ChildWatchdogWarningSummary, "s
 
 export interface SubagentNotifyDetails {
 	workflowReceiptPath?: string;
+	asyncDir?: string;
 	agent: string;
 	status: "completed" | "failed" | "paused" | "stopped";
 	source?: "async" | "foreground";
@@ -54,6 +64,16 @@ export interface SubagentNotifyDetails {
 	watchdogBlockers?: SubagentNotifyWatchdogBlocker[];
 }
 
+export interface IncrementalChildCompletion {
+	workflowRunId: string;
+	childKey: string;
+	childRunId?: string;
+	outcome: "completed" | "failed" | "paused" | "stopped";
+	outputReference?: string;
+	error?: string;
+	workflowRunning: boolean;
+}
+
 export interface CompletionNotification {
 	[key: string]: unknown;
 	id?: string | null;
@@ -77,12 +97,16 @@ export interface CompletionNotification {
 		agent?: string;
 		status?: string;
 		state?: string;
+		revival?: string;
 		success?: boolean;
 		output?: string;
 		structuredOutput?: unknown;
+		structuredOutputPath?: string;
 		outputState?: "present" | "absent" | "unknown";
 		outputReference?: string | { path?: string };
 		artifactPaths?: { outputPath?: string };
+		outputSaveError?: string;
+		artifactOutputSaveFailed?: true;
 		detached?: boolean;
 		exitCode?: number | null;
 		processSignal?: string | null;
@@ -109,6 +133,7 @@ export interface CompletionNotification {
 	intercomDelivered?: boolean;
 	parallelHandoff?: ParallelHandoffReference;
 	scheduleOrigin?: ScheduleOrigin;
+	asyncDir?: string;
 }
 
 interface NotifyTimerApi {
@@ -121,18 +146,35 @@ export interface RegisterSubagentNotifyOptions {
 	timers?: NotifyTimerApi;
 	now?: () => number;
 	ownership?: Pick<ResultDeliveryOwnership, "owns">;
+	sendRegistry?: CompletionSendRegistry;
 }
 
 export interface CompletionNotifier {
 	deliver(result: CompletionNotification): Promise<boolean>;
+	/** True while a completion is batched, being sent, or accepted as a wake that Pi has not started yet. */
 	hasPendingDelivery(): boolean;
+	/** Releases a completion wake once Pi starts it (native message_start). */
+	messageStarted(message: AgentMessage): void;
+	/** Adopts wakes a reloaded notifier left queued for the same session manager and session UUID. */
+	bindSession(sessionManager: Pick<ExtensionContext["sessionManager"], "getSessionId">): void;
+	/** Drops queued wakes unless the session is only reloading extensions. */
+	sessionShutdown(reason: string | undefined): void;
+	/** Send every batched completion now instead of waiting for its batch timer. */
+	flush(): void;
 	dispose(): void;
 }
 
 const CHILD_OUTPUT_PREVIEW_MAX_BYTES = 4 * 1024;
 const CHILD_OUTPUT_PREVIEW_COUNT = 8;
 const PREVIEW_TRUNCATION_MARKER = "...[preview truncated]";
+const COMPLETION_SEND_TTL_MS = 10 * 60 * 1000;
+const COMPLETION_SEND_REGISTRY_CAP = 4_096;
 type CompletionChild = NonNullable<CompletionNotification["results"]>[number];
+interface RetainedPathError { path: string; code?: string; message: string }
+type RetainedPathProjection =
+	| { status: "verified"; path: string }
+	| { status: "unavailable" }
+	| { status: "error"; error: RetainedPathError };
 
 function truncateUtf8Head(value: string, maxBytes: number): { text: string; truncated: boolean } {
 	const bytes = Buffer.from(value, "utf8");
@@ -161,10 +203,31 @@ function childSavedOutputPath(child: CompletionChild): string | undefined {
 	return outputPathFromReference(child.outputReference);
 }
 
+function nonemptyPath(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function retainedChildPath(value: unknown, producerConfirmed = false): RetainedPathProjection {
+	const path = nonemptyPath(value);
+	if (!path) return { status: "unavailable" };
+	if (producerConfirmed) return { status: "verified", path };
+	try {
+		return statSync(path).isFile() ? { status: "verified", path } : { status: "unavailable" };
+	} catch (error) {
+		const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : undefined;
+		if (code === "ENOENT" || code === "ENOTDIR") return { status: "unavailable" };
+		return { status: "error", error: { path, ...(code ? { code } : {}), message: error instanceof Error ? error.message : String(error) } };
+	}
+}
+
+function formatRetainedPathError(label: string, error: RetainedPathError): string {
+	return `  ${label} verification failed: stat ${error.code ? boundedSafeText(error.code, 32) : "unknown"}; path=${boundedSafeText(error.path, 384)}; ${boundedSafeText(error.message, 512)}`;
+}
+
 function childStatus(child: CompletionChild, workflowState?: string): string {
 	const knownStatus = child.status === "complete"
 		? "completed"
-		: child.status === "completed" || child.status === "failed" || child.status === "paused" || child.status === "stopped" || child.status === "detached"
+		: child.status === "running" || child.status === "completed" || child.status === "failed" || child.status === "paused" || child.status === "stopped" || child.status === "detached"
 			? child.status
 		: undefined;
 	if (knownStatus) return knownStatus;
@@ -220,7 +283,13 @@ function formatChildOutputBlock(children: SubagentNotifyChildOutput[] | undefine
 		const runId = child.runId ? boundedSafeText(child.runId) : "unavailable";
 		const status = boundedSafeText(child.status) || "unavailable";
 		lines.push(`- key=${key} run=${runId} status=${status}`);
+		if (child.revival) lines.push(`  ${boundedSafeText(child.revival)}`);
 		lines.push(`  Saved output: ${child.savedOutputPath ? boundedSafeText(child.savedOutputPath) : "unavailable"}`);
+		if (child.outputArtifactPath) lines.push(`  Output artifact (retention-managed): ${boundedSafeText(child.outputArtifactPath)}`);
+		if (child.structuredOutputPath) lines.push(`  Structured output (retention-managed): ${boundedSafeText(child.structuredOutputPath)}`);
+		if (child.outputArtifactError) lines.push(formatRetainedPathError("Output artifact", child.outputArtifactError));
+		if (child.structuredOutputError) lines.push(formatRetainedPathError("Structured output", child.structuredOutputError));
+		if (child.previewTruncated && !child.savedOutputPath && !child.outputArtifactPath) lines.push("  Full output unavailable");
 		if (index >= CHILD_OUTPUT_PREVIEW_COUNT) {
 			lines.push("  Preview: unavailable (notice preview budget exceeded)");
 			continue;
@@ -257,6 +326,7 @@ function formatChildRun(child: { runId: string; workflowKey?: string; agent?: st
 
 function formatCorrelationLines(details: SubagentNotifyDetails): string[] {
 	return [
+		details.asyncDir ? `Retention-managed async directory: ${boundedSafeText(details.asyncDir)}` : undefined,
 		details.workflowRunId ? `Workflow run: ${details.workflowRunId}` : undefined,
 		details.childRuns?.length ? `Child runs: ${details.childRuns.map(formatChildRun).join(", ")}` : undefined,
 		details.reconciledFromDetachedChild ? `Reconciled detached child: ${details.reconciledFromDetachedChild}` : undefined,
@@ -308,6 +378,40 @@ export function formatSingleCompletion(details: SubagentNotifyDetails): string {
 		.join("\n");
 }
 
+export function scheduledCompletionTriggersTurn(origin: ScheduleOrigin | undefined, outcome: string): boolean {
+	return !(origin?.quiet === true && outcome === "completed");
+}
+
+/**
+ * Child settlement is useful context, but an ordinary successful child does not
+ * establish the workflow's dependency barrier while its workflow is running.
+ * Keep actionable outcomes waking the parent, and preserve a terminal child as
+ * the barrier for hosts that do not emit a separate workflow completion wake.
+ */
+export function incrementalChildCompletionTriggersTurn(
+	child: Pick<IncrementalChildCompletion, "outcome" | "workflowRunning">,
+	origin: ScheduleOrigin | undefined,
+): boolean {
+	if (child.workflowRunning && child.outcome === "completed") return false;
+	return scheduledCompletionTriggersTurn(origin, child.outcome);
+}
+
+export function formatIncrementalChildCompletion(child: IncrementalChildCompletion): string {
+	const statusText = child.outcome === "completed" ? "completed"
+		: child.outcome === "failed" ? "failed"
+			: child.outcome === "paused" ? "paused (needs attention)"
+				: "stopped";
+	const workflowStatus = child.workflowRunning ? "workflow still running" : "workflow finished";
+	return [
+		`Workflow child ${statusText}: **${child.childKey}**`,
+		`Workflow run: ${child.workflowRunId}`,
+		...(child.childRunId ? [`Child run: ${child.childRunId}`] : []),
+		...(child.outputReference ? [`Output: ${child.outputReference}`] : []),
+		...(child.error ? [`Error: ${child.error}`] : []),
+		`Status: ${workflowStatus}`,
+	].join("\n");
+}
+
 export function parseSubagentNotifyContent(content: string): SubagentNotifyDetails | undefined {
 	const lines = content.split("\n");
 	const match = (lines[0] ?? "").match(/^(Background task|Detached foreground task) (completed|failed|paused|stopped): \*\*(.+?)\*\*(?:\s+(\([^)]*\)))?$/);
@@ -406,7 +510,7 @@ const notificationDebug = debuglog("pi-subagents-notify");
 type TraceIdentity = Pick<CompletionNotification, "id" | "runId" | "source">;
 type NotificationReason = "disposed" | "missing_session" | "foreground_session_mismatch" | "not_owned"
 	| "intercom_delivered" | "deduped_ttl" | "deduped_pending" | "batch_deferred"
-	| "emit_foreground_session_mismatch" | "emit_not_owned" | "send_accepted" | "send_failed" | "dispose_pending";
+	| "emit_foreground_session_mismatch" | "emit_not_owned" | "send_joined" | "send_accepted" | "send_failed" | "dispose_pending";
 
 // Slice before sanitizing: diagnostic work and each identity are bounded even for
 // malformed result metadata. Never include task/output, paths, or error bodies.
@@ -444,22 +548,102 @@ interface PendingCompletion {
 	resolve(accepted: boolean): void;
 }
 
-function sendCompletion(pi: Pick<ExtensionAPI, "sendMessage">, items: PendingCompletion[]): boolean {
+export interface CompletionSendClaim {
+	owned: boolean;
+	outcome: Promise<boolean>;
+	settle?(accepted: boolean): void;
+}
+
+export interface CompletionSendRegistry {
+	claim(key: string, now: number): CompletionSendClaim;
+}
+
+interface CompletionSendEntry {
+	outcome: Promise<boolean>;
+	resolve(accepted: boolean): void;
+	deliveredAt?: number;
+}
+
+/** A fresh registry is injectable so tests and separately scoped runtimes stay isolated. */
+export function createCompletionSendRegistry(
+	ttlMs = COMPLETION_SEND_TTL_MS,
+	cap = COMPLETION_SEND_REGISTRY_CAP,
+): CompletionSendRegistry {
+	const entries = new Map<string, CompletionSendEntry>();
+	const prune = (now: number) => {
+		for (const [key, entry] of entries) {
+			if (entry.deliveredAt !== undefined && now - entry.deliveredAt > ttlMs) entries.delete(key);
+		}
+		if (entries.size <= cap) return;
+		for (const [key, entry] of entries) {
+			if (entries.size <= cap) break;
+			if (entry.deliveredAt !== undefined) entries.delete(key);
+		}
+	};
+	return {
+		claim(key, now) {
+			prune(now);
+			const existing = entries.get(key);
+			if (existing) return { owned: false, outcome: existing.outcome };
+			let resolve!: (accepted: boolean) => void;
+			const entry: CompletionSendEntry = {
+				outcome: new Promise<boolean>((settle) => { resolve = settle; }),
+				resolve: (accepted) => resolve(accepted),
+			};
+			entries.set(key, entry);
+			return {
+				owned: true,
+				outcome: entry.outcome,
+				settle(accepted) {
+					if (entries.get(key) !== entry) return;
+					if (accepted) {
+						entry.deliveredAt = now;
+						prune(now);
+					} else {
+						entries.delete(key);
+					}
+					entry.resolve(accepted);
+				},
+			};
+		},
+	};
+}
+
+const completionSendRegistrySymbol = Symbol.for("pi-subagents.completion-send-registry.v1");
+const processGlobal = globalThis as typeof globalThis & { [completionSendRegistrySymbol]?: CompletionSendRegistry };
+const processCompletionSendRegistry = processGlobal[completionSendRegistrySymbol]
+	?? (processGlobal[completionSendRegistrySymbol] = createCompletionSendRegistry());
+
+// Reload replaces extension instances, not Pi's session manager or queued wakes.
+// A manager can change sessions; retain wakes only while its UUID is unchanged.
+type QueuedWakes = { sessionId: string; wakes: string[] };
+const queuedWakesSymbol = Symbol.for("pi-subagents.queued-completion-wakes.v2");
+const wakeGlobal = globalThis as typeof globalThis & { [queuedWakesSymbol]?: WeakMap<object, QueuedWakes> };
+const queuedWakes = wakeGlobal[queuedWakesSymbol] ?? (wakeGlobal[queuedWakesSymbol] = new WeakMap<object, QueuedWakes>());
+
+function sendCompletion(pi: Pick<ParentWake, "sendMessage">, items: PendingCompletion[], unstartedWakes: string[]): boolean {
 	if (items.length === 0) return true;
 	const details = items.map((item) => item.details);
 	const content = details.length === 1 ? formatSingleCompletion(details[0]!) : formatGroupedCompletion(details);
 	const display = details.some((detail) => detail.source === "foreground" || detail.status !== "completed" || detail.scheduleOrigin !== undefined);
+	const triggerTurn = items.some((item) => item.triggerTurn);
+	// Pi can queue an accepted wake behind the current turn or past agent_settled.
+	// Recorded before sending in case Pi starts the message synchronously.
+	if (triggerTurn) unstartedWakes.push(content);
 	try {
-		pi.sendMessage(
+		const appended = pi.sendMessage(
 			{
 				customType: "subagent-notify",
 				content,
 				display,
 			},
-			{ triggerTurn: items.some((item) => item.triggerTurn) },
+			{ triggerTurn },
 		);
+		// An idle parent's appended notice gets no message_start; its wake prompt holds liveness instead.
+		if (appended) unstartedWakes.splice(unstartedWakes.lastIndexOf(content), 1);
 		return true;
 	} catch {
+		if (triggerTurn) unstartedWakes.splice(unstartedWakes.lastIndexOf(content), 1);
 		return false;
 	}
 }
@@ -487,8 +671,11 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 		|| summary.startsWith("Paused after interrupt.")
 	);
 	const status = stopped ? "stopped" : paused ? "paused" : result.success ? "completed" : "failed";
-	const taskInfo =
-		result.taskIndex !== undefined && result.totalTasks !== undefined
+	const runningChildren = (result.mode === "workflow" || agent === "workflow")
+		? result.results?.filter((child) => childStatus(child) === "running").length ?? 0 : 0;
+	const taskInfo = runningChildren > 0
+		? ` (${status === "completed" ? "dispatch complete; " : ""}${runningChildren} ${runningChildren === 1 ? "child" : "children"} running or uncollected)`
+		: result.taskIndex !== undefined && result.totalTasks !== undefined
 			? ` (${result.taskIndex + 1}/${result.totalTasks})`
 			: undefined;
 
@@ -538,12 +725,21 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 			const workflowKey = typeof child.workflowKey === "string" && child.workflowKey.trim() ? child.workflowKey.trim() : undefined;
 			const runId = typeof child.runId === "string" && child.runId.trim() ? child.runId.trim() : undefined;
 			const savedOutputPath = childSavedOutputPath(child);
+			const outputArtifact = child.artifactOutputSaveFailed === true ? { status: "unavailable" as const } : retainedChildPath(child.artifactPaths?.outputPath);
+			const structuredOutput = child.stopped === true || child.timedOut === true
+				? { status: "unavailable" as const }
+				: retainedChildPath(child.structuredOutputPath, child.structuredOutput !== undefined);
 			return {
 				...(workflowKey ? { workflowKey } : {}),
 				...(runId ? { runId } : {}),
 				...(typeof child.agent === "string" ? { agent: child.agent } : {}),
 				status: childStatus(child, result.state),
+				...(typeof child.revival === "string" && child.revival ? { revival: child.revival } : {}),
 				...(savedOutputPath ? { savedOutputPath } : {}),
+				...(outputArtifact.status === "verified" ? { outputArtifactPath: outputArtifact.path } : {}),
+				...(structuredOutput.status === "verified" ? { structuredOutputPath: structuredOutput.path } : {}),
+				...(outputArtifact.status === "error" ? { outputArtifactError: outputArtifact.error } : {}),
+				...(structuredOutput.status === "error" ? { structuredOutputError: structuredOutput.error } : {}),
 				...(inline.preview ? { preview: inline.preview } : { preview: "" }),
 				...(inline.truncated ? { previewTruncated: true } : {}),
 				...(inline.unavailableReason ? { previewUnavailableReason: inline.unavailableReason } : {}),
@@ -551,15 +747,18 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 		})
 		: undefined;
 	const reconciledFromDetachedChild = typeof result.reconciledFromDetachedChild === "string" ? result.reconciledFromDetachedChild : undefined;
+	const asyncDir = nonemptyPath(result.asyncDir);
 	const watchdogBlockers: SubagentNotifyWatchdogBlocker[] = [];
-	const collectWatchdogBlockers = (owner: string, progress: ChildWatchdogProgress | undefined) => {
+	const watchdogConcerns: string[] = [];
+	const collectWatchdogFindings = (owner: string, progress: ChildWatchdogProgress | undefined) => {
 		for (const warning of progress?.warnings ?? []) {
-			if (warning.severity !== "blocker") continue;
-			watchdogBlockers.push({ agent: owner, summary: warning.summary, addressed: warning.addressed, stalemate: warning.stalemate });
+			if (warning.importance !== "high") continue;
+			if (warning.severity === "blocker") watchdogBlockers.push({ agent: owner, summary: warning.summary, addressed: warning.addressed, stalemate: warning.stalemate });
+			else watchdogConcerns.push(`${owner}: ${warning.summary}\nEvidence: ${warning.evidence}\nRecommended action: ${warning.recommendedAction}`);
 		}
 	};
-	collectWatchdogBlockers(agent, result.watchdog);
-	for (const child of result.results ?? []) collectWatchdogBlockers(typeof child.agent === "string" ? child.agent : agent, child.watchdog);
+	collectWatchdogFindings(agent, result.watchdog);
+	for (const child of result.results ?? []) collectWatchdogFindings(typeof child.agent === "string" ? child.agent : agent, child.watchdog);
 	const session =
 		result.shareUrl
 			? { label: "Session", value: result.shareUrl }
@@ -577,9 +776,10 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 		status,
 		...(scheduleOrigin ? { scheduleOrigin } : {}),
 		...(workflowReceiptPath ? { workflowReceiptPath } : {}),
+		...(asyncDir ? { asyncDir } : {}),
 		...(result.source ? { source: result.source } : {}),
 		...(taskInfo ? { taskInfo } : {}),
-		resultPreview,
+		resultPreview: watchdogConcerns.length ? `${resultPreview}\n\nHigh-importance watchdog concerns:\n${watchdogConcerns.map((warning) => `- ${warning}`).join("\n")}` : resultPreview,
 		...(typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {}),
 		...(handoffPath ? { handoffPath } : {}),
 		...(workflowRunId ? { workflowRunId } : {}),
@@ -592,16 +792,19 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 }
 
 export default function registerSubagentNotify(
-	pi: ExtensionAPI,
+	pi: Pick<ExtensionAPI, "events"> & Pick<ParentWake, "sendMessage">,
 	state: Pick<SubagentState, "currentSessionId" | "completionOwnerId">,
 	options: RegisterSubagentNotifyOptions = {},
 ): CompletionNotifier {
 	const seen = new Map<string, number>();
 	const pending = new Map<string, Promise<boolean>>();
-	const ttlMs = 10 * 60 * 1000;
+	const ttlMs = COMPLETION_SEND_TTL_MS;
 	const now = options.now ?? Date.now;
+	const sendRegistry = options.sendRegistry ?? processCompletionSendRegistry;
 	const batchConfig = resolveCompletionBatchConfig(options.batchConfig);
 	const batchers = new Map<string, CompletionBatcher<PendingCompletion>>();
+	let unstartedWakes: string[] = [];
+	let bound = false;
 	let disposed = false;
 	const ownsResult = options.ownership?.owns
 		?? ((sessionId: string, completionOwnerId: unknown, _runKey?: string) => sessionId === state.currentSessionId
@@ -627,8 +830,20 @@ export default function registerSubagentNotify(
 			(owned ? accepted : rejected).push(item);
 		}
 		settle(rejected, false);
-		const sent = sendCompletion(pi, accepted);
-		settle(accepted, sent, sent ? "send_accepted" : "send_failed");
+		const claimed: Array<{ item: PendingCompletion; claim: CompletionSendClaim }> = [];
+		for (const item of accepted) {
+			const claim = sendRegistry.claim(item.key, now());
+			if (claim.owned) {
+				claimed.push({ item, claim });
+				continue;
+			}
+			traceNotification("send_joined", item.trace);
+			void claim.outcome.then((outcome) => settle([item], outcome, outcome ? undefined : "send_failed"));
+		}
+		const claimedItems = claimed.map(({ item }) => item);
+		const sent = sendCompletion(pi, claimedItems, unstartedWakes);
+		for (const { claim } of claimed) claim.settle?.(sent);
+		settle(claimedItems, sent, sent ? "send_accepted" : "send_failed");
 	};
 	const getBatcher = (result: CompletionNotification) => {
 		const key = completionBatchKey(result);
@@ -685,7 +900,7 @@ export default function registerSubagentNotify(
 			sessionId: result.sessionId,
 			completionOwnerId: result.completionOwnerId,
 			runKey: completionRunKey(result),
-			triggerTurn: result.triggerTurn !== false,
+			triggerTurn: result.triggerTurn !== false && scheduledCompletionTriggersTurn(result.scheduleOrigin, details.status),
 			resolve,
 		};
 		if (notificationDebug.enabled) item.trace = traceIdentity(result);
@@ -705,6 +920,7 @@ export default function registerSubagentNotify(
 	};
 
 	const unsubscribeAsync = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, (data) => {
+		if ((data as CompletionNotification).awaitedByWorkflow === true) return;
 		void deliver(data as CompletionNotification);
 	});
 	const unsubscribeForeground = pi.events.on(SUBAGENT_FOREGROUND_COMPLETE_EVENT, (data) => {
@@ -713,7 +929,29 @@ export default function registerSubagentNotify(
 
 	return {
 		deliver,
-		hasPendingDelivery: () => pending.size > 0,
+		hasPendingDelivery: () => pending.size > 0 || unstartedWakes.length > 0,
+		messageStarted(message) {
+			if (message.role !== "custom" || message.customType !== "subagent-notify") return;
+			const index = unstartedWakes.indexOf(message.content as string);
+			if (index !== -1) unstartedWakes.splice(index, 1);
+		},
+		bindSession(sessionManager) {
+			if (disposed) return;
+			const sessionId = sessionManager.getSessionId(); // UUID, not state.currentSessionId's possible file path.
+			const retained = queuedWakes.get(sessionManager);
+			const wakes = retained?.sessionId === sessionId ? retained.wakes : [];
+			// Before the first bind, local wakes belong to this session; after it, to the previous one.
+			if (!bound) wakes.push(...unstartedWakes);
+			bound = true;
+			unstartedWakes = wakes;
+			queuedWakes.set(sessionManager, { sessionId, wakes });
+		},
+		sessionShutdown(reason) {
+			if (reason !== "reload") unstartedWakes.length = 0;
+		},
+		flush() {
+			for (const batcher of batchers.values()) batcher.flush();
+		},
 		dispose() {
 			if (disposed) return;
 			disposed = true;
@@ -728,4 +966,4 @@ export default function registerSubagentNotify(
 			}
 		},
 	};
-}
+}

package/dist/extensions/pi-subagents/src/runs/background/owned-process-tree.ts

@@ -35,6 +35,23 @@ function activeProcessGroupMembers(processGroupId: number): number[] | { diagnos
 	return members;
 }
 
+function knownDetachedDescendants(processGroupId: number): number[] {
+	const result = spawnSync("ps", ["-axo", "pid=,ppid=,pgid=,stat="], { encoding: "utf-8" });
+	if (result.error || result.status !== 0) return [];
+	const owned = new Set<number>();
+	const outside: { pid: number; ppid: number }[] = [];
+	for (const line of result.stdout.split("\n")) {
+		const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)/.exec(line);
+		if (!match || match[4]!.startsWith("Z")) continue;
+		const pid = Number(match[1]);
+		const ppid = Number(match[2]);
+		const pgid = Number(match[3]);
+		if (pgid === processGroupId) owned.add(pid);
+		else outside.push({ pid, ppid });
+	}
+	return outside.filter((row) => owned.has(row.ppid)).map((row) => row.pid);
+}
+
 async function waitUntilGroupTerminal(
 	processGroupId: number,
 	timeoutMs: number,
@@ -56,6 +73,15 @@ function observed(processGroupId: number): ProcessTreeTerminal {
 	return { state: "observed", mechanism: "posix-process-group", processGroupId, verifiedAt: Date.now() };
 }
 
+function observedUnlessLiveDetached(processGroupId: number, detached: readonly number[]): ProcessTreeTerminal {
+	const live = detached.filter((pid) => {
+		const result = spawnSync("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf-8" });
+		return result.status === 0 && Boolean(result.stdout.trim()) && !result.stdout.trim().startsWith("Z");
+	});
+	if (live.length === 0) return observed(processGroupId);
+	return { state: "unknown", reason: "verification-failed", diagnostic: `Owned detached descendant(s) still active: ${live.join(", ")}.` };
+}
+
 /** Owns one writer process group and arbitrates its cleanup exactly once. */
 export interface OwnedProcessTreeController {
 	terminate(): Promise<ProcessTreeTerminal>;
@@ -77,12 +103,13 @@ export function createOwnedProcessTreeController(
 				signalProcess(target, "SIGTERM");
 				return { state: "unknown", reason: "unsupported-platform" };
 			}
+			const detached = knownDetachedDescendants(pid);
 			const term = signalProcess(target, "SIGTERM");
 			if (term !== "sent" && term !== "absent") {
 				return { state: "unknown", reason: "signal-failed", diagnostic: term.diagnostic };
 			}
 			const termExit = await waitUntilGroupTerminal(pid, options.termGraceMs ?? DEFAULT_TERM_GRACE_MS);
-			if (termExit === false) return observed(pid);
+			if (termExit === false) return observedUnlessLiveDetached(pid, detached);
 
 			const kill = signalProcess(target, "SIGKILL");
 			if (kill !== "sent" && kill !== "absent") {
@@ -95,10 +122,10 @@ export function createOwnedProcessTreeController(
 			if (killExit !== false) {
 				return { state: "unknown", reason: "verification-failed", diagnostic: killExit.diagnostic };
 			}
-			return observed(pid);
+			return observedUnlessLiveDetached(pid, detached);
 		})();
 		return termination;
 	};
 
 	return { terminate, finishAfterWriterClose: terminate };
-}
+}

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

@@ -0,0 +1,18 @@
+import * as fs from "node:fs";
+
+let resolved = false;
+let cachedScope: string | undefined;
+
+/** Linux PID namespace identity, cached because reconciliation is a polling path. */
+export function currentPidNamespaceScope(): string | undefined {
+	if (resolved) return cachedScope;
+	resolved = true;
+	if (process.platform !== "linux") return undefined;
+	try {
+		const scope = fs.readlinkSync("/proc/self/ns/pid", "utf-8").trim();
+		cachedScope = scope || undefined;
+	} catch {
+		cachedScope = undefined;
+	}
+	return cachedScope;
+}