@henryqw/pi-subagent 23.0.1 → 23.0.2

package/README.md

@@ -113,7 +113,7 @@ An isolated request has one durable ID, one goal, and 1–8 typed tasks:
       "modelClass": "balanced",
       "requirements": "Implement the smallest correct repair.",
       "deliverable": "A committed candidate in the owned worktree.",
-      "dependsOn": ["inspect"],
+      "dependsOn": [],
       "contextFrom": ["inspect"],
       "checks": [
         { "command": "pnpm", "args": ["test", "--", "refresh"] }
@@ -131,7 +131,7 @@ An isolated request has one durable ID, one goal, and 1–8 typed tasks:
 }
 ```
 
-`dependsOn` controls scheduling. `contextFrom` may name completed text tasks and preserves the declared order. Changesets require focused task checks; a graph with changesets requires final checks. A canonical root `package.json` test script is required: the runner adds `pnpm test` to final checks if missing, and Main runs it on the combined integration checkout before promotion. Checks and judgments bind to exact Git identities; candidate drift, Main drift, mutation during validation, ambiguity, or conflicts stop promotion and retain evidence.
+`dependsOn` controls scheduling. `contextFrom` also schedules dependencies and carries completed text outputs in the declared order. Do not repeat the same task in both fields. Changesets require focused task checks; a graph with changesets requires final checks. A canonical root `package.json` test script is required: the runner adds `pnpm test` to final checks if missing, and Main runs it on the combined integration checkout before promotion. Checks and judgments bind to exact Git identities; candidate drift, Main drift, mutation during validation, ambiguity, or conflicts stop promotion and retain evidence.
 
 `delegate_task`, `subagent_resume`, and `subagent_integrate advance` return a durable request ID after the wave is saved; productive work continues while Main is free. Main can do other work or end its turn instead of sleeping or polling. Pi sends a follow-up in the launching session whenever a checked worker becomes ready or a worker needs attention, and again when the wave finishes. A worker whose exact turn ends without a changed clean commit—including a failed or aborted turn—needs attention, not an inferred candidate; use `subagent_status` for its saved evidence. If delivery is missed, inspect `subagent_status`.
 
@@ -147,9 +147,11 @@ A queued follow-up runs after the current turn settles and must produce a new cl
 
 After a coordinator interruption, run `/subagent recover` once. It acquires the repository productive lease before changing any orphaned `pending` or `running` state, preserves unreadable state files and retained candidates, and reports blockers and existing continuations to Main without replaying prompts, merges, promotion, or cleanup. If another productive run holds the lease, it only reads status and reports the live owner; wait rather than taking over. Repeating the command is safe. Main uses `subagent_status` for exact identities and the recovery tools in the interface table above for deliberate decisions; the command never stages or promotes. Direct Herdr tab recovery remains in `/subagent`.
 
+If an isolated worker produced no candidate, `subagent_abort` terminates it and removes only proven unchanged, clean owned resources. Cleanup includes ignored-file checks and never discards unique commits. If productive work is still settling, termination is uncertain, or cleanup fails, the request stays aborted with retained-resource evidence. Inspect `subagent_status`, resolve the reported blocker, then repeat `subagent_abort` to reconcile cleanup; it does not replay worker prompts. Dirty work, unique commits, and uncertain allocations remain for deliberate manual recovery.
+
 The following details describe exact identity and retained-work requirements.
 
-A checked candidate stays retained if Main is dirty. Staging, combined validation, and promotion require Main to be clean at the pinned committed identity; clean your local edits deliberately before using those actions. No dirty work is replayed or merged automatically. Pass the exact `generation`, candidate (`taskId`, `attempt`, `candidate`) and `expectedTip` identities reported by status to stage; pass the generation and combined `expectedTip` to integrate. If Main advances cleanly before promotion, call `subagent_integrate refresh` with the recorded `expectedMain`, old `expectedTip`, and new clean `newMain`. Main must restage selected immutable candidates into the new generation and rerun combined checks. Dirty or divergent Main blocks refresh. Stale identities fail. If integration allocation was uncertain, `subagent_stage resolve` first proves the owned checkout is still at its base before starting the selected merge; otherwise it retains the intent. At most two integration worktrees may remain unreleased per request; a superseded generation is read-only. To release a superseded *clean* integration checkout, call `subagent_integrate` with `{ id, action: "release", generation, expectedTip }`, using that generation's last staged tip (or integration base when no stage completed). To release a rejected candidate after its worker has terminated and all generations using it are released, pass `{ id, action: "release", generation: <latest generation number, or 1>, taskId, attempt, expectedTip: <candidate tip> }`. Release persists each host/checkout/branch step, verifies ownership and cleanliness (including ignored files), and deletes the branch only if its ref still names the exact tip. Dirty, conflicted, changed, or uncertain resources remain for manual inspection; retry the same release after resolving the obstacle. Released checkouts free a retained slot; abort is available after every retained resource is released. Rejection can invalidate dependent work; if fresh dependent execution is impossible, start a new request instead of forcing promotion. Productive requests have no whole-run wall-clock deadline. Resume does not reset the recorded policy or correction count. Child limits, abort signals, process I/O, status inspection, exact termination, and cleanup retain finite safety bounds.
+A checked candidate stays retained if Main is dirty. Staging, combined validation, and promotion require Main to be clean at the pinned committed identity; clean your local edits deliberately before using those actions. No dirty work is replayed or merged automatically. Pass the exact `generation`, candidate (`taskId`, `attempt`, `candidate`) and `expectedTip` identities reported by status to stage; pass the generation and combined `expectedTip` to integrate. If Main advances cleanly before promotion, call `subagent_integrate refresh` with the recorded `expectedMain`, old `expectedTip`, and new clean `newMain`. Main must restage selected immutable candidates into the new generation and rerun combined checks. Dirty or divergent Main blocks refresh. Stale identities fail. If integration allocation was uncertain, `subagent_stage resolve` first proves the owned checkout is still at its base before starting the selected merge; otherwise it retains the intent. At most two integration worktrees may remain unreleased per request; a superseded generation is read-only. To release a superseded *clean* integration checkout, call `subagent_integrate` with `{ id, action: "release", generation, expectedTip }`, using that generation's last staged tip (or integration base when no stage completed). To release a rejected candidate after its worker has terminated and all generations using it are released, pass `{ id, action: "release", generation: <latest generation number, or 1>, taskId, attempt, expectedTip: <candidate tip> }`. Release persists each host/checkout/branch step, verifies ownership and cleanliness (including ignored files), and deletes the branch only if its ref still names the exact tip. Dirty, conflicted, changed, or uncertain resources remain for manual inspection; retry the same release after resolving the obstacle. Released checkouts free a retained slot; abort is available after every retained resource is released. Rejection can invalidate dependent work; if fresh dependent execution is impossible, start a new request instead of forcing promotion. Productive requests have no whole-run wall-clock deadline. Resume does not reset the recorded policy or correction count. Text tasks have two dispatch attempts; inspection failures before dispatch do not consume one. Verification requires passing preliminary checks and any required judgment; it cannot override failed review. Child limits, abort signals, process I/O, status inspection, exact termination, and cleanup retain finite safety bounds.
 
 The extension never pushes, opens a pull request, publishes, deploys, force-cleans recoverable work, or silently falls back to Main.
 

package/dist/herdr-runtime.d.ts

@@ -95,6 +95,7 @@ export declare class HerdrHostRuntime implements HostRuntime {
         outcome: "unknown";
         failure: string;
     }>;
+    private proveAbsentAgentForCleanup;
     cleanupHost(input: {
         requestId: ExecuteRequest["id"];
         kind: HostCleanupKind;

package/dist/herdr-runtime.js

@@ -643,9 +643,41 @@ export class HerdrHostRuntime {
             return { outcome: "unknown", failure: safeText(error) };
         }
     }
+    async proveAbsentAgentForCleanup(allocation, attempt, context) {
+        requireIntentIdentity(allocation, attempt);
+        assertAgentIntent(allocation, attempt);
+        this.assertLeasePath(allocation.leasePath, attempt.correlationToken);
+        await this.assertPrivateLeaseDirectories(allocation.leasePath, true);
+        await this.assertPrivateLease(allocation.leasePath, true);
+        const agents = (await this.listAgents(allocation.worktreeCwd, context)).map((agent) => ({
+            name: typeof agent.name === "string" ? agent.name : undefined,
+            paneId: exactString(agent.pane_id, "Herdr listed agent pane ID"),
+            tabId: exactString(agent.tab_id, "Herdr listed agent tab ID"),
+        }));
+        if (agents.some((agent) => agent.name === allocation.agentName
+            || agent.paneId === allocation.paneId || agent.tabId === allocation.tabId)) {
+            throw new Error("The exact absent-agent allocation now has a matching Herdr agent.");
+        }
+        const paneIsAbsent = await this.paneAbsent(allocation.paneId, allocation.worktreeCwd, context);
+        if (!paneIsAbsent)
+            await this.assertStartableAgentPane(allocation, context, { requireExclusiveTty: true });
+        if ((await this.scanLease(allocation.leasePath, allocation.worktreeCwd, context, undefined, true)).length) {
+            throw new Error("The absent-agent process lease still has holders.");
+        }
+        await this.delay(50, context.signal);
+        if ((await this.scanLease(allocation.leasePath, allocation.worktreeCwd, context, undefined, true)).length) {
+            throw new Error("The absent-agent process lease did not remain empty for two consecutive scans.");
+        }
+        return paneIsAbsent;
+    }
     async cleanupHost(input, context) {
-        if (input.attempt.termination?.status !== "terminated") {
-            return { outcome: "blocked", failure: "Host cleanup requires exact recorded worker termination." };
+        const terminationProven = input.attempt.termination?.status === "terminated";
+        const agentIntents = input.attempt.allocations.filter((intent) => intent.kind === "agent");
+        const latestAgent = agentIntents.at(-1);
+        const neverOwned = !input.attempt.termination && latestAgent?.status === "absent"
+            && agentIntents.every((intent) => intent.status === "absent");
+        if (!terminationProven && !neverOwned) {
+            return { outcome: "blocked", failure: "Host cleanup requires exact worker termination or a definitive absent-agent allocation." };
         }
         try {
             if (input.kind === "worker_tab") {
@@ -663,8 +695,19 @@ export class HerdrHostRuntime {
                 if (tabId === allocation.workspaceRootTabId)
                     throw new Error("Saved worker tab aliases the workspace root tab.");
                 const paneId = exactString(allocation.paneId, "saved worker pane ID");
-                if (!await this.paneAbsent(paneId, allocation.worktreeCwd, context)) {
-                    return { outcome: "blocked", failure: "The exact saved worker pane still exists after termination." };
+                const paneIsAbsent = neverOwned
+                    ? await this.proveAbsentAgentForCleanup(latestAgent, input.attempt, context)
+                    : await this.paneAbsent(paneId, allocation.worktreeCwd, context);
+                if (!paneIsAbsent) {
+                    if (!neverOwned)
+                        return { outcome: "blocked", failure: "The exact saved worker pane still exists after termination." };
+                    const closed = await this.herdr.exec(["pane", "close", paneId], this.processOptions(allocation.worktreeCwd, context, HERDR_OPERATION_CAP_MS));
+                    if (closed.code !== 0 || closed.killed)
+                        return { outcome: "blocked", failure: safeText(herdrCommandFailure(["pane", "close"], closed)) };
+                    requireOkResponse(closed.stdout, "Herdr pane close response");
+                    if (!await this.paneAbsent(paneId, allocation.worktreeCwd, context)) {
+                        return { outcome: "blocked", failure: "The exact unstarted worker pane still exists after close." };
+                    }
                 }
                 const workspaceIsAbsent = await this.workspaceAbsent(workspaceId, workspace, context);
                 const tab = await this.getTab(tabId, allocation.worktreeCwd, context);
@@ -686,6 +729,9 @@ export class HerdrHostRuntime {
             const workerCleanup = input.attempt.cleanup.find((step) => step.kind === "worker_tab");
             if (workerCleanup?.status !== "completed")
                 return { outcome: "blocked", failure: "Workspace cleanup must follow worker-tab reconciliation." };
+            if (neverOwned && !await this.proveAbsentAgentForCleanup(latestAgent, input.attempt, context)) {
+                return { outcome: "blocked", failure: "The exact unstarted worker pane remains after worker-tab cleanup." };
+            }
             const allocation = ownedIntent(input.attempt, "workspace");
             requireIntentIdentity(allocation, input.attempt);
             assertWorkspaceIntent(allocation, input.attempt);

package/dist/runner.d.ts

@@ -334,6 +334,7 @@ export declare class IsolatedRunner {
     private cleanupPromoted;
     private requireExactIntegration;
     abort(id: string, root: string, outerSignal?: AbortSignal): Promise<RunResponse>;
+    private cleanupAborted;
     status(id: string, root: string, outerSignal?: AbortSignal): Promise<RunResponse>;
     private run;
     private dispatchTask;

package/dist/runner.js

@@ -305,10 +305,17 @@ function stagedDependencySnapshot(state, taskId, tip) {
 function textRetryEligible(state, task) {
     const attempt = task.attempts.at(-1);
     return task.status === "needs_attention"
-        && attempt?.status === "failed"
+        && (!attempt || attempt.status === "failed" || attempt.status === "superseded")
         && task.attempts.length < 2
         && taskDependenciesCompleted(state, task.taskId);
 }
+function hasPassingPreliminaryEvidence(request, attempt) {
+    return Boolean(attempt.candidate && attempt.candidateBase
+        && checkBatchPasses(attempt.preliminaryChecks, request.checks, attempt.candidate)
+        && (!request.judgment || reviewEvidencePasses(attempt.preliminaryReview, "preliminary", request.judgment.criterion, attempt.candidateBase, attempt.candidate))
+        && !attempt.prompts.some((prompt) => prompt.status === "ambiguous")
+        && allocationByKind(attempt, "agent")?.agentName && !attempt.termination);
+}
 function changesetTaskState(state, id) {
     const task = taskState(state, id);
     if (task.kind !== "changeset")
@@ -523,10 +530,10 @@ export class IsolatedRunner {
         const { states: entries, invalidIds } = await this.store.list(root);
         return { invalidIds, states: entries.map(({ state }) => state), requests: entries.map(({ state }) => ({
                 id: state.request.id, name: state.request.goal,
-                status: state.status === "completed" && (state.tasks.some((task) => task.kind === "changeset" && task.attempts.some((attempt) => attempt.cleanup.some((step) => step.status !== "completed")))
+                status: ["completed", "aborted"].includes(state.status) && (state.tasks.some((task) => task.kind === "changeset" && task.attempts.some((attempt) => attempt.cleanup.some((step) => step.status !== "completed")))
                     || state.integration.generations.some((generation) => generation.cleanup?.some((step) => step.status !== "completed")
                         || (generation.worktree && generation.cleanup?.every((step) => step.status === "completed") !== true)))
-                    ? "completed · retained" : state.status,
+                    ? `${state.status} · retained` : state.status,
                 tasks: state.request.tasks.map((task) => ({
                     id: task.id, name: task.requirements, kind: task.kind,
                     status: state.tasks.find((item) => item.taskId === task.id).status,
@@ -543,7 +550,7 @@ export class IsolatedRunner {
             inventory = await this.withProductiveRun(root, async (lifecycle) => await this.store.withLock(root, async () => {
                 const listed = await this.listRequests(root);
                 for (const request of listed.requests) {
-                    if (request.status !== "pending" && request.status !== "running")
+                    if (!["pending", "running", "needs_attention"].includes(request.status))
                         continue;
                     const handle = await this.store.load(root, request.id);
                     if (this.recoverInterrupted(handle.state))
@@ -560,7 +567,7 @@ export class IsolatedRunner {
         }
         const requests = [];
         for (const request of inventory.requests) {
-            if (["pending", "running", "needs_attention", "completed · retained"].includes(request.status)) {
+            if (["pending", "running", "needs_attention", "completed · retained", "aborted · retained"].includes(request.status)) {
                 requests.push(await this.status(request.id, root));
             }
         }
@@ -754,8 +761,8 @@ export class IsolatedRunner {
                         throw new Error(`Text task ${task.taskId} cannot be verified.`);
                     if (!textRetryEligible(state, task)) {
                         const attempt = task.attempts.at(-1);
-                        if (attempt?.status !== "failed" || task.attempts.length >= 2) {
-                            throw new Error(`Text task ${task.taskId} retry requires a failed latest attempt and fewer than two attempts.`);
+                        if ((attempt && !["failed", "superseded"].includes(attempt.status)) || task.attempts.length >= 2) {
+                            throw new Error(`Text task ${task.taskId} retry requires an unstarted, failed or superseded dispatch and fewer than two attempts.`);
                         }
                         throw new Error(`Text task ${task.taskId} dependencies are not completed.`);
                     }
@@ -1587,7 +1594,7 @@ export class IsolatedRunner {
         return await this.store.withLock(root, async (lifecycle) => {
             const handle = await this.store.load(root, id);
             const state = handle.state;
-            if (terminal(state))
+            if (terminal(state) && state.status !== "aborted")
                 return this.response(state);
             if (state.integration.candidates.some((candidate) => candidate.worker !== "released")
                 || state.integration.generations.some((generation) => generation.worktree
@@ -1609,7 +1616,31 @@ export class IsolatedRunner {
                 for (const attempt of task.attempts) {
                     if (!allocationByKind(attempt, "agent")?.agentName || attempt.termination?.status === "terminated")
                         continue;
-                    await this.terminateWithSafety(handle, task, attempt, this.terminationCandidate(attempt), outerSignal, safetyDeadline, true);
+                    if (attempt.termination) {
+                        const safety = new DeadlineScope(safetyDeadline, () => this.coordinatorRuntime.now(), outerSignal);
+                        try {
+                            const result = await safety.call((context) => this.hostRuntime.reconcileWorkerTermination({
+                                task: changesetTaskRequest(state, task.taskId), attempt,
+                                workerId: attempt.termination.workerId, candidate: attempt.termination.candidate,
+                            }, context));
+                            if (result.outcome !== "terminated")
+                                throw new Error(result.outcome === "unknown"
+                                    ? result.failure : "Exact worker remains active; termination was not replayed.");
+                            attempt.termination = { ...attempt.termination, status: "terminated", at: this.coordinatorRuntime.now() };
+                            delete attempt.termination.failure;
+                        }
+                        catch (error) {
+                            attempt.termination.status = "unknown";
+                            attempt.termination.failure = errorText(error);
+                            this.attention(task, attempt.termination.failure);
+                        }
+                        finally {
+                            safety.close();
+                        }
+                    }
+                    else {
+                        await this.terminateWithSafety(handle, task, attempt, this.terminationCandidate(attempt), outerSignal, safetyDeadline, true);
+                    }
                 }
             }
             state.status = "aborted";
@@ -1617,9 +1648,73 @@ export class IsolatedRunner {
             state.accepted = false;
             state.updatedAt = this.coordinatorRuntime.now();
             await handle.save();
+            // In-flight checks or allocation callbacks must settle before removing their checkout.
+            if (!lifecycle.productiveRunLeaseActive)
+                await this.cleanupAborted(handle, outerSignal);
             return this.response(state);
         }, { purpose: "abort" });
     }
+    async cleanupAborted(handle, signal) {
+        const state = handle.state;
+        const scope = new DeadlineScope(this.coordinatorRuntime.now() + CLEANUP_SAFETY_BUDGET_MS, () => this.coordinatorRuntime.now(), signal);
+        try {
+            for (const task of state.tasks) {
+                if (task.kind !== "changeset")
+                    continue;
+                for (const attempt of task.attempts) {
+                    if (attempt.cleanup.every((step) => step.status === "completed"))
+                        continue;
+                    const worker = allocationByKind(attempt, "worktree")?.worktree;
+                    const expected = worker ? { ...attempt.waveBase, branch: `refs/heads/${worker.branch}` } : undefined;
+                    let pending = attempt.cleanup.find((step) => step.status !== "completed");
+                    try {
+                        if (attempt.allocations.some((item) => item.status === "allocating" || item.status === "unknown")) {
+                            throw new Error("Allocation ownership is uncertain; preserve the recorded resources for inspection.");
+                        }
+                        if (allocationByKind(attempt, "agent") && attempt.termination?.status !== "terminated") {
+                            throw new Error("Exact worker termination remains unproved.");
+                        }
+                        if (expected && attempt.termination && attempt.termination.candidate.head !== expected.head) {
+                            throw new Error("Aborted worker may contain committed work; automatic cleanup preserves it.");
+                        }
+                        for (const step of attempt.cleanup) {
+                            if (step.status === "completed")
+                                continue;
+                            pending = step;
+                            const kind = step.kind;
+                            step.status = "running";
+                            delete step.failure;
+                            await handle.save();
+                            if ((kind === "worker_tab" || kind === "workspace") && allocationByKind(attempt, kind)) {
+                                const result = await scope.call((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 if ((kind === "worktree" || kind === "branch") && worker && expected) {
+                                const result = await scope.call((context) => this.integrationGit.release(state.root, worker, expected, kind, context.signal));
+                                if (result.outcome !== "ready")
+                                    throw new Error(result.failure);
+                            }
+                            step.status = "completed";
+                            await handle.save();
+                        }
+                    }
+                    catch (error) {
+                        if (pending.status === "completed")
+                            pending.status = "running";
+                        pending.failure = bounded(`Abort cleanup retained resources: ${errorText(error)}`);
+                        await handle.save();
+                    }
+                }
+            }
+        }
+        finally {
+            scope.close();
+        }
+    }
     async status(id, root, outerSignal) {
         root = realpathSync.native(root);
         return await this.store.withLock(root, async () => {
@@ -2354,9 +2449,7 @@ export class IsolatedRunner {
         if (!attempt.readiness || !attempt.candidate || !attempt.candidateBase || !attempt.preliminaryChecks
             || !sameIdentity(attempt.readiness.candidate, attempt.candidate)
             || !sameIdentity(attempt.readiness.base, attempt.candidateBase)
-            || !checkBatchPasses(attempt.preliminaryChecks, request.checks, attempt.candidate)
-            || (request.judgment && !reviewEvidencePasses(attempt.preliminaryReview, "preliminary", request.judgment.criterion, attempt.candidateBase, attempt.candidate))
-            || !allocationByKind(attempt, "agent")?.agentName || attempt.termination) {
+            || !hasPassingPreliminaryEvidence(request, attempt)) {
             throw new Error(`Task ${task.taskId} has no exact ready live candidate.`);
         }
         if (state.integration.candidates.some((candidate) => candidate.taskId === task.taskId && !candidate.decision)) {
@@ -2380,31 +2473,23 @@ export class IsolatedRunner {
         }, context)), "Retained task candidate identity");
         if (!isCleanCommitted(candidate))
             throw new Error("Retained task candidate is not clean and committed.");
-        if (attempt.readiness) {
-            if (!sameIdentity(candidate, attempt.readiness.candidate))
-                throw new Error("Ready retained task candidate drifted from its exact lineage.");
-            task.status = "ready_to_integrate";
-            task.failure = undefined;
-            await this.saveProductive(handle);
-            this.retainCandidate(handle.state, task);
-            handle.state.status = "needs_attention";
-            await this.saveProductive(handle);
-            return this.response(handle.state);
-        }
         const request = changesetTaskRequest(handle.state, task.taskId);
         if (!attempt.candidate || !attempt.candidateBase || !sameIdentity(candidate, attempt.candidate)
-            || !checkBatchPasses(attempt.preliminaryChecks, request.checks, candidate)) {
-            throw new Error("Retained task work lacks exact passing preliminary candidate evidence.");
+            || !hasPassingPreliminaryEvidence(request, attempt)) {
+            throw new Error("Retained task work lacks exact passing preliminary checks, judgment or live ownership.");
         }
-        attempt.readiness = {
+        if (attempt.readiness && (!sameIdentity(candidate, attempt.readiness.candidate)
+            || !sameIdentity(attempt.candidateBase, attempt.readiness.base))) {
+            throw new Error("Ready retained task candidate drifted from its exact lineage.");
+        }
+        attempt.readiness ??= {
             candidate: attempt.candidate,
             base: attempt.candidateBase,
             at: nextAttemptEventAt(attempt, this.coordinatorRuntime.now()),
         };
+        this.retainCandidate(handle.state, task);
         task.status = "ready_to_integrate";
         task.failure = undefined;
-        await this.saveProductive(handle);
-        this.retainCandidate(handle.state, task);
         handle.state.status = "needs_attention";
         await this.saveProductive(handle);
         return this.response(handle.state);
@@ -2593,6 +2678,26 @@ export class IsolatedRunner {
         await this.saveProductive(handle);
     }
     recoverInterrupted(state) {
+        if (state.status === "needs_attention") {
+            let changed = false;
+            for (const task of state.tasks) {
+                if (task.kind !== "changeset" || task.status !== "ready_to_integrate"
+                    || state.integration.candidates.some((candidate) => candidate.taskId === task.taskId))
+                    continue;
+                const attempt = latestAttempt(task);
+                if (hasPassingPreliminaryEvidence(changesetTaskRequest(state, task.taskId), attempt)) {
+                    this.attention(task, "Candidate readiness was saved before retention; verify to reconstruct the candidate from exact passing evidence.");
+                    changed = true;
+                    continue;
+                }
+                delete attempt.readiness;
+                this.attention(task, "Readiness lacked passing preliminary checks, judgment or live ownership; retained work requires attention.");
+                changed = true;
+            }
+            if (changed)
+                state.updatedAt = this.coordinatorRuntime.now();
+            return changed;
+        }
         if (state.status === "pending") {
             const ready = readyPendingTasks(state).filter((task) => task.attempts.length === 0);
             if (!ready.length)
@@ -2718,11 +2823,6 @@ export class IsolatedRunner {
                 attempt.status = "failed";
                 attempt.failure = boundedFailure;
             }
-            else {
-                if (task.attempts.length >= 2)
-                    throw new Error(`Text task ${task.taskId} cannot record another failed attempt.`);
-                task.attempts.push({ number: task.attempts.length + 1, status: "failed", failure: boundedFailure });
-            }
         }
         task.status = "needs_attention";
         task.failure = boundedFailure;
@@ -2746,12 +2846,15 @@ export class IsolatedRunner {
             }
             else if (attention?.kind === "changeset" && !attention.attempts.at(-1)?.termination) {
                 const attempt = attention.attempts.at(-1);
-                if (attempt && this.correctionAllowed(state, changesetTaskRequest(state, attention.taskId), attempt)) {
+                const hasEvidence = Boolean(attempt && !state.integration.candidates.length
+                    && hasPassingPreliminaryEvidence(changesetTaskRequest(state, attention.taskId), attempt));
+                if (attempt?.readiness && hasEvidence) {
+                    continuation = { id: state.request.id, action: "verify", taskId: attention.taskId };
+                }
+                else if (attempt && this.correctionAllowed(state, changesetTaskRequest(state, attention.taskId), attempt)) {
                     continuation = { id: state.request.id, action: "retry", taskId: attention.taskId };
                 }
-                else if ((attempt?.readiness && !state.integration.candidates.length)
-                    || (attempt?.candidate && attempt.candidateBase
-                        && checkBatchPasses(attempt.preliminaryChecks, changesetTaskRequest(state, attention.taskId).checks, attempt.candidate))) {
+                else if (hasEvidence) {
                     continuation = { id: state.request.id, action: "verify", taskId: attention.taskId };
                 }
             }
@@ -2763,6 +2866,9 @@ export class IsolatedRunner {
             text: bounded([
                 `Pi Subagent ${state.request.id}: ${state.status}.`,
                 `Tasks: ${completed}/${state.tasks.length} completed, ${rejected} rejected. Accepted: ${state.accepted}.`,
+                ...(state.status === "aborted" && state.tasks.some((task) => task.kind === "changeset"
+                    && task.attempts.some((attempt) => attempt.cleanup.some((step) => step.status !== "completed")))
+                    ? ["Aborted resources remain retained. Inspect cleanup evidence; retry subagent_abort after active work settles or cleanup blockers are resolved. Unique commits and uncertain work are never discarded."] : []),
                 ...(main?.status === "current" ? ["Main: current at the recorded exact identity."] : []),
                 ...(main?.status === "drifted" ? [
                     `Main: drifted from ${main.expected.branch}@${main.expected.head} to ${main.actual.branch}@${main.actual.head}.`,

package/dist/schema.js

@@ -653,10 +653,10 @@ function validateTextTaskState(taskState) {
         ? taskState.attempts.length ? "superseded" : undefined
         : taskState.status === "running"
             ? "running"
-            : taskState.status === "completed"
-                ? "completed"
-                : "failed";
-    if (latest?.status !== expectedLatestStatus) {
+            : "completed";
+    if (taskState.status === "needs_attention"
+        ? latest && !["failed", "superseded"].includes(latest.status)
+        : latest?.status !== expectedLatestStatus) {
         throw new Error(`Text task ${taskState.taskId} status ${taskState.status} has an incompatible latest attempt.`);
     }
     if ((taskState.failure !== undefined) !== (taskState.status === "needs_attention")) {
@@ -665,8 +665,8 @@ function validateTextTaskState(taskState) {
     if (taskState.failure !== undefined) {
         requireRuntimeTextByteLength(taskState.failure, `Text task ${taskState.taskId} failure`);
     }
-    if (taskState.status === "needs_attention" && latest?.failure !== taskState.failure) {
-        throw new Error(`Text task ${taskState.taskId} needs-attention failure must exactly match its latest attempt failure.`);
+    if (taskState.status === "needs_attention" && latest?.status === "failed" && latest.failure === undefined) {
+        throw new Error(`Text task ${taskState.taskId} lacks its latest execution failure.`);
     }
 }
 /** Check the persisted integration projection against the request before recovery or promotion. */

package/docs/orchestration.md

@@ -88,7 +88,7 @@ Every task declares `id`, `kind`, `role`, `modelClass`, `requirements`, `deliver
 - A `text` task runs in a disposable child worktree and must leave it unchanged.
 - A `changeset` task requires focused checks and owns one worktree, Herdr workspace, worker tab, and retained worker.
 - `dependsOn` controls ready waves; dependent tasks can run from a selected staged snapshot only after Main explicitly advances it.
-- `contextFrom` may reference completed text tasks only and preserves declaration order.
+- `contextFrom` may reference completed text tasks only, implies scheduling dependencies, and preserves declaration order. It must not overlap `dependsOn`.
 - A graph containing changesets requires final checks. The repository root must have a `package.json` test script; admission prepends canonical `pnpm test` if absent from final checks. Combined validation rejects a changed root test script.
 
 Admission and worker-wave dispatch pin Main's exact committed branch, HEAD, and tree without inspecting or modifying its staged, unstaged, or untracked edits. Worker allocation verifies the same committed identity around worktree creation, including resumed waves; staged-dependent waves verify their clean integration snapshot. A dirty Main can therefore produce a checked retained candidate, but branch/HEAD drift stops new waves. The runner executes ready worker tasks concurrently, inspects clean committed candidates, runs preliminary task checks and optional preliminary judgment, then records ready candidates for Main. **It does not automatically integrate them.** Main selects exact candidates via `subagent_stage` into an owned integration checkout in explicit order. Each stage is a committed merge of the candidate, not a mutation of Main. Conflicts retain the checkout for Main to resolve; `resolve` verifies the exact two-parent merge instead of replaying an uncertain merge. Main can explicitly run dependent tasks from an exact staged tip with `subagent_integrate advance` and stage their results afterward. Independent candidates may be staged without re-running workers.
@@ -118,7 +118,9 @@ State version 5 is stored privately under:
 <agent-dir>/config/pi-subagent/state/<repository-hash>/<request-id>.json
 ```
 
-Strict parsing rejects unknown properties, malformed evidence, invalid lineage, and old v4 state without migration; preserve old files and recover their work manually. Writes are atomic and repository productive work uses a durable process lease. `delegate_task` and `subagent_resume` acknowledge only after durable state is saved, then continue productive work asynchronously. A durably recorded worker attention state sends an immediate once-per-transition Pi follow-up to the launching session, even while siblings run; the wave also reports its final outcome. Isolated workers persist a private exact Pi session under the owned process lease so a proved final answer without a changed clean commit becomes attention rather than an indefinitely pending prompt. Missing or mismatched session proof cannot establish completion and never authorizes prompt replay. `subagent_status` is read-only and remains the recovery authority if a follow-up is missed. `subagent_resume` accepts only the continuation reported by state. `subagent_abort` performs exact worker termination and teardown.
+Strict parsing rejects unknown properties, malformed evidence, invalid lineage, and old v4 state without migration; preserve old files and recover their work manually. Writes are atomic and repository productive work uses a durable process lease. `delegate_task` and `subagent_resume` acknowledge only after durable state is saved, then continue productive work asynchronously. A durably recorded worker attention state sends an immediate once-per-transition Pi follow-up to the launching session, even while siblings run; the wave also reports its final outcome. Isolated workers persist a private exact Pi session under the owned process lease so a proved final answer without a changed clean commit becomes attention rather than an indefinitely pending prompt. Missing or mismatched session proof cannot establish completion and never authorizes prompt replay. `subagent_status` is read-only and remains the recovery authority if a follow-up is missed. `subagent_resume` accepts only the continuation reported by state. `subagent_abort` performs exact worker termination and conservative teardown. Without a retained candidate, it removes only owned checkouts still clean and unchanged from their pinned base, including ignored-file checks. Active productive execution defers cleanup until it settles. Repeating abort on an aborted request reconciles pending cleanup without replaying uncertain termination. Dirty or committed work and uncertain allocations stay retained with visible blockers; `/subagent recover` includes aborted requests with retained resources.
+
+Text attempt history records dispatches, not pre-dispatch inspection failures. Such failures retain task-level attention without adding an attempt or rewriting earlier execution diagnostics. A recorded interrupted dispatch still consumes an attempt. Verification requires the same passing preliminary checks, judgment, and ownership as candidate retention; readiness and the verified candidate are saved together.
 
 Productive execution has no whole-run wall-clock deadline. Long productive work and later resumes remain valid. The request retains its original policy snapshot and correction count; a resume cannot refill them. Current configuration may tighten the correction allowance. Child idle/hard runtime, subprocess I/O, status inspection, termination, cleanup, and outer abort remain bounded independently.
 

package/extensions/isolated.ts

@@ -659,7 +659,7 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 	pi.registerTool({
 		name: "subagent_abort",
 		label: "Subagent abort",
-		description: "Abort one unfinished isolated request; retained candidates and integration checkouts must be explicitly rejected and released first. Terminate only exact owned workers.",
+		description: "Abort an isolated request; reject and release retained candidates and integration checkouts first. Terminate only exact owned workers. Repeat abort to reconcile cleanup of unchanged no-candidate allocations; preserve dirty or committed work.",
 		parameters: IdOnlySchema,
 		prepareArguments: parseIdOnly,
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {

package/package.json

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

package/skills/pi-subagent/SKILL.md

@@ -26,12 +26,12 @@ Use one compact `role`/`name`/`task` packet, `tasks` for independent packets, or
 
 # Isolated requests
 
-Give the request a unique ID and goal. Give each task a unique ID, kind, Role, model class, bounded requirements, deliverable, `dependsOn`, and `contextFrom`. Changesets require focused task checks, and a graph containing changesets requires final checks. The root must have a `package.json` test script; `pnpm test` is added to final checks if missing and runs against the combined tip before Main promotion. Text context may name only completed text tasks and preserves declared order.
+Give the request a unique ID and goal. Give each task a unique ID, kind, Role, model class, bounded requirements, deliverable, `dependsOn`, and `contextFrom`. Changesets require focused task checks, and a graph containing changesets requires final checks. The root must have a `package.json` test script; `pnpm test` is added to final checks if missing and runs against the combined tip before Main promotion. Text context may name only completed text tasks, preserves declared order, and implies a scheduling dependency; do not repeat an edge in `dependsOn` and `contextFrom`.
 
 Every changeset advances automatically after preliminary checks pass. While a locally owned changeset task is actively working, the user may open `/subagent` to queue bounded same-worker revisions or withdraw all still-pending instructions into the native editor and submit one replacement. Cancellation after withdrawal leaves the originals removed; already-claimed instructions cannot be recalled. Each revision must produce a new clean commit and rerun preliminary checks. When no queued revision remains, the runner seals and durably records the exact ready candidate without waiting for sibling workers. There is no guaranteed post-completion editing window, and late follow-ups fail visibly.
 
 A ready candidate does not integrate automatically. Each checked worker triggers a follow-up while its siblings continue; inspect `subagent_status` and immediately use `subagent_stage` with the exact `generation`, `taskId`, `attempt`, candidate `tip`, and `expectedTip` to select and merge it into the owned integration checkout. Stage and resolve are available during the active wave; wait for the wave to settle before rejecting or revising. Resolve conflicts in the integration checkout and verify with `resolve`; never edit Main to resolve them. For dependents, `subagent_integrate advance` acknowledges a durable background wave, then reports checked candidates as they finish. When selected work is staged and the wave settles, use `subagent_integrate validate` on the exact `combinedTip` for full root checks and optional final judgment; `promote` requires passing evidence and unchanged Main. One Main-authored committed correction to a definitively failed combined validation can be recorded with `correct`, then revalidated. Only proven promotion triggers selected-worker termination and verified cleanup. Failures, ambiguity, conflicts, interruption, child-limit exhaustion, or Main drift retain work and never waive checks or identity guards. The extension never pushes, opens a pull request, publishes, or deploys.
 
-After a coordinator interruption in the canonical repository, ask the user to run `/subagent recover` once: it acquires the productive lease, classifies orphaned interruptions, preserves invalid files and retained work, and sends Main one follow-up with blockers and next actions. A live productive lease is read-only and cannot be taken over. Recovery never replays prompts, merges, promotion, or cleanup. Use `subagent_status` to inspect exact durable state without mutation, including candidate identities, generations, and retained resources. `subagent_resume` handles only the reported retry/verify/finalize continuation; it cannot replace Main's stage/integrate decisions or reset policy/corrections. `subagent_stage reject` or `revise` freezes a generation containing the candidate and invalidates dependent attempts; restage chosen work in a new generation. If Main advances cleanly before promotion, use `subagent_integrate refresh` with exact old/new Main and combined-tip identities; restage immutable candidates into the new generation and rerun combined validation. Dirty or divergent Main blocks refresh. At most two unreleased integration worktrees may coexist. Rejected candidates and superseded generations remain retained until Main explicitly calls `subagent_integrate release` with the exact generation and tip; for a rejected worker include its task ID and attempt after releasing all generations using it. Dirty/conflicted or unproved resources block release without force deletion. Impossible fresh dependent work after rejection needs a new request. `subagent_abort` cannot discard retained candidates or integration generations; it may finish once all are released. Old v4 state is rejected (current state is v5), not migrated. Status, abort, process I/O, termination, and verified post-promotion cleanup keep finite safety budgets.
+After a coordinator interruption in the canonical repository, ask the user to run `/subagent recover` once: it acquires the productive lease, classifies orphaned interruptions, preserves invalid files and retained work, and sends Main one follow-up with blockers and next actions. A live productive lease is read-only and cannot be taken over. Recovery never replays prompts, merges, promotion, or cleanup. Use `subagent_status` to inspect exact durable state without mutation, including candidate identities, generations, and retained resources. `subagent_resume` handles only the reported retry/verify/finalize continuation; it cannot replace Main's stage/integrate decisions or reset policy/corrections. `subagent_stage reject` or `revise` freezes a generation containing the candidate and invalidates dependent attempts; restage chosen work in a new generation. If Main advances cleanly before promotion, use `subagent_integrate refresh` with exact old/new Main and combined-tip identities; restage immutable candidates into the new generation and rerun combined validation. Dirty or divergent Main blocks refresh. At most two unreleased integration worktrees may coexist. Rejected candidates and superseded generations remain retained until Main explicitly calls `subagent_integrate release` with the exact generation and tip; for a rejected worker include its task ID and attempt after releasing all generations using it. Dirty/conflicted or unproved resources block release without force deletion. Impossible fresh dependent work after rejection needs a new request. `subagent_abort` cannot discard retained candidates or integration generations; release them first. For workers without candidates, abort cleans only proven unchanged, clean owned resources. If cleanup is deferred or blocked, inspect status and repeat abort after resolving the blocker. Dirty or committed work and uncertain allocations remain for manual recovery. Old v4 state is rejected (current state is v5), not migrated. Status, abort, process I/O, termination, and verified post-promotion cleanup keep finite safety budgets.
 
 All launches use the global policy in `config/pi-subagent/config.json`: productive concurrency, per-child turns/tokens, and idle timeout. Ephemeral children also have a hard runtime limit; isolated requests have a correction cap. Productive requests have no whole-run wall-clock deadline. Request fields cannot replenish or override limits.