pi-subagents 0.57.0 → 0.58.0

package/src/runs/shared/mcp-direct-tool-allowlist.ts

@@ -2,7 +2,9 @@ import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { findConfiguredProjectRoot } from "../../agents/agents.ts";
 import { getAgentDir, getProjectConfigDir } from "../../shared/utils.ts";
+import { loadAgentPluginMcpServers, loadPackageMcpServers, type McpServerDefinition } from "./mcp-config-sources.ts";
 
 const CACHE_VERSION = 1;
 const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
@@ -24,36 +26,39 @@ const IMPORT_PATHS = {
 type ToolPrefix = "server" | "none" | "short";
 type ImportKind = keyof typeof IMPORT_PATHS;
 
-interface ServerEntry {
-	command?: string;
-	args?: string[];
-	socket?: string;
-	env?: Record<string, string>;
-	cwd?: string;
-	url?: string;
-	headers?: Record<string, string>;
-	requestHeadersCommand?: {
-		command: string;
-		args?: string[];
-		env?: Record<string, string>;
-		timeoutMs?: number;
-	};
-	auth?: "oauth" | "bearer" | false;
-	bearerToken?: string;
-	bearerTokenEnv?: string;
-	exposeResources?: boolean;
-	includeTools?: string[];
-	excludeTools?: string[];
-	protocolVersion?: string;
-	directTools?: boolean | string[];
-}
+type ServerEntry = McpServerDefinition;
 
-interface McpConfig {
+export interface McpConfig {
 	mcpServers: Record<string, ServerEntry>;
 	imports?: ImportKind[];
 	settings?: {
 		toolPrefix?: ToolPrefix;
 		directTools?: boolean;
+		agentPluginPaths?: unknown;
+	};
+}
+
+export const MCP_RUNTIME_SNAPSHOT_EVENT = "pi-mcp-adapter:runtime-snapshot:v1" as const;
+export const MCP_RUNTIME_SNAPSHOT_VERSION = 1 as const;
+
+export interface McpRuntimeServerSnapshot {
+	readonly name: string;
+	readonly definition: ServerEntry;
+	readonly runtime: true;
+	readonly persisted: false;
+}
+
+interface McpRuntimeSnapshotRequest {
+	version: typeof MCP_RUNTIME_SNAPSHOT_VERSION;
+	name: string;
+	result?:
+		| { ok: true; snapshot: McpRuntimeServerSnapshot }
+		| { ok: false; error: Error };
+}
+
+export interface McpRuntimeSnapshotHost {
+	events: {
+		emit(event: string, request: McpRuntimeSnapshotRequest): void;
 	};
 }
 
@@ -80,17 +85,62 @@ interface MetadataCache {
 
 export interface ResolvedMcpDirectToolSelection { name: string; selector: string }
 
-export function resolveMcpDirectToolSelections(mcpDirectTools: string[] | undefined, cwd = process.cwd()): ResolvedMcpDirectToolSelection[] {
-	if (!mcpDirectTools?.length) return [];
+export interface McpDirectToolResolution {
+	selections: ResolvedMcpDirectToolSelection[];
+	unresolvedSelectors: string[];
+	/** Normal loaded config plus the selected runtime server definitions. */
+	mcpConfig?: McpConfig;
+	runtimeServerNames?: string[];
+}
+
+function normalizeSelectors(selectors: string[] | undefined): string[] {
+	return [...new Set((selectors ?? []).map((selector) => selector.replace(/\/+$/, "")).filter(Boolean))];
+}
+
+export function resolveMcpDirectToolResolution(
+	mcpDirectTools: string[] | undefined,
+	cwd = process.cwd(),
+	runtimeSnapshotHost?: McpRuntimeSnapshotHost,
+	configOverride?: McpConfig,
+): McpDirectToolResolution {
+	const selectors = normalizeSelectors(mcpDirectTools);
+	if (selectors.length === 0) return { selections: [], unresolvedSelectors: [] };
+
+	const config = configOverride ?? loadMcpConfig(cwd);
+	const { servers: selectedServers, tools: selectedTools } = parseSelections(selectors);
+	const runtimeSelectionServers = new Set([...selectedServers, ...selectedTools.keys()]);
+	const runtimeServers = resolveRuntimeMcpServers(config, runtimeSelectionServers, runtimeSnapshotHost);
+	const resolvedConfig = Object.keys(runtimeServers).length > 0
+		? mergeConfigs(config, { mcpServers: runtimeServers })
+		: config;
+	validateSelectedServerDefinitions(resolvedConfig, selectors);
+	const cache = loadMetadataCache();
+	if (!cache) return { selections: [], unresolvedSelectors: selectors };
+	const selections = resolveDirectToolSelections(resolvedConfig, cache, getToolPrefix(resolvedConfig.settings?.toolPrefix), selectors);
+	const unresolvedSelectors = selectors.filter((selector) =>
+		selector.includes("/")
+			? !selections.some((selection) => selection.selector === selector)
+			: !selections.some((selection) => selection.selector.startsWith(`${selector}/`)),
+	);
+	return {
+		selections,
+		unresolvedSelectors,
+		...(Object.keys(runtimeServers).length > 0
+			? { mcpConfig: resolvedConfig, runtimeServerNames: Object.keys(runtimeServers) }
+			: {}),
+	};
+}
 
-	try {
-		const config = loadMcpConfig(cwd);
-		const cache = loadMetadataCache();
-		if (!cache) return [];
-		return resolveDirectToolSelections(config, cache, getToolPrefix(config.settings?.toolPrefix), mcpDirectTools);
-	} catch {
-		return [];
-	}
+export function resolveMcpDirectToolSelections(
+	mcpDirectTools: string[] | undefined,
+	cwd = process.cwd(),
+	runtimeSnapshotHost?: McpRuntimeSnapshotHost,
+): ResolvedMcpDirectToolSelection[] {
+	return resolveMcpDirectToolResolution(mcpDirectTools, cwd, runtimeSnapshotHost).selections;
+}
+
+export function formatUnresolvedMcpDirectToolSelectors(selectors: readonly string[]): string {
+	return `Unresolved MCP direct-tool selectors: ${selectors.join(", ")}. Direct MCP tools require a matching configured server and fresh metadata cache; runtime-registered servers require a host/pi-mcp-adapter handoff before child launch.`;
 }
 
 function loadMetadataCache(): MetadataCache | null {
@@ -110,20 +160,76 @@ function loadMetadataCache(): MetadataCache | null {
 	return raw as unknown as MetadataCache;
 }
 
+function resolveRuntimeMcpServers(
+	config: McpConfig,
+	selectedServers: ReadonlySet<string>,
+	runtimeSnapshotHost: McpRuntimeSnapshotHost | undefined,
+): Record<string, ServerEntry> {
+	if (!runtimeSnapshotHost) return {};
+	const runtimeServers: Record<string, ServerEntry> = {};
+	for (const serverName of selectedServers) {
+		if (Object.hasOwn(config.mcpServers, serverName)) continue;
+		try {
+			const snapshot = getRuntimeMcpServerSnapshot(runtimeSnapshotHost, serverName);
+			runtimeServers[serverName] = snapshot.definition;
+		} catch {
+			// Missing, disposed, or shadowed runtime servers remain unresolved below.
+		}
+	}
+	return runtimeServers;
+}
+
+function getRuntimeMcpServerSnapshot(
+	host: McpRuntimeSnapshotHost,
+	name: string,
+): McpRuntimeServerSnapshot {
+	const request: McpRuntimeSnapshotRequest = {
+		version: MCP_RUNTIME_SNAPSHOT_VERSION,
+		name,
+	};
+	host.events.emit(MCP_RUNTIME_SNAPSHOT_EVENT, request);
+	if (!request.result) throw new Error("pi-mcp-adapter is not installed for this Pi instance");
+	if (!request.result.ok) throw request.result.error;
+	const snapshot = request.result.snapshot;
+	if (
+		!snapshot ||
+		snapshot.name !== name ||
+		snapshot.runtime !== true ||
+		snapshot.persisted !== false ||
+		!snapshot.definition ||
+		typeof snapshot.definition !== "object" ||
+		Array.isArray(snapshot.definition)
+	) {
+		throw new Error(`Invalid MCP runtime snapshot for server "${name}"`);
+	}
+	return snapshot;
+}
+
 function loadMcpConfig(cwd: string): McpConfig {
+	const resolvedCwd = path.resolve(cwd);
+	const projectRoot = findConfiguredProjectRoot(resolvedCwd) ?? resolvedCwd;
 	let config: McpConfig = { mcpServers: {} };
-	for (const sourcePath of getConfigPaths(cwd)) {
+	for (const sourcePath of getConfigPaths(projectRoot)) {
 		const loaded = readConfig(sourcePath);
 		if (!loaded) continue;
-		config = mergeConfigs(config, expandImports(loaded, cwd));
+		config = mergeConfigs(config, expandImports(loaded, projectRoot));
 	}
-	return config;
+
+	const packageServers = loadPackageMcpServers(projectRoot);
+	const pluginServers = loadAgentPluginMcpServers(config.settings?.agentPluginPaths, projectRoot);
+	const packageOnlyServers = Object.fromEntries(
+		Object.entries(packageServers).filter(([name]) => !Object.hasOwn(pluginServers, name)),
+	);
+	return mergeConfigs(
+		{ mcpServers: packageOnlyServers },
+		mergeConfigs({ mcpServers: pluginServers }, config),
+	);
 }
 
-function getConfigPaths(cwd: string): string[] {
+function getConfigPaths(projectRoot: string): string[] {
 	const piGlobalPath = path.join(getAgentDir(), "mcp.json");
-	const projectPath = path.resolve(cwd, ".mcp.json");
-	const projectPiPath = path.resolve(getProjectConfigDir(cwd), "mcp.json");
+	const projectPath = path.resolve(projectRoot, ".mcp.json");
+	const projectPiPath = path.resolve(getProjectConfigDir(projectRoot), "mcp.json");
 	const sources: string[] = [];
 	if (GENERIC_GLOBAL_CONFIG_PATH !== piGlobalPath) sources.push(GENERIC_GLOBAL_CONFIG_PATH);
 	sources.push(piGlobalPath);
@@ -253,8 +359,7 @@ export function resolveMcpDirectToolNames(mcpDirectTools: string[] | undefined,
 function parseSelections(selections: string[]): { servers: Set<string>; tools: Map<string, Set<string>> } {
 	const servers = new Set<string>();
 	const tools = new Map<string, Set<string>>();
-	for (let item of selections) {
-		item = item.replace(/\/+$/, "");
+	for (const item of selections) {
 		if (item.includes("/")) {
 			const [server, tool] = item.split("/", 2);
 			if (server && tool) {
@@ -270,6 +375,14 @@ function parseSelections(selections: string[]): { servers: Set<string>; tools: M
 	return { servers, tools };
 }
 
+function validateSelectedServerDefinitions(config: McpConfig, selectors: string[]): void {
+	const { servers, tools } = parseSelections(selectors);
+	for (const serverName of new Set([...servers, ...tools.keys()])) {
+		const definition = config.mcpServers[serverName];
+		if (definition) computeMcpServerHash(definition);
+	}
+}
+
 function isServerCacheValid(entry: ServerCacheEntry | undefined, definition: ServerEntry): entry is ServerCacheEntry {
 	if (!entry || entry.configHash !== computeMcpServerHash(definition)) return false;
 	if (!entry.cachedAt || typeof entry.cachedAt !== "number") return false;

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

@@ -205,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.
  */

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

@@ -1,6 +1,6 @@
 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";
 
@@ -279,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.
  *
@@ -313,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);
@@ -326,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(
@@ -341,7 +353,7 @@ export function resolveEffectiveSubagentModel(
 		parentModel,
 		availableModels,
 		preferredProvider,
-		{ ...options, source: "inherited" },
+		{ ...options, source: options?.source ?? "inherited" },
 	);
 }
 

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/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)}`;