pi-subagents 0.56.0 → 0.58.0

package/src/runs/shared/model-exclusions.ts

@@ -20,14 +20,30 @@ type RecordModelFailureOptions = ModelExclusionTarget & {
 
 let exclusions: ModelExclusion[] = [];
 let loaded = false;
-let defaultTTLMs = 24 * 60 * 60_000; // 24 hours, overridable via setDefaultTTL
+/** Default duration for a new model exclusion when no per-record TTL is supplied. */
+export const DEFAULT_MODEL_EXCLUSION_TTL_MS = 24 * 60 * 60_000;
+/** Keeps a new expiry safely below JavaScript's maximum Date timestamp. */
+export const MAX_MODEL_EXCLUSION_TTL_MS = 8_000_000_000_000_000;
+const MAX_DATE_TIMESTAMP_MS = 8_640_000_000_000_000;
+let defaultTTLMs = DEFAULT_MODEL_EXCLUSION_TTL_MS;
+let loadedTTLCeilingMs: number | undefined;
 let persistTimer: ReturnType<typeof setTimeout> | null = null;
 let persistSeq = 0;
 
-/** Override the default exclusion TTL. */
-export function setDefaultTTL(ms: number): void {
-	if (!Number.isFinite(ms) || ms <= 0) throw new Error("Default model exclusion TTL must be a finite positive number.");
+/**
+ * Override the default TTL applied to newly recorded model exclusions.
+ *
+ * @param ms Duration in milliseconds. Must be finite and positive.
+ * @returns Nothing.
+ */
+// TEST:test/unit/model-exclusions.test.ts[model exclusions — TTL expiry]
+export function setDefaultTTL(ms: number, options?: { shortenExisting?: boolean }): void {
+	if (!Number.isFinite(ms) || ms <= 0 || ms > MAX_MODEL_EXCLUSION_TTL_MS) {
+		throw new Error(`Default model exclusion TTL must be a finite positive number no greater than ${MAX_MODEL_EXCLUSION_TTL_MS}.`);
+	}
 	defaultTTLMs = ms;
+	loadedTTLCeilingMs = options?.shortenExisting ? ms : undefined;
+	if (loaded && loadedTTLCeilingMs !== undefined && shortenExclusionsToTTL(exclusions, loadedTTLCeilingMs, Date.now())) schedulePersist();
 }
 
 /**
@@ -78,9 +94,23 @@ function ensureLoaded(): void {
 		const raw = fs.readFileSync(getExclusionsFilePath(), "utf-8");
 		const data = JSON.parse(raw);
 		if (data.version === 1) {
+			if (!Array.isArray(data.exclusions)) throw new Error("Model exclusion store version 1 must contain an exclusions array.");
+			for (let index = 0; index < data.exclusions.length; index++) {
+				const entry = data.exclusions[index];
+				if (!entry || typeof entry !== "object" || Array.isArray(entry)) throw new Error(`Model exclusion store entry ${index} must be an object.`);
+				if (entry.reason !== undefined && typeof entry.reason !== "string") throw new Error(`Model exclusion store entry ${index} has an invalid reason.`);
+				for (const field of ["recordedAt", "expiresAt"] as const) {
+					const timestamp = entry[field];
+					if (typeof timestamp !== "number" || !Number.isFinite(timestamp) || timestamp <= 0 || timestamp > MAX_DATE_TIMESTAMP_MS) {
+						throw new Error(`Model exclusion store entry ${index} has an invalid ${field}.`);
+					}
+				}
+			}
 			const now = Date.now();
 			exclusions = (data.exclusions ?? []).filter((e: ModelExclusion) => e.expiresAt > now);
+			const shortened = loadedTTLCeilingMs !== undefined && shortenExclusionsToTTL(exclusions, loadedTTLCeilingMs, now);
 			exclusions = deduplicate(exclusions);
+			if (shortened) schedulePersist();
 		}
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
@@ -175,6 +205,18 @@ export function isExcluded(modelId: string, provider: string): boolean {
 	return exclusions.some((entry) => entryMatches(entry, modelId, provider, Date.now()));
 }
 
+/**
+ * Return the active exclusion matching a full model id, if any.
+ *
+ * The caller uses this for hard-fail diagnostics; fallback filtering should
+ * continue to use {@link filterFallbackCandidates}.
+ */
+export function findModelExclusion(fullId: string, now = Date.now()): Readonly<ModelExclusion> | undefined {
+	ensureLoaded();
+	const { provider, modelId } = parseModelKey(fullId);
+	return exclusions.find((entry) => entryMatches(entry, modelId, provider, now));
+}
+
 /**
  * Number of live (non-expired) exclusions.
  */
@@ -205,7 +247,10 @@ export function parseModelKey(fullId: string): { provider?: string; modelId: str
  * Filter a list of candidate fullIds, removing excluded models/providers and
  * duplicates while preserving order.
  */
-export function filterFallbackCandidates(candidates: string[], opts?: { now?: number }): string[] {
+export function filterFallbackCandidates(candidates: string[], opts?: {
+	now?: number;
+	onExcluded?: (candidate: string, exclusion: Readonly<ModelExclusion>) => void;
+}): string[] {
 	ensureLoaded();
 	const timestamp = opts?.now ?? Date.now();
 	const seen = new Set<string>();
@@ -213,8 +258,11 @@ export function filterFallbackCandidates(candidates: string[], opts?: { now?: nu
 	for (const raw of candidates) {
 		if (!raw || seen.has(raw)) continue;
 		const { provider: candidateProvider, modelId: candidateModelId } = parseModelKey(raw);
-		const excluded = exclusions.some((entry) => entryMatches(entry, candidateModelId, candidateProvider, timestamp));
-		if (excluded) continue;
+		const exclusion = exclusions.find((entry) => entryMatches(entry, candidateModelId, candidateProvider, timestamp));
+		if (exclusion) {
+			opts?.onExcluded?.(raw, exclusion);
+			continue;
+		}
 		seen.add(raw);
 		filtered.push(raw);
 	}
@@ -241,3 +289,17 @@ function prune(items: ModelExclusion[], now: number): void {
 	}
 	items.length = write;
 }
+
+function shortenExclusionsToTTL(items: ModelExclusion[], ttlMs: number, now: number): boolean {
+	let changed = false;
+	for (const entry of items) {
+		const configuredExpiry = entry.recordedAt + ttlMs;
+		if (entry.expiresAt > configuredExpiry) {
+			entry.expiresAt = configuredExpiry;
+			changed = true;
+		}
+	}
+	const previousLength = items.length;
+	prune(items, now);
+	return changed || items.length !== previousLength;
+}

package/src/runs/shared/model-fallback.ts

@@ -1,7 +1,8 @@
 import { splitKnownThinkingSuffix, type ModelInfo as AvailableModelInfo } from "../../shared/model-info.ts";
 import type { Usage } from "../../shared/types.ts";
-import { filterFallbackCandidates, parseModelKey, recordModelFailure } from "./model-exclusions.ts";
+import { filterFallbackCandidates, findModelExclusion, parseModelKey, recordModelFailure } from "./model-exclusions.ts";
 import { checkModelScope, type ModelScopeCheckRule, type ModelScopeViolation, type ModelSource } from "./model-scope.ts";
+import { redactSecretValues } from "./permissions.ts";
 
 export type { AvailableModelInfo };
 
@@ -278,6 +279,14 @@ function enforceModelScopes(
 	for (const violation of violations) (onWarn ?? defaultScopeWarn)(violation);
 }
 
+function throwForExplicitModelExclusion(model: string): void {
+	const exclusion = findModelExclusion(model);
+	if (!exclusion) return;
+	const reason = redactSecretValues((exclusion.reason ?? "runtime-failure").replace(/[\u0000-\u001f\u007f]+/g, " ")).slice(0, 240);
+	const expiry = Number.isFinite(exclusion.expiresAt) ? `; expires: ${new Date(exclusion.expiresAt).toISOString()}` : "";
+	throw new Error(`Requested subagent model '${model}' is excluded and cannot be replaced by a fallback (reason: ${reason}${expiry}).`);
+}
+
 /**
  * Resolve the `--model` override passed to a spawned subagent.
  *
@@ -312,6 +321,9 @@ export function resolveSubagentModelOverride(
 	} else {
 		resolved = resolveRequiredSubagentModelCandidate(explicit, availableModels, preferredProvider);
 	}
+	if (resolved && explicit !== undefined && options?.source === "explicit") {
+		throwForExplicitModelExclusion(resolved);
+	}
 	if (resolved && options?.scope) {
 		const source: ModelSource = explicit === undefined ? "inherited" : (options.source ?? "inherited");
 		enforceModelScopes(resolved, options.scope, source, options.onWarn);
@@ -325,14 +337,15 @@ export function resolveEffectiveSubagentModel(
 	parentModel: ParentModel | undefined,
 	availableModels: AvailableModelInfo[] | undefined,
 	preferredProvider?: string,
-	options?: Omit<ResolveSubagentModelOverrideOptions, "source">,
+	options?: ResolveSubagentModelOverrideOptions,
 ): string | undefined {
+	const source = options?.source ?? (explicitModel !== undefined ? "explicit" : "inherited");
 	const resolved = resolveSubagentModelOverride(
 		explicitModel ?? agentModel,
 		parentModel,
 		availableModels,
 		preferredProvider,
-		{ ...options, source: explicitModel !== undefined ? "explicit" : "inherited" },
+		{ ...options, source },
 	);
 	if (resolved || explicitModel === undefined) return resolved;
 	return resolveSubagentModelOverride(
@@ -340,7 +353,7 @@ export function resolveEffectiveSubagentModel(
 		parentModel,
 		availableModels,
 		preferredProvider,
-		{ ...options, source: "inherited" },
+		{ ...options, source: options?.source ?? "inherited" },
 	);
 }
 
@@ -394,7 +407,12 @@ export function buildModelCandidates(
 		seen.add(normalized);
 		candidates.push(normalized);
 	}
-	return filterFallbackCandidates(candidates);
+	return filterFallbackCandidates(candidates, {
+		onExcluded(candidate, exclusion) {
+			const reason = redactSecretValues((exclusion.reason ?? "runtime-failure").replace(/[\u0000-\u001f\u007f]+/g, " ")).slice(0, 240);
+			console.warn(`[pi-subagents] Skipping model '${candidate}' due to a cached exclusion (reason: ${reason}; expires: ${new Date(exclusion.expiresAt).toISOString()}).`);
+		},
+	});
 }
 
 const RETRYABLE_MODEL_FAILURE_PATTERNS = [
@@ -419,6 +437,7 @@ const RETRYABLE_MODEL_FAILURE_PATTERNS = [
 	/overloaded/i,
 	/service unavailable/i,
 	/temporar(?:ily)? unavailable/i,
+	/connection\s+(?:error|reset|closed|aborted)/i,
 	/connection refused/i,
 	/fetch failed/i,
 	/network error/i,
@@ -451,6 +470,21 @@ export function isRetryableModelFailure(error: string | undefined): boolean {
 	return RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error));
 }
 
+function messageError(message: unknown): string | undefined {
+	if (!message || typeof message !== "object") return undefined;
+	const value = (message as { errorMessage?: unknown }).errorMessage;
+	return typeof value === "string" ? value : undefined;
+}
+
+export function isRetryableModelFailureAttempt(input: { error: string | undefined; messages?: readonly unknown[]; toolCount?: number }): boolean {
+	if (!isRetryableModelFailure(input.error)) return false;
+	if ((input.toolCount ?? 0) > 0) return false;
+	if (input.error === "Subagent produced no output (possible model cold-start or empty response).") return true;
+	if ((input.toolCount ?? 0) === 0 && (input.messages?.length ?? 0) === 0) return true;
+	const error = input.error?.trim();
+	return Boolean(error && input.messages?.some((message) => messageError(message)?.trim() === error));
+}
+
 export function recordRetryableModelFailure(model: string | undefined, error: string | undefined): void {
 	if (!model || !isRetryableModelFailure(error)) return;
 	const { provider, modelId } = parseModelKey(model);

package/src/runs/shared/mutation-evidence.ts

@@ -9,8 +9,13 @@ const MAX_TRACKED_PATHS = 500;
 const MAX_HASH_BYTES = 1024 * 1024;
 const MAX_TIMEOUT_FILES = 20;
 
+function gitArguments(args: string[]): string[] {
+	// Mutation evidence must not block child startup on a stale fsmonitor daemon.
+	return ["-c", "core.fsmonitor=false", ...args];
+}
+
 function gitOutput(cwd: string, args: string[], maxBuffer = MAX_HASH_BYTES): string {
-	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer });
+	return execFileSync("git", gitArguments(args), { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer });
 }
 
 function splitNul(output: string): string[] {
@@ -21,7 +26,7 @@ function hashLargeDiff(cwd: string, relativePath: string): string {
 	const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tracked-diff-"));
 	const diffPath = path.join(tempDir, "diff.patch");
 	try {
-		execFileSync("git", ["diff", "--no-ext-diff", "--binary", `--output=${diffPath}`, "HEAD", "--", relativePath], { cwd, stdio: "ignore" });
+		execFileSync("git", gitArguments(["diff", "--no-ext-diff", "--binary", `--output=${diffPath}`, "HEAD", "--", relativePath]), { cwd, stdio: "ignore" });
 		const hash = createHash("sha256");
 		const buffer = Buffer.allocUnsafe(64 * 1024);
 		const fd = fs.openSync(diffPath, "r");

package/src/runs/shared/nested-events.ts

@@ -199,8 +199,10 @@ function sanitizeTokenUsage(value: unknown): NestedRunSummary["totalTokens"] | u
 	const input = clampNumber(raw.input);
 	const output = clampNumber(raw.output);
 	const total = clampNumber(raw.total);
+	const window = clampNumber(raw.window);
+	const windowPeak = clampNumber(raw.windowPeak);
 	return input !== undefined && output !== undefined && total !== undefined
-		? { input, output, total }
+		? { input, output, total, ...(window !== undefined ? { window } : {}), ...(windowPeak !== undefined ? { windowPeak } : {}) }
 		: undefined;
 }
 

package/src/runs/shared/nested-render.ts

@@ -1,4 +1,4 @@
-import { formatDuration, formatModelThinking, formatTokens, shortenPath } from "../../shared/formatters.ts";
+import { formatDuration, formatModelThinking, formatTokenUsage, shortenPath } from "../../shared/formatters.ts";
 import { formatActivityLabel } from "../../shared/status-format.ts";
 import type { ActivityState, NestedRunSummary, NestedStepSummary } from "../../shared/types.ts";
 
@@ -68,7 +68,7 @@ function formatNestedActivity(input: {
 	if (input.currentPath) facts.push(shortenPath(input.currentPath));
 	if (input.turnCount !== undefined) facts.push(`${input.turnCount} turns`);
 	if (input.toolCount !== undefined) facts.push(`${input.toolCount} tools`);
-	if (input.totalTokens) facts.push(`${formatTokens(input.totalTokens.total)} tok`);
+	if (input.totalTokens) facts.push(formatTokenUsage(input.totalTokens));
 	const activity = formatActivityLabel(input.lastActivityAt, input.activityState as ActivityState | undefined);
 	return activity || facts.length ? [activity, ...facts].filter(Boolean).join(" | ") : undefined;
 }

package/src/runs/shared/parallel-utils.ts

@@ -28,22 +28,29 @@ export interface RunnerSubagentStep {
 	outputName?: string;
 	structured?: boolean;
 	cwd?: string;
+	/** Original cwd input retained for launch diagnostics. */
+	requestedCwd?: string;
 	model?: string;
+	contextLimit?: number;
 	fast?: boolean;
 	thinking?: string;
 	thinkingCeiling?: import("../../shared/model-info.ts").ThinkingLevel;
 	modelCandidates?: string[];
 	/** The primary model is inherited from the parent session and should not be verified against the child-reported active registry model. */
 	skipPrimaryModelVerification?: boolean;
-	modelVerificationRegistry?: Array<{ provider: string; id: string; fullId: string }>;
+	modelVerificationRegistry?: Array<{ provider: string; id: string; fullId: string; contextWindow?: number }>;
 	tools?: string[];
 	extensions?: string[];
 	subagentOnlyExtensions?: string[];
 	mcpDirectTools?: string[];
+	mcpConfig?: import("./mcp-direct-tool-allowlist.ts").McpConfig;
+	runtimeServerNames?: string[];
+	mutationTools?: string[];
 	completionGuard?: boolean;
 	systemPrompt?: string | null;
 	systemPromptMode?: "append" | "replace";
 	inheritProjectContext: boolean;
+	inheritGlobalContext: boolean;
 	inheritSkills: boolean;
 	skills?: string[];
 	outputPath?: string;

package/src/runs/shared/pi-args.ts

@@ -9,7 +9,10 @@ import {
 	type NestedPathEntry,
 } from "./nested-path.ts";
 import {
-	resolveMcpDirectToolSelections,
+	formatUnresolvedMcpDirectToolSelectors,
+	resolveMcpDirectToolResolution,
+	type McpConfig,
+	type McpRuntimeSnapshotHost,
 	type ResolvedMcpDirectToolSelection,
 } from "./mcp-direct-tool-allowlist.ts";
 import { resolvePiPackageRoot } from "./pi-spawn.ts";
@@ -141,6 +144,7 @@ export const SUBAGENT_STEER_CAPABILITY_ENV = "PI_SUBAGENT_STEER_CAPABILITY";
 export const SUBAGENT_STEER_ACK_DIR_ENV = "PI_SUBAGENT_STEER_ACK_DIR";
 export const PI_INTERCOM_STABLE_ID_ENV = "PI_INTERCOM_STABLE_ID";
 export const PI_INTERCOM_SESSION_ID_ENV = "PI_INTERCOM_SESSION_ID";
+export const SUBAGENT_INHERIT_GLOBAL_CONTEXT_ENV = "PI_SUBAGENT_INHERIT_GLOBAL_CONTEXT";
 
 export interface BuildPiArgsInput {
 	parentSessionId?: string;
@@ -153,6 +157,7 @@ export interface BuildPiArgsInput {
 	thinking?: string | false;
 	systemPromptMode?: "append" | "replace";
 	inheritProjectContext: boolean;
+	inheritGlobalContext: boolean;
 	inheritSkills: boolean;
 	requireReadTool?: boolean;
 	tools?: string[];
@@ -160,6 +165,8 @@ export interface BuildPiArgsInput {
 	subagentOnlyExtensions?: string[];
 	systemPrompt?: string | null;
 	mcpDirectTools?: string[];
+	mcpConfig?: McpConfig;
+	runtimeServerNames?: string[];
 	cwd?: string;
 	promptFileStem?: string;
 	intercomSessionName?: string;
@@ -202,6 +209,7 @@ export interface BuildPiArgsInput {
 	capabilityCeiling?: ResolvedSubagentCapabilityCeiling;
 	thinkingCeiling?: import("../../shared/model-info.ts").ThinkingLevel;
 	extensionBindings?: ExtensionBindings;
+	runtimeSnapshotHost?: McpRuntimeSnapshotHost;
 }
 
 export interface BuildPiArgsResult {
@@ -278,6 +286,8 @@ export interface ResolvePiLaunchToolPlanInput {
 	extensions?: string[];
 	subagentOnlyExtensions?: string[];
 	mcpDirectTools?: string[];
+	mcpConfig?: McpConfig;
+	runtimeServerNames?: string[];
 	cwd?: string;
 	requireReadTool?: boolean;
 	structuredOutput?:
@@ -294,6 +304,7 @@ export interface ResolvePiLaunchToolPlanInput {
 	inheritedCapabilityCeiling?: ResolvedSubagentCapabilityCeiling;
 	agentName?: string;
 	permissionRules?: PermissionRules;
+	runtimeSnapshotHost?: McpRuntimeSnapshotHost;
 }
 
 export interface PiLaunchToolPlan {
@@ -316,6 +327,8 @@ export interface PiLaunchToolPlan {
 	capabilityAudit?: SubagentCapabilityAudit;
 	/** Non-fatal launch warnings; they do not change behavior. */
 	warnings: string[];
+	mcpConfig?: McpConfig;
+	runtimeServerNames?: string[];
 }
 
 function extensionIdentifier(value: string): string {
@@ -337,6 +350,21 @@ function hasPermissionRules(rules: PermissionRules | undefined): boolean {
 	return rules !== undefined && Object.keys(rules).length > 0;
 }
 
+function filterRuntimeMcpConfig(
+	config: McpConfig,
+	runtimeServerNames: readonly string[],
+	effectiveRuntimeServerNames: readonly string[],
+): McpConfig {
+	const runtimeNames = new Set(runtimeServerNames);
+	const effectiveNames = new Set(effectiveRuntimeServerNames);
+	return {
+		...config,
+		mcpServers: Object.fromEntries(
+			Object.entries(config.mcpServers).filter(([name]) => !runtimeNames.has(name) || effectiveNames.has(name)),
+		),
+	};
+}
+
 export function projectLaunchResolvedChildExtensions(
 	toolPlan: Pick<
 		PiLaunchToolPlan,
@@ -461,15 +489,27 @@ export function resolvePiLaunchToolPlan(
 					!requestedBuiltinTools.includes(tool) &&
 					(tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js")),
 			);
-	const resolvedMcpSelections = capabilityCeiling?.denyExtensions
-		? []
-		: resolveMcpDirectToolSelections(input.mcpDirectTools, input.cwd);
+	const mcpResolution = capabilityCeiling?.denyExtensions
+		? { selections: [], unresolvedSelectors: [] }
+		: resolveMcpDirectToolResolution(input.mcpDirectTools, input.cwd, input.runtimeSnapshotHost, input.mcpConfig);
+	if (mcpResolution.unresolvedSelectors.length > 0) {
+		throw new Error(formatUnresolvedMcpDirectToolSelectors(mcpResolution.unresolvedSelectors));
+	}
+	const resolvedMcpSelections = mcpResolution.selections;
 	const effectiveMcpSelections = resolvedMcpSelections.filter(
 		(selection) => !allowedToolSet || allowedToolSet.has(selection.name),
 	);
 	const effectiveMcpTools = effectiveMcpSelections.map(
 		(selection) => selection.name,
 	);
+	const runtimeServerNames = mcpResolution.runtimeServerNames ?? input.runtimeServerNames ?? [];
+	const effectiveRuntimeServerNames = runtimeServerNames.filter((serverName) =>
+		effectiveMcpSelections.some((selection) => selection.selector.startsWith(`${serverName}/`)),
+	);
+	const effectiveMcpConfig = mcpResolution.mcpConfig ?? input.mcpConfig;
+	const filteredMcpConfig = effectiveMcpConfig
+		? filterRuntimeMcpConfig(effectiveMcpConfig, runtimeServerNames, effectiveRuntimeServerNames)
+		: undefined;
 	const explicitToolAllowlist =
 		input.tools !== undefined ||
 		(input.mcpDirectTools?.length ?? 0) > 0 ||
@@ -605,6 +645,9 @@ export function resolvePiLaunchToolPlan(
 		extensionArgs,
 		disableAmbientExtensions,
 		warnings,
+		...(effectiveRuntimeServerNames.length > 0 && filteredMcpConfig
+			? { mcpConfig: filteredMcpConfig, runtimeServerNames: effectiveRuntimeServerNames }
+			: {}),
 		...(capabilityAudit ? { capabilityAudit } : {}),
 	};
 }
@@ -644,6 +687,8 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 		extensions: input.extensions,
 		subagentOnlyExtensions: input.subagentOnlyExtensions,
 		mcpDirectTools: input.mcpDirectTools,
+		mcpConfig: input.mcpConfig,
+		runtimeServerNames: input.runtimeServerNames,
 		cwd: input.cwd,
 		requireReadTool: input.requireReadTool,
 		structuredOutput: input.structuredOutput,
@@ -656,6 +701,7 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 		),
 		agentName: input.childAgentName,
 		permissionRules: input.permissionRules,
+		runtimeSnapshotHost: input.runtimeSnapshotHost,
 	});
 	if (toolPlan.explicitToolAllowlist) {
 		args.push(
@@ -669,6 +715,14 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	}
 	for (const extPath of toolPlan.extensionArgs)
 		args.push("--extension", extPath);
+	let tempDir: string | undefined;
+	if (toolPlan.mcpConfig && toolPlan.runtimeServerNames?.length) {
+		if (!tempDir)
+			tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
+		const mcpConfigPath = path.join(tempDir, "mcp-config.json");
+		fs.writeFileSync(mcpConfigPath, JSON.stringify(toolPlan.mcpConfig, null, 2), { mode: 0o600 });
+		args.push("--mcp-config", mcpConfigPath);
+	}
 
 	if (!input.inheritProjectContext) {
 		args.push("--no-context-files");
@@ -677,9 +731,9 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 		args.push("--no-skills");
 	}
 
-	let tempDir: string | undefined;
 	if (input.systemPrompt !== undefined && input.systemPrompt !== null) {
-		tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
+		if (!tempDir)
+			tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
 		const stem = (input.promptFileStem ?? "prompt").replace(/[^\w.-]/g, "_");
 		const promptPath = path.join(tempDir, `${stem}.md`);
 		// Inject <active_agent> tag so @gotgenes/pi-permission-system can
@@ -817,6 +871,7 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	env.PI_SUBAGENT_INHERIT_PROJECT_CONTEXT = input.inheritProjectContext
 		? "1"
 		: "0";
+	env[SUBAGENT_INHERIT_GLOBAL_CONTEXT_ENV] = input.inheritGlobalContext ? "1" : "0";
 	env.PI_SUBAGENT_INHERIT_SKILLS = input.inheritSkills ? "1" : "0";
 	env[PI_INTERCOM_STABLE_ID_ENV] = input.intercomSessionName || undefined;
 	env[PI_INTERCOM_SESSION_ID_ENV] = undefined;

package/src/runs/shared/process-signal.ts

@@ -2,6 +2,19 @@ export function formatProcessSignalError(signal: string): string {
 	return `Subagent process terminated by signal ${signal}.`;
 }
 
+export function formatMidToolExitError(input: {
+	toolName: string;
+	exitCode: number | null;
+	processSignal?: string | null;
+}): string {
+	const terminal = [`exit ${input.exitCode ?? "unknown"}`, ...(input.processSignal ? [`signal ${input.processSignal}`] : [])].join(", ");
+	return `Subagent process exited during '${input.toolName}' tool execution (${terminal}) before the tool completed. Earlier assistant output is not a terminal result.`;
+}
+
+export function isOrdinaryToolForMidToolExit(toolName: string): boolean {
+	return toolName !== "intercom" && toolName !== "contact_supervisor";
+}
+
 export function isUnexplainedProcessSignal(input: {
 	processSignal?: string | null;
 	interrupted?: boolean;

package/src/runs/shared/run-history.ts

@@ -2,6 +2,9 @@ import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir } from "../../shared/utils.ts";
+import { isUnexplainedProcessSignal } from "./process-signal.ts";
+
+export type RunOutcome = "completed" | "failed" | "timed_out" | "stopped" | "interrupted";
 
 export interface RunEntry {
 	agent: string;
@@ -9,6 +12,7 @@ export interface RunEntry {
 	taskHash?: string;
 	ts: number;
 	status: "ok" | "error";
+	outcome?: RunOutcome;
 	duration: number;
 	exit?: number;
 }
@@ -129,14 +133,30 @@ function appendPrivateHistoryLine(historyPath: string, line: string): void {
 	}
 }
 
-export function recordRun(agent: string, task: string, exitCode: number, durationMs: number): void {
+export function recordRun(
+	agent: string,
+	task: string,
+	exitCode: number,
+	durationMs: number,
+	terminal: { interrupted?: boolean; processSignal?: string | null; stopped?: boolean; timedOut?: boolean; turnBudgetExceeded?: boolean } = {},
+): void {
 	try {
+		const outcome: RunOutcome = terminal.stopped
+			? "stopped"
+			: terminal.interrupted
+				? "interrupted"
+				: terminal.timedOut
+					? "timed_out"
+					: exitCode !== 0 && isUnexplainedProcessSignal(terminal)
+						? "stopped"
+						: exitCode === 0 ? "completed" : "failed";
 		const entry: RunEntry = {
 			agent,
 			task: REDACTED_TASK,
 			taskHash: hashTask(task),
 			ts: Math.floor(Date.now() / 1000),
 			status: exitCode === 0 ? "ok" : "error",
+			outcome,
 			duration: durationMs,
 			...(exitCode !== 0 ? { exit: exitCode } : {}),
 		};

package/src/runs/shared/single-output.ts

@@ -96,6 +96,23 @@ function formatOutputPathInstruction(outputPath: string, capabilities?: OutputIn
 	].join("\n");
 }
 
+export function requestedOutputPathFromTask(task: string): string | undefined {
+	for (const line of task.split(/\r?\n/).reverse()) {
+		const match = line.match(/^\s*(?:Write your findings to(?: exactly this path)?:|The runtime will persist it to exactly this path:)\s*(.+?)\s*$/i);
+		if (!match?.[1]) continue;
+		const requested = match[1].trim();
+		return requested.startsWith("`") && requested.endsWith("`") ? requested.slice(1, -1) : requested;
+	}
+	return undefined;
+}
+
+export function outputPathMappingFromTask(task: string, savedPath: string | undefined): { requestedPath: string; savedPath: string } | undefined {
+	const requestedPath = requestedOutputPathFromTask(task);
+	if (!requestedPath || !savedPath) return undefined;
+	if (path.isAbsolute(requestedPath) && path.normalize(requestedPath) === path.normalize(savedPath)) return undefined;
+	return { requestedPath, savedPath };
+}
+
 export function injectSingleOutputInstruction(task: string, outputPath: string | undefined, capabilities?: OutputInstructionCapabilities): string {
 	if (!outputPath) return task;
 	return `${task}\n\n---\n**Output:**\n${formatOutputPathInstruction(outputPath, capabilities)}`;