pi-cohort 7.1.2 → 7.2.1

package/src/runs/background/external-attempt.ts

@@ -8,10 +8,11 @@
  * before the task arg and forwards all other args unchanged.
  */
 import * as path from "node:path";
+import { PINNED_AGENT_DIR_OVERRIDE } from "../../shared/agent-dir.ts";
 import { fileURLToPath } from "node:url";
 import type { Message } from "@earendil-works/pi-ai";
 import type { Usage } from "../../shared/types.ts";
-import { getPiSpawnCommand } from "../shared/pi-spawn.ts";
+import { getPiSpawnCommand, type PiRuntimeIdentity } from "../shared/pi-spawn.ts";
 import { isMutatingTool } from "../shared/long-running-guard.ts";
 import type { ExternalAttemptResult, ExternalExecution } from "../shared/external-execution.ts";
 import type { OnNewSessionMessage } from "../../execution-backend/session-watcher.ts";
@@ -36,6 +37,7 @@ interface SynthesizedChildEvent {
 export type OnSynthesizedChildEvent = (event: SynthesizedChildEvent) => void;
 
 export interface RunExternalBackgroundAttemptInput {
+	readonly runtime: PiRuntimeIdentity;
 	readonly owner: ExternalExecution;
 	readonly attemptId: string;
 	/**
@@ -148,13 +150,15 @@ export async function runExternalBackgroundAttempt(
 	args.push("--extension", REPORTING_EXTENSION_PATH);
 	if (taskArg !== undefined) args.push(taskArg);
 
-	const spawnSpec = getPiSpawnCommand(args);
+	const spawnSpec = getPiSpawnCommand(args, input.runtime);
 
 	const mergedEnv: Record<string, string> = {};
 	for (const [key, value] of Object.entries(environment)) {
 		if (value !== undefined) mergedEnv[key] = value;
 	}
 
+	if (PINNED_AGENT_DIR_OVERRIDE) mergedEnv.PI_CODING_AGENT_DIR = PINNED_AGENT_DIR_OVERRIDE;
+
 	const onNewSessionMessage: OnNewSessionMessage | undefined = onChildEvent
 		? (message) => synthesizeChildEvents(message, onChildEvent)
 		: undefined;

package/src/runs/background/notify.ts

@@ -40,18 +40,7 @@ interface SubagentResult {
 	totalTasks?: number;
 }
 
-export default function registerSubagentNotify(pi: ExtensionAPI): void {
-	const unsubscribeStoreKey = "__pi_subagents_notify_unsubscribe__";
-	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.
-		}
-	}
-
+export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 	const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
 	const ttlMs = 10 * 60 * 1000;
 
@@ -104,5 +93,5 @@ export default function registerSubagentNotify(pi: ExtensionAPI): void {
 		);
 	};
 
-	globalStore[unsubscribeStoreKey] = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
+	return pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
 }

package/src/runs/background/run-id-resolver.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { ASYNC_DIR, RESULTS_DIR, type SubagentState } from "../../shared/types.ts";
-import { findAsyncRunPrefixMatches, type AsyncRunLocation } from "./async-resume.ts";
+import { ASYNC_DIR, LEGACY_ASYNC_DIR, RESULTS_DIR, type SubagentState } from "../../shared/types.ts";
+import { findAsyncRunPrefixMatches, resolveAsyncRunLocation, winningAsyncRunEntries, type AsyncRunLocation } from "./async-resume.ts";
 import { assertSafeNestedId, findNestedRunMatchesById, type NestedRoute, type NestedRunMatch, type NestedRunResolutionScope } from "../shared/nested-events.ts";
 
 export type ResolvedSubagentRunId =
@@ -11,20 +11,17 @@ export type ResolvedSubagentRunId =
 
 export interface ResolveSubagentRunIdDeps {
 	state?: SubagentState;
-	asyncDirRoot?: string;
+	asyncDirRoot?: string | readonly string[];
 	resultsDir?: string;
 	nested?: NestedRunResolutionScope;
+	readOnlyLegacy?: boolean;
 }
 
-function exactAsyncLocation(id: string, asyncDirRoot: string, resultsDir: string): AsyncRunLocation | undefined {
-	const asyncDir = path.join(asyncDirRoot, id);
+function exactAsyncLocation(id: string, asyncDirRoot: string | readonly string[], resultsDir: string): AsyncRunLocation | undefined {
+	const exact = winningAsyncRunEntries(asyncDirRoot, id).find((entry) => entry.id === id);
 	const resultPath = path.join(resultsDir, `${id}.json`);
-	if (!fs.existsSync(asyncDir) && !fs.existsSync(resultPath)) return undefined;
-	return {
-		asyncDir: fs.existsSync(asyncDir) ? asyncDir : null,
-		resultPath: fs.existsSync(resultPath) ? resultPath : null,
-		resolvedId: id,
-	};
+	if (!exact && !fs.existsSync(resultPath)) return undefined;
+	return resolveAsyncRunLocation({ id }, asyncDirRoot, resultsDir);
 }
 
 function foregroundIds(state: SubagentState | undefined): string[] {
@@ -37,7 +34,7 @@ function nestedScopeFromState(state: SubagentState | undefined): NestedRunResolu
 	const seen = new Set<string>();
 	const add = (route: NestedRoute | undefined) => {
 		if (!route) return;
-		const key = `${route.rootRunId}:${route.eventSink}:${route.controlInbox}`;
+		const key = JSON.stringify([route.rootRunId, route.capabilityToken, route.eventSink, route.controlInbox]);
 		if (seen.has(key)) return;
 		seen.add(key);
 		routes.push(route);
@@ -47,20 +44,21 @@ function nestedScopeFromState(state: SubagentState | undefined): NestedRunResolu
 	return { routes };
 }
 
-function asyncPrefixMatches(prefix: string, asyncDirRoot: string, resultsDir: string): Array<{ id: string; location: AsyncRunLocation }> {
+function asyncPrefixMatches(prefix: string, asyncDirRoot: string | readonly string[], resultsDir: string): Array<{ id: string; location: AsyncRunLocation }> {
 	return findAsyncRunPrefixMatches(prefix, asyncDirRoot, resultsDir);
 }
 
 export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps = {}): ResolvedSubagentRunId | undefined {
 	assertSafeNestedId("id", id);
-	const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
+	const asyncDirRoot = deps.asyncDirRoot ?? [ASYNC_DIR, LEGACY_ASYNC_DIR];
 	const resultsDir = deps.resultsDir ?? RESULTS_DIR;
 
 	const nestedScope = deps.nested ?? nestedScopeFromState(deps.state);
 	if (deps.state?.foregroundControls.has(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 } : {});
+	const nestedOptions = { scope: nestedScope, readOnlyLegacy: deps.readOnlyLegacy };
+	const exactNested = findNestedRunMatchesById(id, nestedOptions);
 	if (exactNested.length > 1) throw new Error(`Nested run id '${id}' is ambiguous across authorized registries. Provide the full id after stale registries are cleaned up.`);
 	if (exactNested[0]) return { kind: "nested", id, match: exactNested[0] };
 
@@ -71,11 +69,10 @@ export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps
 	for (const match of asyncPrefixMatches(id, asyncDirRoot, resultsDir)) {
 		matches.push({ kind: "async", id: match.id, location: match.location });
 	}
-	for (const match of findNestedRunMatchesById(id, nestedScope ? { prefix: true, scope: nestedScope } : { prefix: true })) {
+	for (const match of findNestedRunMatchesById(id, { ...nestedOptions, prefix: true })) {
 		matches.push({ kind: "nested", id: match.run.id, match });
 	}
-	const unique = new Map(matches.map((match) => [`${match.kind}:${match.id}`, match]));
-	const values = [...unique.values()];
+	const values = matches;
 	if (values.length > 1) {
 		throw new Error(`Ambiguous subagent run id prefix '${id}' matched: ${values.map((match) => `${match.kind}:${match.id}`).join(", ")}. Provide a longer id.`);
 	}

package/src/runs/background/run-status.ts

@@ -1,16 +1,17 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { readStatus } from "../../shared/utils.ts";
 import { formatAsyncRunList, formatAsyncRunOutputPath, formatAsyncRunProgressLabel, listAsyncRuns } from "./async-status.ts";
 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 NestedRunSummary, type SubagentState } from "../../shared/types.ts";
-import { resolveAsyncRunLocation } from "./async-resume.ts";
+import { ASYNC_DIR, LEGACY_ASYNC_DIR, RESULTS_DIR, type AsyncStatus, type Details, type NestedRunSummary, type SubagentState } from "../../shared/types.ts";
+import { isLegacyAsyncDir, resolveAsyncRunLocation } from "./async-resume.ts";
 import { resolveSubagentRunId } from "./run-id-resolver.ts";
 import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
 import { readRunnerLogTail, reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
-import { attachRootChildrenToSteps, findNestedRouteForRootId, projectNestedRegistryForRoot, type NestedRunResolutionScope } from "../shared/nested-events.ts";
+import { attachRootChildrenToSteps, findNestedRouteForRootId, isLegacyNestedRoute, projectNestedRegistryForRoot, type NestedRunResolutionScope } from "../shared/nested-events.ts";
 
 interface RunStatusParams {
 	action?: "status";
@@ -20,7 +21,7 @@ interface RunStatusParams {
 }
 
 interface RunStatusDeps {
-	asyncDirRoot?: string;
+	asyncDirRoot?: string | readonly string[];
 	resultsDir?: string;
 	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
 	now?: () => number;
@@ -98,7 +99,7 @@ function formatNestedExactStatus(rootRunId: string, run: NestedRunSummary): stri
 }
 
 export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDeps = {}): AgentToolResult<Details> {
-	const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
+	const asyncDirRoot = deps.asyncDirRoot ?? [ASYNC_DIR, LEGACY_ASYNC_DIR];
 	const resultsDir = deps.resultsDir ?? RESULTS_DIR;
 	if (!params.id && !params.runId && !params.dir) {
 		if (deps.nested) {
@@ -128,10 +129,10 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 	try {
 		const requestedId = params.id ?? params.runId;
 		if (!params.dir && requestedId) {
-			const resolved = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
+			const resolved = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested, readOnlyLegacy: true });
 			if (resolved?.kind === "nested") {
-				reconcileNestedAsyncDescendants(resolved.match.route, { resultsDir, kill: deps.kill, now: deps.now });
-				const refreshed = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
+				if (!isLegacyNestedRoute(resolved.match.route)) reconcileNestedAsyncDescendants(resolved.match.route, { resultsDir, kill: deps.kill, now: deps.now });
+				const refreshed = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested, readOnlyLegacy: true });
 				const nested = refreshed?.kind === "nested" ? refreshed : resolved;
 				return { content: [{ type: "text", text: formatNestedExactStatus(nested.match.rootRunId, nested.match.run) }], details: { mode: "single", results: [] } };
 			}
@@ -161,7 +162,17 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 	if (asyncDir) {
 		let reconciliation;
 		try {
-			reconciliation = reconcileAsyncRun(asyncDir, { resultsDir, kill: deps.kill, now: deps.now });
+			const statusPath = path.join(asyncDir, "status.json");
+			let stored: AsyncStatus | null = null;
+			try {
+				stored = readStatus(asyncDir);
+				if (fs.existsSync(statusPath) && (!stored || typeof stored !== "object" || Array.isArray(stored))) throw new Error(`Invalid async status '${statusPath}': expected an object.`);
+			} catch (error) {
+				if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+			}
+			reconciliation = isLegacyAsyncDir(asyncDir) || (stored && stored.state !== "running" && stored.state !== "queued")
+				? { status: stored, message: undefined, resultPath }
+				: reconcileAsyncRun(asyncDir, { resultsDir, kill: deps.kill, now: deps.now });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			return {
@@ -179,8 +190,8 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			let nestedWarning: string | undefined;
 			try {
 				const nestedRoute = findNestedRouteForRootId(status.runId);
-				if (nestedRoute) reconcileNestedAsyncDescendants(nestedRoute, { resultsDir, kill: deps.kill, now: deps.now });
-				nestedChildren = projectNestedRegistryForRoot(status.runId)?.children ?? [];
+				if (nestedRoute && !isLegacyAsyncDir(asyncDir) && !isLegacyNestedRoute(nestedRoute)) reconcileNestedAsyncDescendants(nestedRoute, { resultsDir, kill: deps.kill, now: deps.now });
+				nestedChildren = projectNestedRegistryForRoot(status.runId, { readOnlyLegacy: true })?.children ?? [];
 				attachRootChildrenToSteps(status.runId, status.steps, nestedChildren);
 			} catch (error) {
 				nestedWarning = `Nested status unavailable: ${error instanceof Error ? error.message : String(error)}`;

package/src/runs/background/stale-run-reconciler.ts

@@ -240,6 +240,9 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 			asyncDir,
 			sessionId: status.sessionId,
 			sessionFile: status.sessionFile,
+			sessionDir: status.sessionDir,
+			runtime: status.runtime,
+			cwd: status.cwd,
 		},
 	};
 }
@@ -326,8 +329,13 @@ export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOp
 
 	const runId = effectiveStatus.runId || path.basename(asyncDir);
 	const resultPath = path.join(options.resultsDir ?? RESULTS_DIR, `${runId}.json`);
+	if (effectiveStatus.state === "queued") {
+		return { status: effectiveStatus, repaired: false, resultPath, message: "Unresolved async startup: queued run has not published running status; start a new run." };
+	}
+	if (terminal(effectiveStatus.state)) return { status: effectiveStatus, repaired: false, resultPath };
+
 	if (fs.existsSync(resultPath)) {
-		const terminalStatus = effectiveStatus.state === "running" || effectiveStatus.state === "queued"
+		const terminalStatus = effectiveStatus.state === "running"
 			? terminalStatusFromResult(effectiveStatus, resultPath, now)
 			: undefined;
 		if (terminalStatus) {

package/src/runs/background/subagent-runner.ts

@@ -1,11 +1,12 @@
 import { spawn, spawnSync } from "node:child_process";
+import { PINNED_AGENT_DIR_OVERRIDE } from "../../shared/agent-dir.ts";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import type { Message } from "@earendil-works/pi-ai";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { appendJsonl, getArtifactPaths } from "../../shared/artifacts.ts";
-import { PI_CODING_AGENT_PACKAGE, getPiSpawnCommand, resolveInstalledPiPackageRoot } from "../shared/pi-spawn.ts";
+import { getPiSpawnCommand, parsePiRuntime, PiRuntimeLaunchError, type PiRuntimeIdentity } from "../shared/pi-spawn.ts";
 import { captureSingleOutputSnapshot, finalizeSingleOutput, formatSavedOutputReference, resolveSingleOutput, type SingleOutputSnapshot } from "../shared/single-output.ts";
 import {
 	type ActivityState,
@@ -110,8 +111,7 @@ interface SubagentRunConfig {
 	sessionDir?: string;
 	asyncDir: string;
 	sessionId?: string | null;
-	piPackageRoot?: string;
-	piArgv1?: string;
+	runtime: PiRuntimeIdentity;
 	forwardedFlags?: string[];
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
@@ -244,21 +244,18 @@ function runPiStreaming(
 	args: string[],
 	cwd: string,
 	outputFile: string,
-	env?: Record<string, string | undefined>,
-	piPackageRoot?: string,
-	piArgv1?: string,
+	env: Record<string, string | undefined> | undefined,
+	runtime: PiRuntimeIdentity,
 	maxSubagentDepth?: number,
 	childEventContext?: ChildEventContext,
 	registerInterrupt?: (interrupt: (() => void) | undefined) => void,
 	onChildEvent?: (event: ChildEvent) => void,
 ): Promise<RunPiStreamingResult> {
-	return new Promise((resolve) => {
+	return new Promise((resolve, reject) => {
+		const spawnSpec = getPiSpawnCommand(args, runtime);
 		const outputStream = fs.createWriteStream(outputFile, { flags: "w" });
 		const spawnEnv = { ...process.env, ...(env ?? {}), ...getSubagentDepthEnv(maxSubagentDepth) };
-		const spawnSpec = getPiSpawnCommand(args, {
-			...(piPackageRoot ? { piPackageRoot } : {}),
-			...(piArgv1 ? { argv1: piArgv1 } : {}),
-		});
+		if (PINNED_AGENT_DIR_OVERRIDE) spawnEnv.PI_CODING_AGENT_DIR = PINNED_AGENT_DIR_OVERRIDE;
 		const child = spawn(spawnSpec.command, spawnSpec.args, {
 			cwd,
 			stdio: ["ignore", "pipe", "pipe"],
@@ -431,6 +428,7 @@ function runPiStreaming(
 			clearDrainTimers();
 		});
 		child.on("close", (exitCode, signal) => {
+			if (settled) return;
 			settled = true;
 			registerInterrupt?.(undefined);
 			clearDrainTimers();
@@ -460,22 +458,13 @@ function runPiStreaming(
 			clearDrainTimers();
 			clearStdioGuard();
 			outputStream.end();
-			const finalOutput = getFinalOutput(messages) || rawStdoutLines.join("\n").trim();
-			const spawnErrorMessage = spawnError instanceof Error ? spawnError.message : String(spawnError);
-			resolve({ stderr, exitCode: 1, messages, usage, model, error: error ?? assistantError ?? spawnErrorMessage, finalOutput, observedMutationAttempt });
+			reject(new PiRuntimeLaunchError(`Failed to spawn selected Pi runtime ${runtime.nodeExecPath} ${runtime.piEntryPath}: ${String(spawnError)}`));
 		});
 	});
 }
 
-function resolvePiPackageRootFallback(): string {
-	const root = resolveInstalledPiPackageRoot();
-	if (root) return root;
-	throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
-}
-
-async function exportSessionHtml(sessionFile: string, outputDir: string, piPackageRoot?: string): Promise<string> {
-	const pkgRoot = piPackageRoot ?? resolvePiPackageRootFallback();
-	const exportModulePath = path.join(pkgRoot, "dist", "core", "export-html", "index.js");
+async function exportSessionHtml(sessionFile: string, outputDir: string, piPackageRoot: string): Promise<string> {
+	const exportModulePath = path.join(piPackageRoot, "dist", "core", "export-html", "index.js");
 	const moduleUrl = pathToFileURL(exportModulePath).href;
 	const mod = await import(moduleUrl);
 	const exportFromFile = (mod as { exportFromFile?: (inputPath: string, options?: { outputPath?: string }) => string })
@@ -587,8 +576,7 @@ export interface SingleStepContext {
 	flatIndex: number;
 	flatStepCount: number;
 	outputFile: string;
-	piPackageRoot?: string;
-	piArgv1?: string;
+	runtime: PiRuntimeIdentity;
 	forwardedFlags?: string[];
 	registerInterrupt?: (interrupt: (() => void) | undefined) => void;
 	nestedRoute?: NestedRouteInfo;
@@ -636,6 +624,7 @@ export async function runSingleStep(
 			output: message,
 			exitCode: 1,
 			error: message,
+			sessionFile: step.sessionFile,
 		};
 	}
 
@@ -673,11 +662,11 @@ export async function runSingleStep(
 	const attemptNotes: string[] = [];
 	const eventsPath = path.join(path.dirname(ctx.outputFile), "events.jsonl");
 	let finalResult: RunPiStreamingResult | undefined;
+	let finalSessionFile = step.sessionFile;
 	let finalOutputSnapshot: SingleOutputSnapshot | undefined;
 	let completionGuardTriggeredFinal = false;
 	let executionSurface: ExecutionSurfaceResult | undefined;
 
-	const asyncDir = path.dirname(ctx.outputFile);
 	let externalOwner: ExternalExecution | undefined;
 
 	if (backendSelection.selection.kind === "external") {
@@ -687,6 +676,7 @@ export async function runSingleStep(
 		const ownerController = new AbortController();
 		try {
 			externalOwner = await createExternalExecution({
+				runtime: ctx.runtime,
 				runId: ctx.id,
 				childId: `${step.agent}-${ctx.flatIndex}`,
 				backend: selection.backend,
@@ -695,8 +685,8 @@ export async function runSingleStep(
 				signal: ownerController.signal,
 			});
 		} catch (startErr) {
-			const message = safeExternalFailure("startup", startErr);
-			return { agent: step.agent, output: message, exitCode: 1, error: message };
+			const message = startErr instanceof PiRuntimeLaunchError ? startErr.message : safeExternalFailure("startup", startErr);
+			return { agent: step.agent, output: message, exitCode: 1, error: message, sessionFile: step.sessionFile };
 		}
 
 		// Bridge registerInterrupt to an AbortController for the current external attempt.
@@ -718,7 +708,9 @@ export async function runSingleStep(
 				// External background: baseArgs=[] (no --mode json or -p); task is the last arg.
 				// Core allocates a trusted session file for every external attempt regardless of sessionEnabled.
 				// Caller owns tempDir cleanup (F1): cleanupTempDir is in finally, not in the helper.
-				const attemptSessionFile = path.join(asyncDir, `session-${ctx.flatIndex}-attempt-${index}.jsonl`);
+				if (!step.sessionFile) fs.mkdirSync(ctx.sessionDir!, { recursive: true });
+				const attemptSessionFile = step.sessionFile ?? path.join(ctx.sessionDir!, `session-${ctx.flatIndex}-attempt-${index}.jsonl`);
+				finalSessionFile = attemptSessionFile;
 				const { args, env, tempDir } = buildPiArgs({
 					baseArgs: [],
 					task,
@@ -754,6 +746,7 @@ export async function runSingleStep(
 				try {
 					try {
 						run = await runExternalBackgroundAttempt({
+							runtime: ctx.runtime,
 							owner: externalOwner,
 							attemptId: `${ctx.id}-${ctx.flatIndex}-attempt-${index}`,
 							args,
@@ -764,6 +757,7 @@ export async function runSingleStep(
 							onChildEvent: ctx.onChildEvent,
 						});
 					} catch (error) {
+						if (error instanceof PiRuntimeLaunchError) throw error;
 						run = {
 							stderr: "",
 							exitCode: 1,
@@ -840,7 +834,7 @@ export async function runSingleStep(
 				attemptNotes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
 			}
 		} catch (error) {
-			const message = safeExternalFailure("attempt", error);
+			const message = error instanceof PiRuntimeLaunchError ? error.message : safeExternalFailure("attempt", error);
 			finalResult = {
 				stderr: "",
 				exitCode: 1,
@@ -854,7 +848,6 @@ export async function runSingleStep(
 			ctx.registerInterrupt?.(undefined);
 		}
 	} else {
-		// Native path: unchanged, uses runPiStreaming.
 	for (let index = 0; index < candidates.length; index++) {
 		const candidate = candidates[index];
 		ctx.onAttemptStart?.({ model: candidate, thinking: resolveEffectiveThinking(candidate, step.thinking) });
@@ -898,13 +891,16 @@ export async function runSingleStep(
 				step.cwd ?? ctx.cwd,
 				ctx.outputFile,
 				env,
-				ctx.piPackageRoot,
-				ctx.piArgv1,
+				ctx.runtime,
 				step.maxSubagentDepth,
 				{ eventsPath, runId: ctx.id, stepIndex: ctx.flatIndex, agent: step.agent },
 				ctx.registerInterrupt,
 				ctx.onChildEvent,
 			);
+		} catch (error) {
+			if (!(error instanceof PiRuntimeLaunchError)) throw error;
+			finalResult = { stderr: "", exitCode: 1, messages: [], usage: emptyUsage(), error: error.message, finalOutput: "" };
+			break;
 		} finally {
 			cleanupTempDir(tempDir); // F1: ensure no prompt-dir leak on throw
 		}
@@ -1086,7 +1082,7 @@ export async function runSingleStep(
 		output: outputForSummary,
 		exitCode: effectiveFinalExitCode,
 		error: effectiveFinalError,
-		sessionFile: step.sessionFile,
+		sessionFile: finalSessionFile ?? (sessionEnabled && sessionDir ? findLatestSessionFile(sessionDir) ?? undefined : undefined),
 		model: finalResult?.model,
 		attemptedModels: attemptedModels.length > 0 ? attemptedModels : undefined,
 		modelAttempts,
@@ -1229,6 +1225,7 @@ function ensureParallelProgressFile(cwd: string, group: Extract<RunnerStep, { pa
 }
 
 async function runSubagent(config: SubagentRunConfig): Promise<void> {
+	config.runtime = parsePiRuntime(config.runtime, `Async run ${config.id}`);
 	const { id, steps, resultPath, cwd, placeholder, taskIndex, totalTasks, maxOutput, artifactsDir, artifactConfig } =
 		config;
 	let previousOutput = "";
@@ -1253,7 +1250,6 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 	let activityTimer: NodeJS.Timeout | undefined;
 	let previousCumulativeTokens: TokenUsage = { input: 0, output: 0, total: 0 };
 	let previousCumulativeCost = 0;
-	let latestSessionFile: string | undefined;
 
 	const parallelGroups: Array<{ start: number; count: number; stepIndex: number }> = [];
 	const initialStatusSteps: RunnerStatusStep[] = [];
@@ -1317,6 +1313,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 		|| shareEnabled
 		|| flatSteps.some((step) => Boolean(step.sessionFile));
 	const statusPayload: RunnerStatusPayload = {
+		runtime: config.runtime,
 		runId: id,
 		...(config.sessionId ? { sessionId: config.sessionId } : {}),
 		mode: config.resultMode ?? (flatSteps.length > 1 ? "chain" : "single"),
@@ -1874,8 +1871,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 					artifactsDir, artifactConfig, id,
 					flatIndex: fi, flatStepCount: Math.max(statusPayload.steps.length, 1),
 					outputFile: path.join(asyncDir, `output-${fi}.log`),
-					piPackageRoot: config.piPackageRoot,
-					piArgv1: config.piArgv1,
+					runtime: config.runtime,
 					forwardedFlags: config.forwardedFlags,
 					executionBackendCoordinator,
 					executionBackendConfig,
@@ -1891,6 +1887,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				statusPayload.steps[fi].endedAt = taskEndTime;
 				statusPayload.steps[fi].durationMs = taskEndTime - taskStartTime;
 				statusPayload.steps[fi].exitCode = singleResult.exitCode;
+				statusPayload.steps[fi].sessionFile = singleResult.sessionFile;
 				statusPayload.steps[fi].model = singleResult.model;
 				statusPayload.steps[fi].thinking = resolveEffectiveThinking(singleResult.model, statusPayload.steps[fi].thinking);
 				statusPayload.steps[fi].attemptedModels = singleResult.attemptedModels;
@@ -2111,7 +2108,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						}));
 
 						const taskSessionDir = config.sessionDir
-							? path.join(config.sessionDir, `parallel-${taskIdx}`)
+							? path.join(config.sessionDir, `parallel-${fi}`)
 							: undefined;
 						const { taskForRun, taskCwd } = prepareParallelTaskRun(task, cwd, worktreeSetup, taskIdx);
 
@@ -2122,8 +2119,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 							artifactsDir, artifactConfig, id,
 							flatIndex: fi, flatStepCount: flatSteps.length,
 							outputFile: path.join(asyncDir, `output-${fi}.log`),
-							piPackageRoot: config.piPackageRoot,
-							piArgv1: config.piArgv1,
+							runtime: config.runtime,
 							forwardedFlags: config.forwardedFlags,
 							executionBackendCoordinator,
 							executionBackendConfig,
@@ -2134,9 +2130,6 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 							onAttemptStart: (attempt) => updateStepModel(fi, attempt.model, attempt.thinking),
 							onChildEvent: (event) => updateStepFromChildEvent(fi, event),
 						});
-						if (task.sessionFile) {
-							latestSessionFile = task.sessionFile;
-						}
 
 						const taskEndTime = Date.now();
 						const taskDuration = taskEndTime - taskStartTime;
@@ -2145,6 +2138,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						statusPayload.steps[fi].endedAt = taskEndTime;
 						statusPayload.steps[fi].durationMs = taskDuration;
 						statusPayload.steps[fi].exitCode = singleResult.exitCode;
+						statusPayload.steps[fi].sessionFile = singleResult.sessionFile;
 						statusPayload.steps[fi].model = singleResult.model;
 						statusPayload.steps[fi].thinking = resolveEffectiveThinking(singleResult.model, statusPayload.steps[fi].thinking);
 						statusPayload.steps[fi].attemptedModels = singleResult.attemptedModels;
@@ -2186,7 +2180,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				for (let t = 0; t < group.parallel.length; t++) {
 					const fi = groupStartFlatIndex + t;
 					const sessionTokens = config.sessionDir
-						? parseSessionTokens(path.join(config.sessionDir, `parallel-${t}`))
+						? parseSessionTokens(path.join(config.sessionDir, `parallel-${fi}`))
 						: null;
 					const taskTokens = sessionTokens ?? tokenUsageFromAttempts(parallelResults[t]?.modelAttempts);
 					if (!taskTokens) continue;
@@ -2286,12 +2280,11 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			const singleResult = await runSingleStep(seqStep, {
 				previousOutput, placeholder, cwd, sessionEnabled,
 				outputs,
-				sessionDir: config.sessionDir,
+				sessionDir: config.sessionDir ? path.join(config.sessionDir, `parallel-${flatIndex}`) : undefined,
 				artifactsDir, artifactConfig, id,
 				flatIndex, flatStepCount: flatSteps.length,
 				outputFile: path.join(asyncDir, `output-${flatIndex}.log`),
-				piPackageRoot: config.piPackageRoot,
-				piArgv1: config.piArgv1,
+				runtime: config.runtime,
 				forwardedFlags: config.forwardedFlags,
 				executionBackendCoordinator,
 				executionBackendConfig,
@@ -2302,9 +2295,6 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				onAttemptStart: (attempt) => updateStepModel(flatIndex, attempt.model, attempt.thinking),
 				onChildEvent: (event) => updateStepFromChildEvent(flatIndex, event),
 			});
-			if (seqStep.sessionFile) {
-				latestSessionFile = seqStep.sessionFile;
-			}
 
 			previousOutput = singleResult.output;
 			results.push({
@@ -2333,26 +2323,15 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			}
 			statusPayload.outputs = outputs;
 
-			const cumulativeTokens = config.sessionDir ? parseSessionTokens(config.sessionDir) : null;
-			let stepTokens: TokenUsage | null = cumulativeTokens
-				? {
-						input: cumulativeTokens.input - previousCumulativeTokens.input,
-						output: cumulativeTokens.output - previousCumulativeTokens.output,
-						total: cumulativeTokens.total - previousCumulativeTokens.total,
-					}
-				: null;
-			if (cumulativeTokens) {
-				previousCumulativeTokens = cumulativeTokens;
-				previousCumulativeCost = cumulativeTokens.cost;
-			} else {
-				stepTokens = tokenUsageFromAttempts(singleResult.modelAttempts);
-				if (stepTokens) {
-					previousCumulativeTokens = {
-						input: previousCumulativeTokens.input + stepTokens.input,
-						output: previousCumulativeTokens.output + stepTokens.output,
-						total: previousCumulativeTokens.total + stepTokens.total,
-					};
-				}
+			const sessionTokens = config.sessionDir ? parseSessionTokens(path.join(config.sessionDir, `parallel-${flatIndex}`)) : null;
+			const stepTokens = sessionTokens ?? tokenUsageFromAttempts(singleResult.modelAttempts);
+			if (stepTokens) {
+				previousCumulativeTokens = {
+					input: previousCumulativeTokens.input + stepTokens.input,
+					output: previousCumulativeTokens.output + stepTokens.output,
+					total: previousCumulativeTokens.total + stepTokens.total,
+				};
+				previousCumulativeCost += sessionTokens?.cost ?? 0;
 			}
 
 			const stepEndTime = Date.now();
@@ -2360,6 +2339,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			statusPayload.steps[flatIndex].endedAt = stepEndTime;
 			statusPayload.steps[flatIndex].durationMs = stepEndTime - stepStartTime;
 			statusPayload.steps[flatIndex].exitCode = singleResult.exitCode;
+			statusPayload.steps[flatIndex].sessionFile = singleResult.sessionFile;
 			statusPayload.steps[flatIndex].model = singleResult.model;
 			statusPayload.steps[flatIndex].thinking = resolveEffectiveThinking(singleResult.model, statusPayload.steps[flatIndex].thinking);
 			statusPayload.steps[flatIndex].attemptedModels = singleResult.attemptedModels;
@@ -2427,22 +2407,16 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 		: resultMode === "parallel"
 			? `parallel:${flatSteps.map((s) => s.agent).join("+")}`
 			: `chain:${flatSteps.map((s) => s.agent).join("->")}`;
-	let sessionFile: string | undefined;
+	const sessionFile = results.findLast((result) => result.sessionFile)?.sessionFile;
 	let shareUrl: string | undefined;
 	let gistUrl: string | undefined;
 	let shareError: string | undefined;
 
 	if (shareEnabled) {
-		sessionFile = config.sessionDir
-			? (findLatestSessionFile(config.sessionDir) ?? undefined)
-			: undefined;
-		if (!sessionFile && latestSessionFile) {
-			sessionFile = latestSessionFile;
-		}
 		if (sessionFile) {
 			try {
 				const exportDir = config.sessionDir ?? path.dirname(sessionFile);
-				const htmlPath = await exportSessionHtml(sessionFile, exportDir, config.piPackageRoot);
+				const htmlPath = await exportSessionHtml(sessionFile, exportDir, config.runtime.piPackageRoot);
 				const share = createShareLink(htmlPath);
 				if ("error" in share) shareError = share.error;
 				else {
@@ -2461,7 +2435,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 		clearInterval(activityTimer);
 		activityTimer = undefined;
 	}
-	const effectiveSessionFile = sessionFile ?? latestSessionFile;
+	const effectiveSessionFile = sessionFile;
 	const runEndedAt = Date.now();
 	statusPayload.state = interrupted ? "paused" : results.every((r) => r.success) ? "complete" : "failed";
 	statusPayload.activityState = undefined;
@@ -2509,6 +2483,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 
 	try {
 		writeAtomicJson(resultPath, {
+			runtime: config.runtime,
 			id,
 			agent: agentName,
 			mode: resultMode,