@selesai/code 0.9.11 → 0.9.12

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

@@ -14,7 +14,7 @@ import {
 	createCompletionBatcher,
 	resolveCompletionBatchConfig,
 } from "./completion-batcher.ts";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT, type ParallelHandoffReference, type SubagentState } from "../../shared/types.ts";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT, type ParallelHandoffReference, type ScheduleOrigin, type SubagentState } from "../../shared/types.ts";
 import { isUnexplainedProcessSignal } from "../shared/process-signal.ts";
 
 export interface SubagentNotifyDetails {
@@ -24,9 +24,14 @@ export interface SubagentNotifyDetails {
 	taskInfo?: string;
 	resultPreview: string;
 	durationMs?: number;
+	workflowRunId?: string;
+	childRuns?: Array<{ runId: string; workflowKey?: string; agent?: string; status?: string }>;
+	reconciledFromDetachedChild?: string;
 	sessionLabel?: string;
 	sessionValue?: string;
 	handoffPath?: string;
+	/** Present when a durable schedule launched the run. */
+	scheduleOrigin?: ScheduleOrigin;
 }
 
 export interface CompletionNotification {
@@ -38,12 +43,18 @@ export interface CompletionNotification {
 	summary?: string;
 	exitCode?: number;
 	state?: string;
+	mode?: string;
+	runId?: string | null;
+	reconciledFromDetachedChild?: string;
 	processSignal?: string | null;
 	interrupted?: boolean;
 	timedOut?: boolean;
 	stopped?: boolean;
 	turnBudgetExceeded?: boolean;
 	results?: Array<{
+		runId?: string;
+		workflowKey?: string;
+		agent?: string;
 		status?: string;
 		success?: boolean;
 		exitCode?: number | null;
@@ -63,10 +74,12 @@ export interface CompletionNotification {
 	taskIndex?: number;
 	totalTasks?: number;
 	sessionId?: string | null;
+	completionOwnerId?: string | null;
 	triggerTurn?: boolean;
 	/** True when an acknowledged grouped intercom relay already delivered this run. */
 	intercomDelivered?: boolean;
 	parallelHandoff?: ParallelHandoffReference;
+	scheduleOrigin?: ScheduleOrigin;
 }
 
 interface NotifyTimerApi {
@@ -90,15 +103,37 @@ function formatSessionLine(details: SubagentNotifyDetails): string | undefined {
 	return details.sessionLabel ? `${details.sessionLabel}: ${details.sessionValue}` : details.sessionValue;
 }
 
+function formatChildRun(child: { runId: string; workflowKey?: string; agent?: string; status?: string }): string {
+	const label = child.workflowKey ?? child.agent;
+	const status = child.status ? ` (${child.status})` : "";
+	return `${label ? `${label}=` : ""}${child.runId}${status}`;
+}
+
+function formatCorrelationLines(details: SubagentNotifyDetails): string[] {
+	return [
+		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,
+	].filter((line): line is string => line !== undefined);
+}
+
 export function formatSingleCompletion(details: SubagentNotifyDetails): string {
 	const sessionLine = formatSessionLine(details);
+	const correlationLines = formatCorrelationLines(details);
 	const taskKind = details.source === "foreground" ? "Detached foreground task" : "Background task";
+	const scheduleLine = details.scheduleOrigin
+		? `Scheduled run from **${details.scheduleOrigin.name ?? details.scheduleOrigin.id}** (schedule ${details.scheduleOrigin.id}).`
+		: undefined;
 	return [
 		`${taskKind} ${details.status}: **${details.agent}**${details.taskInfo ?? ""}`,
 		"",
+		scheduleLine,
+		scheduleLine ? "" : undefined,
 		details.resultPreview.trim() ? details.resultPreview : "(no output)",
 		details.handoffPath ? "" : undefined,
 		details.handoffPath ? `Parallel handoff: ${details.handoffPath}` : undefined,
+		correlationLines.length && !details.handoffPath ? "" : undefined,
+		...correlationLines,
 		sessionLine ? "" : undefined,
 		sessionLine,
 	]
@@ -110,7 +145,17 @@ export function parseSubagentNotifyContent(content: string): SubagentNotifyDetai
 	const lines = content.split("\n");
 	const match = (lines[0] ?? "").match(/^(Background task|Detached foreground task) (completed|failed|paused|stopped): \*\*(.+?)\*\*(?:\s+(\([^)]*\)))?$/);
 	if (!match) return undefined;
-	const body = lines.slice(2);
+	let body = lines.slice(2);
+	// Restore the schedule origin so a re-rendered notice keeps its attribution and
+	// does not fold the line into the result preview.
+	const scheduleMatch = (body[0] ?? "").match(/^Scheduled run from \*\*(.+?)\*\* \(schedule (.+?)\)\.$/);
+	let parsedScheduleOrigin: ScheduleOrigin | undefined;
+	if (scheduleMatch) {
+		const label = scheduleMatch[1]!;
+		const id = scheduleMatch[2]!;
+		parsedScheduleOrigin = { id, ...(label === id ? {} : { name: label }) };
+		body = body.slice(body[1]?.trim() === "" ? 2 : 1);
+	}
 	let sessionIndex = -1;
 	for (let i = body.length - 1; i >= 1; i--) {
 		if (body[i - 1]?.trim() === "" && /^(Session|Session file|Session share error):\s+/.test(body[i]!)) {
@@ -120,11 +165,27 @@ export function parseSubagentNotifyContent(content: string): SubagentNotifyDetai
 	}
 	const sessionLine = sessionIndex >= 0 ? body[sessionIndex] : undefined;
 	const handoffIndex = body.findIndex((line) => line.startsWith("Parallel handoff: "));
-	const metadataIndexes = [sessionIndex, handoffIndex].filter((index) => index >= 0);
+	const workflowRunIndex = body.findIndex((line) => line.startsWith("Workflow run: "));
+	const childRunsIndex = body.findIndex((line) => line.startsWith("Child runs: "));
+	const reconciledIndex = body.findIndex((line) => line.startsWith("Reconciled detached child: "));
+	const metadataIndexes = [sessionIndex, handoffIndex, workflowRunIndex, childRunsIndex, reconciledIndex].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;
+	const workflowRunId = workflowRunIndex >= 0 ? body[workflowRunIndex]!.slice("Workflow run: ".length).trim() : undefined;
+	const childRuns = childRunsIndex >= 0
+		? body[childRunsIndex]!.slice("Child runs: ".length).split(", ").map((part) => {
+			const trimmed = part.trim();
+			const statusMatch = trimmed.match(/^(.*?)(?: \(([^)]*)\))?$/);
+			const raw = statusMatch?.[1] ?? trimmed;
+			const separator = raw.indexOf("=");
+			return separator >= 0
+				? { workflowKey: raw.slice(0, separator), runId: raw.slice(separator + 1), ...(statusMatch?.[2] ? { status: statusMatch[2] } : {}) }
+				: { runId: raw, ...(statusMatch?.[2] ? { status: statusMatch[2] } : {}) };
+		}).filter((child) => child.runId)
+		: undefined;
+	const reconciledFromDetachedChild = reconciledIndex >= 0 ? body[reconciledIndex]!.slice("Reconciled detached child: ".length).trim() : undefined;
 	let sessionLabel: string | undefined;
 	let sessionValue: string | undefined;
 	if (sessionLine) {
@@ -137,8 +198,12 @@ export function parseSubagentNotifyContent(content: string): SubagentNotifyDetai
 		status: match[2] as SubagentNotifyDetails["status"],
 		...(match[1] === "Detached foreground task" ? { source: "foreground" as const } : {}),
 		...(match[4] ? { taskInfo: match[4] } : {}),
+		...(parsedScheduleOrigin ? { scheduleOrigin: parsedScheduleOrigin } : {}),
 		resultPreview,
 		...(handoffPath ? { handoffPath } : {}),
+		...(workflowRunId ? { workflowRunId } : {}),
+		...(childRuns?.length ? { childRuns } : {}),
+		...(reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {}),
 		...(sessionLabel && sessionValue ? { sessionLabel, sessionValue } : {}),
 	};
 }
@@ -150,9 +215,10 @@ export function formatGroupedCompletion(details: SubagentNotifyDetails[]): strin
 		const detail = details[index];
 		if (!detail) continue;
 		const sessionLine = formatSessionLine(detail);
-		blocks.push(`${index + 1}. ${detail.agent}${detail.taskInfo ?? ""}`);
+		blocks.push(`${index + 1}. ${detail.agent}${detail.taskInfo ?? ""}${detail.scheduleOrigin ? ` — scheduled run from ${detail.scheduleOrigin.name ?? detail.scheduleOrigin.id} (schedule ${detail.scheduleOrigin.id})` : ""}`);
 		blocks.push(detail.resultPreview.trim() ? detail.resultPreview : "(no output)");
 		if (detail.handoffPath) blocks.push(`Parallel handoff: ${detail.handoffPath}`);
+		blocks.push(...formatCorrelationLines(detail));
 		if (sessionLine) blocks.push(sessionLine);
 		blocks.push("");
 	}
@@ -170,7 +236,7 @@ function sendCompletion(pi: Pick<ExtensionAPI, "sendMessage">, items: PendingCom
 	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");
+	const display = details.some((detail) => detail.source === "foreground" || detail.status !== "completed" || detail.scheduleOrigin !== undefined);
 	try {
 		pi.sendMessage(
 			{
@@ -217,6 +283,18 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 		? result.parallelHandoff as { path?: unknown }
 		: undefined;
 	const handoffPath = typeof parallelHandoff?.path === "string" ? parallelHandoff.path : undefined;
+	const rawRunId = typeof result.runId === "string" ? result.runId : typeof result.id === "string" ? result.id : undefined;
+	const workflowRunId = (result.mode === "workflow" || agent === "workflow") && rawRunId ? rawRunId : undefined;
+	const childRuns = result.results?.flatMap((child) => {
+		if (typeof child.runId !== "string" || !child.runId.trim()) return [];
+		return [{
+			runId: child.runId,
+			...(typeof child.workflowKey === "string" ? { workflowKey: child.workflowKey } : {}),
+			...(typeof child.agent === "string" ? { agent: child.agent } : {}),
+			...(typeof child.status === "string" ? { status: child.status } : {}),
+		}];
+	}) ?? [];
+	const reconciledFromDetachedChild = typeof result.reconciledFromDetachedChild === "string" ? result.reconciledFromDetachedChild : undefined;
 	const session =
 		result.shareUrl
 			? { label: "Session", value: result.shareUrl }
@@ -225,21 +303,29 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 				: result.sessionFile
 					? { label: "Session file", value: result.sessionFile }
 					: undefined;
+	const rawOrigin = result.scheduleOrigin;
+	const scheduleOrigin = rawOrigin && typeof rawOrigin.id === "string"
+		? { id: rawOrigin.id, ...(typeof rawOrigin.name === "string" ? { name: rawOrigin.name } : {}) }
+		: undefined;
 	return {
 		agent,
 		status,
+		...(scheduleOrigin ? { scheduleOrigin } : {}),
 		...(result.source ? { source: result.source } : {}),
 		...(taskInfo ? { taskInfo } : {}),
 		resultPreview: summary,
 		...(typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {}),
 		...(handoffPath ? { handoffPath } : {}),
+		...(workflowRunId ? { workflowRunId } : {}),
+		...(childRuns.length ? { childRuns } : {}),
+		...(reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {}),
 		...(session ? { sessionLabel: session.label, sessionValue: session.value } : {}),
 	};
 }
 
 export default function registerSubagentNotify(
 	pi: ExtensionAPI,
-	state: Pick<SubagentState, "currentSessionId" | "sessionLineage">,
+	state: Pick<SubagentState, "currentSessionId" | "completionOwnerId">,
 	options: RegisterSubagentNotifyOptions = {},
 ): CompletionNotifier {
 	const seen = new Map<string, number>();
@@ -250,9 +336,6 @@ export default function registerSubagentNotify(
 	const batchers = new Map<string, CompletionBatcher<PendingCompletion>>();
 	let disposed = false;
 
-	const ownsSession = (sessionId: string) =>
-		sessionId === state.currentSessionId || state.sessionLineage?.includes(sessionId) === true;
-
 	const settle = (items: PendingCompletion[], accepted: boolean) => {
 		for (const item of items) {
 			pending.delete(item.key);
@@ -277,7 +360,8 @@ export default function registerSubagentNotify(
 	};
 
 	const deliver = (result: CompletionNotification): Promise<boolean> => {
-		if (disposed || typeof result.sessionId !== "string" || !ownsSession(result.sessionId)) return Promise.resolve(false);
+		if (disposed || typeof result.sessionId !== "string" || result.sessionId !== state.currentSessionId) return Promise.resolve(false);
+		if (result.source !== "foreground" && (!state.completionOwnerId || result.completionOwnerId !== state.completionOwnerId)) return Promise.resolve(false);
 		if (result.intercomDelivered === true) return Promise.resolve(true);
 		const key = buildCompletionKey(result, "notify");
 		const seenAt = seen.get(key);

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

@@ -2,14 +2,18 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { MISSION_BINDING_FILE } from "../../missions/lifecycle.ts";
+import { encodeIndexSegment, indexSegmentAliases, MAX_INDEX_SEGMENT_BYTES } from "./index-segment.ts";
 
 const RESULT_INDEX_VERSION = 1;
 const RESULT_INDEX_DIR = "result-index";
 const SESSION_INDEX_DIR = "sessions";
+const RUN_INDEX_DIR = "runs";
 const OBSERVER_INDEX_DIR = "observers";
 const TOOL_CALL_INDEX_DIR = "tool-calls";
 const RESULT_PENDING_DIR = "result-pending";
 const MISSION_OBSERVER = "mission";
+const JSON_EXTENSION = ".json";
+const MAX_JSON_FILE_STEM_BYTES = MAX_INDEX_SEGMENT_BYTES - Buffer.byteLength(JSON_EXTENSION, "utf-8");
 
 export interface ResultIndexEntry {
 	version: 1;
@@ -21,7 +25,15 @@ export interface ResultIndexEntry {
 }
 
 function encodeSegment(value: string): string {
-	return encodeURIComponent(value);
+	return encodeIndexSegment(value);
+}
+
+function encodedJsonFileName(value: string): string {
+	return `${encodeIndexSegment(value, MAX_JSON_FILE_STEM_BYTES)}${JSON_EXTENSION}`;
+}
+
+function encodedJsonFileNames(value: string): string[] {
+	return indexSegmentAliases(value, MAX_JSON_FILE_STEM_BYTES).map((segment) => `${segment}${JSON_EXTENSION}`);
 }
 
 function nonEmptyString(value: unknown): string | undefined {
@@ -29,7 +41,7 @@ function nonEmptyString(value: unknown): string | undefined {
 }
 
 export function resultFileName(runId: string): string {
-	return `${runId}.json`;
+	return `${runId}${JSON_EXTENSION}`;
 }
 
 export function resultFilePath(resultsDir: string, runId: string): string {
@@ -40,12 +52,39 @@ function sessionIndexDir(resultsDir: string, sessionId: string): string {
 	return path.join(resultsDir, RESULT_INDEX_DIR, SESSION_INDEX_DIR, encodeSegment(sessionId));
 }
 
+function sessionIndexDirs(resultsDir: string, sessionId: string): string[] {
+	return indexSegmentAliases(sessionId).map((segment) => path.join(resultsDir, RESULT_INDEX_DIR, SESSION_INDEX_DIR, segment));
+}
+
 function resultIndexPath(resultsDir: string, sessionId: string, runId: string): string {
-	return path.join(sessionIndexDir(resultsDir, sessionId), `${encodeSegment(runId)}.json`);
+	return path.join(sessionIndexDir(resultsDir, sessionId), encodedJsonFileName(runId));
+}
+
+function resultIndexPaths(resultsDir: string, sessionId: string, runId: string): string[] {
+	return sessionIndexDirs(resultsDir, sessionId).flatMap((dir) => encodedJsonFileNames(runId).map((fileName) => path.join(dir, fileName)));
+}
+
+function runIndexPath(resultsDir: string, runId: string): string {
+	return path.join(resultsDir, RESULT_INDEX_DIR, RUN_INDEX_DIR, encodedJsonFileName(runId));
 }
 
 function resultPendingPath(resultsDir: string, sessionId: string, runId: string): string {
-	return path.join(resultsDir, RESULT_PENDING_DIR, encodeSegment(sessionId), `${encodeSegment(runId)}.json`);
+	return path.join(resultsDir, RESULT_PENDING_DIR, encodeSegment(sessionId), encodedJsonFileName(runId));
+}
+
+function resultPendingPaths(resultsDir: string, sessionId: string, runId: string): string[] {
+	return indexSegmentAliases(sessionId).flatMap((segment) => encodedJsonFileNames(runId).map((fileName) => path.join(resultsDir, RESULT_PENDING_DIR, segment, fileName)));
+}
+
+function pendingSessionDirs(resultsDir: string, sessionId: string): string[] {
+	return indexSegmentAliases(sessionId).map((segment) => path.join(resultsDir, RESULT_PENDING_DIR, segment));
+}
+
+function firstExistingResultFile(paths: string[]): string | undefined {
+	for (const filePath of paths) {
+		if (existingResultFile(filePath)) return filePath;
+	}
+	return undefined;
 }
 
 function observerIndexDir(resultsDir: string, observer: string): string {
@@ -53,15 +92,15 @@ function observerIndexDir(resultsDir: string, observer: string): string {
 }
 
 function observerIndexPath(resultsDir: string, observer: string, runId: string): string {
-	return path.join(observerIndexDir(resultsDir, observer), `${encodeSegment(runId)}.json`);
+	return path.join(observerIndexDir(resultsDir, observer), encodedJsonFileName(runId));
 }
 
 function toolCallIndexDir(resultsDir: string, toolCallId: string): string {
-	return path.join(resultsDir, RESULT_INDEX_DIR, TOOL_CALL_INDEX_DIR, encodeSegment(toolCallId));
+	return path.join(resultsDir, RESULT_INDEX_DIR, TOOL_CALL_INDEX_DIR, encodeIndexSegment(toolCallId));
 }
 
 function toolCallIndexPath(resultsDir: string, toolCallId: string, runId: string): string {
-	return path.join(toolCallIndexDir(resultsDir, toolCallId), `${encodeSegment(runId)}.json`);
+	return path.join(toolCallIndexDir(resultsDir, toolCallId), encodedJsonFileName(runId));
 }
 
 function parseResultIndexEntry(value: unknown): ResultIndexEntry | undefined {
@@ -97,6 +136,11 @@ export function writeResultIndexForData(resultPath: string, data: Record<string,
 	};
 	const resultsDir = path.dirname(resultPath);
 	writeAtomicJson(resultIndexPath(resultsDir, sessionId, runId), entry);
+	try {
+		writeAtomicJson(runIndexPath(resultsDir, runId), entry);
+	} catch (error) {
+		console.error(`Failed to write async result run index for '${resultPath}':`, error);
+	}
 	const toolCallId = nonEmptyString(data.toolCallId);
 	try {
 		if (toolCallId) writeAtomicJson(toolCallIndexPath(resultsDir, toolCallId, runId), entry);
@@ -136,17 +180,26 @@ export function writeAsyncResultFile(resultPath: string, data: Record<string, un
 export function removeResultIndex(resultsDir: string, sessionId: string | undefined, runId: string | undefined, toolCallId?: string): void {
 	if (!runId) return;
 	if (sessionId) {
-		try {
-			fs.rmSync(resultIndexPath(resultsDir, sessionId, runId), { force: true });
-		} catch {
-			// Index cleanup must not affect result delivery.
+		for (const indexPath of resultIndexPaths(resultsDir, sessionId, runId)) {
+			try {
+				fs.rmSync(indexPath, { force: true });
+			} catch {
+				// Index cleanup must not affect result delivery.
+			}
 		}
-		try {
-			fs.rmSync(resultPendingPath(resultsDir, sessionId, runId), { force: true });
-		} catch {
-			// Pending cleanup must not affect result delivery.
+		for (const pendingPath of resultPendingPaths(resultsDir, sessionId, runId)) {
+			try {
+				fs.rmSync(pendingPath, { force: true });
+			} catch {
+				// Pending cleanup must not affect result delivery.
+			}
 		}
 	}
+	try {
+		fs.rmSync(runIndexPath(resultsDir, runId), { force: true });
+	} catch {
+		// Index cleanup must not affect result delivery.
+	}
 	if (toolCallId) {
 		try {
 			fs.rmSync(toolCallIndexPath(resultsDir, toolCallId, runId), { force: true });
@@ -180,7 +233,7 @@ function existingResultFile(resultPath: string): boolean {
 }
 
 function pendingResultExists(resultsDir: string, sessionId: string, runId: string): boolean {
-	return existingResultFile(resultPendingPath(resultsDir, sessionId, runId));
+	return firstExistingResultFile(resultPendingPaths(resultsDir, sessionId, runId)) !== undefined;
 }
 
 function pendingResultPayloadMatches(filePath: string, sessionId: string, runId: string): boolean {
@@ -193,16 +246,34 @@ function pendingResultPayloadMatches(filePath: string, sessionId: string, runId:
 	}
 }
 
+function assertPendingResultPayloadMatches(filePath: string, sessionId: string, runId: string): boolean {
+	const data = JSON.parse(fs.readFileSync(filePath, "utf-8")) as Record<string, unknown>;
+	return (nonEmptyString(data.runId) ?? nonEmptyString(data.id)) === runId && nonEmptyString(data.sessionId) === sessionId;
+}
+
 export function promotePendingResultFile(resultsDir: string, sessionId: string, runId: string, file = resultFileName(runId), options: { logFailure?: boolean } = {}): "none" | "promoted" | "pending" {
 	if (file !== path.basename(file) || !file.endsWith(".json")) return "none";
-	const pendingPath = resultPendingPath(resultsDir, sessionId, runId);
-	if (!existingResultFile(pendingPath)) return "none";
+	const pendingPath = firstExistingResultFile(resultPendingPaths(resultsDir, sessionId, runId));
+	if (!pendingPath) return "none";
 	const resultPath = path.join(resultsDir, file);
 	try {
-		fs.rmSync(resultPath, { force: true });
+		// POSIX rename replaces the destination atomically. Deleting it first lets a
+		// losing promoter unlink the result that another promoter just published.
 		fs.renameSync(pendingPath, resultPath);
 		return existingResultFile(resultPath) ? "promoted" : "pending";
 	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT" || code === "EEXIST" || code === "EPERM" || code === "EACCES") {
+			const pendingExists = existingResultFile(pendingPath);
+			const resultExists = existingResultFile(resultPath);
+			if (pendingExists) {
+				if (!resultExists && options.logFailure !== false) console.error(`Failed to promote pending async result '${pendingPath}' to '${resultPath}':`, error);
+				return "pending";
+			}
+			if (resultExists) return "promoted";
+			if (options.logFailure !== false) console.error(`Pending async result '${pendingPath}' disappeared without a promoted result at '${resultPath}'.`);
+			return "none";
+		}
 		if (options.logFailure !== false) console.error(`Failed to promote pending async result '${pendingPath}' to '${resultPath}':`, error);
 		return "pending";
 	}
@@ -216,33 +287,15 @@ interface ResultPayloadLocation {
 
 function pendingResultLocationForSessionRun(resultsDir: string, sessionId: string, runId: string, file = resultFileName(runId)): ResultPayloadLocation | undefined {
 	if (file !== path.basename(file) || !file.endsWith(".json")) return undefined;
-	const pendingPath = resultPendingPath(resultsDir, sessionId, runId);
-	return existingResultFile(pendingPath) && pendingResultPayloadMatches(pendingPath, sessionId, runId)
-		? { file, path: pendingPath, state: "pending" }
-		: undefined;
+	const pendingPath = firstExistingResultFile(resultPendingPaths(resultsDir, sessionId, runId));
+	if (!pendingPath || !pendingResultPayloadMatches(pendingPath, sessionId, runId)) return undefined;
+	return { file, path: pendingPath, state: "pending" };
 }
 
-function pendingResultLocationForIndexedRun(resultsDir: string, runId: string): ResultPayloadLocation | undefined {
-	const root = path.join(resultsDir, RESULT_PENDING_DIR);
-	let sessions: fs.Dirent[];
-	try {
-		sessions = fs.readdirSync(root, { withFileTypes: true });
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT") console.error(`Failed to inspect pending async result root '${root}':`, error);
-		return undefined;
-	}
-	for (const session of sessions) {
-		if (!session.isDirectory()) continue;
-		let sessionId: string;
-		try {
-			sessionId = decodeURIComponent(session.name);
-		} catch {
-			continue;
-		}
-		const location = pendingResultLocationForSessionRun(resultsDir, sessionId, runId);
-		if (location) return location;
-	}
-	return undefined;
+export function fallbackResultPayloadPathForSessionRun(resultsDir: string, sessionId: string, runId: string): string | undefined {
+	const pendingPath = firstExistingResultFile(resultPendingPaths(resultsDir, sessionId, runId));
+	if (!pendingPath || !assertPendingResultPayloadMatches(pendingPath, sessionId, runId)) return undefined;
+	return pendingPath;
 }
 
 function resultPayloadLocationFromIndex(resultsDir: string, entry: ResultIndexEntry): ResultPayloadLocation | undefined {
@@ -257,15 +310,20 @@ function resultPayloadLocationFromIndex(resultsDir: string, entry: ResultIndexEn
 }
 
 function readResultIndexForSessionRun(resultsDir: string, sessionId: string, runId: string): ResultIndexEntry | undefined {
-	try {
-		const entry = parseResultIndexEntry(JSON.parse(fs.readFileSync(resultIndexPath(resultsDir, sessionId, runId), "utf-8")));
-		if (!entry || entry.sessionId !== sessionId || entry.runId !== runId) return undefined;
-		return entry;
-	} catch (error) {
-		const code = (error as NodeJS.ErrnoException).code;
-		if (code !== "ENOENT" && code !== "ENOTDIR") console.error(`Ignoring invalid async result index for '${runId}':`, error);
-		return undefined;
+	for (const indexPath of resultIndexPaths(resultsDir, sessionId, runId)) {
+		try {
+			const entry = parseResultIndexEntry(JSON.parse(fs.readFileSync(indexPath, "utf-8")));
+			if (!entry || entry.sessionId !== sessionId || entry.runId !== runId) continue;
+			return entry;
+		} catch (error) {
+			const code = (error as NodeJS.ErrnoException).code;
+			if (code === "EPERM" || code === "EACCES") throw error;
+			if (code !== "ENOENT" && code !== "ENOTDIR") {
+				console.error(`Ignoring invalid async result index for '${runId}':`, error);
+			}
+		}
 	}
+	return undefined;
 }
 
 export function resultPayloadPathForSessionRun(resultsDir: string, sessionId: string, runId: string): string | undefined {
@@ -286,27 +344,24 @@ export function resultPayloadPathForMissionObserverRun(resultsDir: string, runId
 }
 
 export function resultPayloadPathForIndexedRun(resultsDir: string, runId: string): string | undefined {
-	const root = path.join(resultsDir, RESULT_INDEX_DIR, SESSION_INDEX_DIR);
-	let sessions: fs.Dirent[] = [];
+	const entryPath = runIndexPath(resultsDir, runId);
 	try {
-		sessions = fs.readdirSync(root, { withFileTypes: true });
+		const entry = parseResultIndexEntry(JSON.parse(fs.readFileSync(entryPath, "utf-8")));
+		if (!entry || entry.runId !== runId) {
+			fs.rmSync(entryPath, { force: true });
+			return undefined;
+		}
+		const location = resultPayloadLocationFromIndex(resultsDir, entry);
+		if (location) return location.path;
+		fs.rmSync(entryPath, { force: true });
 	} catch (error) {
 		const code = (error as NodeJS.ErrnoException).code;
-		if (code !== "ENOENT" && code !== "ENOTDIR") console.error(`Failed to inspect async result session index root '${root}':`, error);
-	}
-	for (const session of sessions) {
-		if (!session.isDirectory()) continue;
-		const entryPath = path.join(root, session.name, `${encodeSegment(runId)}.json`);
-		try {
-			const entry = parseResultIndexEntry(JSON.parse(fs.readFileSync(entryPath, "utf-8")));
-			if (!entry || entry.runId !== runId) continue;
-			const location = resultPayloadLocationFromIndex(resultsDir, entry);
-			if (location) return location.path;
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") console.error(`Ignoring invalid async result index '${entryPath}':`, error);
+		if (code !== "ENOENT" && code !== "ENOTDIR") {
+			console.error(`Ignoring invalid async result run index '${entryPath}':`, error);
+			try { fs.rmSync(entryPath, { force: true }); } catch {}
 		}
 	}
-	return pendingResultLocationForIndexedRun(resultsDir, runId)?.path;
+	return undefined;
 }
 
 function indexedResultFile(resultsDir: string, entry: ResultIndexEntry, includePending = false): string | undefined {
@@ -323,7 +378,7 @@ function listIndexFiles(dir: string): string[] {
 			.map((entry) => path.join(dir, entry.name));
 	} catch (error) {
 		const code = (error as NodeJS.ErrnoException).code;
-		if (code === "ENOENT" || code === "ENOTDIR") return [];
+		if (code === "ENOENT" || code === "ENOTDIR" || code === "EPERM" || code === "EACCES") return [];
 		throw error;
 	}
 	return files;
@@ -348,44 +403,56 @@ function resultFilesFromIndexDir(resultsDir: string, dir: string, includePending
 }
 
 export function resultFilesForSession(resultsDir: string, sessionId: string): string[] {
-	return resultFilesFromIndexDir(resultsDir, sessionIndexDir(resultsDir, sessionId));
+	const files = new Set<string>();
+	for (const dir of sessionIndexDirs(resultsDir, sessionId)) {
+		for (const file of resultFilesFromIndexDir(resultsDir, dir)) files.add(file);
+	}
+	return [...files];
 }
 
 function pendingResultFilesForSession(resultsDir: string, sessionId: string): string[] {
-	const dir = path.join(resultsDir, RESULT_PENDING_DIR, encodeSegment(sessionId));
-	let entries: fs.Dirent[];
-	try {
-		entries = fs.readdirSync(dir, { withFileTypes: true });
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
-		throw error;
-	}
 	const files = new Set<string>();
-	for (const entry of entries) {
-		if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-		const pendingPath = path.join(dir, entry.name);
+	for (const dir of pendingSessionDirs(resultsDir, sessionId)) {
+		let entries: fs.Dirent[];
 		try {
-			const data = JSON.parse(fs.readFileSync(pendingPath, "utf-8")) as Record<string, unknown>;
-			const runId = nonEmptyString(data.runId) ?? nonEmptyString(data.id);
-			if (runId && nonEmptyString(data.sessionId) === sessionId) files.add(resultFileName(runId));
+			entries = fs.readdirSync(dir, { withFileTypes: true });
 		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") console.error(`Ignoring invalid pending async result '${pendingPath}':`, error);
+			const code = (error as NodeJS.ErrnoException).code;
+			if (code === "ENOENT" || code === "ENOTDIR" || code === "EPERM" || code === "EACCES") continue;
+			throw error;
+		}
+		for (const entry of entries) {
+			if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+			const pendingPath = path.join(dir, entry.name);
+			try {
+				const data = JSON.parse(fs.readFileSync(pendingPath, "utf-8")) as Record<string, unknown>;
+				const runId = nonEmptyString(data.runId) ?? nonEmptyString(data.id);
+				if (runId && nonEmptyString(data.sessionId) === sessionId) files.add(resultFileName(runId));
+			} catch (error) {
+				if ((error as NodeJS.ErrnoException).code !== "ENOENT") console.error(`Ignoring invalid pending async result '${pendingPath}':`, error);
+			}
 		}
 	}
 	return [...files];
 }
 
 export function resultCandidateFilesForSession(resultsDir: string, sessionId: string): string[] {
-	return [...new Set([
-		...resultFilesFromIndexDir(resultsDir, sessionIndexDir(resultsDir, sessionId), true),
-		...pendingResultFilesForSession(resultsDir, sessionId),
-	])];
+	const files = new Set<string>();
+	for (const dir of sessionIndexDirs(resultsDir, sessionId)) {
+		for (const file of resultFilesFromIndexDir(resultsDir, dir, true)) files.add(file);
+	}
+	for (const file of pendingResultFilesForSession(resultsDir, sessionId)) files.add(file);
+	return [...files];
 }
 
 export function resultFilesForToolCall(resultsDir: string, toolCallId: string): string[] {
 	return resultFilesFromIndexDir(resultsDir, toolCallIndexDir(resultsDir, toolCallId));
 }
 
+export function resultCandidateFilesForToolCall(resultsDir: string, toolCallId: string): string[] {
+	return resultFilesFromIndexDir(resultsDir, toolCallIndexDir(resultsDir, toolCallId), true);
+}
+
 export function missionObserverResultFiles(resultsDir: string): string[] {
 	return resultFilesFromIndexDir(resultsDir, observerIndexDir(resultsDir, MISSION_OBSERVER));
 }
@@ -403,7 +470,8 @@ export function cleanupResultIndexes(resultsDir: string, now = Date.now(), maxAg
 		try {
 			entries = fs.readdirSync(dir, { withFileTypes: true });
 		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
+			const code = (error as NodeJS.ErrnoException).code;
+			if (code === "ENOENT" || code === "ENOTDIR" || code === "EPERM" || code === "EACCES") return;
 			throw error;
 		}
 		for (const entry of entries) {