pi-subagents 0.75.0 → 0.76.1

package/src/runs/foreground/subagent-executor.js

@@ -59,7 +59,7 @@ import { assertRequiredChildExtensionsAdmitted, hasMandatoryRequiredChildExtensi
 import { finalizeSingleOutput, injectSingleOutputInstruction, normalizeSingleOutputOverride, outputPathMappingFromTask, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.js";
 import { assertJsonSchemaObject, cleanupStructuredOutputRuntime, createStructuredOutputRuntime } from "../shared/structured-output.js";
 import { compactForegroundDetails, getSingleResultOutput, PROMPT_REDACTED, readStatus, resolveChildCwd, sumResultsCost, sumResultsUsage, toAgentToolUsage } from "../../shared/utils.js";
-import { discardPreservedWorktrees, formatParallelHandoffError, formatParallelHandoffReference, formatStoredParallelHandoffCleanup, parallelHandoffPath, readParallelHandoffManifest, recordParallelHandoffMerge, recordParallelHandoffSupersession, writeParallelHandoffGroup, writeWorktreeSetupHandoff } from "../shared/parallel-handoff.js";
+import { discardPreservedWorktrees, formatParallelHandoffError, formatParallelHandoffReference, protectRetainedWorktreeForResume, formatStoredParallelHandoffCleanup, parallelHandoffPath, readParallelHandoffManifest, recordParallelHandoffMerge, recordParallelHandoffSupersession, writeParallelHandoffGroup, writeWorktreeSetupHandoff } from "../shared/parallel-handoff.js";
 import { summarizeContextModes } from "../shared/context-mode.js";
 import { attachNestedChildrenToResultChildren, buildSubagentResultIntercomPayload, deliverSubagentResultIntercomEvent, formatSubagentResultReceipt, resolveSubagentResultStatus, stripDetailsOutputsForIntercomReceipt, } from "../../intercom/result-intercom.js";
 import { applySteeringRecoveryAgentConfig, asyncReviveRequiresRecoveryDescriptor, buildRevivedAsyncTask, readAsyncRecoveryDescriptor, resolveAsyncResumeTarget, resolveAsyncRunLocation } from "../background/async-resume.js";
@@ -107,6 +107,7 @@ import { authorizeWorkflowResourceHost, claimWorkflowChildPermit, consumeWorkflo
 import { deepFreezeWorkflowArgs, normalizeWorkflowArgs, resolveStructuredWorkflowResource, resolveWorkflowResource } from "../../workflows/workflow-resources.js";
 import { stableJsonDigest } from "../../shared/launch-contract.js";
 import { cleanupWorktrees, createWorktrees, preflightWorktreeSource, withWorktreeTransaction, diffWorktrees, formatWorktreeDiffSummary, } from "../shared/worktree.js";
+import { applyReviewedCleanupPlan, formatCleanupReceipt, loadReviewedCleanupPlan } from "../shared/worktree-cleanup-apply.js";
 import { createWorktreeCleanupPlan, formatWorktreeCleanupPlan } from "../shared/worktree-cleanup-plan.js";
 import { DIRS, DEFAULT_ARTIFACT_CONFIG, DEFAULT_MAX_OUTPUT, DEFAULT_FORK_PREAMBLE, SUBAGENT_ACTIONS, SUBAGENT_ASYNC_STARTED_EVENT, SUBAGENT_CHILD_STATUS_EVENT, SUBAGENT_CONTROL_EVENT, SUBAGENT_CONTROL_INTERCOM_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION, checkSubagentDepth, resolveChildMaxSubagentDepth, resolveCurrentMaxSubagentDepth, resolveMaxSubagentSpawnsPerRun, truncateOutput, wrapForkTask, } from "../../shared/types.js";
 import { deriveChildSessionName } from "../../shared/child-session-name.js";
@@ -465,6 +466,7 @@ function rememberForegroundRun(state, input) {
                 ...(result.error ? { error: result.error } : {}),
                 ...(result.finalOutput ? { finalOutput: result.finalOutput } : {}),
                 ...(result.outputState ? { outputState: result.outputState } : {}),
+                ...(result.outputPartial ? { outputPartial: true } : {}),
                 ...(result.outputMode ? { outputMode: result.outputMode } : {}),
                 ...(result.savedOutputPath ? { savedOutputPath: result.savedOutputPath } : {}),
                 ...(result.outputSaveError ? { outputSaveError: result.outputSaveError } : {}),
@@ -549,6 +551,7 @@ function updateRememberedForegroundChild(state, input) {
         ...(input.result.error ? { error: input.result.error } : {}),
         ...(input.result.finalOutput ? { finalOutput: input.result.finalOutput } : {}),
         outputState: input.result.outputState,
+        outputPartial: input.result.outputPartial,
         outputMode: input.result.outputMode,
         savedOutputPath: input.result.savedOutputPath,
         outputSaveError: input.result.outputSaveError,
@@ -1645,6 +1648,19 @@ async function resumeAsyncRun(input) {
             : "External runners do not persist Pi sessions and cannot be resumed.";
         return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
     }
+    if (input.params.baseRef !== undefined && "managedWorktree" in target && target.managedWorktree === true) {
+        return { content: [{ type: "text", text: "Cannot resume with baseRef: retained managed-worktree children continue in their existing worktree. Start a new worktree run from that base ref instead." }], isError: true, details: { mode: "management", results: [] } };
+    }
+    if (target.source === "async" && target.managedWorktree && target.asyncDir) {
+        try {
+            const protectedCwd = await protectRetainedWorktreeForResume(parallelHandoffPath(target.asyncDir), target.runId, target.index, input.signal);
+            if (path.resolve(protectedCwd) !== path.resolve(effectiveCwd))
+                throw new Error("Retained worktree cwd changed during resume admission.");
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
+        }
+    }
     if (target.source === "async" && target.runner?.type === "external-job") {
         if (attachChain)
             return { content: [{ type: "text", text: "External-job follow-up does not support chain attachment. Use action='resume' with message instead." }], isError: true, details: { mode: "management", results: [] } };
@@ -1792,9 +1808,6 @@ async function resumeAsyncRun(input) {
     if (!revivalSessionFile) {
         return { content: [{ type: "text", text: `Async run '${target.runId}' child ${target.index} does not have a persisted session file to resume from.` }], isError: true, details: { mode: "management", results: [] } };
     }
-    if (input.params.baseRef !== undefined && "managedWorktree" in target && target.managedWorktree === true) {
-        return { content: [{ type: "text", text: "Cannot resume with baseRef: retained managed-worktree children continue in their existing worktree. Start a new worktree run from that base ref instead." }], isError: true, details: { mode: "management", results: [] } };
-    }
     if (target.source === "async" && asyncReviveRequiresRecoveryDescriptor(target)) {
         return { content: [{ type: "text", text: `Async child '${target.runId}' is missing its required run fan-out recovery identity. Start a new run instead.` }], isError: true, details: { mode: "management", results: [] } };
     }
@@ -2080,6 +2093,7 @@ async function emitForegroundResultIntercom(input) {
             ...(result.sessionName ? { sessionName: result.sessionName } : {}),
             status: foregroundResultIntercomStatus(result),
             outputState: result.outputState ?? "unknown",
+            ...(result.outputPartial ? { outputPartial: true } : {}),
             summary: resultSummaryForIntercom(result),
             index,
             artifactPath: result.artifactPaths?.outputPath,
@@ -4971,7 +4985,7 @@ export function createSubagentExecutor(deps) {
                     if (deps.state.currentSessionId !== currentSessionId || deps.state.completionOwnerId !== completionOwnerId)
                         return false;
                     try {
-                        deps.pi.sendMessage({
+                        (deps.parentWake ?? deps.pi).sendMessage({
                             customType: "subagent-workflow-result-write-failed",
                             content: message,
                             display: true,
@@ -5523,7 +5537,7 @@ export function createSubagentExecutor(deps) {
                                     workflowRunning: notification.workflowRunning,
                                 });
                                 try {
-                                    deps.pi.sendMessage({
+                                    (deps.parentWake ?? deps.pi).sendMessage({
                                         customType: "subagent-incremental-child-notify",
                                         content: formatIncrementalChildCompletion(notification),
                                         display: notification.outcome !== "completed",
@@ -6122,11 +6136,35 @@ export function createSubagentExecutor(deps) {
                 if (deps.allowMutatingManagementActions === false) {
                     return { content: [{ type: "text", text: "Action 'worktree.cleanup' is not available from child-safe subagent fanout mode." }], isError: true, details: { mode: "management", results: [] } };
                 }
+                if (paramsWithResolvedCwd.mode === "apply") {
+                    try {
+                        if (!paramsWithResolvedCwd.repo?.trim() || !paramsWithResolvedCwd.planId?.trim() || paramsWithResolvedCwd.handoffPath !== undefined)
+                            throw new Error("worktree.cleanup apply requires explicit repo and planId, without handoffPath.");
+                        const repo = path.resolve(requestCwd, paramsWithResolvedCwd.repo);
+                        const plan = loadReviewedCleanupPlan(repo, paramsWithResolvedCwd.planId);
+                        const decision = resolveAuthorityDecision({ action: "discardWorktree", ...(deps.config.authorityPolicy === undefined ? {} : { policy: deps.config.authorityPolicy }) });
+                        if (decision === "forbid")
+                            throw new Error("Authority policy forbids worktree cleanup.");
+                        if (decision === "confirm") {
+                            if (!ctx.hasUI)
+                                throw new Error("Authority policy requires interactive confirmation for worktree cleanup.");
+                            if (!await ctx.ui.confirm("Apply reviewed worktree cleanup?", `Repository: ${plan.repoRoot}\nPlan: ${plan.planId}\nRemove up to ${plan.entries.filter((entry) => entry.decision === "remove").length} eligible worktrees. All local branches are retained.`))
+                                return { content: [{ type: "text", text: "Worktree cleanup canceled." }], details: { mode: "management", results: [] } };
+                        }
+                        const applied = await applyReviewedCleanupPlan({ repo: plan.repoRoot, planId: plan.planId, authorized: true, signal,
+                            foregroundRunOwnership: (runId) => deps.state.foregroundControls.has(runId) ? "active" : (deps.state.foregroundRuns?.get(runId)?.children.length && deps.state.foregroundRuns.get(runId).children.every((child) => child.status !== "detached")) ? "terminal" : "unknown",
+                        });
+                        return { content: [{ type: "text", text: formatCleanupReceipt(applied) }], details: { mode: "management", results: [] } };
+                    }
+                    catch (error) {
+                        return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
+                    }
+                }
                 if (paramsWithResolvedCwd.mode !== "plan") {
-                    return { content: [{ type: "text", text: "worktree.cleanup currently supports mode='plan' only; apply/removal is not available yet." }], isError: true, details: { mode: "management", results: [] } };
+                    return { content: [{ type: "text", text: "worktree.cleanup requires mode='plan' or mode='apply'." }], isError: true, details: { mode: "management", results: [] } };
                 }
                 if (paramsWithResolvedCwd.planId !== undefined) {
-                    return { content: [{ type: "text", text: "worktree.cleanup plan mode does not accept planId; apply is not available yet." }], isError: true, details: { mode: "management", results: [] } };
+                    return { content: [{ type: "text", text: "worktree.cleanup plan mode does not accept planId." }], isError: true, details: { mode: "management", results: [] } };
                 }
                 try {
                     const created = createWorktreeCleanupPlan({
@@ -6395,10 +6433,13 @@ export function createSubagentExecutor(deps) {
             if (action === "doctor") {
                 let currentSessionFile = null;
                 let currentSessionId = deps.state.currentSessionId;
+                let budgetSessionId = deps.state.currentSessionId;
                 let sessionError;
                 try {
                     currentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
                     currentSessionId = ctx.sessionManager.getSessionId();
+                    // Launch admission's key (resolveCurrentSessionId) without its throw for an unbound session.
+                    budgetSessionId = currentSessionFile ?? currentSessionId;
                 }
                 catch (error) {
                     sessionError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
@@ -6411,9 +6452,9 @@ export function createSubagentExecutor(deps) {
                     if (!sessionError)
                         sessionError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
                 }
-                const spawnBudget = getSpawnBudgetSnapshot(deps.state, deps.config, currentSessionId);
-                const activeAsyncCapacity = currentSessionId
-                    ? getActiveAsyncCapacitySnapshot(currentSessionId, resolveMaxActiveAsyncRunsPerSession(deps.config.maxActiveAsyncRunsPerSession), { liveWorkflowRunIds: new Set(deps.state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(deps.config.capacity?.abandonedSlotReleaseAfterMs) })
+                const spawnBudget = getSpawnBudgetSnapshot(deps.state, deps.config, budgetSessionId);
+                const activeAsyncCapacity = budgetSessionId
+                    ? getActiveAsyncCapacitySnapshot(budgetSessionId, resolveMaxActiveAsyncRunsPerSession(deps.config.maxActiveAsyncRunsPerSession), { liveWorkflowRunIds: new Set(deps.state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(deps.config.capacity?.abandonedSlotReleaseAfterMs) })
                     : { used: 0, limit: resolveMaxActiveAsyncRunsPerSession(deps.config.maxActiveAsyncRunsPerSession) ?? 0 };
                 deps.state.activeAsyncCapacity = activeAsyncCapacity;
                 return {
@@ -6427,6 +6468,8 @@ export function createSubagentExecutor(deps) {
                                 requestedSessionDir: paramsWithResolvedCwd.sessionDir,
                                 currentSessionFile,
                                 currentSessionId,
+                                spawnBudget,
+                                activeAsyncCapacity,
                                 orchestratorTarget,
                                 sessionError,
                                 expandTilde: deps.expandTilde,