pi-subagents 0.35.0 → 0.36.0

package/src/runs/background/fleet-view.ts

@@ -16,6 +16,7 @@ import {
 } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
+import { contextModeLabel, summarizeContextModes } from "../shared/context-mode.ts";
 import { formatAsyncRunOutputPath, formatAsyncRunProgressLabel, listAsyncRuns, type AsyncRunSummary } from "./async-status.ts";
 
 const DEFAULT_TRANSCRIPT_LINES = 80;
@@ -277,15 +278,17 @@ function formatAsyncFleetLines(runs: AsyncRunSummary[]): string[] {
 		const activity = formatActivityFacts(run);
 		const cwd = run.cwd ? shortenPath(run.cwd) : shortenPath(run.asyncDir);
 		const pending = run.pendingAppends ? ` | ${run.pendingAppends} pending append${run.pendingAppends === 1 ? "" : "s"}` : "";
-		lines.push(`- ${run.id} | ${run.state}${activity ? ` | ${activity}` : ""} | ${run.mode} | ${progress}${pending} | ${cwd}`);
+		const runContext = contextModeLabel(run.context);
+		lines.push(`- ${run.id} | ${run.state}${activity ? ` | ${activity}` : ""} | ${run.mode}${runContext ? ` ${runContext}` : ""} | ${progress}${pending} | ${cwd}`);
 		lines.push(`  status: subagent({ action: "status", id: "${run.id}" })`);
 		lines.push(`  transcript: subagent({ action: "status", id: "${run.id}", view: "transcript" })`);
 		for (const step of run.steps) {
 			const display = step.label ? `${step.label} (${step.agent})` : step.agent;
+			const stepContext = contextModeLabel(step.context);
 			const phase = step.phase ? `[${step.phase}] ` : "";
 			const stepActivity = formatActivityFacts(step);
 			const modelThinking = formatModelThinking(step.model, step.thinking);
-			const parts = [`${step.index}. ${phase}${display}`, step.status, stepActivity, modelThinking].filter(Boolean);
+			const parts = [`${step.index}. ${phase}${display}${stepContext ? ` ${stepContext}` : ""}`, step.status, stepActivity, modelThinking].filter(Boolean);
 			lines.push(`  ${parts.join(" | ")}`);
 			const output = path.join(run.asyncDir, `output-${step.index}.log`);
 			if (fs.existsSync(output)) lines.push(`    output: ${shortenPath(output)}`);
@@ -385,8 +388,9 @@ function selectTranscriptStep(status: AsyncStatus, options: TranscriptOptions):
 function stepStateLine(mode: SubagentRunMode, index: number | undefined, step: AsyncJobStep | undefined): string | undefined {
 	if (index === undefined || !step) return undefined;
 	const modelThinking = formatModelThinking(step.model, step.thinking);
+	const context = contextModeLabel(step.context);
 	const parts = [
-		`${mode === "parallel" ? "Agent" : "Step"}: ${index} (${step.agent})`,
+		`${mode === "parallel" ? "Agent" : "Step"}: ${index} (${step.agent})${context ? ` ${context}` : ""}`,
 		step.status,
 		formatActivityFacts(step),
 		modelThinking,
@@ -428,10 +432,11 @@ export function formatAsyncRunTranscript(status: AsyncStatus, asyncDir: string,
 	const sessionFile = selected.index !== undefined ? selected.step?.sessionFile : status.sessionFile;
 	const eventsPath = path.join(asyncDir, "events.jsonl");
 
+	const context = contextModeLabel(status.context ?? summarizeContextModes((status.steps ?? []).map((step) => step.context)));
 	const lines = [
 		`Run: ${status.runId}`,
 		`State: ${status.state}`,
-		`Mode: ${status.mode}`,
+		`Mode: ${status.mode}${context ? ` ${context}` : ""}`,
 		stepStateLine(status.mode, selected.index, selected.step),
 		selected.hint,
 	].filter((line): line is string => Boolean(line));

package/src/runs/background/notify.ts

@@ -1,28 +1,20 @@
 /**
- * Subagent completion notifications.
+ * Completion notification delivery.
  *
- * Successful (completed) async results are held briefly and emitted as a
- * single grouped message when sibling jobs finish within a short window (see
- * `completion-batcher.ts`). Failed and paused results bypass grouping and fire
- * immediately, flushing any held successes first, so failure and attention
- * signals are never delayed.
+ * Async result files call this notifier directly and are deleted only after
+ * `sendMessage()` accepts the notification. The event bus remains an
+ * observation channel, not a delivery acknowledgement.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.ts";
+import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.ts";
 import {
 	type CompletionBatchConfig,
 	type CompletionBatcher,
 	createCompletionBatcher,
 	resolveCompletionBatchConfig,
 } from "./completion-batcher.ts";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT, type SubagentState } from "../../shared/types.ts";
-
-interface ChainStepResult {
-	agent: string;
-	output: string;
-	success: boolean;
-}
+import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT, type ParallelHandoffReference, type SubagentState } from "../../shared/types.ts";
 
 export interface SubagentNotifyDetails {
 	agent: string;
@@ -33,27 +25,30 @@ export interface SubagentNotifyDetails {
 	durationMs?: number;
 	sessionLabel?: string;
 	sessionValue?: string;
+	handoffPath?: string;
 }
 
-interface SubagentResult {
-	id: string | null;
+export interface CompletionNotification {
+	[key: string]: unknown;
+	id?: string | null;
 	source?: "async" | "foreground";
-	agent: string | null;
-	success: boolean;
-	summary: string;
+	agent?: string | null;
+	success?: boolean;
+	summary?: string;
 	exitCode?: number;
 	state?: string;
-	timestamp: number;
+	timestamp?: number;
 	durationMs?: number;
 	cwd?: string;
 	sessionFile?: string;
 	shareUrl?: string;
 	gistUrl?: string;
 	shareError?: string;
-	results?: ChainStepResult[];
 	taskIndex?: number;
 	totalTasks?: number;
 	sessionId?: string | null;
+	triggerTurn?: boolean;
+	parallelHandoff?: ParallelHandoffReference;
 }
 
 interface NotifyTimerApi {
@@ -67,6 +62,11 @@ export interface RegisterSubagentNotifyOptions {
 	now?: () => number;
 }
 
+export interface CompletionNotifier {
+	deliver(result: CompletionNotification): Promise<boolean>;
+	dispose(): void;
+}
+
 function formatSessionLine(details: SubagentNotifyDetails): string | undefined {
 	if (!details.sessionValue) return undefined;
 	return details.sessionLabel ? `${details.sessionLabel}: ${details.sessionValue}` : details.sessionValue;
@@ -79,6 +79,8 @@ export function formatSingleCompletion(details: SubagentNotifyDetails): string {
 		`${taskKind} ${details.status}: **${details.agent}**${details.taskInfo ?? ""}`,
 		"",
 		details.resultPreview.trim() ? details.resultPreview : "(no output)",
+		details.handoffPath ? "" : undefined,
+		details.handoffPath ? `Parallel handoff: ${details.handoffPath}` : undefined,
 		sessionLine ? "" : undefined,
 		sessionLine,
 	]
@@ -99,7 +101,12 @@ export function parseSubagentNotifyContent(content: string): SubagentNotifyDetai
 		}
 	}
 	const sessionLine = sessionIndex >= 0 ? body[sessionIndex] : undefined;
-	const resultPreview = (sessionIndex >= 0 ? body.slice(0, sessionIndex) : body).join("\n").trim() || "(no output)";
+	const handoffIndex = body.findIndex((line) => line.startsWith("Parallel handoff: "));
+	const metadataIndexes = [sessionIndex, handoffIndex].filter((index) => index >= 0);
+	const firstMetadataIndex = metadataIndexes.length ? Math.min(...metadataIndexes) : body.length;
+	const resultEnd = firstMetadataIndex > 0 && body[firstMetadataIndex - 1]?.trim() === "" ? firstMetadataIndex - 1 : firstMetadataIndex;
+	const resultPreview = body.slice(0, resultEnd).join("\n").trim() || "(no output)";
+	const handoffPath = handoffIndex >= 0 ? body[handoffIndex]!.slice("Parallel handoff: ".length).trim() : undefined;
 	let sessionLabel: string | undefined;
 	let sessionValue: string | undefined;
 	if (sessionLine) {
@@ -113,6 +120,7 @@ export function parseSubagentNotifyContent(content: string): SubagentNotifyDetai
 		...(match[1] === "Detached foreground task" ? { source: "foreground" as const } : {}),
 		...(match[4] ? { taskInfo: match[4] } : {}),
 		resultPreview,
+		...(handoffPath ? { handoffPath } : {}),
 		...(sessionLabel && sessionValue ? { sessionLabel, sessionValue } : {}),
 	};
 }
@@ -126,35 +134,47 @@ export function formatGroupedCompletion(details: SubagentNotifyDetails[]): strin
 		const sessionLine = formatSessionLine(detail);
 		blocks.push(`${index + 1}. ${detail.agent}${detail.taskInfo ?? ""}`);
 		blocks.push(detail.resultPreview.trim() ? detail.resultPreview : "(no output)");
+		if (detail.handoffPath) blocks.push(`Parallel handoff: ${detail.handoffPath}`);
 		if (sessionLine) blocks.push(sessionLine);
 		blocks.push("");
 	}
 	return blocks.join("\n").trimEnd();
 }
 
-function sendCompletion(pi: Pick<ExtensionAPI, "sendMessage">, details: SubagentNotifyDetails[]): void {
-	if (details.length === 0) return;
-	const content = details.length === 1
-		? formatSingleCompletion(details[0]!)
-		: formatGroupedCompletion(details);
-	pi.sendMessage(
-		{
-			customType: "subagent-notify",
-			content,
-			display: true,
-		},
-		{ triggerTurn: true },
-	);
+interface PendingCompletion {
+	key: string;
+	details: SubagentNotifyDetails;
+	triggerTurn: boolean;
+	resolve(accepted: boolean): void;
+}
+
+function sendCompletion(pi: Pick<ExtensionAPI, "sendMessage">, items: PendingCompletion[]): boolean {
+	if (items.length === 0) return true;
+	const details = items.map((item) => item.details);
+	const content = details.length === 1 ? formatSingleCompletion(details[0]!) : formatGroupedCompletion(details);
+	try {
+		pi.sendMessage(
+			{
+				customType: "subagent-notify",
+				content,
+				display: true,
+			},
+			{ triggerTurn: items.some((item) => item.triggerTurn) },
+		);
+		return true;
+	} catch {
+		return false;
+	}
 }
 
-function completionBatchKey(result: SubagentResult): string {
+function completionBatchKey(result: CompletionNotification): string {
 	const sessionId = typeof result.sessionId === "string" ? result.sessionId.trim() : "";
 	if (sessionId) return `session:${sessionId}`;
 	const cwd = typeof result.cwd === "string" ? result.cwd.trim() : "";
 	return cwd ? `cwd:${cwd}` : "unknown";
 }
 
-export function buildCompletionDetails(result: SubagentResult): SubagentNotifyDetails {
+export function buildCompletionDetails(result: CompletionNotification): SubagentNotifyDetails {
 	const agent = result.agent ?? "unknown";
 	const summary = typeof result.summary === "string" ? result.summary : "";
 	const paused = !result.success && (
@@ -163,12 +183,15 @@ export function buildCompletionDetails(result: SubagentResult): SubagentNotifyDe
 		|| summary.startsWith("Paused after interrupt.")
 	);
 	const status = paused ? "paused" : result.success ? "completed" : "failed";
-
 	const taskInfo =
 		result.taskIndex !== undefined && result.totalTasks !== undefined
 			? ` (${result.taskIndex + 1}/${result.totalTasks})`
 			: undefined;
 
+	const parallelHandoff = result.parallelHandoff && typeof result.parallelHandoff === "object"
+		? result.parallelHandoff as { path?: unknown }
+		: undefined;
+	const handoffPath = typeof parallelHandoff?.path === "string" ? parallelHandoff.path : undefined;
 	const session =
 		result.shareUrl
 			? { label: "Session", value: result.shareUrl }
@@ -177,7 +200,6 @@ export function buildCompletionDetails(result: SubagentResult): SubagentNotifyDe
 				: result.sessionFile
 					? { label: "Session file", value: result.sessionFile }
 					: undefined;
-
 	return {
 		agent,
 		status,
@@ -185,6 +207,7 @@ export function buildCompletionDetails(result: SubagentResult): SubagentNotifyDe
 		...(taskInfo ? { taskInfo } : {}),
 		resultPreview: summary,
 		...(typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {}),
+		...(handoffPath ? { handoffPath } : {}),
 		...(session ? { sessionLabel: session.label, sessionValue: session.value } : {}),
 	};
 }
@@ -193,102 +216,91 @@ export default function registerSubagentNotify(
 	pi: ExtensionAPI,
 	state: Pick<SubagentState, "currentSessionId">,
 	options: RegisterSubagentNotifyOptions = {},
-): () => void {
-	const unsubscribeStoreKey = "__pi_subagents_notify_unsubscribe__";
-	const batcherStoreKey = "__pi_subagents_notify_batcher__";
-	const globalStore = globalThis as Record<string, unknown>;
-	const previousUnsubscribe = globalStore[unsubscribeStoreKey];
-	if (typeof previousUnsubscribe === "function") {
-		try {
-			previousUnsubscribe();
-		} catch {
-			// Best effort cleanup for stale handlers from an older reload.
-		}
-	}
-	const previousBatcher = globalStore[batcherStoreKey];
-	if (previousBatcher && typeof (previousBatcher as { dispose?: () => void }).dispose === "function") {
-		try {
-			(previousBatcher as { dispose: () => void }).dispose();
-		} catch {
-			// Best effort cleanup for a stale batcher from an older reload.
-		}
-	}
-
-	const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
+): CompletionNotifier {
+	const seen = new Map<string, number>();
+	const pending = new Map<string, Promise<boolean>>();
 	const ttlMs = 10 * 60 * 1000;
-	const nowFn = options.now ?? Date.now;
+	const now = options.now ?? Date.now;
 	const batchConfig = resolveCompletionBatchConfig(options.batchConfig);
-	const batchers = new Map<string, CompletionBatcher<SubagentNotifyDetails>>();
+	const batchers = new Map<string, CompletionBatcher<PendingCompletion>>();
 	let disposed = false;
 
-	const handleComplete = (data: unknown) => {
-		if (disposed) return;
-		const result = data as SubagentResult;
-		if (typeof result.sessionId !== "string" || result.sessionId !== state.currentSessionId) return;
-		const now = nowFn();
-		const key = buildCompletionKey(result, "notify");
-		if (markSeenWithTtl(seen, key, now, ttlMs)) return;
-
-		const details = buildCompletionDetails(result);
-		if (result.source === "foreground") {
-			sendCompletion(pi, [details]);
-			return;
+	const settle = (items: PendingCompletion[], accepted: boolean) => {
+		for (const item of items) {
+			pending.delete(item.key);
+			if (accepted) markSeenWithTtl(seen, item.key, now(), ttlMs);
+			item.resolve(accepted);
 		}
-		const batchKey = completionBatchKey(result);
-		let batcher = batchers.get(batchKey);
+	};
+	const emit = (items: PendingCompletion[]) => settle(items, sendCompletion(pi, items));
+	const getBatcher = (result: CompletionNotification) => {
+		const key = completionBatchKey(result);
+		let batcher = batchers.get(key);
 		if (!batcher) {
-			batcher = createCompletionBatcher<SubagentNotifyDetails>({
+			batcher = createCompletionBatcher<PendingCompletion>({
 				config: batchConfig,
-				emit: (items) => sendCompletion(pi, items),
+				emit,
 				...(options.timers ? { timers: options.timers } : {}),
-				now: nowFn,
+				now,
 			});
-			batchers.set(batchKey, batcher);
+			batchers.set(key, batcher);
 		}
+		return batcher;
+	};
+
+	const deliver = (result: CompletionNotification): Promise<boolean> => {
+		if (disposed || typeof result.sessionId !== "string" || result.sessionId !== state.currentSessionId) return Promise.resolve(false);
+		const key = buildCompletionKey(result, "notify");
+		const seenAt = seen.get(key);
+		if (seenAt !== undefined && now() - seenAt <= ttlMs) return Promise.resolve(true);
+		if (seenAt !== undefined) seen.delete(key);
+		const inFlight = pending.get(key);
+		if (inFlight) return inFlight;
+		const details = buildCompletionDetails(result);
+		let resolve!: (accepted: boolean) => void;
+		const completion = new Promise<boolean>((settleCompletion) => { resolve = settleCompletion; });
+		pending.set(key, completion);
+		const item: PendingCompletion = {
+			key,
+			details,
+			triggerTurn: result.triggerTurn !== false,
+			resolve,
+		};
+		if (details.source === "foreground") {
+			emit([item]);
+			return completion;
+		}
+		const batcher = getBatcher(result);
 		if (details.status !== "completed") {
-			// Failures and paused runs bypass grouping. Flush any held
-			// successes for the same owner first so they are not stranded
-			// behind this signal, then emit the non-completion result immediately.
 			batcher.flush();
-			sendCompletion(pi, [details]);
-			return;
+			emit([item]);
+			return completion;
 		}
-		batcher.push(details);
+		batcher.push(item);
+		return completion;
 	};
 
-	const unsubscribers = [
-		pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete),
-		pi.events.on(SUBAGENT_FOREGROUND_COMPLETE_EVENT, handleComplete),
-	].filter((unsubscribe): unsubscribe is () => void => typeof unsubscribe === "function");
-	const batcherRegistration = { dispose };
+	const unsubscribeAsync = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, (data) => {
+		void deliver(data as CompletionNotification);
+	});
+	const unsubscribeForeground = pi.events.on(SUBAGENT_FOREGROUND_COMPLETE_EVENT, (data) => {
+		void deliver(data as CompletionNotification);
+	});
 
-	function dispose(): void {
-		if (disposed) return;
-		disposed = true;
-		for (const batcher of batchers.values()) {
-			try {
-				batcher.dispose();
-			} catch {
-				// Best effort cleanup must continue through every owned batcher.
-			}
-		}
-		batchers.clear();
-		for (const unsubscribe of unsubscribers) {
-			try {
-				unsubscribe();
-			} catch {
-				// Best effort cleanup must continue through every owned handler.
+	return {
+		deliver,
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			for (const batcher of batchers.values()) settle(batcher.dispose(), false);
+			batchers.clear();
+			for (const unsubscribe of [unsubscribeAsync, unsubscribeForeground]) {
+				try {
+					unsubscribe?.();
+				} catch {
+					// The runtime is already shutting down; pending records stay on disk.
+				}
 			}
-		}
-		if (globalStore[unsubscribeStoreKey] === dispose) {
-			delete globalStore[unsubscribeStoreKey];
-		}
-		if (globalStore[batcherStoreKey] === batcherRegistration) {
-			delete globalStore[batcherStoreKey];
-		}
-	}
-
-	globalStore[unsubscribeStoreKey] = dispose;
-	globalStore[batcherStoreKey] = batcherRegistration;
-	return dispose;
+		},
+	};
 }