@fitchmultz/pi-subagents 0.0.0-stage → 0.44.5

package/dist/runs/foreground/question-control.js

@@ -0,0 +1,88 @@
+import * as path from "node:path";
+import { formatRunAction } from "../../shared/status-format.js";
+import { cancelSupervisorQuestion, claimQuestionRevival, formatSupervisorQuestions, listSupervisorQuestions, questionProcessAlive, questionRecoveryHint, readQuestionState, recordQuestionDelivery, releaseQuestionRevival, saveQuestionAnswer, supervisorQuestionPage } from "../shared/supervisor-questions.js";
+import { liveLaunchOverrideNotice, nestedResolutionScopeForExecutor, reviveSavedSubagent } from "./foreground-control.js";
+function questionResult(questions, text) {
+    return { content: [{ type: "text", text }], details: { mode: "management", results: [], ...supervisorQuestionPage(questions) } };
+}
+export function projectSupervisorQuestions(result, params, ownerSessionId, childSafe = false) {
+    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, params, ownerSessionId, events) {
+    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) {
+    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/dist/runs/foreground/run-async-path.js

@@ -0,0 +1,205 @@
+import * as path from "node:path";
+import { resolveRootSessionId } from "../../shared/session-identity.js";
+import { toModelInfo } from "../../shared/model-info.js";
+import { resolveStepBehavior } from "../../shared/settings.js";
+import { normalizeSkillInput } from "../../agents/skills.js";
+import { executeAsyncChain, executeAsyncSingle } from "../background/async-execution.js";
+import { resolveConfiguredChildProjectTrustPolicy } from "../shared/pi-args.js";
+import { wrapChainTasksForAgentContext, wrapTaskForAgentContext } from "../../shared/agent-context-policy.js";
+import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
+import { resolveTopLevelParallelConcurrency, resolveTopLevelParallelMaxTasks, resolveChildMaxSubagentDepth, resolveCurrentMaxSubagentDepth, } from "../../shared/types.js";
+import { maxParallelTasksMessage, resolveTopLevelOutputOverride, usesAgentDefaultOutput, } from "./subagent-params.js";
+import { buildChainWorktreeTaskCwdError, buildParallelModeError, buildParallelWorktreeTaskCwdError, collectChainSessionFiles, findDuplicateAbsoluteParallelOutputPath, findDuplicateParallelOutputPath, } from "./execution-input.js";
+export function runAsyncPath(data, deps) {
+    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, effectiveCwd);
+        if (chainWorktreeTaskCwdError) {
+            return {
+                content: [{ type: "text", text: chainWorktreeTaskCwdError }],
+                isError: true,
+                details: { mode: "chain", 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 = ctx.modelRegistry.getAvailable().map(toModelInfo);
+    const currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth);
+    const controlIntercomTarget = intercomBridge.orchestratorTarget;
+    const childIntercomTarget = (agent, index) => 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, 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", 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;
+}