@henryqw/pi-subagent 27.5.2 → 27.5.4

package/dist/runner.d.ts

@@ -350,6 +350,7 @@ export declare class IsolatedRunner {
     private releaseRejected;
     private releaseSuperseded;
     private cleanupPromoted;
+    private cleanupPromotedStage;
     private requireExactIntegration;
     listOrphanRequests(cwd: string): Promise<{
         invalidIds: string[];

package/dist/runner.js

@@ -592,6 +592,8 @@ export function nextIntegrationAction(state) {
                 return `Call subagent_integrate refresh with generation ${generation.number + 1}, expectedTip ${JSON.stringify(generation.combinedTip)}, and identical expectedMain and newMain; then restage the candidates and validate again.`;
             }
             return undefined;
+        case "promoted":
+            return `Promotion is proven, but cleanup retained resources; resolve the recorded cleanup failures without discarding work, then call subagent_integrate cleanup with ${exact}.`;
         default:
             return undefined;
     }
@@ -1062,6 +1064,8 @@ export class IsolatedRunner {
                 if (action.action === "reject" && allocationByKind(attempt, "agent")) {
                     if (await this.terminateWithSafety(handle, task, attempt, action.candidate, scope.signal))
                         task.status = "rejected";
+                    else
+                        this.attention(task, `Worker termination is unproved: ${attempt.termination.failure}`);
                     await this.saveProductive(handle);
                 }
                 if (action.action === "revise") {
@@ -1605,101 +1609,123 @@ export class IsolatedRunner {
         // Promotion proves selection independently of worker or checkout cleanup.
         for (const stage of generation.stages)
             changesetTaskState(state, stage.taskId).status = "completed";
+        const generationCleanup = generation.cleanup ??= [{ kind: "worktree", status: "pending" }, { kind: "branch", status: "pending" }];
+        const stepLists = [...generation.stages.map((stage) => changesetTaskState(state, stage.taskId).attempts[stage.attempt - 1].cleanup),
+            generationCleanup];
+        // Record each failure on the step it blocks; other stages and the integration checkout continue.
+        const blocked = (steps, error) => {
+            const step = steps.find((item) => item.status === "running") ?? steps.find((item) => item.status !== "completed");
+            if (step)
+                step.failure = bounded(`Cleanup requires attention: ${errorText(error)}`);
+        };
         await this.saveProductive(handle);
+        let main;
         try {
-            const main = await this.callProductive(handle, scope, (context) => this.gitRuntime.inspectMain({ root: state.root }, context));
-            if (!sameIdentity(main, promoted))
-                throw new Error("Main changed or became dirty after promotion; cleanup is blocked.");
+            main = await this.callProductive(handle, scope, (context) => this.gitRuntime.inspectMain({ root: state.root }, context));
+        }
+        catch (error) {
+            for (const steps of stepLists)
+                blocked(steps, error);
+        }
+        if (main && !sameIdentity(main, promoted)) {
+            for (const steps of stepLists)
+                blocked(steps, new Error("Main changed or became dirty after promotion; cleanup is blocked."));
+        }
+        else if (main) {
             for (const stage of generation.stages) {
                 const task = changesetTaskState(state, stage.taskId);
                 const attempt = task.attempts[stage.attempt - 1];
-                const candidate = state.integration.candidates.find((item) => item.taskId === stage.taskId && item.attempt === stage.attempt
-                    && sameIdentity(item.tip, stage.source));
-                const worker = allocationByKind(attempt, "worktree")?.worktree;
-                if (!worker)
-                    throw new Error("Promoted worker lacks a proven checkout.");
-                candidate.worker = "release_pending";
-                await this.saveProductive(handle);
-                if (attempt.termination?.status !== "terminated") {
-                    if (attempt.termination) {
-                        const result = await this.callProductive(handle, scope, (context) => this.hostRuntime.reconcileWorkerTermination({
-                            task: changesetTaskRequest(state, task.taskId), attempt,
-                            workerId: attempt.termination.workerId, candidate: stage.source,
-                        }, context));
-                        if (result.outcome !== "terminated")
-                            throw new Error("Worker termination cannot be proved; never replay termination.");
-                        attempt.termination = { status: "terminated", workerId: attempt.termination.workerId,
-                            candidate: stage.source, at: this.coordinatorRuntime.now() };
-                        await this.saveProductive(handle);
-                    }
-                    else if (!await this.terminateWithSafety(handle, task, attempt, stage.source, scope.signal)) {
-                        throw new Error("Worker termination was not proved.");
-                    }
+                try {
+                    await this.cleanupPromotedStage(handle, generation, receipts, promoted, stage, task, attempt, scope);
                 }
-                for (const kind of CLEANUP_KINDS) {
-                    const step = attempt.cleanup.find((item) => item.kind === kind);
+                catch (error) {
+                    blocked(attempt.cleanup, error);
+                }
+                await this.saveProductive(handle);
+            }
+            try {
+                for (const step of generationCleanup) {
                     if (step.status === "completed")
                         continue;
                     step.status = "running";
                     await this.saveProductive(handle);
-                    if (kind === "worker_tab" || kind === "workspace") {
-                        const result = await this.callProductive(handle, scope, (context) => this.hostRuntime.cleanupHost({
-                            requestId: state.request.id, kind, task: changesetTaskRequest(state, task.taskId), attempt,
-                        }, context));
-                        if (result.outcome === "blocked")
-                            throw new Error(result.failure);
-                    }
-                    else {
-                        const result = await this.callProductive(handle, scope, (context) => this.integrationGit.cleanup(state.root, generation.worktree, worker, generation.expectedMain, receipts, promoted, kind, context.signal, generation.correction));
-                        if (result.outcome !== "ready")
-                            throw new Error(result.failure);
-                    }
+                    const result = await this.callProductive(handle, scope, (context) => this.integrationGit.cleanup(state.root, generation.worktree, generation.worktree, generation.expectedMain, receipts, promoted, step.kind, context.signal, generation.correction));
+                    if (result.outcome !== "ready")
+                        throw new Error(result.failure);
                     step.status = "completed";
                     delete step.failure;
                     await this.saveProductive(handle);
                 }
-                candidate.worker = "released";
-                // Same-attempt revisions share this exact worker checkout; release historical
-                // rejected tips only after the physical checkout has been proved removed.
-                for (const old of state.integration.candidates.filter((item) => item.decision === "rejected"
-                    && item.taskId === stage.taskId && item.attempt === stage.attempt))
-                    old.worker = "released";
-                await this.saveProductive(handle);
             }
-            generation.cleanup ??= [{ kind: "worktree", status: "pending" }, { kind: "branch", status: "pending" }];
-            await this.saveProductive(handle);
-            for (const kind of ["worktree", "branch"]) {
-                const step = generation.cleanup.find((item) => item.kind === kind);
-                if (step.status === "completed")
-                    continue;
-                step.status = "running";
-                await this.saveProductive(handle);
-                const result = await this.callProductive(handle, scope, (context) => this.integrationGit.cleanup(state.root, generation.worktree, generation.worktree, generation.expectedMain, receipts, promoted, kind, context.signal, generation.correction));
-                if (result.outcome !== "ready")
-                    throw new Error(result.failure);
-                step.status = "completed";
-                delete step.failure;
-                await this.saveProductive(handle);
+            catch (error) {
+                blocked(generationCleanup, error);
             }
         }
-        catch (error) {
-            generation.failure = undefined; // Promotion remains proven; cleanup evidence stays inspectable.
-            const pending = generation.cleanup?.find((step) => step.status === "running")
-                ?? generation.stages.flatMap((stage) => changesetTaskState(state, stage.taskId).attempts[stage.attempt - 1].cleanup)
-                    .find((step) => step.status === "running");
-            if (pending)
-                pending.failure = bounded(`Cleanup requires attention: ${errorText(error)}`);
-            await this.saveProductive(handle);
-        }
-        if (state.tasks.every((task) => task.status === "completed" || task.status === "rejected")
+        // Promotion remains proven; the request stays visible until every promoted resource is released.
+        if (stepLists.every((steps) => steps.every((step) => step.status === "completed"))
+            && state.tasks.every((task) => task.status === "completed" || task.status === "rejected")
             && state.integration.candidates.every((candidate) => candidate.decision || generation.stages.some((stage) => stage.taskId === candidate.taskId && stage.attempt === candidate.attempt && sameIdentity(stage.source, candidate.tip)))) {
             state.final = { status: "passed", identity: promoted, checks: generation.checks,
                 ...(generation.review ? { review: generation.review } : {}) };
             state.status = "completed";
             state.accepted = true;
             state.acceptedAt = this.coordinatorRuntime.now();
+        }
+        await this.saveProductive(handle);
+    }
+    async cleanupPromotedStage(handle, generation, receipts, promoted, stage, task, attempt, scope) {
+        const state = handle.state;
+        const candidate = state.integration.candidates.find((item) => item.taskId === stage.taskId && item.attempt === stage.attempt
+            && sameIdentity(item.tip, stage.source));
+        const worker = allocationByKind(attempt, "worktree")?.worktree;
+        if (!worker)
+            throw new Error("Promoted worker lacks a proven checkout.");
+        candidate.worker = "release_pending";
+        await this.saveProductive(handle);
+        if (attempt.termination?.status !== "terminated") {
+            if (attempt.termination) {
+                const result = await this.callProductive(handle, scope, (context) => this.hostRuntime.reconcileWorkerTermination({
+                    task: changesetTaskRequest(state, task.taskId), attempt,
+                    workerId: attempt.termination.workerId, candidate: stage.source,
+                }, context));
+                if (result.outcome !== "terminated")
+                    throw new Error("Worker termination cannot be proved; never replay termination.");
+                attempt.termination = { status: "terminated", workerId: attempt.termination.workerId,
+                    candidate: stage.source, at: this.coordinatorRuntime.now() };
+                await this.saveProductive(handle);
+            }
+            else if (!await this.terminateWithSafety(handle, task, attempt, stage.source, scope.signal)) {
+                throw new Error(`Worker termination was not proved: ${attempt.termination.failure}`);
+            }
+        }
+        for (const kind of CLEANUP_KINDS) {
+            const step = attempt.cleanup.find((item) => item.kind === kind);
+            if (step.status === "completed")
+                continue;
+            step.status = "running";
+            await this.saveProductive(handle);
+            if (kind === "worker_tab" || kind === "workspace") {
+                const result = await this.callProductive(handle, scope, (context) => this.hostRuntime.cleanupHost({
+                    requestId: state.request.id, kind, task: changesetTaskRequest(state, task.taskId), attempt,
+                }, context));
+                if (result.outcome === "blocked")
+                    throw new Error(result.failure);
+            }
+            else {
+                const result = await this.callProductive(handle, scope, (context) => this.integrationGit.cleanup(state.root, generation.worktree, worker, generation.expectedMain, receipts, promoted, kind, context.signal, generation.correction));
+                if (result.outcome !== "ready")
+                    throw new Error(result.failure);
+            }
+            step.status = "completed";
+            delete step.failure;
             await this.saveProductive(handle);
         }
+        candidate.worker = "released";
+        // Same-attempt revisions share this exact worker checkout; release historical
+        // rejected tips only after the physical checkout has been proved removed.
+        for (const old of state.integration.candidates.filter((item) => item.decision === "rejected"
+            && item.taskId === stage.taskId && item.attempt === stage.attempt))
+            old.worker = "released";
     }
     async requireExactIntegration(handle, generation, receipts, scope, allowDirtyMain = false) {
         const root = handle.state.root;
@@ -2736,7 +2762,6 @@ export class IsolatedRunner {
             if (result.outcome !== "terminated") {
                 const failure = boundedRuntimeText(result.failure, "Worker termination failure");
                 attempt.termination = { status: "unknown", workerId, candidate, failure };
-                this.attention(task, `Worker termination is unproved: ${failure}`);
                 return false;
             }
             attempt.termination = { status: "terminated", workerId, candidate, at: this.coordinatorRuntime.now() };
@@ -2745,7 +2770,6 @@ export class IsolatedRunner {
         catch (error) {
             this.rethrowStopped(error);
             attempt.termination = { status: "unknown", workerId, candidate, failure: errorText(error) };
-            this.attention(task, `Worker termination is unproved: ${errorText(error)}`);
             return false;
         }
         finally {

package/docs/orchestration.md

@@ -295,6 +295,8 @@ Rejection invalidates dependent work. Rejection and revision ignore dependent wo
 
 Use the generation's exact `combinedTip` as `expectedTip`. `advance` dispatches ready dependents from that snapshot. `correct` records one clean committed correction after a definitive failed check or review. `reconcile` inspects interrupted validation or promotion without replaying uncertain promotion. `cleanup` finishes proved post-promotion cleanup.
 
+Post-promotion cleanup handles each promoted stage separately. A blocked termination or cleanup step records its failure on that step, and cleanup continues with the other stages and then the promoted integration checkout. Clean Main at the promoted identity is a shared precondition; if Main changed, every pending step records the blocker. Dirty, untracked, or ignored files block worktree removal and stay preserved. Until every promoted termination and cleanup step completes, the request stays `needs_attention` with promotion proven, selected tasks `completed`, and not accepted, so `/subagent` lists it. Resolve the recorded blockers, then call `cleanup` again; the request becomes `completed` and accepted only after cleanup completes.
+
 Validation acknowledges only after saving the exact generation's validation intent. Checks and final judgment then run in the background. Later turn cancellation does not cancel acknowledged validation; session replacement or shutdown does. Acknowledgement is not passing evidence. Inspect status if the completion follow-up fails.
 
 #### Refresh
@@ -375,7 +377,7 @@ The report lists removed, skipped, and failed resources. After complete cleanup,
 
 ### Prune leftover worktrees
 
-Run `/subagent prune` to clean up leftover worker and integration checkouts under `.worktrees/`. Their branches have the name `pi-subagent/subagent-` plus 24 hex characters. The command also cleans up such branches that have no checkout. The review lists each item with its path, branch, and tip. For each item, it also shows why the command can remove the item, or it shows every exact blocker. The command can remove an item only when all of these conditions are true:
+Run `/subagent prune` to clean up leftover worker and integration checkouts under `.worktrees/`. Their branches have the name `pi-subagent/subagent-` plus 24 hex characters. The command also cleans up such branches that have no checkout. The review starts with the number of removable and blocked items. It groups the items by the exact reason that the command can remove them, or by their exact blockers, and shows each reason once. Under each reason, it identifies each item by the first 8 of its 24 hex characters. The command can remove an item only when all of these conditions are true:
 
 - Its branch tip is already in Main's HEAD or in the local `origin` default-branch ref. The command does not fetch.
 - Its checkout has no tracked or untracked changes. No merge, rebase, cherry-pick, revert, or bisect is in progress.
@@ -387,7 +389,7 @@ One confirmation removes every listed removable item. When the command removes a
 
 If a top-level ignored entry is new or changed, the command skips the checkout. If the full list of ignored entries of a checkout does not fit in that dialog, the command excludes the checkout. The command blocks checkouts with initialized submodules. It also blocks owned checkouts that are detached or on another branch. Remove them manually.
 
-The list shows removable items first. The command never cuts a long list silently. The list ends with `+N more not shown`, and the command does not remove the items that it did not show in that run. Run `/subagent prune` again to review them.
+The list shows removable items first. The command never cuts a long list silently. The list ends with `+N more not shown`, where `N` counts items, and the command does not remove the items that it did not show in that run. Run `/subagent prune` again to review them.
 
 The command checks each item again immediately before removal and skips an item that changed. If the session or branch changes during removal, the command skips the remaining steps. The command deletes a branch only if the branch still points at the reviewed tip. Then the command reconciles each aborted request that recorded a removed resource. It uses the same guarded path as a repeated `subagent_abort`, so the cleanup of that request no longer shows as pending.
 

package/extensions/subagent-command.ts

@@ -100,13 +100,12 @@ const errorText = (error: unknown): string => clean(error instanceof Error ? err
 const completed = (status: string) => ["completed", "success", "failed", "failure", "aborted", "integrated"].includes(status);
 const priority = (status: string) => /attention|blocked|retained|failed/i.test(status) ? 0 : completed(status) ? 2 : 1;
 
-const ignoredSummary = ({ ignored }: PruneItem) => !ignored.length ? "none"
-	: `${ignored.length} (${ignored.slice(0, 5).join(", ")}${ignored.length > 5 ? `, +${ignored.length - 5} more` : ""})`;
 const PRUNE_IGNORED_CONFIRM_CODE_POINTS = 4_000;
 const NOT_SHOWN = "they are not removed in this run; run /subagent prune again after this run.";
 
 /** Fit whole item lines within `max` code points; never cut silently, and report exactly which items were shown. */
-function fitItems<T>(header: string, items: readonly T[], line: (item: T) => string, max: number, omitted = NOT_SHOWN): { text: string; shown: T[] } {
+function fitItems<T>(header: string, items: readonly T[], line: (item: T) => string, max: number, omitted = NOT_SHOWN,
+	count: (item: T) => number = () => 1): { text: string; shown: T[] } {
 	const lines = [header];
 	const shown: T[] = [];
 	let size = [...header].length;
@@ -119,18 +118,30 @@ function fitItems<T>(header: string, items: readonly T[], line: (item: T) => str
 		size += length;
 		shown.push(item);
 	}
-	if (shown.length < items.length) lines.push(`+${items.length - shown.length} more not shown; ${omitted}`);
+	const hidden = items.slice(shown.length).reduce((sum, item) => sum + count(item), 0);
+	if (hidden) lines.push(`+${hidden} more not shown; ${omitted}`);
 	return { text: lines.join("\n"), shown };
 }
 
-/** Prunable items come first so a long blocked list cannot hide them; only shown items may be removed. */
+/** Groups items by exact reason, prunable groups first, in lines of 10 IDs so a long list is cut at whole lines.
+ * Only shown items may be removed. IDs are display-only; removal uses the reviewed items. */
 function pruneReview({ root, items }: PrunePlan): { text: string; shown: PruneItem[] } {
 	if (!items.length) return { text: `No pi-subagent worktrees or branches in ${root}.`, shown: [] };
+	const groups = new Map<string, PruneItem[]>();
+	for (const item of [...items.filter((item) => item.prunable), ...items.filter((item) => !item.prunable)]) {
+		const title = item.prunable ? `✓ Prunable: ${item.reason}` : `✗ Blocked: ${item.path ? item.reason : `${item.reason}; no checkout`}`;
+		if (groups.has(title)) groups.get(title)!.push(item);
+		else groups.set(title, [item]);
+	}
+	const rows = [...groups].flatMap(([title, group]) => Array.from({ length: Math.ceil(group.length / 10) }, (_, index) => {
+		const chunk = group.slice(index * 10, index * 10 + 10);
+		const ids = chunk.map(({ branch }) => clean(branch.replace(/^pi-subagent\/subagent-/, "").slice(0, 8))).join(", ");
+		return { items: chunk, text: `${index ? "" : `${clean(title, 600)} (${group.length}):\n`}  ${ids}` };
+	}));
 	const prunable = items.filter((item) => item.prunable).length;
-	return fitItems(`Subagent prune review in ${root}: ${prunable} prunable, ${items.length - prunable} blocked.`,
-		[...items.filter((item) => item.prunable), ...items.filter((item) => !item.prunable)],
-		(item) => clean(`${item.prunable ? "✓ prunable" : "✗ blocked"} · ${item.path ?? "(no checkout)"} · ${item.branch} · ${item.tip.slice(0, 12)} · ${item.reason} · ignored: ${ignoredSummary(item)}`, 600),
-		ROLES_REPORT_CODE_POINTS);
+	const reviewed = fitItems(`Subagent prune review in ${root}: ${prunable} prunable, ${items.length - prunable} blocked. IDs are the first 8 characters after pi-subagent/subagent-.`,
+		rows, (row) => row.text, ROLES_REPORT_CODE_POINTS, NOT_SHOWN, (row) => row.items.length);
+	return { text: reviewed.text, shown: reviewed.shown.flatMap((row) => row.items) };
 }
 
 function discardReview(plan: DiscardPlan) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "27.5.2",
+  "version": "27.5.4",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",