pi-subagents 0.67.0 → 0.69.0

package/src/runs/background/result-files.ts

@@ -241,10 +241,15 @@ function pendingResultExists(resultsDir: string, sessionId: string, runId: strin
 	return firstExistingResultFile(resultPendingPaths(resultsDir, sessionId, runId)) !== undefined;
 }
 
+export function resultPayloadMatchesSessionRun(data: unknown, sessionId: string, runId: string): boolean {
+	if (!data || typeof data !== "object" || Array.isArray(data)) return false;
+	const record = data as Record<string, unknown>;
+	return (nonEmptyString(record.runId) ?? nonEmptyString(record.id)) === runId && nonEmptyString(record.sessionId) === sessionId;
+}
+
 function pendingResultPayloadMatches(filePath: string, sessionId: string, runId: string): boolean {
 	try {
-		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;
+		return resultPayloadMatchesSessionRun(JSON.parse(fs.readFileSync(filePath, "utf-8")), sessionId, runId);
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code !== "ENOENT" && !isUnaddressableResultCandidate(error)) console.error(`Ignoring invalid pending async result '${filePath}':`, error);
 		return false;
@@ -252,8 +257,7 @@ 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;
+	return resultPayloadMatchesSessionRun(JSON.parse(fs.readFileSync(filePath, "utf-8")), sessionId, runId);
 }
 
 export function promotePendingResultFile(resultsDir: string, sessionId: string, runId: string, file = resultFileName(runId), options: { logFailure?: boolean } = {}): "none" | "promoted" | "pending" {

package/src/runs/background/result-watcher.ts

@@ -70,6 +70,7 @@ type ResultFileChild = {
 	sessionName?: string;
 	output?: string;
 	structuredOutput?: unknown;
+	structuredOutputPath?: string;
 	outputState?: SubagentOutputState;
 	error?: string;
 	success?: boolean;
@@ -81,6 +82,8 @@ type ResultFileChild = {
 	processSignal?: string | null;
 	sessionFile?: string;
 	artifactPaths?: { outputPath?: string };
+	outputSaveError?: string;
+	artifactOutputSaveFailed?: true;
 	intercomTarget?: string;
 	children?: unknown;
 };
@@ -408,7 +411,9 @@ export function createResultWatcher(
 			if (typeof data.sessionId !== "string" || !data.sessionId) return;
 			const sessionId = data.sessionId;
 			const completionOwnerId = data.completionOwnerId;
-			const runId = data.runId ?? data.id ?? file.replace(/\.json$/i, "");
+			const runId = typeof data.runId === "string" && data.runId
+				? data.runId
+				: typeof data.id === "string" && data.id ? data.id : file.replace(/\.json$/i, "");
 			const toolCallId = typeof data.toolCallId === "string" ? data.toolCallId : undefined;
 			let observerSucceeded = true;
 			try {
@@ -428,7 +433,7 @@ export function createResultWatcher(
 			if (!ownsCompletion(sessionId, completionOwnerId, epoch)) return;
 			// Recorded before dedupe and before the unlink below so bg_wait can
 			// use the in-memory record or its bounded durable replay after cleanup.
-			recordWaitCompletion(state, runId, data, Date.now(), completionTtlMs, {
+			const completionPersisted = recordWaitCompletion(state, runId, data, Date.now(), completionTtlMs, {
 				resultsDir,
 				sessionId,
 			});
@@ -456,6 +461,10 @@ export function createResultWatcher(
 				}
 				if (!ownsCompletion(sessionId, completionOwnerId, epoch)) return;
 				if (markReplacedPayload()) return;
+				if (!completionPersisted) {
+					scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
+					return;
+				}
 				if (!removeDeliveredResult(file, sessionId, runId, toolCallId)) scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
 				return;
 			}
@@ -513,6 +522,10 @@ export function createResultWatcher(
 				}
 				if (!ownsCompletion(sessionId, completionOwnerId, epoch)) return;
 				if (markReplacedPayload()) return;
+				if (!completionPersisted) {
+					scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
+					return;
+				}
 				if (!removeDeliveredResult(file, sessionId, runId, toolCallId)) scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
 				return;
 			}
@@ -600,6 +613,10 @@ export function createResultWatcher(
 				return;
 			}
 			if (!ownsCompletion(sessionId, completionOwnerId, epoch)) return;
+			if (!completionPersisted) {
+				scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
+				return;
+			}
 			if (!removeDeliveredResult(file, sessionId, runId, toolCallId)) scheduleResult(file, triggerTurn, RETRY_DELAY_MS);
 		} catch (error) {
 			if (isAccessDenied(error)) {

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

@@ -19,13 +19,13 @@ import {
 	type ChildWatchdogStatusEvent,
 } from "../../watchdog/child-status.ts";
 import { projectChildLifecycle, type ChildLifecycleAction, type ChildLifecycleState } from "../shared/child-lifecycle.ts";
-import { formatSubagentModelVerificationError } from "../shared/model-fallback.ts";
+import { formatSubagentModelVerificationError } from "../shared/model-resolution.ts";
+import { formatChildModelResolutionDiagnostic, isChildModelResolutionFailure } from "../shared/model-resolution-diagnostic.ts";
 import { isMutatingTool, resolveCurrentPath } from "../shared/long-running-guard.ts";
 import { effectiveToolTimeoutMs, formatToolTimeoutMessage, toolTimeoutCallKey } from "../shared/tool-timeout.ts";
 import { createReportedChildSessionInput, type InProcessChildLaunch } from "../shared/child-launch.ts";
 import { childSessionHasQueuedMessages, projectChildSessionEventForJson, type ChildSession, type ChildSessionEvent, type ChildSessionFactory } from "../shared/child-session.ts";
 import { formatSteerMessage } from "../shared/subagent-prompt-runtime.ts";
-import { getReadonlySessionEvidence, requestReadonlySessionEvidence, type SettledReadonlyEvidence } from "../shared/readonly-session-evidence.ts";
 import type { SteerDeliveryStatus, SteerRequest } from "./control-channel.ts";
 import { takeMatchingAcceptedSteer, unconsumedSteerReason } from "./steering.ts";
 
@@ -99,16 +99,6 @@ export interface RunChildSessionInput {
 	modelVerificationRegistry?: Array<{ provider: string; id: string; fullId: string }>;
 	modelResponseAliases?: Record<string, string[]>;
 	mutationTools?: readonly string[];
-	/** Internal guarded continuation handoff; never part of persisted results. */
-	readonlyContinuation?: { source: ChildSession; expected: SettledReadonlyEvidence; modelId: string };
-	collectReadonlyEvidence?: boolean;
-	canContinue?: () => boolean;
-}
-
-const settledChildren = new WeakMap<RunChildSessionResult, ChildSession>();
-export function getSettledReadonlyChild(result: RunChildSessionResult): ChildSession | undefined {
-	const child = settledChildren.get(result);
-	return child && getReadonlySessionEvidence(child) ? child : undefined;
 }
 
 export interface RunChildSessionResult {
@@ -118,6 +108,7 @@ export interface RunChildSessionResult {
 	toolCount: number;
 	durationMs: number;
 	model?: string;
+	nativeMachine?: { provider: "herdr"; machineId: string; initialGit?: import("../../shared/types.ts").HerdrRemoteGitStatus; finalGit?: import("../../shared/types.ts").HerdrRemoteGitStatus };
 	error?: string;
 	finalOutput: string;
 	outputState: SubagentOutputState;
@@ -133,12 +124,12 @@ export interface RunChildSessionResult {
 	currentToolArgs?: string;
 	currentPath?: string;
 	afterCompactionSettlement?: boolean;
+	abortRecoveryDiagnostic?: string;
 	/** Set by the runner while it finalizes the attempt. */
 	toolBudget?: ToolBudgetState;
 	toolBudgetBlocked?: boolean;
 	structuredOutput?: unknown;
 	runtimeAcknowledgedExtensions?: RuntimeAcknowledgedChildExtensions;
-	abortRecoveryDiagnostic?: string;
 	effects?: EffectsProjection;
 }
 
@@ -575,8 +566,21 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 			const closed = finish();
 			const finalOutput = getFinalOutput(messages);
 			let finalError = error ?? assistantError;
-			if (!finalError && promptError !== undefined) {
-				finalError = promptError instanceof Error ? promptError.message : String(promptError);
+			const promptErrorMessage = promptError === undefined ? undefined : promptError instanceof Error ? promptError.message : String(promptError);
+			if (!finalError && promptErrorMessage !== undefined) {
+				finalError = promptErrorMessage;
+			}
+			// A child launched without the ambient extensions resolves a provider
+			// extension's model as "not found". Annotate only a creation/prompt failure
+			// that produced no turn; keep the core error and add the rule and the
+			// remedies that load the extension for this child.
+			if (promptErrorMessage !== undefined
+				&& finalError === promptErrorMessage
+				&& isChildModelResolutionFailure(promptErrorMessage)
+				&& messages.length === 0
+				&& usage.turns === 0
+				&& !input.launch.session.ambientExtensions) {
+				finalError = `${promptErrorMessage}\n\n${formatChildModelResolutionDiagnostic({ agent: input.launch.config.agent, model: input.launch.session.model, host: "runner", capabilityCeiling: input.launch.toolPlan.capabilityCeiling })}`;
 			}
 			const forcedDrainAfterFinalSuccess = (forced || forcedTermination) && (cleanTerminalAssistantStopReceived || agentSettledReceived) && !finalError;
 			const forcedDrainAfterEmptyTerminal = forcedDrainAfterFinalSuccess && hasEmptyTerminalAssistantResponse(messages);
@@ -596,6 +600,7 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 					toolCount,
 					durationMs: Date.now() - startedAt,
 					model,
+					nativeMachine: session?.machineEvidence ? { provider: "herdr", machineId: session.machineEvidence.machineId, ...(session.machineEvidence.initial ? { initialGit: session.machineEvidence.initial } : {}), ...(session.machineEvidence.final ? { finalGit: session.machineEvidence.final } : {}) } : undefined,
 					error: stopped ? stopMessage() : timedOut ? (error ?? timeoutMessage()) : interrupted || (forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal) ? undefined : finalError,
 					finalOutput: (timedOut || stopped) && !finalOutput.trim() ? (stopped ? stopMessage() : error ?? timeoutMessage()) : finalOutput,
 					outputState: finalOutput.trim() ? "present" : "absent",
@@ -612,7 +617,6 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 					currentPath,
 					afterCompactionSettlement: afterCompactionSettlement || undefined,
 				});
-				if (session && !forced && !forcedTermination && !interrupted && !timedOut && !stopped && getReadonlySessionEvidence(session)) settledChildren.set(result, session);
 				resolve(result);
 			});
 		};
@@ -634,17 +638,7 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 
 		void (async () => {
 			try {
-				const continuation = input.readonlyContinuation;
-				const checkContinuation = () => {
-					if (!continuation) return;
-					if (interrupted || timedOut || stopped || input.canContinue?.() !== true
-						|| (input.runDeadlineAt !== undefined && Date.now() >= input.runDeadlineAt)
-						|| getReadonlySessionEvidence(continuation.source) !== continuation.expected
-						|| continuation.source.detached || continuation.source.shutDown) throw new Error("Read-only continuation handoff vetoed");
-				};
-				checkContinuation();
 				const createInput = createReportedChildSessionInput(input.launch, input.transcriptWriter);
-				if (input.collectReadonlyEvidence || continuation) requestReadonlySessionEvidence(createInput, continuation?.expected);
 				const created = await input.factory.create(createInput);
 				if (settled) {
 					void created.dispose();
@@ -661,8 +655,6 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 					if (cleanTerminalAssistantStopReceived || agentSettledReceived) queuedDrainHold = true;
 					return followUp(text);
 				};
-				checkContinuation();
-				if (continuation && (created.modelId !== continuation.modelId || input.launch.capture.completionIntentContext?.()?.model?.api !== continuation.expected.api)) throw new Error("Read-only continuation model changed");
 				unsubscribe = created.subscribe(processEvent);
 				input.registerWatchdogStatus?.((event) => processEvent(event as unknown as ChildSessionEvent));
 				input.registerSteer?.(async (request) => {
@@ -686,7 +678,6 @@ export function runChildSession(input: RunChildSessionInput): Promise<RunChildSe
 					return queued;
 				});
 				if (interrupted || timedOut || stopped) abortChild();
-				checkContinuation();
 				await created.prompt(input.prompt);
 				promptSettled = true;
 				settle(undefined);

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

@@ -8,11 +8,9 @@
  * 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 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";
 
@@ -37,13 +35,6 @@ const CHORD_PEER_ALIASES = [
 	{ specifier: "@earendil-works/chord/context", pkg: "@earendil-works/chord", subpath: "./context" },
 ];
 
-/** Experimental dependencies accidentally published in exactly Pi 0.85.0. */
-const PI0850_PEER_ALIASES = [
-	{ 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" },
-];
-
 interface PackageManifest {
 	name?: unknown;
 	version?: unknown;
@@ -132,40 +123,20 @@ function findPeerPackageDir(piPackageRoot: string, pkg: string, hostName: unknow
 }
 
 /** The alias map the runner needs, or the specifiers that could not be resolved. */
-export function resolveHostPeerAliases(
-	piPackageRoot: string,
-	extensionRoot = fileURLToPath(new URL("../../../", import.meta.url)),
-): { aliases: Record<string, string>; missing: string[]; supplemental: string[] } {
+export function resolveHostPeerAliases(piPackageRoot: string): { aliases: Record<string, string>; missing: string[] } {
 	const aliases: Record<string, string> = {};
 	const missing: string[] = [];
-	const supplemental: string[] = [];
 	const hostManifest = readManifest(piPackageRoot);
-	const isPi0850 = hostManifest?.version === "0.85.0";
 	// Only known stable pre-chord versions may omit it. Unknown/prerelease
 	// hosts retain the required aliases, rather than hiding a broken install.
 	const stableVersion = typeof hostManifest?.version === "string" ? /^0\.(\d+)\.\d+$/.exec(hostManifest.version) : null;
 	const isPreChord = stableVersion !== null && Number(stableVersion[1]) < 85;
-	const required = [...HOST_PEER_ALIASES, ...(isPreChord ? [] : CHORD_PEER_ALIASES), ...(isPi0850 ? PI0850_PEER_ALIASES : [])];
+	const required = [...HOST_PEER_ALIASES, ...(isPreChord ? [] : CHORD_PEER_ALIASES)];
 	for (const { specifier, pkg, subpath } of required) {
 		const packageDir = findPeerPackageDir(piPackageRoot, pkg, hostManifest?.name);
-		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")
-			&& isPi0850
-			&& (!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);
-				}
-			}
-		}
+		const target = packageDir ? resolvePackageSubpath(packageDir, subpath) : undefined;
 		if (target && fs.existsSync(target)) aliases[specifier] = target;
 		else missing.push(specifier);
 	}
-	return { aliases, missing, supplemental };
+	return { aliases, missing };
 }

package/src/runs/background/runner-child-launch.ts

@@ -35,6 +35,9 @@ export function buildRunnerChildLaunch(step: RunnerSubagentStep, ctx: RunnerChil
 		? formatAcceptancePrompt(step.effectiveAcceptance, { reportOptional: isAgentContract(step.agentContract), structuredOutput: Boolean(step.structuredOutput?.acceptanceReportPath) })
 		: "";
 	return buildInProcessChildLaunch({
+		machine: step.machine,
+		remoteSkillNames: step.skills,
+		remoteReads: step.remoteReads,
 		parentSessionId: step.parentSessionId,
 		forkCacheKey: step.context === "fork" ? deriveForkPromptCacheKey(step.parentSessionId) : undefined,
 		sessionEnabled: attempt.sessionEnabled,
@@ -50,8 +53,8 @@ export function buildRunnerChildLaunch(step: RunnerSubagentStep, ctx: RunnerChil
 		allowNestedSubagents: step.allowNestedSubagents,
 		extensions: step.extensions,
 		subagentOnlyExtensions: step.subagentOnlyExtensions,
+		requiredExtensions: step.requiredExtensions,
 		fast: step.fast,
-		modelCandidates: step.modelCandidates,
 		systemPrompt: acceptancePrompt ? `${step.systemPrompt ?? ""}\n${acceptancePrompt}` : step.systemPrompt ?? "",
 		systemPromptMode: step.systemPromptMode,
 		mcpDirectTools: step.mcpDirectTools,

package/src/runs/background/runner-child-sessions.ts

@@ -10,7 +10,7 @@
  */
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
-import { createDefaultChildSessionFactory, type ChildSessionFactory, type DefaultChildSessionFactoryOptions } from "../shared/child-session.ts";
+import { createPlacementChildSessionFactory, type ChildSessionFactory, type DefaultChildSessionFactoryOptions } from "../shared/child-session.ts";
 
 export interface RunnerChildSessionConfig {
 	/** Test seam: module whose default export is a `ChildSessionFactory`, or a function returning one. */
@@ -22,7 +22,7 @@ function isChildSessionFactory(value: unknown): value is ChildSessionFactory {
 }
 
 export async function loadRunnerChildSessionFactory(config: RunnerChildSessionConfig, options?: DefaultChildSessionFactoryOptions): Promise<ChildSessionFactory> {
-	if (!config.childSessionFactoryModule) return createDefaultChildSessionFactory(options);
+	if (!config.childSessionFactoryModule) return createPlacementChildSessionFactory(options);
 	const loaded = await import(pathToFileURL(path.resolve(config.childSessionFactoryModule)).href) as { default?: unknown };
 	const candidate = typeof loaded.default === "function" ? (loaded.default as () => unknown)() : loaded.default;
 	if (!isChildSessionFactory(candidate)) {

package/src/runs/background/runner-http-dispatcher.ts

@@ -0,0 +1,119 @@
+import { EventEmitter } from "node:events";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { getConfigDirName } from "../../shared/utils.ts";
+
+/** Pi's default undici header/body idle timeout. */
+export const DEFAULT_HTTP_IDLE_TIMEOUT_MS = 300_000;
+
+export interface HttpIdleTimeoutResolution {
+	timeoutMs: number;
+	source: "project" | "global" | "default";
+	warning?: string;
+}
+
+/**
+ * Mirrors pi-coding-agent's `parseHttpIdleTimeoutMs`: numbers (or numeric
+ * strings) are floored, `"disabled"` means 0, anything else is invalid.
+ */
+export function parseHttpIdleTimeoutMs(value: unknown): number | undefined {
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed.toLowerCase() === "disabled") return 0;
+		if (trimmed.length === 0) return undefined;
+		return parseHttpIdleTimeoutMs(Number(trimmed));
+	}
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return undefined;
+	return Math.floor(value);
+}
+
+function readSetting(file: string): { present: boolean; value?: unknown; error?: string } {
+	let raw: string;
+	try {
+		raw = fs.readFileSync(file, "utf8");
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return { present: false };
+		return { present: false, error: `cannot read ${file}: ${error instanceof Error ? error.message : String(error)}` };
+	}
+	try {
+		const parsed = JSON.parse(raw) as unknown;
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { present: false };
+		if (!Object.hasOwn(parsed, "httpIdleTimeoutMs")) return { present: false };
+		return { present: true, value: (parsed as Record<string, unknown>).httpIdleTimeoutMs };
+	} catch (error) {
+		return { present: false, error: `cannot parse ${file}: ${error instanceof Error ? error.message : String(error)}` };
+	}
+}
+
+/**
+ * Resolves Pi's `httpIdleTimeoutMs` the way the host does: the project
+ * `.pi/settings.json` overrides the global `<agentDir>/settings.json`, and an
+ * unset value falls back to 300 000 ms. Detached runners install their own
+ * undici dispatcher before pi-coding-agent is loaded, so they cannot borrow
+ * Pi's SettingsManager and must read the setting themselves.
+ */
+export function resolveHttpIdleTimeoutMs(options: { agentDir: string; cwd: string }): HttpIdleTimeoutResolution {
+	const candidates: Array<{ source: "project" | "global"; file: string }> = [
+		{ source: "project", file: path.join(options.cwd, getConfigDirName(), "settings.json") },
+		{ source: "global", file: path.join(options.agentDir, "settings.json") },
+	];
+	const warnings: string[] = [];
+	for (const candidate of candidates) {
+		const read = readSetting(candidate.file);
+		if (read.error) {
+			warnings.push(read.error);
+			continue;
+		}
+		if (!read.present) continue;
+		const timeoutMs = parseHttpIdleTimeoutMs(read.value);
+		if (timeoutMs === undefined) {
+			// Pi rejects the merged value outright; a malformed override must not
+			// silently fall through to a different scope's setting.
+			warnings.push(`invalid httpIdleTimeoutMs in ${candidate.file}: ${String(read.value)}`);
+			return { timeoutMs: DEFAULT_HTTP_IDLE_TIMEOUT_MS, source: "default", warning: warnings.join("; ") };
+		}
+		return { timeoutMs, source: candidate.source, ...(warnings.length ? { warning: warnings.join("; ") } : {}) };
+	}
+	return { timeoutMs: DEFAULT_HTTP_IDLE_TIMEOUT_MS, source: "default", ...(warnings.length ? { warning: warnings.join("; ") } : {}) };
+}
+
+/** Dispatcher options shared by the runner and its regression test. */
+export function runnerHttpDispatcherOptions(timeoutMs: number): {
+	allowH2: false;
+	proxyTunnel: true;
+	headersTimeout: number;
+	bodyTimeout: number;
+} {
+	return {
+		allowH2: false,
+		// Keep HTTP origins on CONNECT tunnels, matching Pi's dispatcher.
+		proxyTunnel: true,
+		headersTimeout: timeoutMs,
+		bodyTimeout: timeoutMs,
+	};
+}
+
+/**
+ * Installs the runner's proxy-aware undici dispatcher as the process global and
+ * routes global fetch through it, with header/body idle clocks taken from Pi's
+ * `httpIdleTimeoutMs`. Detached runners skip Pi's CLI dispatcher setup: the Node
+ * entrypoint never runs it, and the binary bootstrap runs inside the extension
+ * factory, before Pi applies the setting to its own dispatcher. Best effort: a
+ * failure logs and leaves the existing dispatcher in place.
+ */
+export function installRunnerHttpDispatcher(options: { agentDir: string; cwd: string }): 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 idle = resolveHttpIdleTimeoutMs(options);
+		if (idle.warning) console.error(`[pi-subagents] httpIdleTimeoutMs: ${idle.warning}; using ${idle.timeoutMs}ms`);
+		const dispatcher = new undici.EnvHttpProxyAgent(runnerHttpDispatcherOptions(idle.timeoutMs));
+		// 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)}`);
+	}
+}

package/src/runs/background/scheduled-runs.ts

@@ -15,6 +15,7 @@ import { previewSimpleWorkflowRun } from "../../workflows/scripted-workflow.ts";
 import { resolveGitRepositoryIdentity } from "../../workflows/chat-progress.ts";
 import { getConfigDirName } from "../../shared/utils.ts";
 import { normalizeWorktreeBaseRef } from "../shared/worktree.ts";
+import { deepFreezeWorkflowArgs, normalizeWorkflowArgs } from "../../workflows/workflow-resources.ts";
 
 export const SCHEDULED_RUN_ACTIONS = [
 	"schedule.create",
@@ -40,7 +41,7 @@ export type ScheduleRunState = "running" | "skipped" | "missed" | "completed" |
 export type ScheduleTrigger =
 	| { kind: "once"; at: string; nextRunAt?: string }
 	| { kind: "interval"; every: string; everyMs: number; anchorAt: string; nextRunAt: string };
-export type ScheduleTarget = { workflowScript: string; baseRef?: string };
+export type ScheduleTarget = { workflowScript: string; args: Record<string, unknown>; baseRef?: string };
 
 export interface ScheduleRecord {
 	schemaVersion: 1;
@@ -283,14 +284,17 @@ function readJson(file: string, label: string): unknown {
 
 function parseScheduleTarget(value: unknown, file: string): ScheduleTarget {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Schedule record '${file}' has invalid trigger or target.`);
-	const target = value as { workflowScript?: unknown; baseRef?: unknown; agent?: unknown; task?: unknown };
+	const target = value as { workflowScript?: unknown; args?: unknown; baseRef?: unknown; agent?: unknown; task?: unknown };
 	if (typeof target.workflowScript === "string" && target.workflowScript.trim()) {
+		let baseRef: string | undefined;
 		try {
-			const baseRef = normalizeWorktreeBaseRef(target.baseRef);
-			return { workflowScript: target.workflowScript.trim(), ...(baseRef === undefined ? {} : { baseRef }) };
+			baseRef = normalizeWorktreeBaseRef(target.baseRef);
 		} catch (error) {
 			throw new Error(`Schedule record '${file}' has an invalid baseRef: ${error instanceof Error ? error.message : String(error)}`);
 		}
+		const normalizedArgs = normalizeWorkflowArgs(target.args);
+		if ("error" in normalizedArgs) throw new Error(`Schedule record '${file}' has invalid args: ${normalizedArgs.error}`);
+		return { workflowScript: target.workflowScript.trim(), args: deepFreezeWorkflowArgs(normalizedArgs.args), ...(baseRef === undefined ? {} : { baseRef }) };
 	}
 	if (target.agent !== undefined || target.task !== undefined) throw new Error(`Schedule record '${file}' uses a removed legacy agent target; recreate it with target.workflowScript.`);
 	throw new Error(`Schedule record '${file}' requires a workflowScript target.`);
@@ -447,7 +451,9 @@ function sanitizeTarget(params: SubagentParamsLike): { target?: ScheduleTarget;
 	}
 	const acceptanceErrors = validateExecutionAcceptance(params as Parameters<typeof validateExecutionAcceptance>[0]);
 	if (acceptanceErrors.length) return { error: acceptanceErrors.join(" ") };
-	return { target: { workflowScript: params.workflowScript.trim(), ...(baseRef === undefined ? {} : { baseRef }) } };
+	const normalizedArgs = normalizeWorkflowArgs(params.args);
+	if ("error" in normalizedArgs) return { error: normalizedArgs.error };
+	return { target: { workflowScript: params.workflowScript.trim(), args: deepFreezeWorkflowArgs(normalizedArgs.args), ...(baseRef === undefined ? {} : { baseRef }) } };
 }
 
 function executionParams(schedule: ScheduleRecord, quiet = false): SubagentParamsLike {

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

@@ -99,13 +99,13 @@ interface ResultChildOutcome {
 	sessionFile?: string;
 	model?: string;
 	thinking?: string;
-	attemptedModels?: string[];
-	modelAttempts?: NonNullable<AsyncStatus["steps"]>[number]["modelAttempts"];
+	requestedModel?: string;
 	contextOverflow?: boolean;
 }
 
 interface ResultRepairData {
 	state: "complete" | "failed" | "partial" | "paused" | "stopped" | "rejected";
+	error?: string;
 	results?: ResultChildOutcome[];
 }
 
@@ -120,7 +120,8 @@ function regularFileExists(filePath: string): boolean {
 
 function readResultRepairData(resultPath: string): ResultRepairData | undefined {
 	try {
-		const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as { success?: boolean; state?: string; exitCode?: number; results?: unknown };
+		const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as { success?: boolean; state?: string; exitCode?: number; error?: unknown; results?: unknown };
+		if (data.error !== undefined && typeof data.error !== "string") throw new Error(`Invalid async result file '${resultPath}': error must be a string.`);
 		const state = data.success ? "complete" : data.state === "stopped" ? "stopped" : data.state === "rejected" ? "rejected" : data.state === "partial" ? "partial" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
 		const results = Array.isArray(data.results)
 			? data.results.map((entry, index) => {
@@ -131,7 +132,7 @@ function readResultRepairData(resultPath: string): ResultRepairData | undefined
 				return child;
 			})
 			: undefined;
-		return { state, ...(results ? { results } : {}) };
+		return { state, ...(data.error ? { error: data.error } : {}), ...(results ? { results } : {}) };
 	} catch (error) {
 		if (isNotFoundError(error)) return undefined;
 		throw new Error(`Failed to read async result file '${resultPath}': ${getErrorMessage(error)}`, {
@@ -146,9 +147,16 @@ function childState(overallState: ResultRepairData["state"], child: ResultChildO
 	return overallState;
 }
 
+function failureDiagnostic(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value : undefined;
+}
+
 function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now: number): AsyncStatus | undefined {
 	const repair = readResultRepairData(resultPath);
 	if (!repair) return undefined;
+	const rootError = failureDiagnostic(status.error)
+		?? failureDiagnostic(repair.error)
+		?? repair.results?.map((child) => child.success === false ? failureDiagnostic(child.error) : undefined).find(Boolean);
 	const steps = (status.steps ?? []).map((step, index) => {
 		if (step.status !== "running" && step.status !== "pending") return step;
 		const child = repair.results?.[index];
@@ -167,14 +175,14 @@ function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now:
 			sessionFile: step.sessionFile ?? child?.sessionFile,
 			model,
 			thinking,
-			attemptedModels: child?.attemptedModels ?? step.attemptedModels,
-			modelAttempts: child?.modelAttempts ?? step.modelAttempts,
+			requestedModel: child?.requestedModel ?? step.requestedModel,
 			contextOverflow: child?.contextOverflow ?? step.contextOverflow,
 		};
 	});
 	const terminalStatus: AsyncStatus = {
 		...status,
 		state: repair.state,
+		...(rootError && (repair.state === "failed" || repair.state === "partial") ? { error: rootError } : {}),
 		...(status.lifecycleArtifactVersion === 3 && (!status.processTerminal || status.processTerminal.state === "pending") ? {
 			processTerminal: { version: 1 as const, state: "unknown" as const, runId: status.runId, runnerProcessInstanceId: "observer-unavailable", reason: "observer-unavailable" as const },
 		} : {}),
@@ -264,8 +272,7 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 				error: step.status === "complete" || step.status === "completed" ? undefined : step.error ?? message,
 				success: step.status === "complete" || step.status === "completed",
 				model: step.model,
-				attemptedModels: step.attemptedModels,
-				modelAttempts: step.modelAttempts,
+				requestedModel: step.requestedModel,
 				contextOverflow: step.contextOverflow,
 				sessionFile: step.sessionFile,
 			})),
@@ -378,9 +385,26 @@ export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOp
 			? terminalStatusFromResult(effectiveStatus, existingResultPath, now)
 			: undefined;
 		if (terminalStatus) {
-			writeAtomicJson(path.join(asyncDir, "status.json"), terminalStatus);
-			updateActiveRunIndex(asyncDir, terminalStatus.state, terminalStatus.toolCallId);
-			return { status: terminalStatus, repaired: true, resultPath: existingResultPath, message: "Existing async result file was used to repair stale running status." };
+			const currentStatus = readStatus(asyncDir);
+			const currentRootError = failureDiagnostic(currentStatus?.error);
+			const currentTerminal = currentStatus?.processTerminal?.state === "observed" || currentStatus?.processTerminal?.state === "unknown"
+				? currentStatus.processTerminal
+				: undefined;
+			const steps = terminalStatus.steps?.map((step, index) => {
+				const currentStepTerminal = currentStatus?.steps?.[index]?.processTerminal;
+				return currentStepTerminal?.state === "observed" || currentStepTerminal?.state === "unknown"
+					? { ...step, processTerminal: currentStepTerminal }
+					: step;
+			});
+			const statusToWrite: AsyncStatus = {
+				...terminalStatus,
+				...(currentRootError ? { error: currentRootError } : {}),
+				...(currentTerminal ? { processTerminal: currentTerminal } : {}),
+				...(steps ? { steps } : {}),
+			};
+			writeAtomicJson(statusPath, statusToWrite);
+			updateActiveRunIndex(asyncDir, statusToWrite.state, statusToWrite.toolCallId);
+			return { status: statusToWrite, repaired: true, resultPath: existingResultPath, message: "Existing async result file was used to repair stale running status." };
 		}
 		if (effectiveStatus.displayDismissedAt === undefined) return { status: effectiveStatus, repaired: false, resultPath: existingResultPath };
 	}