@oh-my-pi/pi-coding-agent 17.0.2 → 17.0.3

package/src/task/parallel.ts

@@ -83,6 +83,49 @@ export async function mapWithConcurrencyLimit<T, R>(
 	return { results, aborted: signal?.aborted ?? false };
 }
 
+/** Result of a concurrency-limited operation that waits for every launched item. */
+export interface ParallelSettledResult<R> {
+	/** Settled results in original input order; absent entries were never launched after cancellation. */
+	results: (PromiseSettledResult<R> | undefined)[];
+	/** Whether cancellation prevented scheduling all items. */
+	aborted: boolean;
+}
+
+/**
+ * Execute items with a concurrency limit without failing fast. Rejections are
+ * captured at their input position and already launched siblings always settle
+ * before this function returns. Cancellation stops new launches but preserves
+ * the settled state of every item that began.
+ */
+export async function mapWithConcurrencyLimitAllSettled<T, R>(
+	items: T[],
+	concurrency: number,
+	fn: (item: T, index: number, signal: AbortSignal) => Promise<R>,
+	signal?: AbortSignal,
+): Promise<ParallelSettledResult<R>> {
+	const normalizedConcurrency = Number.isFinite(concurrency) ? Math.floor(concurrency) : items.length;
+	const effectiveConcurrency = normalizedConcurrency > 0 ? normalizedConcurrency : items.length;
+	const limit = Math.max(1, Math.min(effectiveConcurrency, items.length));
+	const results: (PromiseSettledResult<R> | undefined)[] = new Array(items.length);
+	const workerSignal = signal ?? new AbortController().signal;
+	let nextIndex = 0;
+
+	const worker = async (): Promise<void> => {
+		while (!workerSignal.aborted) {
+			const index = nextIndex++;
+			if (index >= items.length) return;
+			try {
+				results[index] = { status: "fulfilled", value: await fn(items[index], index, workerSignal) };
+			} catch (reason) {
+				results[index] = { status: "rejected", reason };
+			}
+		}
+	};
+
+	await Promise.all(Array.from({ length: limit }, () => worker()));
+	return { results, aborted: workerSignal.aborted };
+}
+
 /**
  * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
  *

package/src/task/persisted-revive.ts

@@ -79,9 +79,10 @@ export function createPersistedSubagentReviverFactory(
 			});
 			const artifactManager = ctx.session.sessionManager.getArtifactManager();
 			if (artifactManager) reopened.adoptArtifactManager(artifactManager);
-			// Reuse the parent's live MCP connections via proxy tools (no
-			// re-discovery), exactly as the executor does for live subagents.
-			const mcpManager = MCPManager.instance();
+			// A restricted persisted contract must not consult process-global MCP
+			// state: same-name MCP tools are untrusted capability sources.
+			const restrictToolNames = init.restrictToolNames === true;
+			const mcpManager = restrictToolNames ? undefined : MCPManager.instance();
 			const mcpProxyTools = mcpManager ? createMCPProxyTools(mcpManager) : [];
 			const { session } = await createAgentSession({
 				cwd: ctx.session.sessionManager.getCwd(),
@@ -99,16 +100,27 @@ export function createPersistedSubagentReviverFactory(
 				taskDepth,
 				toolNames: init.tools,
 				outputSchema: init.outputSchema,
+				outputSchemaMode: init.outputSchemaMode,
+				restrictToolNames: restrictToolNames || undefined,
 				requireYieldTool: true,
 				systemPrompt: () => [init.systemPrompt],
 				// Old files predate persisted spawns: deny re-spawning rather than let
 				// createAgentSession default to wildcard ("*").
 				spawns: init.spawns ?? "",
 				hasUI: false,
-				enableLsp: ctx.enableLsp,
-				enableMCP: !mcpManager,
-				mcpManager,
-				customTools: mcpProxyTools.length > 0 ? mcpProxyTools : undefined,
+				enableLsp: restrictToolNames ? false : ctx.enableLsp,
+				...(restrictToolNames
+					? {
+							enableIrc: false,
+							enableMCP: false,
+							preloadedExtensionPaths: [],
+							preloadedCustomToolPaths: [],
+						}
+					: {
+							enableMCP: !mcpManager,
+							mcpManager,
+							customTools: mcpProxyTools.length > 0 ? mcpProxyTools : undefined,
+						}),
 			});
 			// Clamp the active set to the persisted list: createAgentSession's
 			// `alwaysInclude` can re-add non-defaultInactive extension/custom tools