pi-subagents 0.65.0 → 0.65.1

package/src/intercom/supervisor-ui.ts

@@ -17,6 +17,7 @@ export interface SupervisorRequestMessageDetails {
 	childIndex?: number;
 	childTarget?: string;
 	interview?: unknown;
+	requestBody?: string;
 	replyHint?: string;
 }
 
@@ -107,7 +108,7 @@ function optionalString(value: unknown): boolean {
 
 function requestDetails(value: unknown): SupervisorRequestMessageDetails | undefined {
 	if (!isRecord(value)) return undefined;
-	if (!optionalString(value.id) || !optionalString(value.requestId) || !optionalString(value.replyHint) || !optionalString(value.runId) || !optionalString(value.agent) || !optionalString(value.childTarget)) return undefined;
+	if (!optionalString(value.id) || !optionalString(value.requestId) || !optionalString(value.replyHint) || !optionalString(value.requestBody) || !optionalString(value.runId) || !optionalString(value.agent) || !optionalString(value.childTarget)) return undefined;
 	if (value.reason !== undefined && !isSupervisorReason(value.reason)) return undefined;
 	if (value.expectsReply !== undefined && typeof value.expectsReply !== "boolean") return undefined;
 	if (value.childIndex !== undefined && (typeof value.childIndex !== "number" || !Number.isFinite(value.childIndex))) return undefined;
@@ -153,7 +154,7 @@ function requestLines(message: SupervisorMessageLike, details: SupervisorRequest
 	if (details.childTarget) lines.push(`Child target: ${boundedField(details.childTarget)}`);
 	lines.push(`Request ID: ${requestId}`);
 	if (details.expectsReply) lines.push(`Reply with: ${displayText(details.replyHint ?? supervisorReplyHint(requestId), MAX_BODY_CHARS, expanded)}`);
-	lines.push("", "Request:", displayText(contentText(message.content) || "(no request body)", MAX_BODY_CHARS, expanded));
+	lines.push("", "Request:", displayText((details.requestBody ?? contentText(message.content)) || "(no request body)", MAX_BODY_CHARS, expanded));
 	if (details.interview !== undefined) lines.push("", "Interview shape:", interviewText(details.interview, expanded));
 	return lines;
 }

package/src/missions/workflow-state.ts

@@ -18,6 +18,12 @@ export interface MissionWorkflowState {
 	set(key: string, value: unknown): void;
 }
 
+export interface MissionWorkflowStateOptions {
+	isProcessAlive?: (pid: number) => boolean;
+	getProcessStartKey?: (pid: number) => string | undefined;
+	retryDelaysMs?: readonly number[];
+}
+
 export function missionStatePath(location: MissionStoreLocation, missionId: string): string {
 	return path.join(location.missionDir, validateMissionId(missionId), "state.json");
 }
@@ -66,13 +72,22 @@ function windowsProcessStartKey(pid: number): string | undefined {
 	}
 }
 
+let currentProcessKey: string | undefined | null = null;
+
 function processStartKey(pid: number): string | undefined {
+	// Foreign PIDs can be reused while this process lives, so resolve them afresh.
+	if (pid !== process.pid) return computeProcessStartKey(pid);
+	if (currentProcessKey === null) currentProcessKey = computeProcessStartKey(pid);
+	return currentProcessKey;
+}
+
+function computeProcessStartKey(pid: number): string | undefined {
 	if (process.platform === "linux") return linuxProcessStartKey(pid) ?? psProcessStartKey(pid);
 	if (process.platform === "win32") return windowsProcessStartKey(pid);
 	return undefined;
 }
 
-const CURRENT_PROCESS_KEY = processStartKey(process.pid);
+type StateLockOptions = Required<MissionWorkflowStateOptions>;
 
 function readStateLockOwner(lockPath: string): StateLockOwner | undefined {
 	try {
@@ -91,13 +106,13 @@ function readStateLockOwner(lockPath: string): StateLockOwner | undefined {
 	return undefined;
 }
 
-function stateLockIsStale(lockPath: string, now = Date.now()): boolean {
+function stateLockIsStale(lockPath: string, options: StateLockOptions, now = Date.now()): boolean {
 	const owner = readStateLockOwner(lockPath);
 	if (owner) {
-		if (!isProcessAlive(owner.pid)) return true;
+		if (!options.isProcessAlive(owner.pid)) return true;
 		if (owner.processKey) {
-			const currentProcessKey = owner.pid === process.pid ? CURRENT_PROCESS_KEY : processStartKey(owner.pid);
-			if (currentProcessKey) return owner.processKey !== currentProcessKey;
+			const observedProcessKey = options.getProcessStartKey(owner.pid);
+			if (observedProcessKey) return owner.processKey !== observedProcessKey;
 			if (owner.pid === process.pid) return true;
 		}
 		return false;
@@ -140,11 +155,11 @@ function waitForStateLock(delayMs: number | undefined, lockPath: string): void {
 	waitForFileSystemRetry(delayMs);
 }
 
-function reclaimStaleStateLock(lockPath: string, reclaimPath: string): boolean {
-	if (!stateLockIsStale(lockPath)) return false;
+function reclaimStaleStateLock(lockPath: string, reclaimPath: string, options: StateLockOptions): boolean {
+	if (!stateLockIsStale(lockPath, options)) return false;
 	if (!tryMakeDirectory(reclaimPath, 0o700)) return false;
 	try {
-		if (!stateLockIsStale(lockPath)) return false;
+		if (!stateLockIsStale(lockPath, options)) return false;
 		fs.rmSync(lockPath, { recursive: true, force: true });
 		return true;
 	} finally {
@@ -152,7 +167,7 @@ function reclaimStaleStateLock(lockPath: string, reclaimPath: string): boolean {
 	}
 }
 
-function withStateFileLock<T>(filePath: string, operation: () => T): T {
+function withStateFileLock<T>(filePath: string, operation: () => T, options: StateLockOptions): T {
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
 	const lockPath = `${filePath}.lock`;
 	const reclaimPath = `${lockPath}.reclaim`;
@@ -163,7 +178,7 @@ function withStateFileLock<T>(filePath: string, operation: () => T): T {
 				fs.rmSync(reclaimPath, { recursive: true, force: true });
 				continue;
 			}
-			waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+			waitForStateLock(options.retryDelaysMs[attempt], lockPath);
 			continue;
 		}
 		let acquired = false;
@@ -171,17 +186,18 @@ function withStateFileLock<T>(filePath: string, operation: () => T): T {
 			acquired = tryMakeDirectory(lockPath, 0o700);
 		} catch (error) {
 			if (isRetryableFileSystemError(error)) {
-				waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+				waitForStateLock(options.retryDelaysMs[attempt], lockPath);
 				continue;
 			}
 			throw new Error(`Failed to acquire mission state lock '${lockPath}': ${error instanceof Error ? error.message : String(error)}`);
 		}
 		if (!acquired) {
-			if (reclaimStaleStateLock(lockPath, reclaimPath)) continue;
-			waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+			if (reclaimStaleStateLock(lockPath, reclaimPath, options)) continue;
+			waitForStateLock(options.retryDelaysMs[attempt], lockPath);
 			continue;
 		}
-		owner = { pid: process.pid, token: randomUUID(), createdAt: Date.now(), ...(CURRENT_PROCESS_KEY ? { processKey: CURRENT_PROCESS_KEY } : {}) };
+		const key = options.getProcessStartKey(process.pid);
+		owner = { pid: process.pid, token: randomUUID(), createdAt: Date.now(), ...(key ? { processKey: key } : {}) };
 		try {
 			fs.writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify(owner), { encoding: "utf-8", mode: 0o600 });
 		} catch (error) {
@@ -205,8 +221,13 @@ function validateStateKey(value: unknown): string {
 	return value;
 }
 
-export function createMissionWorkflowState(location: MissionStoreLocation, missionId: string): MissionWorkflowState {
+export function createMissionWorkflowState(location: MissionStoreLocation, missionId: string, options: MissionWorkflowStateOptions = {}): MissionWorkflowState {
 	const filePath = missionStatePath(location, missionId);
+	const lockOptions: StateLockOptions = {
+		isProcessAlive: options.isProcessAlive ?? isProcessAlive,
+		getProcessStartKey: options.getProcessStartKey ?? processStartKey,
+		retryDelaysMs: options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS,
+	};
 	let loaded = false;
 	let values: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
 
@@ -254,7 +275,7 @@ export function createMissionWorkflowState(location: MissionStoreLocation, missi
 				writePrivateAtomicJson(filePath, next);
 				values = next;
 				loaded = true;
-			});
+			}, lockOptions);
 		},
 	};
 }

package/src/runs/background/async-execution.ts

@@ -146,6 +146,7 @@ interface AsyncExecutionContext {
 	currentModel?: ParentModel;
 	/** Optional model-scope enforcement resolved from subagent settings. */
 	modelScope?: ModelScopeConfig;
+	modelResponseAliases?: Record<string, string[]>;
 	/** Whether the parent session has an interactive UI. */
 	interactive?: boolean;
 	/** The executor's own child runtime when the launch comes from an in-process child. */
@@ -586,7 +587,10 @@ function spawnRunner(cfg: object, suffix: string, cwd: string, initialStatus: Om
 			stdoutFd = fs.openSync(logPaths.stdoutPath, "a");
 			stderrFd = fs.openSync(logPaths.stderrPath, "a");
 		}
-		const proc = spawn(nodeCommand, [jitiCliPath, runner, cfgPath], {
+		const preload = hostPeerAliases.supplemental.length > 0
+			? ["--import", new URL("../../../runner-server-preload.mjs", import.meta.url).href]
+			: [];
+		const proc = spawn(nodeCommand, [...preload, jitiCliPath, runner, cfgPath], {
 			cwd,
 			...backgroundProcessOptions(),
 			stdio: ["ignore", stdoutFd ?? "ignore", stderrFd ?? "ignore"],
@@ -1021,6 +1025,7 @@ export function buildAsyncRunnerSteps(id: string, params: AsyncRunnerStepBuildPa
 			modelCandidates: externalRunner ? undefined : modelCandidates,
 			...(primaryModelFromParent ? { skipPrimaryModelVerification: true } : {}),
 			...(availableModels && availableModels.length > 0 ? { modelVerificationRegistry: availableModels } : {}),
+			...(ctx.modelResponseAliases ? { modelResponseAliases: ctx.modelResponseAliases } : {}),
 			tools: a.tools,
 			excludeTools: a.excludeTools,
 			allowNestedSubagents: a.allowNestedSubagents,
@@ -1822,6 +1827,7 @@ export function executeAsyncSingle(
 	});
 	const recoveryAgentConfig = params.recoveryAgentConfig ?? agentConfig;
 	const recoveryDescriptor: SteeringRecoveryDescriptor = {
+		...(ctx.modelResponseAliases ? { modelResponseAliases: ctx.modelResponseAliases } : {}),
 		version: 1,
 		...(lane ? { lane } : {}),
 		launchContractDigest,
@@ -1910,6 +1916,7 @@ export function executeAsyncSingle(
 						modelCandidates,
 						...(modelOrigin === "inherited" ? { skipPrimaryModelVerification: true } : {}),
 						...(availableModels && availableModels.length > 0 ? { modelVerificationRegistry: availableModels } : {}),
+						...(ctx.modelResponseAliases ? { modelResponseAliases: ctx.modelResponseAliases } : {}),
 						tools: agentConfig.tools,
 						excludeTools: agentConfig.excludeTools,
 						allowNestedSubagents: agentConfig.allowNestedSubagents,

package/src/runs/background/async-resume.ts

@@ -15,6 +15,7 @@ import { parallelHandoffPath, resolveRetainedWorktreeCwd } from "../shared/paral
 import { normalizeWorktreeBaseRef } from "../shared/worktree.ts";
 import { intersectThinkingCeilings, parseThinkingLevel, type ThinkingLevel } from "../../shared/thinking-ceiling.ts";
 import { assertWorkflowGraphHostSteps } from "../shared/host-step-status.ts";
+import { validateModelResponseAliases } from "../../shared/model-response-aliases.ts";
 
 export interface AsyncResumeParams {
 	id?: string;
@@ -317,7 +318,7 @@ export function readAsyncRecoveryDescriptor(asyncDir: string | undefined): Steer
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid async recovery descriptor '${descriptorPath}': expected an object.`);
 	const parsed = value as Record<string, unknown>;
 	const allowedFields = new Set([
-		"version", "launchContractDigest", "sourceRunId", "agentContract", "agent", "sessionFile", "cwd", "model", "modelProvider", "modelOverrideFromParent", "modelOrigin", "fallbackModels", "thinking", "thinkingCeiling", "tools", "allowNestedSubagents", "extensions",
+		"modelResponseAliases", "version", "launchContractDigest", "sourceRunId", "agentContract", "agent", "sessionFile", "cwd", "model", "modelProvider", "modelOverrideFromParent", "modelOrigin", "fallbackModels", "thinking", "thinkingCeiling", "tools", "allowNestedSubagents", "extensions",
 		"subagentOnlyExtensions", "mcpDirectTools", "excludeTools", "mutationTools", "systemPrompt", "systemPromptMode", "inheritProjectContext", "inheritGlobalContext", "inheritSkills", "skills",
 		"skillPath", "agentFilePath", "completionGuard", "memory", "outputPath", "outputMode", "structuredOutputSchema", "acceptance", "sessionDir", "artifactConfig",
 		"artifactsDir", "maxOutput", "controlConfig", "context", "intercomBridge", "absoluteDeadlineAt", "initialTurnBudget", "initialToolBudget", "maxSubagentDepth", "share", "capabilityCeiling",
@@ -337,6 +338,7 @@ export function readAsyncRecoveryDescriptor(asyncDir: string | undefined): Steer
 	} catch (error) {
 		throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${error instanceof Error ? error.message : String(error)}`);
 	}
+	validateModelResponseAliases(parsed.modelResponseAliases, `async recovery descriptor '${descriptorPath}' modelResponseAliases`);
 	if (parsed.capabilityCeiling !== undefined) parsed.capabilityCeiling = parseSubagentCapabilityCeiling(parsed.capabilityCeiling, `async recovery descriptor '${descriptorPath}' capabilityCeiling`);
 	if (parsed.thinkingCeiling !== undefined) parsed.thinkingCeiling = parseThinkingLevel(parsed.thinkingCeiling, `async recovery descriptor '${descriptorPath}' thinkingCeiling`);
 	if (parsed.extensionBindings !== undefined) parsed.extensionBindings = normalizeExtensionBindings(parsed.extensionBindings)!.value;

package/src/runs/background/async-retention.ts

@@ -320,7 +320,16 @@ function readCursor(root: string): RetentionCursor {
 	return value?.version === 1 ? value as unknown as RetentionCursor : { version: 1 };
 }
 
+let currentProcessStartIdentity: string | undefined | null = null;
+
 function processStartIdentity(pid: number): string | undefined {
+	// Foreign PIDs can be reused while this process lives, so resolve them afresh.
+	if (pid !== process.pid) return computeProcessStartIdentity(pid);
+	if (currentProcessStartIdentity === null) currentProcessStartIdentity = computeProcessStartIdentity(pid);
+	return currentProcessStartIdentity;
+}
+
+function computeProcessStartIdentity(pid: number): string | undefined {
 	if (process.platform === "linux") {
 		try {
 			const stat = fs.readFileSync(`/proc/${pid}/stat`).toString("utf8");

package/src/runs/background/notify.ts

@@ -123,6 +123,7 @@ export interface RegisterSubagentNotifyOptions {
 
 export interface CompletionNotifier {
 	deliver(result: CompletionNotification): Promise<boolean>;
+	hasPendingDelivery(): boolean;
 	dispose(): void;
 }
 
@@ -628,6 +629,7 @@ export default function registerSubagentNotify(
 
 	return {
 		deliver,
+		hasPendingDelivery: () => pending.size > 0,
 		dispose() {
 			if (disposed) return;
 			disposed = true;

package/src/runs/background/retained-nested-route-tracker.ts

@@ -0,0 +1,96 @@
+import * as fs from "node:fs";
+import type { SubagentState } from "../../shared/types.ts";
+import { shouldUseNativeFsWatch } from "../../shared/watch-strategy.ts";
+import { hasLiveNestedDescendants, projectNestedEvents } from "../shared/nested-events.ts";
+
+interface RetainedNestedRouteTrackerOptions {
+	pollIntervalMs?: number;
+	platform?: NodeJS.Platform;
+	watch?: typeof fs.watch;
+}
+
+const DEFAULT_POLL_INTERVAL_MS = 5000;
+const REFRESH_DEBOUNCE_MS = 25;
+
+export function createRetainedNestedRouteTracker(
+	state: Pick<SubagentState, "retainedForegroundNestedRoutes">,
+	options: RetainedNestedRouteTrackerOptions = {},
+): { track: (rootRunId: string) => void; clear: () => void } {
+	const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+	const watch = options.watch ?? fs.watch;
+	const watchers = new Map<string, fs.FSWatcher>();
+	const refreshTimers = new Map<string, ReturnType<typeof setTimeout>>();
+	let poller: ReturnType<typeof setInterval> | undefined;
+
+	const close = (rootRunId: string): void => {
+		watchers.get(rootRunId)?.close();
+		watchers.delete(rootRunId);
+		const timer = refreshTimers.get(rootRunId);
+		if (timer) clearTimeout(timer);
+		refreshTimers.delete(rootRunId);
+	};
+
+	const refresh = (rootRunId: string): void => {
+		const retained = state.retainedForegroundNestedRoutes?.get(rootRunId);
+		if (!retained) {
+			close(rootRunId);
+			return;
+		}
+		try {
+			if (hasLiveNestedDescendants(projectNestedEvents(retained).children)) return;
+			state.retainedForegroundNestedRoutes?.delete(rootRunId);
+			close(rootRunId);
+		} catch (error) {
+			console.error(`Failed to refresh retained nested descendants for foreground run '${rootRunId}':`, error);
+		}
+	};
+
+	const scheduleRefresh = (rootRunId: string): void => {
+		if (refreshTimers.has(rootRunId)) return;
+		const timer = setTimeout(() => {
+			refreshTimers.delete(rootRunId);
+			refresh(rootRunId);
+		}, REFRESH_DEBOUNCE_MS);
+		timer.unref?.();
+		refreshTimers.set(rootRunId, timer);
+	};
+
+	const ensurePoller = (): void => {
+		if (poller || (state.retainedForegroundNestedRoutes?.size ?? 0) === 0) return;
+		poller = setInterval(() => {
+			for (const rootRunId of state.retainedForegroundNestedRoutes?.keys() ?? []) refresh(rootRunId);
+			if ((state.retainedForegroundNestedRoutes?.size ?? 0) > 0) return;
+			if (poller) clearInterval(poller);
+			poller = undefined;
+		}, pollIntervalMs);
+		poller.unref?.();
+	};
+
+	const track = (rootRunId: string): void => {
+		const retained = state.retainedForegroundNestedRoutes?.get(rootRunId);
+		if (!retained) return;
+		if (shouldUseNativeFsWatch("retained-nested-route-tracker", options.platform) && !watchers.has(rootRunId)) {
+			try {
+				const watcher = watch(retained.eventSink, () => scheduleRefresh(rootRunId));
+				watcher.on("error", () => close(rootRunId));
+				watcher.unref?.();
+				watchers.set(rootRunId, watcher);
+			} catch {
+				// The bounded safety poll below covers unsupported or failed watchers.
+			}
+		}
+		scheduleRefresh(rootRunId);
+		ensurePoller();
+	};
+
+	const clear = (): void => {
+		if (poller) clearInterval(poller);
+		poller = undefined;
+		for (const rootRunId of watchers.keys()) close(rootRunId);
+		for (const timer of refreshTimers.values()) clearTimeout(timer);
+		refreshTimers.clear();
+		state.retainedForegroundNestedRoutes?.clear();
+	};
+
+	return { track, clear };
+}

package/src/runs/background/run-child-session.ts

@@ -93,6 +93,7 @@ export interface RunChildSessionInput {
 	runDeadlineAt?: number;
 	expectedModelForVerification?: string;
 	modelVerificationRegistry?: Array<{ provider: string; id: string; fullId: string }>;
+	modelResponseAliases?: Record<string, string[]>;
 	mutationTools?: readonly string[];
 }
 
@@ -468,7 +469,7 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 				if (event.message.model) {
 					model = event.message.model;
 					if (input.expectedModelForVerification && !hasToolCall) {
-						const modelVerificationError = formatSubagentModelVerificationError(input.expectedModelForVerification, event.message.model, input.modelVerificationRegistry);
+						const modelVerificationError = formatSubagentModelVerificationError(input.expectedModelForVerification, event.message.model, input.modelVerificationRegistry, input.modelResponseAliases);
 						if (modelVerificationError && !error) error = modelVerificationError;
 					}
 				}

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

@@ -7,11 +7,12 @@
  * this extension and are not installed next to it. pi's own extension loader
  * aliases those specifiers to the copies shipped inside the installed pi
  * package; the parent computes the same map and hands it to the runner
- * through `JITI_ALIAS`, so the runner's child sessions and hooks share one
- * copy of every host package.
+ * through `JITI_ALIAS`, so child sessions and hooks retain host API identity.
+ * Only Pi 0.85.0's missing server exports may come from this extension.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 
 export const JITI_ALIAS_ENV = "JITI_ALIAS";
 
@@ -19,6 +20,12 @@ export const JITI_ALIAS_ENV = "JITI_ALIAS";
 export const HOST_PEER_ALIASES: ReadonlyArray<{ specifier: string; pkg: string; subpath: string }> = [
 	{ specifier: "@earendil-works/pi-coding-agent", pkg: "@earendil-works/pi-coding-agent", subpath: "." },
 	{ specifier: "@earendil-works/pi-agent-core", pkg: "@earendil-works/pi-agent-core", subpath: "." },
+	{ specifier: "@earendil-works/pi-agent-core/node", pkg: "@earendil-works/pi-agent-core", subpath: "./node" },
+	{ specifier: "@earendil-works/chord", pkg: "@earendil-works/chord", subpath: "." },
+	{ specifier: "@earendil-works/chord/context", pkg: "@earendil-works/chord", subpath: "./context" },
+	{ specifier: "@earendil-works/pi-server", pkg: "@earendil-works/pi-server", subpath: "." },
+	{ specifier: "@earendil-works/pi-server/unix", pkg: "@earendil-works/pi-server", subpath: "./unix" },
+	{ specifier: "@earendil-works/pi-client/unix", pkg: "@earendil-works/pi-client", subpath: "./unix" },
 	{ specifier: "@earendil-works/pi-tui", pkg: "@earendil-works/pi-tui", subpath: "." },
 	{ specifier: "@earendil-works/pi-ai", pkg: "@earendil-works/pi-ai", subpath: "./compat" },
 	{ specifier: "@earendil-works/pi-ai/compat", pkg: "@earendil-works/pi-ai", subpath: "./compat" },
@@ -31,6 +38,7 @@ export const HOST_PEER_ALIASES: ReadonlyArray<{ specifier: string; pkg: string;
 
 interface PackageManifest {
 	name?: unknown;
+	version?: unknown;
 	main?: unknown;
 	exports?: unknown;
 }
@@ -112,14 +120,33 @@ export function findHostPeerPackageDir(piPackageRoot: string, pkg: string): stri
 }
 
 /** The alias map the runner needs, or the specifiers that could not be resolved. */
-export function resolveHostPeerAliases(piPackageRoot: string): { aliases: Record<string, string>; missing: string[] } {
+export function resolveHostPeerAliases(
+	piPackageRoot: string,
+	extensionRoot = fileURLToPath(new URL("../../../", import.meta.url)),
+): { aliases: Record<string, string>; missing: string[]; supplemental: string[] } {
 	const aliases: Record<string, string> = {};
 	const missing: string[] = [];
+	const supplemental: string[] = [];
 	for (const { specifier, pkg, subpath } of HOST_PEER_ALIASES) {
 		const packageDir = findHostPeerPackageDir(piPackageRoot, pkg);
-		const target = packageDir ? resolvePackageSubpath(packageDir, subpath) : undefined;
+		let target = packageDir ? resolvePackageSubpath(packageDir, subpath) : undefined;
+		// Pi 0.85.0 omitted this runtime dependency. Never replace working host
+		// exports or extend this exact version contract to other peers/hosts.
+		if ((!target || !fs.existsSync(target))
+			&& (specifier === "@earendil-works/pi-server" || specifier === "@earendil-works/pi-server/unix")
+			&& readManifest(piPackageRoot)?.version === "0.85.0"
+			&& (!packageDir || readManifest(packageDir)?.version === "0.85.0")) {
+			const localDir = findHostPeerPackageDir(extensionRoot, pkg);
+			if (localDir && readManifest(localDir)?.version === "0.85.0") {
+				const localTarget = resolvePackageSubpath(localDir, subpath);
+				if (localTarget && fs.existsSync(localTarget)) {
+					target = localTarget;
+					supplemental.push(specifier);
+				}
+			}
+		}
 		if (target && fs.existsSync(target)) aliases[specifier] = target;
 		else missing.push(specifier);
 	}
-	return { aliases, missing };
+	return { aliases, missing, supplemental };
 }

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

@@ -1,8 +1,26 @@
 import { spawnSync } from "node:child_process";
+import { EventEmitter } from "node:events";
 import * as fs from "node:fs";
+import { createRequire } from "node:module";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import type { Message } from "@earendil-works/pi-ai";
+
+// Detached runners skip Pi's CLI proxy setup. Keep fetch on the same Undici dispatcher.
+function ensureProxyAwareHttpDispatcher(): void {
+	try {
+		// SAFETY: require loads the pinned direct dependency described by these types.
+		const undici = createRequire(import.meta.url)("undici") as typeof import("undici");
+		const dispatcher = new undici.EnvHttpProxyAgent({ allowH2: false });
+		// Fetch rejects stream errors; the listener prevents an unhandled EventEmitter error.
+		EventEmitter.prototype.on.call(dispatcher, "error", () => {});
+		undici.setGlobalDispatcher(dispatcher);
+		undici.install();
+	} catch (error) {
+		console.error(`[pi-subagents] proxy-aware HTTP dispatcher not installed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+ensureProxyAwareHttpDispatcher();
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { writeAsyncResultFile, writePendingAsyncResultFile } from "./result-files.ts";
 import { createFileCoalescer } from "../../shared/file-coalescer.ts";
@@ -1188,6 +1206,7 @@ async function runSingleStepInner(
 			runDeadlineAt: ctx.deadlineAt,
 			expectedModelForVerification,
 			modelVerificationRegistry: step.modelVerificationRegistry,
+			modelResponseAliases: step.modelResponseAliases,
 			mutationTools: step.mutationTools,
 		}));
 		const toolDiagnostic = run.exitCode === 0 && !run.error ? launch.capture.toolDiagnostic() : undefined;

package/src/runs/foreground/execution.ts

@@ -983,6 +983,20 @@ async function runSingleAttempt(
 				compactionStartedReceived = false;
 				afterCompactionSettlement = false;
 			}
+			if (evt.type === "agent_start") {
+				const diagnostic = capture.toolDiagnostic();
+				if (diagnostic) {
+					const message = formatChildToolDiagnostic(diagnostic, { host: "parent" });
+					toolAvailabilityError = message;
+					result.error = message;
+					result.finalOutput = message;
+					progress.status = "failed";
+					progress.error = message;
+					fireUpdate();
+					abortChild();
+					return;
+				}
+			}
 			const lifecycleAction = projectChildLifecycle(evt, false, childLifecycleState);
 			if (evt.type === "agent_settled" && lifecycleAction === "start-drain") {
 				agentSettledReceived = true;
@@ -1086,7 +1100,7 @@ async function runSingleAttempt(
 						progress.model = evt.message.model;
 						if (!result.model) result.model = evt.message.model;
 						if (expectedModelForVerification && !hasToolCall) {
-							const modelVerificationError = formatSubagentModelVerificationError(expectedModelForVerification, evt.message.model, options.availableModels);
+							const modelVerificationError = formatSubagentModelVerificationError(expectedModelForVerification, evt.message.model, options.availableModels, options.modelResponseAliases);
 							if (modelVerificationError && !result.error) result.error = modelVerificationError;
 						}
 					}

package/src/runs/foreground/foreground-history.ts

@@ -5,6 +5,7 @@ import { DIRS } from "../../shared/types.ts";
 import { writePrivateAtomicJson } from "../../shared/atomic-json.ts";
 import { utf8Tail } from "../../shared/utf8.ts";
 import { validateAcceptanceInput } from "../shared/acceptance.ts";
+import { validateModelResponseAliases } from "../../shared/model-response-aliases.ts";
 
 export const MAX_REMEMBERED_FOREGROUND_RUNS = 50;
 const HISTORY_VERSION = 1;
@@ -71,11 +72,12 @@ function isRestorableResumeContract(value: unknown): boolean {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
 	try {
 		if (Buffer.byteLength(JSON.stringify(value), "utf8") > MAX_RESUME_CONTRACT_BYTES) return false;
+		validateModelResponseAliases((value as ForegroundResumeChild["resumeContract"])?.modelResponseAliases);
 	} catch {
 		return false;
 	}
 	const contract = value as NonNullable<ForegroundResumeChild["resumeContract"]>;
-	if (Object.keys(contract).some((key) => !["outputSchema", "agentContract", "acceptance", "output", "outputMode"].includes(key))) return false;
+	if (Object.keys(contract).some((key) => !["modelResponseAliases", "outputSchema", "agentContract", "acceptance", "output", "outputMode"].includes(key))) return false;
 	if (contract.outputSchema !== undefined && (!contract.outputSchema || typeof contract.outputSchema !== "object" || Array.isArray(contract.outputSchema))) return false;
 	if (contract.agentContract !== undefined && (!contract.agentContract || typeof contract.agentContract !== "object" || Array.isArray(contract.agentContract) || contract.agentContract.version !== 1)) return false;
 	if (validateAcceptanceInput(contract.acceptance).length > 0) return false;

package/src/runs/foreground/prompt-audit.ts

@@ -1,7 +1,6 @@
-import { Agent, type StreamFn, type ThinkingLevel } from "@earendil-works/pi-agent-core";
-import { convertToLlm, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { streamSimple } from "@earendil-works/pi-ai/compat";
-import type { Model, ProviderHeaders } from "@earendil-works/pi-ai";
+import type { Agent, StreamFn, ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ProviderHeaders } from "@earendil-works/pi-ai";
 import { agentStreamOptions } from "../../shared/agent-stream-options.ts";
 import type { ForegroundRunControl } from "../../shared/types.ts";
 export type PromptAuditView = "authored" | "runtime" | "effective";
@@ -21,7 +20,7 @@ export interface LivePromptAudit {
 
 const livePrompts = new WeakMap<ForegroundRunControl, Map<number, LivePromptAudit>>();
 
-type RegistryModel = Model<any>;
+type RegistryModel = NonNullable<ExtensionContext["model"]>;
 
 function fullModelId(model: Pick<RegistryModel, "provider" | "id">): string {
 	return `${model.provider}/${model.id}`;
@@ -64,6 +63,11 @@ export async function rewritePromptWithGuidance(input: {
 }): Promise<string> {
 	const model = input.ctx.model;
 	if (!model) throw new Error("Prompt redo needs the current session model to rewrite the authored task.");
+	const [{ Agent }, { convertToLlm }, { streamSimple }] = await Promise.all([
+		import("@earendil-works/pi-agent-core"),
+		import("@earendil-works/pi-coding-agent"),
+		import("@earendil-works/pi-ai/compat"),
+	]);
 	const auth = await resolveRewriteAuth(input.ctx, model);
 	const registeredProvider = (input.ctx.modelRegistry as {
 		getRegisteredProviderConfig?: (provider: string) => { api?: string; streamSimple?: StreamFn } | undefined;