pi-subagents 0.75.0 → 0.76.0

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,
@@ -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({