@fitchmultz/pi-subagents 0.0.0-stage → 0.44.5

package/src/runs/foreground/question-control.ts

@@ -0,0 +1,82 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import * as path from "node:path";
+import type { IntercomEventBus, SubagentExecutionResult } from "../../shared/types.ts";
+import { formatRunAction } from "../../shared/status-format.ts";
+import { cancelSupervisorQuestion, claimQuestionRevival, formatSupervisorQuestions, listSupervisorQuestions, questionProcessAlive, questionRecoveryHint, readQuestionState, recordQuestionDelivery, releaseQuestionRevival, saveQuestionAnswer, supervisorQuestionPage, type SupervisorQuestionView } from "../shared/supervisor-questions.ts";
+import { liveLaunchOverrideNotice, nestedResolutionScopeForExecutor, reviveSavedSubagent } from "./foreground-control.ts";
+import type { ExecutorDeps, SubagentParamsLike } from "./subagent-params.ts";
+
+function questionResult(questions: SupervisorQuestionView[], text: string): SubagentExecutionResult {
+	return { content: [{ type: "text", text }], details: { mode: "management", results: [], ...supervisorQuestionPage(questions) } };
+}
+
+export function projectSupervisorQuestions(result: SubagentExecutionResult, params: SubagentParamsLike, ownerSessionId: string, childSafe = false): SubagentExecutionResult {
+	if (result.isError && !result.content.some((item) => item.type === "text" && /Async run not found|Status file not found/.test(item.text))) return result;
+	const id = params.id ?? params.runId ?? (params.dir ? path.basename(params.dir) : undefined);
+	const questions = listSupervisorQuestions(ownerSessionId, id)
+		.filter((question) => question.state === "awaiting_input" || question.state === "answer_pending");
+	if (!questions.length) return result;
+	const page = supervisorQuestionPage(questions);
+	const questionOnly = result.isError && result.content.some((item) => item.type === "text" && /Async run not found|Status file not found/.test(item.text));
+	return {
+		...result,
+		...(questionOnly ? { isError: false } : {}),
+		content: [{ type: "text", text: [`Supervisor input (not execution completion):\n${formatSupervisorQuestions(page.questions, childSafe)}`,
+			...(page.questionList.nextOffset !== undefined ? [`More questions: ${formatRunAction("questions", id, { offset: page.questionList.nextOffset, limit: page.questionList.limit }, childSafe)}`] : []),
+			...(questionOnly ? [] : result.content.map((item) => item.type === "text" ? item.text : ""))].join("\n\n") }],
+		details: { ...result.details, ...page },
+	};
+}
+
+export function cancelSupervisorInput(result: SubagentExecutionResult, params: SubagentParamsLike, ownerSessionId: string, events?: IntercomEventBus): SubagentExecutionResult {
+	if (result.isError && !result.content.some((item) => item.type === "text" && /No interrupt-capable run|No running async run|has no (active|running) child at index \d+/.test(item.text))) return result;
+	const id = result.details.managementControl?.runId ?? params.id ?? params.runId;
+	if (!id) return result;
+	const questions = listSupervisorQuestions(ownerSessionId, id).filter((question) => (params.index === undefined || params.index === question.index) && (question.state === "awaiting_input" || question.state === "answer_pending"));
+	if (!questions.length) return result;
+	for (const question of questions) {
+		cancelSupervisorQuestion(question);
+		events?.emit("subagent:supervisor-question-resolved", { questionId: question.questionId });
+	}
+	const cancelled = questions.map((question) => readQuestionState(question));
+	return result.isError ? questionResult(cancelled, `Cancelled ${questions.length} pending supervisor question(s). Any live waiter will abort its agent; cancellation is requested, not proof of process exit.`)
+		: { ...result, details: { ...result.details, ...supervisorQuestionPage(cancelled) } };
+}
+
+export function controlSupervisorQuestion(input: { params: SubagentParamsLike; requestCwd: string; ctx: ExtensionContext; deps: ExecutorDeps }): SubagentExecutionResult {
+	try {
+		const { params } = input;
+		const id = params.id ?? params.runId;
+		if (params.dir !== undefined) throw new Error("questions/answer use a run id, not dir.");
+		if (params.index !== undefined && (!Number.isSafeInteger(params.index) || params.index < 0)) throw new Error("index must be a non-negative integer.");
+		const questions = listSupervisorQuestions(input.ctx.sessionManager.getSessionId(), id)
+			.filter((question) => (params.index === undefined || question.index === params.index) && (params.action !== "questions" || params.questionId === undefined || question.questionId === params.questionId));
+		if (params.action === "questions") {
+			const page = supervisorQuestionPage(questions, params), childSafe = Boolean(nestedResolutionScopeForExecutor(input.deps));
+			const text = [formatSupervisorQuestions(page.questions, childSafe),
+				`Questions: ${page.questions.length} shown, ${page.questionList.total} total (offset ${page.questionList.offset}).`,
+				...(page.questionList.nextOffset !== undefined ? [`More questions: ${formatRunAction("questions", id, { offset: page.questionList.nextOffset, limit: page.questionList.limit,
+					...(params.index !== undefined ? { index: params.index } : {}), ...(params.questionId ? { questionId: params.questionId } : {}) }, childSafe)}`] : [])].join("\n\n");
+			return { content: [{ type: "text", text }], details: { mode: "management", results: [], ...page } };
+		}
+		if (!id || !params.questionId) throw new Error("action='answer' requires id and questionId.");
+		const question = questions.find((entry) => entry.questionId === params.questionId);
+		if (!question) throw new Error("Question not found in this session's runs. Resume the owning supervisor session to answer it.");
+		const answer = saveQuestionAnswer(question, params.message ?? "", undefined, params.messageOrigin);
+		input.deps.pi.events.emit("subagent:supervisor-question-resolved", { questionId: question.questionId });
+		if (!question.delivery && questionProcessAlive(question)) return questionResult([readQuestionState(question)], [`Answer saved for question ${question.questionId}. The live child will read it from the durable waiter; delivery is pending, not execution completion.`, liveLaunchOverrideNotice(params)].filter(Boolean).join("\n"));
+		const delivery = readQuestionState(question).delivery;
+		if (delivery) return questionResult([readQuestionState(question)], `Question ${question.questionId} was already answered; no new work started. Delivery: ${delivery.kind}, run: ${delivery.runId}.`);
+		const claim = claimQuestionRevival(question);
+		if (!claim.claimed) return questionResult([readQuestionState(question)], `Answer retained for question ${question.questionId}; continuation ${claim.runId} was already requested. No duplicate process started. Inspect that run first. ${questionRecoveryHint(question, Boolean(nestedResolutionScopeForExecutor(input.deps)))}`);
+		const result = reviveSavedSubagent({ ...input, params: { ...params, message: `${answer.origin === "human" ? "Direct user answer (human origin)" : "Supervisor answer"} to question ${question.questionId}:\n\n${answer.message}\n\nOriginal question:\n${question.message}` } }, { ...question, source: "question" }, claim.runId);
+		if (result.isError) {
+			releaseQuestionRevival(question);
+			return { ...result, details: { ...result.details, ...supervisorQuestionPage([readQuestionState(question)]) } };
+		}
+		recordQuestionDelivery(question, { kind: "revive", runId: claim.runId, deliveredAt: Date.now() });
+		return { ...result, details: { ...result.details, ...supervisorQuestionPage([readQuestionState(question)]) } };
+	} catch (error) {
+		return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
+	}
+}

package/src/runs/foreground/run-async-path.ts

@@ -0,0 +1,243 @@
+import * as path from "node:path";
+import { resolveRootSessionId } from "../../shared/session-identity.ts";
+import { toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
+import { resolveStepBehavior, type ChainStep } from "../../shared/settings.ts";
+import { normalizeSkillInput } from "../../agents/skills.ts";
+import { executeAsyncChain, executeAsyncSingle } from "../background/async-execution.ts";
+import { resolveConfiguredChildProjectTrustPolicy } from "../shared/pi-args.ts";
+import { wrapChainTasksForAgentContext, wrapTaskForAgentContext } from "../../shared/agent-context-policy.ts";
+import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
+import {
+	type SubagentExecutionResult,
+	resolveTopLevelParallelConcurrency,
+	resolveTopLevelParallelMaxTasks,
+	resolveChildMaxSubagentDepth,
+	resolveCurrentMaxSubagentDepth,
+} from "../../shared/types.ts";
+import {
+	type ExecutionContextData,
+	type ExecutorDeps,
+	maxParallelTasksMessage,
+	resolveTopLevelOutputOverride,
+	usesAgentDefaultOutput,
+} from "./subagent-params.ts";
+import {
+	buildChainWorktreeTaskCwdError,
+	buildParallelModeError,
+	buildParallelWorktreeTaskCwdError,
+	collectChainSessionFiles,
+	findDuplicateAbsoluteParallelOutputPath,
+	findDuplicateParallelOutputPath,
+} from "./execution-input.ts";
+
+export function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): SubagentExecutionResult | null {
+	const {
+		params,
+		effectiveCwd,
+		agents,
+		ctx,
+		shareEnabled,
+		sessionRoot,
+		sessionFileForIndex,
+		sessionFileForAgentIndex,
+		artifactsEnabled,
+		artifactsDir,
+		controlConfig,
+		intercomBridge,
+		nestedRoute,
+	} = data;
+	const hasChain = (params.chain?.length ?? 0) > 0;
+	const hasTasks = (params.tasks?.length ?? 0) > 0;
+	const hasSingle = !hasChain && !hasTasks && Boolean(params.agent);
+
+	if (hasChain && params.chain) {
+		const chainWorktreeTaskCwdError = buildChainWorktreeTaskCwdError(params.chain as ChainStep[], effectiveCwd);
+		if (chainWorktreeTaskCwdError) {
+			return {
+				content: [{ type: "text", text: chainWorktreeTaskCwdError }],
+				isError: true,
+				details: { mode: "chain" as const, results: [] },
+			};
+		}
+	}
+
+	if (hasTasks && params.tasks) {
+		const maxParallelTasks = resolveTopLevelParallelMaxTasks(deps.config.parallel?.maxTasks);
+		if (params.tasks.length > maxParallelTasks) {
+			return buildParallelModeError(maxParallelTasksMessage(maxParallelTasks));
+		}
+		if (params.worktree) {
+			const worktreeTaskCwdError = buildParallelWorktreeTaskCwdError(params.tasks, effectiveCwd);
+			if (worktreeTaskCwdError) return buildParallelModeError(worktreeTaskCwdError);
+		}
+	}
+	const id = data.runId;
+	const asyncCtx = {
+		pi: deps.pi,
+		cwd: ctx.cwd,
+		currentSessionId: deps.state.currentSessionId!,
+		rootSessionId: resolveRootSessionId(ctx.sessionManager),
+		currentModelProvider: ctx.model?.provider,
+		projectTrusted: ctx.isProjectTrusted(),
+	};
+	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
+	const currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth);
+	const controlIntercomTarget = intercomBridge.orchestratorTarget;
+	const childIntercomTarget = (agent: string, index: number) => resolveSubagentIntercomTarget(id, agent, index);
+	const projectTrust = resolveConfiguredChildProjectTrustPolicy(deps.config.projectTrust);
+
+	if (hasTasks && params.tasks) {
+		const agentConfigs = params.tasks.map((task) => agents.find((agent) => agent.name === task.agent));
+		const skillOverrides = params.tasks.map((task) => normalizeSkillInput(task.skill));
+		const parallelTasks = params.tasks.map((task, index) => {
+			const outputFromAgentDefault = usesAgentDefaultOutput(task.output);
+			const output = resolveTopLevelOutputOverride({
+				requestedOutput: task.output,
+				agentDefaultOutput: agentConfigs[index]?.output,
+				artifactsDir,
+				runId: id,
+				agent: task.agent,
+				index,
+			});
+			return {
+				agent: task.agent,
+				task: wrapTaskForAgentContext(task.task, params.context, task.agent, agents),
+				cwd: task.cwd,
+				...(task.model ? { model: task.model } : {}),
+				...(skillOverrides[index] !== undefined ? { skill: skillOverrides[index] } : {}),
+				...(output !== undefined ? { output } : {}),
+				...(task.outputMode !== undefined ? { outputMode: task.outputMode } : {}),
+				...(outputFromAgentDefault && output !== undefined ? { outputFromAgentDefault: true } : {}),
+				...(task.outputSchema !== undefined ? { outputSchema: task.outputSchema } : {}),
+				...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
+				...(task.progress !== undefined ? { progress: task.progress } : {}),
+				...(task.acceptance !== undefined ? { acceptance: task.acceptance } : {}),
+			};
+		});
+		const asyncParallelBehaviors = parallelTasks.map((task, index) => resolveStepBehavior(agentConfigs[index]!, {
+			...(task.output !== undefined ? { output: task.output } : {}),
+			...(task.outputMode !== undefined ? { outputMode: task.outputMode } : {}),
+		}));
+		const duplicateOutputError = params.worktree
+			? findDuplicateAbsoluteParallelOutputPath({ tasks: parallelTasks, behaviors: asyncParallelBehaviors })
+			: findDuplicateParallelOutputPath({
+				tasks: parallelTasks,
+				behaviors: asyncParallelBehaviors,
+				paramsCwd: effectiveCwd,
+				ctxCwd: ctx.cwd,
+			});
+		if (duplicateOutputError) return buildParallelModeError(duplicateOutputError);
+		return executeAsyncChain(id, {
+			chain: [{
+				parallel: parallelTasks,
+				concurrency: resolveTopLevelParallelConcurrency(params.concurrency, deps.config.parallel?.concurrency),
+				worktree: params.worktree,
+			}],
+			resultMode: "parallel",
+			agents,
+			ctx: asyncCtx,
+			availableModels,
+			cwd: effectiveCwd,
+			maxOutput: params.maxOutput,
+			timeoutMs: data.foregroundTimeoutMs,
+			artifactsDir: artifactsEnabled ? artifactsDir : undefined,
+			shareEnabled,
+			sessionRoot,
+			chainSkills: [],
+			sessionFilesByFlatIndex: params.tasks.map((_, index) => sessionFileForIndex(index)),
+			maxSubagentDepth: currentMaxSubagentDepth,
+			worktreeSetupHook: deps.config.worktreeSetupHook,
+			worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
+			controlConfig,
+			controlIntercomTarget,
+			childIntercomTarget,
+			nestedRoute,
+			projectTrust,
+		});
+	}
+
+	if (hasChain && params.chain) {
+		const normalized = normalizeSkillInput(params.skill);
+		const chainSkills = normalized ?? [];
+		const chain = wrapChainTasksForAgentContext(params.chain as ChainStep[], params.context, agents);
+		return executeAsyncChain(id, {
+			chain,
+			task: params.task,
+			agents,
+			ctx: asyncCtx,
+			availableModels,
+			cwd: effectiveCwd,
+			chainDir: params.chainDir,
+			maxOutput: params.maxOutput,
+			timeoutMs: data.foregroundTimeoutMs,
+			artifactsDir: artifactsEnabled ? artifactsDir : undefined,
+			shareEnabled,
+			sessionRoot,
+			chainSkills,
+			sessionFilesByFlatIndex: collectChainSessionFiles(chain, sessionFileForIndex, sessionFileForAgentIndex, deps.config.chain?.dynamicFanout?.maxItems),
+			dynamicFanoutMaxItems: deps.config.chain?.dynamicFanout?.maxItems,
+			maxSubagentDepth: currentMaxSubagentDepth,
+			worktreeSetupHook: deps.config.worktreeSetupHook,
+			worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
+			controlConfig,
+			controlIntercomTarget,
+			childIntercomTarget,
+			nestedRoute,
+			projectTrust,
+		});
+	}
+
+	if (hasSingle) {
+		const a = agents.find((x) => x.name === params.agent);
+		if (!a) {
+			return {
+				content: [{ type: "text", text: `Unknown agent: ${params.agent}` }],
+				isError: true,
+				details: { mode: "single" as const, results: [] },
+			};
+		}
+		const effectiveOutput = resolveTopLevelOutputOverride({
+			requestedOutput: params.output,
+			agentDefaultOutput: a.output,
+			artifactsDir,
+			runId: id,
+			agent: params.agent!,
+			index: 0,
+		});
+		const effectiveOutputMode = params.outputMode ?? "inline";
+		const normalizedSkills = normalizeSkillInput(params.skill);
+		const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, a.maxSubagentDepth);
+		return executeAsyncSingle(id, {
+			agent: params.agent!,
+			task: wrapTaskForAgentContext(params.task ?? "", params.context, params.agent, agents),
+			agentConfig: a,
+			ctx: asyncCtx,
+			availableModels,
+			cwd: effectiveCwd,
+			maxOutput: params.maxOutput,
+			timeoutMs: data.foregroundTimeoutMs,
+			artifactsDir: artifactsEnabled ? artifactsDir : undefined,
+			shareEnabled,
+			sessionRoot,
+			sessionFile: sessionFileForIndex(0),
+			skills: normalizedSkills,
+			output: effectiveOutput,
+			outputFromAgentDefault: usesAgentDefaultOutput(params.output) && typeof a.output === "string" && !path.isAbsolute(a.output),
+			outputMode: effectiveOutputMode,
+			outputSchema: params.outputSchema,
+			modelOverride: params.model,
+			maxSubagentDepth,
+			worktreeSetupHook: deps.config.worktreeSetupHook,
+			worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
+			controlConfig,
+			controlIntercomTarget,
+			childIntercomTarget,
+			nestedRoute,
+			acceptance: params.acceptance,
+			progress: params.progress,
+			projectTrust,
+		});
+	}
+
+	return null;
+}