@henryqw/pi-subagent 27.6.3 → 27.8.0

package/README.md

@@ -25,13 +25,14 @@ Configure the profiles that your Roles use in `/task-models`. Direct writer term
 
 Ask Main: “Have a scout trace sign-in without editing files.” Main calls `delegate_task` and stays available until progress and results arrive.
 
-Commands and UI are for you. Tools and the packaged skill are for Main, except `git_read`, which is only for Role-declared children.
+Commands, prompts, and UI are for you. Tools and the packaged skill are for Main, except `git_read`, which is only for Role-declared children.
 
 | Surface | Type | Purpose |
 | --- | --- | --- |
-| `/subagent` | command | Browse direct and isolated work, including requests whose parent checkout was removed. Stop direct workers, inspect isolated work, send follow-ups, or delete owned isolated worktrees after confirmation. Without interactive UI, only reports. |
+| `/subagent` | command | Browse direct and isolated work, including requests whose parent checkout was removed. Stop direct workers, inspect isolated work, send follow-ups, or delete owned isolated worktrees after confirmation. **Select multiple…** applies one action to many rows. Without interactive UI, only reports. |
 | `/subagent roles` | command | List Role sources, resources, resolved model and thinking level, route errors, and file errors. Read-only; requires no Herdr pane. |
-| `/subagent prune` | command | Review remaining worker and integration branches and worktrees. Remove merged resources after confirmation. Requires a running Herdr server; without interactive UI, only reports. |
+| `/subagent prune` | command | Review remaining worker and integration branches and worktrees. Select the items to remove; merged items are selected first. Some blocked items can also be selected, after a separate confirmation. Requires a running Herdr server; without interactive UI, only reports. |
+| `/review [target] [focus]` | prompt | Tell Main to review a change with parallel `reviewer` tasks and give one ship verdict. See [Review a change](#review-a-change). |
 | `/subagent recover` | command | Classify interrupted isolated work in the canonical repository. Send Main request IDs, blockers, and next actions. Requires no UI or Herdr pane. |
 | `delegate_task` | tool | Start authorized shared-checkout work or a durable isolated checked graph. With `dryRun: true`, check the request and show the resolved plan without a launch. |
 | `subagent_status` | tool | Read saved isolated state, exact identities, failed review verdicts, and allowed continuation. Does not replay work. Supports structured output for `codemode`. |
@@ -90,6 +91,21 @@ The launch returns a task ID and first Herdr tab, not the answer. One follow-up
 
 To continue a finished worker, add `"continueFrom": "D7.1"` with the same `role`. This opens a new tab with the saved conversation and a new reference. Continue the newest reference from the original checkout and workspace. For eligibility and stop behavior, see [Continue or stop one direct worker](./docs/orchestration.md#continue-or-stop-one-direct-worker).
 
+### Review a change
+
+Run `/review` to review uncommitted changes against `HEAD`. To review other work, give one target:
+
+| Target | Reviewed change |
+| --- | --- |
+| `A..B` | From `A` to `B` |
+| `feature-branch` | From the merge-base with `main` to the branch |
+| `a1b2c3d` | The commit against its first parent |
+| `#42` | The pull request head against its merge-base with the pull request base |
+
+Text after the target adds a review focus, for example `/review #42 cache invalidation`. If the first word is not a target, Main reviews uncommitted changes and uses all text as the focus. Main changes the target to exact local commit IDs. Reviewers can read only local Git. So, for a pull request, Main fetches the head and base from the pull request repository to `refs/pi-review/`. Main groups changed files by location, starts one read-only `reviewer` task for each group, and merges the findings.
+
+The verdict is **Ship** only if each reviewer task succeeded and answered exactly `PASS`. Otherwise, the verdict is **Do not ship**, with the findings in priority order. If the checkout changed during a review task, the verdict is also **Do not ship**, and you must run the review again. Main does not fix findings. If another `/review` prompt template loads first, Pi keeps that template and reports a name collision.
+
 ### Isolated workflow
 
 ![Isolated workers commit checked candidates; Main stages ready work while siblings run, advances dependents, validates the combined tip, and explicitly promotes](./docs/orchestration-architecture.svg)
@@ -143,6 +159,10 @@ Each row starts with a status symbol: `●` active, `✓` completed, `⚠` needs
 
 Requests whose parent checkout was removed show in the **Orphaned · parent checkout removed** group from any checkout of the same repository. Every isolated request, including an orphaned request, has **Close and delete worktrees (discard work)**. Select it to review owned resources and confirm deletion. **This permanently deletes committed, uncommitted, and ignored content in the listed checkouts.** Cancel makes no change.
 
+Select **Select multiple…** to apply one action to many rows. Select a row to mark it `[x]` or clear it, or use **Select all** or **Clear**, then select **Continue**. The next menu shows only the actions that apply. **Close and delete worktrees (discard work)** applies to isolated requests. **Close/cancel-and-release ALL owned workers** applies to direct workflows that can close. Each request shows its review, then one confirmation covers all of them.
+
+The command reports the number of selected rows that the action skipped.
+
 Only shown resources can be removed; live jobs, uncertain ownership, or other Herdr panes can block removal. Agents and tools cannot trigger this action. See [Close and delete isolated worktrees](./docs/orchestration.md#close-and-delete-isolated-worktrees) for guards and partial cleanup.
 
 Inspection needs a Herdr pane, the configured `scout` Role, and the `fast` route. If it cannot start, the request stays unchanged; Main can use `subagent_status` to read state. See [Inspect and revise active work](./docs/orchestration.md#inspect-and-revise-active-work) for inspection and follow-up details.
@@ -192,6 +212,12 @@ Role Markdown files in `~/.pi/agent/config/pi-subagent/` require frontmatter and
 
 The package ships `implementer`, `reviewer`, and `scout`; same-name user Roles override built-ins. Roles define capabilities, not access or isolation. Unknown frontmatter keys invalidate that file and report its path and key. Other valid Roles load; duplicate names become unavailable. Delegation to an invalid file's claimed Role fails with that file's error. Inspect `/subagent roles`.
 
+The built-in reviewer answers exactly `PASS` when it finds no actionable correctness risk. Otherwise, each finding starts with a priority and a confidence (`high`, `medium`, or `low`), for example `[P1] confidence: high`. Then it gives file and line evidence, the trigger, the impact, and the smallest fix. Each finding blocks approval.
+
+- `P0`: breaks release or operation on ordinary input.
+- `P1`: wrong behavior under a realistic condition.
+- `P2`: wrong behavior in a narrow edge case with limited impact.
+
 The built-in reviewer and scout include `git_read`; existing user reviewers and scouts must add it to `tools`. No additional extension or Bash access is necessary. See [Reviewer Git inspection](./docs/orchestration.md#reviewer-git-inspection) for operations, parameters, limits, and Git requirements.
 
 Children load only declared resources and required adapters. Roles must list their model provider extension. `codemode` requires both `builtin:codemode` in `extensions` and `codemode` in `tools`. Missing Skills, tools, MCP servers, Roles, or routes fail before productive work. Main-only delegation/recovery tools and `ask_question` stay unavailable to children.
@@ -234,6 +260,6 @@ Unverified tab allocations retain evidence but offer no Close action. Reconcile
 
 After coordinator interruption, restart Pi and run `/subagent recover` in the canonical repository. Use `subagent_status` for exact evidence; never take over a live productive lease or replay uncertain prompts, merges, or promotion. See [Recover after interruption](./docs/orchestration.md#recover-after-interruption) and [Recovery and state](./docs/orchestration.md#recovery-and-state).
 
-Run `/subagent prune` for merged leftovers. Removing a checkout deletes its ignored files only after a separate confirmation naming those entries. Dirty, conflicted, changed, or uncertain resources require deliberate inspection. See [Prune leftover worktrees](./docs/orchestration.md#prune-leftover-worktrees) before removal.
+Run `/subagent prune` for leftovers; merged items are selected first. Removing a checkout deletes its ignored files only after a separate confirmation naming those entries. If you select an item that an unfinished request owns, the command closes and deletes that whole request after its review and confirmation. **If you select unowned work with unique commits or changes, a separate confirmation permits its permanent deletion.** Uncertain resources, such as locked checkouts or checkouts that other Herdr panes use, cannot be selected. See [Prune leftover worktrees](./docs/orchestration.md#prune-leftover-worktrees) before removal.
 
-For aborted requests with retained resources, inspect status, resolve blockers, and repeat `subagent_abort` to reconcile cleanup without replaying work. Release rejected candidates and superseded generations explicitly. The extension never pushes, opens pull requests, publishes, deploys, or silently falls back to Main. It force-deletes recoverable work only after the user confirms **Close and delete worktrees (discard work)** in `/subagent`.
+For aborted requests with retained resources, inspect status, resolve blockers, and repeat `subagent_abort` to reconcile cleanup without replaying work. Release rejected candidates and superseded generations explicitly. The extension never pushes, opens pull requests, publishes, deploys, or silently falls back to Main. It force-deletes recoverable work only after the user confirms **Close and delete worktrees (discard work)** in `/subagent` or a force removal in `/subagent prune`.

package/dist/prune.d.ts

@@ -1,4 +1,20 @@
 import { type GitRunner } from "./git-process.ts";
+/** Blockers that a separately confirmed force removal of an unowned item may override; every other kind is hard. */
+export declare const FORCEABLE_PRUNE_BLOCKERS: readonly ["unmerged", "changes", "operation", "submodules"];
+export type PruneBlockerKind = typeof FORCEABLE_PRUNE_BLOCKERS[number] | "owner" | "lease" | "hard";
+export interface PruneBlocker {
+    kind: PruneBlockerKind;
+    text: string;
+}
+/** Saved identity of a readable request that owns a resource name. */
+export interface PruneRequest {
+    id: string;
+    name: string;
+    status: string;
+    directory: string;
+    root: string;
+    orphaned: boolean;
+}
 /** One reviewed pi-subagent branch, with its registered checkout when one exists. */
 export interface PruneItem {
     branch: string;
@@ -7,12 +23,21 @@ export interface PruneItem {
     prunable: boolean;
     /** Why the item is prunable, or every exact blocker. */
     reason: string;
+    blockers: readonly PruneBlocker[];
+    /** The only, readable request that owns the item. */
+    owner?: PruneRequest;
+    /** How a blocked item can still go after separate confirmation: discard of its whole owning request, or
+     * force removal when every blocker is forceable. Absent for prunable and hard-blocked items. */
+    override?: "discard" | "force";
     /** Ignored entries as Git collapses them; removing the checkout deletes them. */
     ignored: readonly string[];
 }
 export interface PruneOwnership {
-    /** The request or state that may still own a resource name (`subagent-<hex>`), if any. */
-    owner(name: string): string | undefined;
+    /** Every request or state that may still own a resource name (`subagent-<hex>`); unreadable state has no request. */
+    owners(name: string): readonly {
+        label: string;
+        request?: PruneRequest;
+    }[];
     /** The live productive lease that blocks pruning, if any. */
     lease?: string;
 }
@@ -44,9 +69,10 @@ export declare function inspectPruneCandidates(root: string, mainCwd: string, gu
 /**
  * Re-verify each reviewed prunable item immediately before removing its checkout, then delete its
  * branch only at the reviewed tip. Ignored entries are deleted only when `allowIgnored` and all of
- * them were in the review. Returns the repository checkouts that still exist.
+ * them were in the review. With `force`, a reviewed forceable item is removed with `--force` while
+ * every fresh blocker is forceable and of a reviewed kind. Returns the repository checkouts that still exist.
  */
-export declare function removePruneCandidates(root: string, mainCwd: string, reviewed: readonly PruneItem[], allowIgnored: boolean, guards: PruneGuards, run?: GitRunner): Promise<{
+export declare function removePruneCandidates(root: string, mainCwd: string, reviewed: readonly PruneItem[], allowIgnored: boolean, force: boolean, guards: PruneGuards, run?: GitRunner): Promise<{
     removals: PruneRemoval[];
     checkouts: string[];
 }>;

package/dist/prune.js

@@ -6,6 +6,9 @@ import { runProcess } from "./process.js";
 import { inspectWorktreeDirty, OWNED_BRANCH_PATTERN, WORKTREES_DIRNAME } from "./worktree.js";
 const HERDR_TIMEOUT_MS = 30_000;
 const IN_PROGRESS_MARKERS = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "REBASE_HEAD", "BISECT_LOG", "rebase-merge", "rebase-apply", "sequencer"];
+/** Blockers that a separately confirmed force removal of an unowned item may override; every other kind is hard. */
+export const FORCEABLE_PRUNE_BLOCKERS = ["unmerged", "changes", "operation", "submodules"];
+const forceable = (kind) => FORCEABLE_PRUNE_BLOCKERS.includes(kind);
 export async function requireGit(run, args, cwd) {
     const result = await run(args, cwd);
     if (result.code !== 0)
@@ -62,14 +65,15 @@ async function classify(snap, branch, mainCwd, ownership, panes, run, root) {
     // A detached or switched owned checkout no longer names the branch; find it by its owned path too.
     const checkout = snap.checkouts.find((item) => item.branch === branch) ?? snap.checkouts.find((item) => item.path === ownedPath);
     const blockers = [];
+    const block = (kind, text) => blockers.push({ kind, text });
     if (checkout && checkout.branch !== branch)
-        blockers.push(`owned checkout is ${checkout.branch ? `on branch ${checkout.branch}` : "detached"}; inspect it manually`);
+        block("hard", `owned checkout is ${checkout.branch ? `on branch ${checkout.branch}` : "detached"}; inspect it manually`);
     let ignored = [];
-    const owner = ownership.owner(name);
-    if (owner)
-        blockers.push(owner);
+    const owners = ownership.owners(name);
+    for (const { label } of owners)
+        block("owner", label);
     if (ownership.lease)
-        blockers.push(ownership.lease);
+        block("lease", ownership.lease);
     let merged;
     for (const target of snap.targets) {
         const result = await run(["merge-base", "--is-ancestor", tip, target.head], root);
@@ -81,44 +85,49 @@ async function classify(snap, branch, mainCwd, ownership, panes, run, root) {
             throw new Error(`git merge-base failed (exit ${result.code}): ${result.stderr.trim().slice(0, 200)}`);
     }
     if (!merged)
-        blockers.push(`branch has commits not in ${snap.targets.map(({ label }) => label).join(" or ")}`);
+        block("unmerged", `branch has commits not in ${snap.targets.map(({ label }) => label).join(" or ")}`);
     if (checkout) {
         const path = checkout.path;
         if (path !== ownedPath)
-            blockers.push("checkout is not at its owned .worktrees path");
+            block("hard", "checkout is not at its owned .worktrees path");
         if (checkout.locked)
-            blockers.push("checkout is locked");
+            block("hard", "checkout is locked");
         if (checkout.missing || !existsSync(path))
-            blockers.push("checkout directory is missing; inspect it, then run git worktree prune");
+            block("hard", "checkout directory is missing; inspect it, then run git worktree prune");
         else {
             const real = realpathSync.native(path);
             if (within(real, realpathSync.native(mainCwd)))
-                blockers.push("Main runs inside the checkout");
+                block("hard", "Main runs inside the checkout");
             const gitDir = await requireGit(run, ["rev-parse", "--absolute-git-dir"], path);
             const markers = IN_PROGRESS_MARKERS.filter((marker) => existsSync(join(gitDir, marker)));
             if (markers.length)
-                blockers.push(`Git operation in progress (${markers.join(", ")})`);
+                block("operation", `Git operation in progress (${markers.join(", ")})`);
             const dirty = await inspectWorktreeDirty(path, run, false);
             if (dirty.failure)
-                blockers.push(`checkout could not be inspected: ${dirty.failure}`);
+                block("hard", `checkout could not be inspected: ${dirty.failure}`);
             else if (dirty.dirty)
-                blockers.push("checkout has tracked or untracked changes");
+                block("changes", "checkout has tracked or untracked changes");
             else if (dirty.initializedSubmodules)
-                blockers.push("checkout has initialized submodules; Git cannot remove it without force, so remove it manually");
+                block("submodules", "checkout has initialized submodules; Git cannot remove it without force");
             if (typeof panes === "string")
-                blockers.push(`Herdr unavailable (${panes}); cannot prove no pane uses the checkout`);
+                block("hard", `Herdr unavailable (${panes}); cannot prove no pane uses the checkout`);
             else {
                 const used = panes.filter((pane) => pane.cwds.some((cwd) => within(path, cwd) || within(real, cwd)));
                 if (used.length)
-                    blockers.push(`Herdr pane ${used.map(({ paneId }) => paneId).join(", ")} works inside the checkout`);
+                    block("hard", `Herdr pane ${used.map(({ paneId }) => paneId).join(", ")} works inside the checkout`);
             }
             ignored = (await requireGit(run, ["status", "--porcelain=v1", "-z", "--ignored=matching", "--untracked-files=normal"], path))
                 .split("\0").filter((entry) => entry.startsWith("!! ")).map((entry) => entry.slice(3));
         }
     }
+    // The owning request's discard review owns its other blockers; a lease or any second owner keeps the item.
+    const owner = owners.length === 1 ? owners[0].request : undefined;
+    const override = !blockers.length ? undefined : owner && !blockers.some(({ kind }) => kind === "lease") ? "discard"
+        : blockers.every(({ kind }) => forceable(kind)) ? "force" : undefined;
     return {
-        branch, tip, ...(checkout ? { path: checkout.path } : {}), prunable: !blockers.length, ignored,
-        reason: blockers.length ? blockers.join("; ") : `merged into ${merged}; ${checkout ? "clean checkout" : "no checkout"}`,
+        branch, tip, ...(checkout ? { path: checkout.path } : {}), prunable: !blockers.length, ignored, blockers,
+        ...(owner ? { owner } : {}), ...(override ? { override } : {}),
+        reason: blockers.length ? blockers.map(({ text }) => text).join("; ") : `merged into ${merged}; ${checkout ? "clean checkout" : "no checkout"}`,
     };
 }
 const existing = (snap) => snap.checkouts.filter((item) => !item.missing && existsSync(item.path)).map(({ path }) => path);
@@ -142,14 +151,17 @@ export async function inspectPruneCandidates(root, mainCwd, guards, run = runGit
         items.push(await classify(snap, branch, mainCwd, ownership, panes, run, root));
     return items;
 }
-async function removeOne(root, mainCwd, reviewed, allowIgnored, guards, run) {
+async function removeOne(root, mainCwd, reviewed, allowIgnored, force, guards, run) {
     const skip = (reason) => ({ outcome: "skipped", item: reviewed, reason });
     const fail = (reason) => ({ outcome: "failed", item: reviewed, reason });
     const { snap, ownership, panes } = await evidence(root, mainCwd, guards, run);
     if (snap.branches.get(reviewed.branch) !== reviewed.tip)
         return skip("branch was deleted or moved since review");
     const fresh = await classify(snap, reviewed.branch, mainCwd, ownership, panes, run, root);
-    if (!fresh.prunable)
+    // Force applies only to an item reviewed as forceable, and only while no blocker of a new or hard kind appears.
+    const forced = force && reviewed.override === "force";
+    if (forced ? !fresh.blockers.every(({ kind }) => forceable(kind) && reviewed.blockers.some((item) => item.kind === kind))
+        : !fresh.prunable)
         return skip(fresh.reason);
     if (fresh.path !== reviewed.path)
         return skip("checkout registration changed since review");
@@ -159,8 +171,8 @@ async function removeOne(root, mainCwd, reviewed, allowIgnored, guards, run) {
     if (fresh.path) {
         if (stale())
             return skip("session or branch changed before removal; reopen /subagent prune");
-        // Git removes ignored content without --force; the checks above approved it.
-        const removed = await run(["worktree", "remove", fresh.path], root);
+        // Git removes ignored content without --force; the checks above approved it. Force also deletes reviewed changes.
+        const removed = await run(["worktree", "remove", ...(forced ? ["--force"] : []), fresh.path], root);
         if (removed.code !== 0)
             return fail(`git worktree remove failed: ${removed.stderr.trim().slice(0, 200)}`);
         if (existsSync(fresh.path))
@@ -176,13 +188,14 @@ async function removeOne(root, mainCwd, reviewed, allowIgnored, guards, run) {
 /**
  * Re-verify each reviewed prunable item immediately before removing its checkout, then delete its
  * branch only at the reviewed tip. Ignored entries are deleted only when `allowIgnored` and all of
- * them were in the review. Returns the repository checkouts that still exist.
+ * them were in the review. With `force`, a reviewed forceable item is removed with `--force` while
+ * every fresh blocker is forceable and of a reviewed kind. Returns the repository checkouts that still exist.
  */
-export async function removePruneCandidates(root, mainCwd, reviewed, allowIgnored, guards, run = runGit) {
+export async function removePruneCandidates(root, mainCwd, reviewed, allowIgnored, force, guards, run = runGit) {
     const removals = [];
     for (const item of reviewed) {
         try {
-            removals.push(await removeOne(root, mainCwd, item, allowIgnored, guards, run));
+            removals.push(await removeOne(root, mainCwd, item, allowIgnored, force, guards, run));
         }
         catch (error) {
             removals.push({ outcome: "failed", item, reason: (error instanceof Error ? error.message : String(error)).slice(0, 300) });

package/dist/runner.js

@@ -678,19 +678,23 @@ export class IsolatedRunner {
     async pruneOwnership(checkouts) {
         const owners = [];
         let lease;
+        const request = ({ state, path }, orphaned) => ({ id: state.request.id, name: state.request.goal,
+            status: inventoryStatus(state), directory: dirname(path), root: state.root, orphaned });
         const orphans = checkouts[0] ? (await this.store.listOrphans(realpathSync.native(checkouts[0]))).states : [];
-        for (const { state } of orphans) {
+        for (const handle of orphans) {
+            const { state } = handle;
             if (!terminal(state))
-                owners.push({ label: `owned by orphaned ${state.status} request ${state.request.id}; close and delete it from /subagent`, text: JSON.stringify(state) });
+                owners.push({ label: `owned by orphaned ${state.status} request ${state.request.id}; close and delete it from /subagent`, text: JSON.stringify(state), request: request(handle, true) });
         }
         for (const checkout of checkouts) {
             const root = realpathSync.native(checkout);
             if (!lease && await this.store.hasProductiveRunLease(root))
                 lease = `productive lease is held by a live run in ${root}`;
             const { states, invalidIds } = await this.store.list(root);
-            for (const { state } of states) {
+            for (const handle of states) {
+                const { state } = handle;
                 if (!terminal(state))
-                    owners.push({ label: `owned by ${state.status} request ${state.request.id}`, text: JSON.stringify(state) });
+                    owners.push({ label: `owned by ${state.status} request ${state.request.id}`, text: JSON.stringify(state), request: request(handle, false) });
             }
             for (const id of invalidIds) {
                 let text;
@@ -701,7 +705,8 @@ export class IsolatedRunner {
                 owners.push({ label: `unreadable state ${id} in ${root} may own it`, text });
             }
         }
-        return { ...(lease ? { lease } : {}), owner: (name) => owners.find(({ text }) => text === undefined || text.includes(name))?.label };
+        return { ...(lease ? { lease } : {}), owners: (name) => owners.filter(({ text }) => text === undefined || text.includes(name))
+                .map(({ label, request }) => ({ label, ...(request ? { request } : {}) })) };
     }
     /** After pruning, reconcile aborted requests that recorded a removed resource through the guarded abort path. */
     async reconcilePrunedAborts(checkouts, names) {

package/docs/orchestration.md

@@ -402,6 +402,8 @@ Each resource is checked again before removal. A live productive lease or local
 
 Main cannot run inside a checkout selected for deletion. A session change stops further removal. Only this request's recorded `pi-subagent/subagent-<24hex>` branches and their exact primary `.worktrees/` paths can be removed. The primary checkout is never removed.
 
+To close and delete many requests, select **Select multiple…** in `/subagent`, select the requests, then select **Continue** and **Close and delete worktrees (discard work)**. The command shows the review of each request. Then one confirmation covers the unblocked resource groups of all of them. The same menu can close all owned workers of each selected direct workflow that can close. The command reports the number of selected rows that the action skipped.
+
 The report lists removed, skipped, and failed resources. After complete cleanup, the request is `aborted`, candidates are `released`, and integration generations are superseded with completed cleanup. Partial cleanup remains visible as retained work. Reopen the request to review the remaining resources. Abort, prune, and release keep their existing preservation rules.
 
 ### Prune leftover worktrees
@@ -410,13 +412,22 @@ Run `/subagent prune` to clean up leftover worker and integration checkouts unde
 
 - 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.
-- No unfinished isolated request, in any checkout of this repository, records it. An unreadable state file blocks every item that it mentions. An unfinished orphaned request, whose parent checkout was removed, also blocks its items. To remove them, open that request in `/subagent` and use **Close and delete worktrees (discard work)**.
+- No unfinished isolated request, in any checkout of this repository, records it. An unreadable state file blocks every item that it mentions. An unfinished orphaned request, whose parent checkout was removed, also blocks its items.
 - No productive run holds a repository lease.
 - No Herdr pane works inside the checkout. If the command cannot inspect Herdr, it refuses every checkout.
 
-One confirmation removes every listed removable item. When the command removes a checkout, it also deletes the ignored files of the checkout, such as `node_modules` or `dist`. So the command includes a checkout with ignored files only after a second confirmation. That confirmation names each ignored entry, and its approval covers all contents of each named entry.
+After the review, the command shows a selection list. Removable items are selected (`[x]`). Blocked items that the command can still remove are not selected; each one shows its short ID and its blockers. Select a row to change it, or use **Select all** or **Clear**. Select **Continue** to remove the selected removable items, or **Cancel** to make no change. Items with other blockers are not in the list.
+
+You can select these blocked items:
+
+- **An item that one readable unfinished request owns**, orphaned or not. The row shows `delete whole request <id>`. The command does not remove the item alone. It shows the [Close and delete](#close-and-delete-isolated-worktrees) review of the whole owning request. After one confirmation, it closes the request and deletes its unblocked resources, as in `/subagent`. That flow also closes the request's own workers and Herdr panes. When you select items of different requests, one confirmation covers all of them.
+- **An unowned item whose blockers are only unique commits, tracked or untracked changes, a Git operation in progress, or initialized submodules.** The row shows `force`. A separate confirmation names each item and its blockers. **This permanently deletes those commits and changes.** Before removal, the command checks the item again. It keeps the item if a new kind of blocker appears. Then it uses `git worktree remove --force` and deletes the branch only at the reviewed tip.
+
+These blockers always keep an item: a productive lease, unreadable state, more than one owner, Main inside the checkout, a locked checkout, a checkout that is not at its owned path or that is detached or on another branch, a missing checkout directory, Herdr that cannot be inspected, and Herdr panes inside an unowned checkout.
+
+When the command removes a checkout, it also deletes the ignored files of the checkout, such as `node_modules` or `dist`. So the command includes a checkout with ignored files only after a second confirmation. That confirmation names each ignored entry, and its approval covers all contents of each named entry.
 
-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.
+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. Remove owned checkouts that are detached or on another branch manually.
 
 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.
 

package/examples/roles/reviewer.md

@@ -16,4 +16,10 @@ Review the supplied candidate read-only. Use only supplied requirements and name
 
 Report only actionable correctness risks introduced by the change, not style preferences, speculative hypotheticals, or unrelated pre-existing issues. Run no tests or commands outside `git_read`. Never edit, write, commit, push, mutate Git or manage worktrees, or invoke external LLM APIs, SDKs, agent harnesses, or model CLIs.
 
-Output exactly `PASS` when there are no findings. Otherwise output findings only, ordered by severity, with file:line evidence, impact, and the smallest valid fix. Any finding blocks approval; never combine `PASS` with findings. Stop when the supplied evidence is covered.
+Output exactly `PASS` when there are no findings. Otherwise output findings only, ordered by priority, then confidence. Start each finding with its priority and confidence, for example `[P1] confidence: high`, then give file:line evidence, the trigger, the impact, and the smallest valid fix:
+
+- `P0`: breaks release or operation on ordinary input, such as data loss, a security bypass, or a crash.
+- `P1`: wrong behavior under a realistic condition, such as a race, a missed error path, or a broken caller.
+- `P2`: wrong behavior in a narrow edge case with limited impact.
+
+Confidence is `high`, `medium`, or `low` that the defect is real; name the affected code path even when low. Any finding blocks approval; never combine `PASS` with findings. Stop when the supplied evidence is covered.

package/extensions/isolated.ts

@@ -522,7 +522,7 @@ export interface IsolatedSurface {
 	prunePlan(cwd: string): Promise<PrunePlan>;
 	discardPlan(cwd: string, request: IsolatedRequest): Promise<DiscardPlan>;
 	discard(cwd: string, plan: DiscardPlan, current: () => boolean): Promise<CleanupReport>;
-	prune(cwd: string, items: readonly PruneItem[], allowIgnored: boolean, current: () => boolean): Promise<CleanupReport>;
+	prune(cwd: string, items: readonly PruneItem[], allowIgnored: boolean, force: boolean, current: () => boolean): Promise<CleanupReport>;
 	inspect(root: string, requestId: string): Promise<readonly string[]>;
 	canFollowup(root: string, requestId: string, taskId: string): boolean;
 	enqueue(root: string, requestId: string, taskId: string, text: string, current: () => boolean): string;
@@ -896,10 +896,10 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 			const root = await lookupRoot(cwd);
 			return { root, items: await inspectPruneCandidates(root, cwd, pruneGuards(root)) };
 		},
-		async prune(cwd, items, allowIgnored, current) {
+		async prune(cwd, items, allowIgnored, force, current) {
 			requireCurrent(current);
 			const root = await lookupRoot(cwd);
-			const { removals, checkouts } = await removePruneCandidates(root, cwd, items, allowIgnored,
+			const { removals, checkouts } = await removePruneCandidates(root, cwd, items, allowIgnored, force,
 				{ ...pruneGuards(root), current: () => current() && !sessionClosed });
 			const removed = removals.filter(({ outcome }) => outcome === "removed");
 			const reconciled = removed.length

package/extensions/subagent-command.ts

@@ -1,6 +1,7 @@
 import { getMarkdownTheme, type ExtensionAPI, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
 import { Box, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import type { DiscardPlan } from "../dist/discard.js";
+import type { PruneItem } from "../dist/prune.js";
 import { compactCost } from "./result-transport.ts";
 
 /** Saved before launch for user matching only; never ownership or mutation authority. */
@@ -59,17 +60,7 @@ export interface IsolatedInventory {
 	invalidIds: readonly string[];
 }
 
-/** One pi-subagent branch and its checkout as reviewed by /subagent prune. */
-export interface PruneItem {
-	branch: string;
-	tip: string;
-	path?: string;
-	prunable: boolean;
-	/** Why the item is prunable, or every exact blocker. */
-	reason: string;
-	/** Ignored entries that removing the checkout deletes. */
-	ignored: readonly string[];
-}
+export type { PruneItem };
 export interface PrunePlan {
 	root: string;
 	items: readonly PruneItem[];
@@ -87,8 +78,8 @@ export interface SubagentCommandAdapter {
 	prunePlan(cwd: string): Promise<PrunePlan>;
 	discardPlan(cwd: string, request: IsolatedRequest): Promise<DiscardPlan>;
 	discard(cwd: string, plan: DiscardPlan, current: () => boolean): Promise<CleanupReport>;
-	/** Re-verify and remove reviewed prunable items; returns a bounded report. */
-	prune(cwd: string, items: readonly PruneItem[], allowIgnored: boolean, current: () => boolean): Promise<CleanupReport>;
+	/** Re-verify and remove reviewed prunable items, and with `force` reviewed forceable items; returns a bounded report. */
+	prune(cwd: string, items: readonly PruneItem[], allowIgnored: boolean, force: boolean, current: () => boolean): Promise<CleanupReport>;
 	/** Read-only Role catalog report with routes and per-file load errors. */
 	roles(ctx: ExtensionContext): RolesReport;
 	inspectInTab(root: string, requestId: string, ctx: ExtensionContext, current: () => boolean): Promise<{ ref: string; tabId: string; name: string; sessionFile: string }>;
@@ -209,6 +200,7 @@ const glyph = (status: string) => TONES[statusTone(status)].glyph;
 const cleanupReport = ({ text, failed, skipped }: CleanupReport): Report => textReport(failed ? "error" : skipped ? "warning" : "success", text);
 
 const PRUNE_IGNORED_CONFIRM_CODE_POINTS = 4_000;
+const shortId = ({ branch }: PruneItem) => branch.replace(/^pi-subagent\/subagent-/, "").slice(0, 8);
 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. */
@@ -246,7 +238,7 @@ function pruneReview({ root, items }: PrunePlan): { report: Report; shown: Prune
 		const section: Section = { heading: `${title} (${group.length})`, tone: group[0]!.prunable ? "success" : "error", rows: [] };
 		return Array.from({ length: Math.ceil(group.length / 10) }, (_, index) => {
 			const chunk = group.slice(index * 10, index * 10 + 10);
-			return { section, index, items: chunk, row: { text: chunk.map(({ branch }) => branch.replace(/^pi-subagent\/subagent-/, "").slice(0, 8)).join(", "), code: true } };
+			return { section, index, items: chunk, row: { text: chunk.map(shortId).join(", "), code: true } };
 		});
 	});
 	const prunable = items.filter((item) => item.prunable).length;
@@ -309,6 +301,31 @@ async function choose<T>(ctx: ExtensionContext, title: string, items: readonly C
 	return index < 0 ? undefined : items[index]!.value;
 }
 
+/** Multi-select on single-choice `select`: each pick toggles one row until Continue. Returns chosen values in
+ * item order, or undefined on Cancel or a changed session. Only selectable rows are offered. */
+async function chooseMany<T>(ctx: ExtensionContext, title: string, items: readonly Choice<T>[], preselected: readonly T[],
+	valid: () => boolean): Promise<T[] | undefined> {
+	type Pick = { kind: "toggle"; value: T } | { kind: "all" } | { kind: "clear" } | { kind: "continue" } | { kind: "cancel" };
+	const chosen = new Set(preselected);
+	for (;;) {
+		const picked = await choose<Pick>(ctx, title, [
+			...items.map((item) => ({ label: `${chosen.has(item.value) ? "[x]" : "[ ]"} ${item.label}`, value: { kind: "toggle" as const, value: item.value } })),
+			{ label: "Select all", value: { kind: "all" } }, { label: "Clear", value: { kind: "clear" } },
+			{ label: `Continue (${chosen.size} selected)`, value: { kind: "continue" } }, { label: "Cancel", value: { kind: "cancel" } },
+		]);
+		if (!valid() || !picked || picked.kind === "cancel") return undefined;
+		if (picked.kind === "continue") return items.map(({ value }) => value).filter((value) => chosen.has(value));
+		if (picked.kind === "all") for (const { value } of items) chosen.add(value);
+		else if (picked.kind === "clear") chosen.clear();
+		else if (!chosen.delete(picked.value)) chosen.add(picked.value);
+	}
+}
+
+// The owner is named once, so clipping keeps the other blockers.
+const pruneLabel = (item: PruneItem) => item.override === "discard"
+	? [`${shortId(item)} · delete whole request ${item.owner!.id} (${item.owner!.status})`, ...item.blockers.filter(({ kind }) => kind !== "owner").map(({ text }) => text)].join(" · ")
+	: `${shortId(item)} · ${item.prunable ? "" : "force · "}${item.reason}`;
+
 export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentCommandAdapter): void {
 	pi.registerEntryRenderer<Report>(REPORT_ENTRY, (entry, _options, theme) => entry.data && reportComponent(entry.data, theme, 1));
 	pi.registerMessageRenderer(RECOVERY_MESSAGE, (message, { outputPad }, theme) => reportComponent(textReport("info", typeof message.content === "string"
@@ -356,6 +373,43 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				ctx.ui.notify("Session or branch changed; reopen /subagent in the current context.", "warning");
 				return false;
 			};
+			/** Review each request's discard plan, then one confirmation covers every shown unblocked group.
+			 * `whole` states that a request is deleted although only some of its resources were selected. Returns false when stale. */
+			const discardRequests = async (requests: readonly IsolatedRequest[], whole = false): Promise<boolean> => {
+				const plans: DiscardPlan[] = [];
+				for (const request of requests) {
+					try {
+						const plan = await adapter.discardPlan(ctx.cwd, request);
+						const reviewed = discardReview(plan);
+						if (!valid()) return false;
+						deliver(ctx, reviewed.report);
+						const items = reviewed.shown.filter((item) => !item.blockers.length);
+						if (items.length) plans.push({ ...plan, items });
+					} catch (error) {
+						if (!valid()) return false;
+						ctx.ui.notify(`Close and delete failed for ${request.id}: ${errorText(error)}`, "error");
+					}
+				}
+				if (!plans.length) return true;
+				const groups = plans.reduce((sum, plan) => sum + plan.items.length, 0);
+				const confirmed = await ctx.ui.confirm("Close and delete worktrees (discard work)", clean(`${whole
+					? `This closes and deletes each whole owning request (${plans.map(({ requestId }) => requestId).join(", ")}), not only the selected worktrees. ` : ""}`
+					+ `Stop the listed workers and delete the ${groups} unblocked resource group(s) shown above${plans.length > 1 ? ` across ${plans.length} requests` : ""}? Committed, uncommitted, and ignored content in the listed checkouts is permanently deleted. Their listed branches, Herdr tabs, and workspaces are removed. Items not shown or blocked are kept.`,
+				PRUNE_IGNORED_CONFIRM_CODE_POINTS));
+				if (!valid()) return false;
+				if (!confirmed) return true;
+				for (const plan of plans) {
+					try {
+						const report = await adapter.discard(ctx.cwd, plan, current);
+						if (!valid()) return false;
+						deliver(ctx, cleanupReport(report));
+					} catch (error) {
+						if (!valid()) return false;
+						ctx.ui.notify(`Close and delete failed for ${plan.requestId}: ${errorText(error)}`, "error");
+					}
+				}
+				return true;
+			};
 			if (command === "prune") {
 				const plan = await adapter.prunePlan(ctx.cwd);
 				const reviewed = pruneReview(plan);
@@ -365,10 +419,20 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				}
 				if (!valid()) return;
 				deliver(ctx, reviewed.report);
-				const prunable = reviewed.shown.filter((item) => item.prunable);
-				if (!prunable.length) return;
-				const confirmed = await ctx.ui.confirm("Prune subagent worktrees", `Remove all ${prunable.length} prunable item(s) listed above? Each is re-verified first; unique commits, tracked or untracked changes, and unlisted items are never removed.`);
-				if (!valid() || !confirmed) return;
+				const options = reviewed.shown.filter((item) => item.prunable || item.override);
+				if (!options.length) return;
+				// Continue confirms prunable items; each is re-verified first. Blocked items need their own confirmation below.
+				const picked = await chooseMany(ctx, "Prune subagent worktrees · prunable items are selected", options.map((item) => ({ label: pruneLabel(item), value: item })),
+					options.filter((item) => item.prunable), valid);
+				if (!picked?.length) return;
+				const forceable = picked.filter((item) => item.override === "force");
+				const forceList = fitItems(`Force remove ${forceable.length} blocked item(s)? This permanently deletes their unique commits, tracked and untracked changes, in-progress Git operations, and initialized submodules, as listed. Each is re-verified first and kept if a new kind of blocker appears:`,
+					forceable, (item) => `${shortId(item)}: ${item.reason}`, PRUNE_IGNORED_CONFIRM_CODE_POINTS);
+				const force = forceList.shown.length > 0 && await ctx.ui.confirm("Force remove blocked worktrees",
+					clean(forceList.text.replace(`Force remove ${forceable.length} blocked`, `Force remove ${forceList.shown.length} blocked`), PRUNE_IGNORED_CONFIRM_CODE_POINTS, true));
+				if (!valid()) return;
+				if (forceable.length && !force) ctx.ui.notify(`Kept ${forceable.length} blocked item(s); force removal was not approved.`, "info");
+				const prunable = [...picked.filter((item) => item.prunable), ...force ? forceList.shown : []];
 				const ignored = prunable.filter((item) => item.ignored.length);
 				// The header uses the full count's width so the shown count always fits.
 				const ignoredList = fitItems(`Also remove ${ignored.length} checkout(s) with ignored files? This permanently deletes these ignored entries and everything inside them:`,
@@ -381,11 +445,19 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				const kept = ignored.length - (allowIgnored ? approvable.length : 0);
 				if (kept) ctx.ui.notify(`Kept ${kept} checkout(s) with ignored content; their deletion was not approved.`, "info");
 				const selected = prunable.filter((item) => !item.ignored.length || (allowIgnored && approvable.includes(item)));
-				if (!selected.length) return;
-				try {
-					const report = await adapter.prune(ctx.cwd, selected, allowIgnored, current);
-					if (valid()) deliver(ctx, cleanupReport(report));
-				} catch (error) { if (valid()) ctx.ui.notify(`Prune failed: ${errorText(error)}`, "error"); }
+				if (selected.length) {
+					try {
+						const report = await adapter.prune(ctx.cwd, selected, allowIgnored, force, current);
+						if (!valid()) return;
+						deliver(ctx, cleanupReport(report));
+					} catch (error) {
+						if (!valid()) return;
+						ctx.ui.notify(`Prune failed: ${errorText(error)}`, "error");
+					}
+				}
+				// Discard owns request-owned items: it closes the request's own workers and panes, then removes its resources.
+				const owners = new Map(picked.flatMap((item) => item.override === "discard" ? [[`${item.owner!.directory}\0${item.owner!.id}`, item.owner!] as const] : []));
+				await discardRequests([...owners.values()].map((owner) => ({ ...owner, tasks: [] })), true);
 				return;
 			}
 			if (!ctx.hasUI) {
@@ -412,18 +484,24 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				if (!valid()) return;
 				if (unavailable) ctx.ui.notify(`Isolated inventory unavailable (${unavailable}). Direct branch recovery remains available; check the canonical Git checkout/configuration.`, "warning");
 				if (inventory?.invalidIds.length) for (const id of inventory.invalidIds) ctx.ui.notify(`Unreadable isolated state ID: ${JSON.stringify(id)}. Preserve this file; inspect the state store before making changes.`, "warning");
-				type Selection = { kind: "direct"; task: DirectTask } | { kind: "isolated"; request: IsolatedRequest; root: string } | { kind: "refresh" } | { kind: "history" } | { kind: "close" };
+				type Selection = { kind: "direct"; task: DirectTask } | { kind: "isolated"; request: IsolatedRequest; root: string } | { kind: "refresh" } | { kind: "history" } | { kind: "many" } | { kind: "close" };
 				// A header row selects Refresh; rows sort by status priority within their group.
 				const group = <T extends { status: string }>(title: string, items: readonly T[], choice: (item: T) => Choice<Selection>): Choice<Selection>[] =>
 					items.length ? [{ label: `── ${title} (${items.length}) ──`, value: { kind: "refresh" } },
 						...[...items].sort((a, b) => priority(a.status) - priority(b.status)).map(choice)] : [];
 				const requests = inventory?.requests ?? [];
 				const isolatedChoice = (request: IsolatedRequest): Choice<Selection> => ({ label: `  ${glyph(request.status)} ${isolatedLabel(request)}`, value: { kind: "isolated", request, root: inventory!.root } });
+				// One row per workflow; new records keep opaque IDs in details. Status is last so clipping preserves the reference.
+				const directChoice = (task: DirectTask): Choice<Selection> => ({ label: `  ${glyph(task.status)} ${directLabel(task)} · ${task.status}${costSuffix(task.cost)}${task.workers.length || task.name === task.id ? "" : ` · ${task.id}`}`, value: { kind: "direct", task } });
+				const groups = [
+					group("Direct", direct.filter((task) => history || !completed(task.status)), directChoice),
+					group("Isolated", requests.filter((request) => !request.orphaned && (history || !completed(request.status) || /retained/i.test(request.status))), isolatedChoice),
+					group("Orphaned · parent checkout removed", requests.filter((request) => request.orphaned), isolatedChoice),
+				].flat();
+				const rows = groups.filter(({ value }) => value.kind === "direct" || value.kind === "isolated");
 				const selections: Choice<Selection>[] = [
-					// One row per workflow; new records keep opaque IDs in details. Status is last so clipping preserves the reference.
-					...group("Direct", direct.filter((task) => history || !completed(task.status)), (task) => ({ label: `  ${glyph(task.status)} ${directLabel(task)} · ${task.status}${costSuffix(task.cost)}${task.workers.length || task.name === task.id ? "" : ` · ${task.id}`}`, value: { kind: "direct", task } })),
-					...group("Isolated", requests.filter((request) => !request.orphaned && (history || !completed(request.status) || /retained/i.test(request.status))), isolatedChoice),
-					...group("Orphaned · parent checkout removed", requests.filter((request) => request.orphaned), isolatedChoice),
+					...groups,
+					...(rows.length ? [{ label: "Select multiple…", value: { kind: "many" as const } }] : []),
 					{ label: "Refresh", value: { kind: "refresh" } },
 					{ label: history ? "Active work" : "Completed / history (including retained work)", value: { kind: "history" } },
 					{ label: "Close", value: { kind: "close" } },
@@ -433,6 +511,34 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				if (!valid() || !selected || selected.kind === "close") return;
 				if (selected.kind === "refresh") continue;
 				if (selected.kind === "history") { history = !history; continue; }
+				if (selected.kind === "many") {
+					const picked = await chooseMany(ctx, "Subagent · select work", rows.map(({ label, value }) => ({ label: label.trim(), value })), [], valid);
+					if (!picked?.length) { if (!valid()) return; continue; }
+					const isolated = picked.flatMap((item) => item.kind === "isolated" ? [item.request] : []);
+					const closable = picked.flatMap((item) => item.kind === "direct" && item.task.canClose ? [item.task] : []);
+					type Batch = "discard" | "close" | "back";
+					const action = await choose<Batch>(ctx, `Subagent · ${picked.length} selected`, [
+						...(isolated.length ? [{ label: `Close and delete worktrees (discard work) of ${isolated.length} isolated request(s)`, value: "discard" as const }] : []),
+						...(closable.length ? [{ label: `Close/cancel-and-release ALL owned workers in ${closable.length} direct workflow(s) (preserve files and commits)`, value: "close" as const }] : []),
+						{ label: "Back / refresh", value: "back" },
+					]);
+					if (!valid()) return;
+					if (!action || action === "back") continue;
+					const skipped = picked.length - (action === "discard" ? isolated.length : closable.length);
+					if (skipped) ctx.ui.notify(`Skipped ${skipped} selected item(s) that this action does not apply to.`, "info");
+					if (action === "discard") { if (!await discardRequests(isolated)) return; continue; }
+					for (const task of closable) {
+						try {
+							const report = await adapter.closeDirect(task, current);
+							if (!valid()) return;
+							deliver(ctx, textReport("success", report));
+						} catch (error) {
+							if (!valid()) return;
+							ctx.ui.notify(`Admission retained for ${clean(directLabel(task))}: ${errorText(error)}. Inspect the exact tab/session; retry Close/cancel-and-release after resolving termination.`, "error");
+						}
+					}
+					continue;
+				}
 				if (selected.kind === "direct") {
 					const { task } = selected;
 					const label = clean(directLabel(task));
@@ -475,21 +581,7 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 					if (!valid() || !action) return;
 					if (action === "back") break;
 					if (action === "discard") {
-						try {
-							const plan = await adapter.discardPlan(ctx.cwd, request);
-							const reviewed = discardReview(plan);
-							if (!valid()) return;
-							deliver(ctx, reviewed.report);
-							const items = reviewed.shown.filter((item) => !item.blockers.length);
-							if (!items.length) continue;
-							const confirmed = await ctx.ui.confirm("Close and delete worktrees (discard work)",
-								`Stop the listed workers and delete the ${items.length} unblocked resource group(s) shown above? Committed, uncommitted, and ignored content in the listed checkouts is permanently deleted. Their listed branches, Herdr tabs, and workspaces are removed. Items not shown or blocked are kept.`);
-							if (!valid()) return;
-							if (confirmed) {
-								const report = await adapter.discard(ctx.cwd, { ...plan, items }, current);
-								if (valid()) deliver(ctx, cleanupReport(report));
-							}
-						} catch (error) { if (valid()) ctx.ui.notify(`Close and delete failed: ${errorText(error)}`, "error"); }
+						if (!await discardRequests([request])) return;
 						break;
 					}
 					if (action === "inspect") {

package/extensions/subagent.ts

@@ -346,7 +346,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		prunePlan: (cwd) => isolatedSurface.prunePlan(cwd),
 		discardPlan: (cwd, request) => isolatedSurface.discardPlan(cwd, request),
 		discard: (cwd, plan, current) => isolatedSurface.discard(cwd, plan, current),
-		prune: (cwd, items, allowIgnored, current) => isolatedSurface.prune(cwd, items, allowIgnored, current),
+		prune: (cwd, items, allowIgnored, force, current) => isolatedSurface.prune(cwd, items, allowIgnored, force, current),
 		async inspectInTab(root, id, ctx, current) {
 			const notices = await isolatedSurface.inspect(root, id);
 			if (!current()) throw new Error("Session or branch changed before status inspection.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "27.6.3",
+  "version": "27.8.0",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",
@@ -19,6 +19,7 @@
     "extensions",
     "docs",
     "examples",
+    "prompts",
     "example.png",
     "README.md",
     "CONTEXT.md",
@@ -63,6 +64,9 @@
     "skills": [
       "./skills"
     ],
+    "prompts": [
+      "./prompts"
+    ],
     "image": "https://raw.githubusercontent.com/HenryQW/pi-harness/main/extensions/pi-subagent/example.png"
   },
   "dependencies": {

package/prompts/review.md

@@ -0,0 +1,20 @@
+---
+description: Review a change with parallel reviewer Subagents and give one ship verdict.
+argument-hint: "[A..B | branch | commit | #PR] [focus]"
+---
+
+Review this target with parallel `reviewer` Subagents: $@
+
+Do not edit files, fix findings, commit, or push.
+
+1. Resolve the first argument to exact local commit IDs with Git. Treat the remaining text as extra review focus. If the first argument is not `#N` and does not resolve as a ref or range, use the empty target and treat all text as focus.
+   - Empty: uncommitted staged, unstaged, and untracked changes against `HEAD`.
+   - `A..B`: base `A`, tip `B`.
+   - Branch: base is `git merge-base main <branch>`, tip is the branch.
+   - Commit: base is its first parent, tip is the commit.
+   - `#N`: run `gh pr view N --json url,baseRefName`. The base repository URL is `url` without `/pull/N`. Run `git fetch <repository URL> +refs/heads/<baseRefName>:refs/pi-review/pr-N-base +refs/pull/N/head:refs/pi-review/pr-N`. Base is the merge-base of the two refs; tip is `refs/pi-review/pr-N`. Reviewers read only local Git, so fetch before delegation.
+   If the target is ambiguous or has no changes, stop and report.
+2. List the changed files, and mark untracked files. Group them by locality: same directory or module, related behavior, and tests with their implementation. Use one group for a small change and at most 5 groups.
+3. Start one `delegate_task` call with `mode: "direct"` and one `tasks` entry per group: `role: "reviewer"`, a short unique `name` (at most 29 characters), `access: "read"`, and a `task` that gives the base and tip commit IDs, its exact file list, and the criteria. For uncommitted changes, give `HEAD` <ID> instead, and tell the reviewer to combine `git_read` diff in `staged` and `working` modes and to read each marked untracked file whole with `read`. Criteria: report actionable correctness risks that the change introduces in these files, with the reviewer finding format; read other files only as context; output exactly `PASS` when there are no findings. Add the extra focus, if any.
+4. When the result arrives, merge the findings: remove duplicates that share a root cause and keep the highest priority, then sort by priority (`P0`, `P1`, `P2`) and confidence. Keep file:line evidence and fixes.
+5. Give one verdict. **Ship** only if every reviewer task succeeded and answered exactly `PASS`. Otherwise **Do not ship**, with the merged findings and any failed or incomplete reviewer task. If any result reports `checkout changed during task`, the verdict is **Do not ship**; rerun the review.