@henryqw/pi-subagent 27.0.0 → 27.1.0

package/dist/schema.d.ts

@@ -121,6 +121,7 @@ export declare const ResumeRequestSchema: Type.TUnion<[Type.TObject<{
     id: Type.TString;
     action: Type.TLiteral<"retry">;
     taskId: Type.TString;
+    instruction: Type.TOptional<Type.TString>;
 }>, Type.TObject<{
     id: Type.TString;
     action: Type.TLiteral<"verify">;
@@ -133,6 +134,7 @@ export declare const ResumeRequestParameters: Type.TObject<{
     id: Type.TString;
     action: Type.TUnion<[Type.TLiteral<"retry">, Type.TLiteral<"verify">, Type.TLiteral<"finalize">]>;
     taskId: Type.TOptional<Type.TString>;
+    instruction: Type.TOptional<Type.TString>;
 }>;
 export type IdOnly = Static<typeof IdOnlySchema>;
 export type CheckCommand = Static<typeof CheckCommandSchema>;
@@ -2389,6 +2391,10 @@ export declare const StatusOutputSchema: Type.TObject<{
             scope: Type.TUnion<[Type.TLiteral<"task">, Type.TLiteral<"final">, Type.TLiteral<"request">]>;
             taskId: Type.TOptional<Type.TString>;
             failure: Type.TOptional<Type.TString>;
+            failedReview: Type.TOptional<Type.TObject<{
+                verdict: Type.TString;
+                verdictTruncated: Type.TBoolean;
+            }>>;
         }>>;
         createdAt: Type.TInteger;
         updatedAt: Type.TInteger;
@@ -2421,6 +2427,7 @@ export declare const StatusOutputSchema: Type.TObject<{
         id: Type.TString;
         action: Type.TLiteral<"retry">;
         taskId: Type.TString;
+        instruction: Type.TOptional<Type.TString>;
     }>, Type.TObject<{
         id: Type.TString;
         action: Type.TLiteral<"verify">;

package/dist/schema.js

@@ -62,7 +62,7 @@ export const ExecuteRequestSchema = Type.Object({
 }, { additionalProperties: false });
 export const IdOnlySchema = Type.Object({ id: IdSchema }, { additionalProperties: false });
 export const ResumeRequestSchema = Type.Union([
-    Type.Object({ id: IdSchema, action: Type.Literal("retry"), taskId: IdSchema }, { additionalProperties: false }),
+    Type.Object({ id: IdSchema, action: Type.Literal("retry"), taskId: IdSchema, instruction: Type.Optional(TextSchema) }, { additionalProperties: false }),
     Type.Object({ id: IdSchema, action: Type.Literal("verify"), taskId: IdSchema }, { additionalProperties: false }),
     Type.Object({ id: IdSchema, action: Type.Literal("finalize") }, { additionalProperties: false }),
 ]);
@@ -75,6 +75,7 @@ export const ResumeRequestParameters = Type.Object({
         ResumeRequestSchema.anyOf[2].properties.action,
     ]),
     taskId: Type.Optional(IdSchema),
+    instruction: ResumeRequestSchema.anyOf[0].properties.instruction,
 }, { additionalProperties: false });
 const AllocationLifecycleFields = {
     generation: Type.Integer({ minimum: 1, maximum: 2 }),
@@ -466,6 +467,7 @@ export const StatusOutputSchema = Type.Object({
             scope: Type.Union([Type.Literal("task"), Type.Literal("final"), Type.Literal("request")]),
             taskId: Type.Optional(IdSchema),
             failure: Type.Optional(Type.String()),
+            failedReview: Type.Optional(Type.Object({ verdict: Type.String(), verdictTruncated: Type.Boolean() })),
         })),
         createdAt: TimestampSchema,
         updatedAt: TimestampSchema,
@@ -635,7 +637,10 @@ export function parseResumeRequest(value) {
     if (!Check(ResumeRequestSchema, value)) {
         throw schemaValidationError("subagent_resume request must match one strict action", Errors(ResumeRequestSchema, value));
     }
-    return value;
+    const request = value;
+    if ("instruction" in request && request.instruction !== undefined)
+        requireExactAllocationText(request.instruction, "Retry instruction");
+    return request;
 }
 export function sameIdentity(left, right) {
     return left.branch === right.branch && left.head === right.head && left.index === right.index && left.tree === right.tree;
@@ -1080,11 +1085,11 @@ export function parseRunState(value) {
             }
             for (let promptIndex = 0; promptIndex < attempt.prompts.length; promptIndex += 1) {
                 const prompt = attempt.prompts[promptIndex];
-                if ((prompt.kind === "followup") !== (prompt.instruction !== undefined)) {
-                    throw new Error(`Follow-up prompt history for ${definition.id} has invalid instruction evidence.`);
+                if (prompt.kind === "followup" ? prompt.instruction === undefined : prompt.kind === "initial" && prompt.instruction !== undefined) {
+                    throw new Error(`Prompt history for ${definition.id} has invalid instruction evidence.`);
                 }
                 if (prompt.instruction !== undefined) {
-                    requireExactAllocationText(prompt.instruction, `Follow-up prompt instruction for ${definition.id}`);
+                    requireExactAllocationText(prompt.instruction, `Prompt instruction for ${definition.id}`);
                 }
                 if (promptIndex === 0)
                     continue;

package/dist/store.d.ts

@@ -48,6 +48,8 @@ export declare class FileRunStore {
         states: RunStateHandle[];
         invalidIds: string[];
     }>;
+    /** Raw text of a state file, for evidence when it does not parse. */
+    readRaw(root: string, id: string): Promise<string>;
     private handle;
 }
 export {};

package/dist/store.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { realpathSync } from "node:fs";
-import { mkdir, open, readdir, realpath } from "node:fs/promises";
+import { lstat, mkdir, open, readdir, realpath } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { extensionConfigDir, readTextFileBounded, writePrivateTextFileAtomically } from "@henryqw/pi-config-store";
 import { check, lock } from "proper-lockfile";
@@ -272,8 +272,13 @@ export class FileRunStore {
         const entries = await this.stateEntries(root);
         const states = [];
         const invalidIds = [];
-        for (const entry of entries.filter((item) => item.isFile())) {
+        for (const entry of entries) {
             const id = entry.name.slice(0, -5);
+            // A symlink, directory, or other non-regular entry is unreadable state, never absent state.
+            if (!entry.isFile()) {
+                invalidIds.push(id);
+                continue;
+            }
             try {
                 states.push(await this.load(root, id));
             }
@@ -283,6 +288,13 @@ export class FileRunStore {
         }
         return { states, invalidIds };
     }
+    /** Raw text of a state file, for evidence when it does not parse. */
+    async readRaw(root, id) {
+        const path = this.statePath(root, id);
+        if (!(await lstat(path)).isFile())
+            throw new Error(`State entry ${id} is not a regular file.`);
+        return await readTextFileBounded(path, STATE_MAX_BYTES);
+    }
     handle(state, path) {
         return new RunStateHandle(state, path, async (contents) => {
             await this.assertSafeDestination(state.root, path);

package/dist/worktree.d.ts

@@ -24,6 +24,9 @@ export type WorktreePayload = {
     commits?: number;
     dirty?: boolean;
 };
+export declare const WORKTREES_DIRNAME = ".worktrees";
+/** Branches `createChildWorktree` creates for workers and integration checkouts, at `<primary>/.worktrees/<branch basename>`. */
+export declare const OWNED_BRANCH_PATTERN: RegExp;
 export declare class WorktreeSetupError extends Error {
     name: string;
     readonly worktree: WorktreeInfo;

package/dist/worktree.js

@@ -3,8 +3,10 @@ import { existsSync, lstatSync } from "node:fs";
 import { appendFile, mkdir, readFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { runGit } from "./git-process.js";
-const WORKTREES_DIRNAME = ".worktrees";
+export const WORKTREES_DIRNAME = ".worktrees";
 const BRANCH_NAMESPACE = "pi-subagent";
+/** Branches `createChildWorktree` creates for workers and integration checkouts, at `<primary>/.worktrees/<branch basename>`. */
+export const OWNED_BRANCH_PATTERN = new RegExp(`^${BRANCH_NAMESPACE}/subagent-[0-9a-f]{24}$`);
 export class WorktreeSetupError extends Error {
     name = "WorktreeSetupError";
     worktree;

package/docs/orchestration.md

@@ -112,7 +112,7 @@ The user's request can authorize the declared local graph, checks, review, and M
 
 `/subagent` opens a native picker for direct recovery and isolated inspection; locally owned active changesets may queue an optional same-worker revision or drain all still-pending instructions into the native editor and submit one replacement. Cancel after draining leaves them withdrawn; claimed instructions are unaffected. Pi's global Option+Up is unchanged. There is no guaranteed post-completion editing window; late follow-ups fail visibly. After readiness, use `subagent_stage revise` with an exact candidate, generation, current `expectedTip`, and instruction when a same-worker correction remains allowed. Material scope growth, missing authorization, user-owned conflicts, or consequential external actions still require a new decision. pi-subagent never pushes, publishes, deploys, or opens a pull request.
 
-`subagent_status` reports ready candidates with `taskId`, `attempt`, and `tip`, plus each generation's number, stage lineage, combined tip, checks, promotion, and retained worktree. Use those exact identities (including branch, HEAD, index, and tree) rather than guessed commits:
+`subagent_status` puts failed review verdicts from every task's latest attempt (also while siblings run), the final gate, and each generation into its model-visible text within one shared 32 KiB budget and counts omitted verdicts; its structured projection carries each verdict up to 32 KiB and sets `verdictTruncated` when it is cut; asynchronous follow-ups keep a short preview and point Main to `subagent_status`. It reports ready candidates with `taskId`, `attempt`, and `tip`, plus each generation's number, stage lineage, combined tip, checks, promotion, and retained worktree. Use those exact identities (including branch, HEAD, index, and tree) rather than guessed commits:
 
 - `subagent_stage`: `{ id, action: "stage" | "resolve" | "reject" | "revise", generation, taskId, attempt, candidate, expectedTip, instruction? }`. `candidate` is the ready candidate's `tip`; `expectedTip` is Main's recorded identity for the first stage or the previous stage's exact tip. `resolve` reconciles a pending/conflicted merge; `reject` and `revise` arbitrate a candidate without changing Main.
 - `subagent_integrate`: `{ id, action: "advance" | "validate" | "correct" | "promote" | "reconcile" | "cleanup", generation, expectedTip }`. Use the generation's exact `combinedTip`. `advance` dispatches ready dependents on that snapshot, `correct` records the single clean committed correction after a definitive failed check/review, `reconcile` inspects an interrupted validation or promotion without replaying an uncertain promotion, and `cleanup` completes proved post-promotion cleanup.
@@ -129,7 +129,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 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.
+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. When a proved finished turn leaves tracked or untracked changes in a valid owned worktree, the runner sends the same worker one commit reminder per attempt, saved as a follow-up prompt record before delivery like any other prompt. It does not use a correction or a dispatch attempt. The runner never commits, stages, stashes, or discards; a commit from the reminder goes through the normal candidate path, and a worktree still dirty after it needs attention. `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. A `retry` that sends a same-worker correction may add an `instruction` (at most 32000 exact characters, no NUL), appended to the correction prompt as Main's instruction after the saved failure and saved in its prompt record before delivery; other actions reject it. `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.
+
+`/subagent prune` reviews every `pi-subagent/subagent-<24 hex>` branch in the repository and its `.worktrees/` checkout. An item is removable only when its tip is an ancestor of Main's HEAD or the local `origin` default-branch ref (no fetch), the checkout is still on its own branch (a detached or switched owned checkout is found by path and blocks), has no tracked or untracked changes, no initialized submodules, and no in-progress Git operation, no non-terminal or unreadable state in any of the repository's checkouts records its name (a non-regular state entry counts as unreadable and may own any name), no productive lease is live, and no Herdr pane works inside the checkout (unavailable Herdr refuses). Removal needs interactive confirmation; checkouts with ignored files need a second confirmation that names each ignored entry in full, and a checkout whose list does not fit is left out; that approval covers each entry with all its contents, and a new or changed top-level ignored entry skips the checkout. Prunable items are listed first, and only items shown in full in both dialogs can be removed; an over-long list ends with an explicit `+N more not shown` line instead of a silent cut. The confirming session's ownership is rechecked immediately before each `git worktree remove` and branch deletion. Each item is re-verified immediately before `git worktree remove`, and its branch is deleted with a compare-and-swap on the reviewed tip. Aborted requests that recorded a removed resource are then reconciled by the guarded abort path, which proves absence; requests it cannot reconcile are reported. State files are never edited directly.
 
 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.
 

package/extensions/isolated.ts

@@ -1,3 +1,4 @@
+import { basename } from "node:path";
 import type { JsonValue } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
@@ -12,6 +13,7 @@ import {
 	type DirectProcessRunner,
 } from "../dist/git-runtime.js";
 import { HerdrHostRuntime } from "../dist/herdr-runtime.js";
+import { inspectPruneCandidates, listHerdrPanes, removePruneCandidates, type PruneGuards, type PruneItem } from "../dist/prune.js";
 import { runProcess as directRunProcess } from "../dist/process.js";
 import { RoleLaunchRuntime, type LaunchRuntimeOptions } from "../dist/launch-runtime.js";
 import { IsolatedRunner, type OperationContext, type RunResponse } from "../dist/runner.js";
@@ -36,10 +38,12 @@ import {
 } from "../dist/schema.js";
 import { FileRunStore } from "../dist/store.js";
 import { workerOutputForMain } from "./result-transport.ts";
-import type { IsolatedInventory } from "./subagent-command.ts";
+import type { IsolatedInventory, PrunePlan } from "./subagent-command.ts";
 
 const LOOKUP_ROOT_TIMEOUT_MS = 5_000;
 const PUBLIC_EVIDENCE_MAX_BYTES = 512;
+/** Tool results return failed review verdicts in full up to this bound; follow-ups keep the short preview. */
+const PUBLIC_REVIEW_VERDICT_MAX_BYTES = 32 * 1024;
 const WORKSPACE_WIDGET_KEY = "pi-subagent-workspaces";
 const WIDGET_FIELD_MAX_CHARS = 32;
 const MAX_WORKSPACE_WIDGET_LINES = 6;
@@ -175,10 +179,25 @@ function updateWorkspaceWidgetSafely(ctx: ExtensionContext, state: RunState, row
 	}
 }
 
-function boundedPublicText(value: string): string {
-	if (Buffer.byteLength(value, "utf8") <= PUBLIC_EVIDENCE_MAX_BYTES) return value;
-	let end = Math.min(value.length, PUBLIC_EVIDENCE_MAX_BYTES);
-	while (end > 0 && Buffer.byteLength(value.slice(0, end), "utf8") > PUBLIC_EVIDENCE_MAX_BYTES) end -= 1;
+/** Join report lines within a follow-up budget, naming how many were omitted. */
+function boundedReport(lines: readonly string[], omitted: string): string {
+	const report: string[] = [];
+	let bytes = 0;
+	let skipped = 0;
+	for (const line of lines.flatMap((entry) => entry.split("\n"))) {
+		const size = Buffer.byteLength(`${line}\n`, "utf8");
+		if (bytes + size > 7_900) { skipped++; continue; }
+		report.push(line);
+		bytes += size;
+	}
+	if (skipped) report.push(`[${skipped} ${omitted}]`);
+	return report.join("\n");
+}
+
+function boundedPublicText(value: string, maxBytes = PUBLIC_EVIDENCE_MAX_BYTES): string {
+	if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
+	let end = Math.min(value.length, maxBytes);
+	while (end > 0 && Buffer.byteLength(value.slice(0, end), "utf8") > maxBytes) end -= 1;
 	return `${value.slice(0, end)}\n[truncated]`;
 }
 
@@ -199,16 +218,18 @@ function publicFailedCheck(evidence: CheckBatchEvidence | undefined) {
 	};
 }
 
-function publicFailedReview(evidence: ReviewEvidence | undefined) {
+function publicFailedReview(evidence: ReviewEvidence | undefined, verdictMaxBytes: number) {
 	if (!evidence || evidence.passed) return undefined;
+	const verdict = boundedPublicText(evidence.verdict, verdictMaxBytes);
 	return {
 		phase: evidence.phase,
-		verdict: boundedPublicText(evidence.verdict),
+		verdict,
+		verdictTruncated: verdict !== evidence.verdict,
 		identityChanged: !sameIdentity(evidence.tip, evidence.identityAfter),
 	};
 }
 
-function publicTaskRecovery(task: RunState["tasks"][number]) {
+function publicTaskRecovery(task: RunState["tasks"][number], verdictMaxBytes: number) {
 	if (task.kind === "text") {
 		const attempt = task.attempts.at(-1);
 		return {
@@ -225,7 +246,7 @@ function publicTaskRecovery(task: RunState["tasks"][number]) {
 
 	const attempt = task.attempts.at(-1);
 	const failedCheck = publicFailedCheck(attempt?.preliminaryChecks);
-	const failedReview = publicFailedReview(attempt?.preliminaryReview);
+	const failedReview = publicFailedReview(attempt?.preliminaryReview, verdictMaxBytes);
 	const cleanup = attempt?.cleanup
 		.filter((step) => step.status !== "completed")
 		.map((step) => ({
@@ -254,14 +275,14 @@ function publicTaskRecovery(task: RunState["tasks"][number]) {
 	};
 }
 
-function publicNeedsAttention(state: RunState, preferredTaskId?: string) {
+function publicNeedsAttention(state: RunState, verdictMaxBytes: number, preferredTaskId?: string) {
 	if (state.status !== "needs_attention") return undefined;
 	const task = state.tasks.find((candidate) => candidate.status === "needs_attention" && candidate.taskId === preferredTaskId)
 		?? state.tasks.find((candidate) => candidate.status === "needs_attention");
-	if (task) return publicTaskRecovery(task);
+	if (task) return publicTaskRecovery(task, verdictMaxBytes);
 	if (state.final.failure || state.final.checks?.passed === false || state.final.review?.passed === false) {
 		const failedCheck = publicFailedCheck(state.final.checks);
-		const failedReview = publicFailedReview(state.final.review);
+		const failedReview = publicFailedReview(state.final.review, verdictMaxBytes);
 		return {
 			scope: "final" as const,
 			...(state.final.failure ? { failure: boundedPublicText(state.final.failure) } : {}),
@@ -275,8 +296,8 @@ function publicNeedsAttention(state: RunState, preferredTaskId?: string) {
 	};
 }
 
-function publicState(state: RunState, preferredTaskId?: string) {
-	const needsAttention = publicNeedsAttention(state, preferredTaskId);
+function publicState(state: RunState, verdictMaxBytes: number, preferredTaskId?: string) {
+	const needsAttention = publicNeedsAttention(state, verdictMaxBytes, preferredTaskId);
 	return {
 		version: state.version,
 		id: state.request.id,
@@ -313,7 +334,7 @@ function publicState(state: RunState, preferredTaskId?: string) {
 				...(combinedTip ? { combinedTip } : {}),
 				...(correction ? { correction } : {}),
 				...(checks ? { checked: checks.passed, failedCheck: publicFailedCheck(checks) } : {}),
-				...(review ? { reviewed: review.passed, failedReview: publicFailedReview(review) } : {}),
+				...(review ? { reviewed: review.passed, failedReview: publicFailedReview(review, verdictMaxBytes) } : {}),
 				...(promotion ? { promotion: promotion.status, ...(promotion.mainAfter ? { mainAfter: promotion.mainAfter } : {}),
 					...(promotion.failure ? { promotionFailure: boundedPublicText(promotion.failure) } : {}) } : {}),
 				...(failure ? { failure: boundedPublicText(failure) } : {}),
@@ -329,6 +350,42 @@ function publicState(state: RunState, preferredTaskId?: string) {
 	};
 }
 
+/** Model-visible failed review verdicts from every task, the final gate, and each generation, within one shared budget.
+ * Pi shows the model `content`, not `structuredContent`; task reviews appear even while sibling tasks still run. */
+function failedReviewText(state: RunState): string {
+	const reviews = [
+		...state.tasks.flatMap((task) => {
+			const review = task.kind === "changeset" ? task.attempts.at(-1)?.preliminaryReview : undefined;
+			return review && !review.passed ? [{ label: `Task ${task.taskId}`, review }] : [];
+		}),
+		...(state.final.review && !state.final.review.passed ? [{ label: "Final", review: state.final.review }] : []),
+		...state.integration.generations.flatMap(({ number, review }) => review && !review.passed ? [{ label: `Integration generation ${number}`, review }] : []),
+	].reduce<{ label: string; review: ReviewEvidence }[]>((merged, entry) => {
+		// Show an identical verdict once, but keep every scope that failed with it.
+		const same = merged.find(({ review }) => review.verdict === entry.review.verdict);
+		if (same) same.label = `${same.label}, ${entry.label}`;
+		else merged.push({ ...entry });
+		return merged;
+	}, []);
+	let budget = PUBLIC_REVIEW_VERDICT_MAX_BYTES;
+	let omitted = 0;
+	const parts: string[] = [];
+	for (const { label, review } of reviews) {
+		if (budget <= 0) { omitted++; continue; }
+		const verdict = boundedPublicText(review.verdict, budget);
+		budget -= Buffer.byteLength(verdict, "utf8");
+		parts.push(`\n\n${label}: failed ${review.phase} review verdict${verdict !== review.verdict ? " (truncated)" : ""}:\n${workerOutputForMain(verdict)}`);
+	}
+	if (omitted) parts.push(`\n\n${omitted} more failed review verdict(s) omitted from this text; structuredContent lists each one.`);
+	return parts.join("");
+}
+
+function hasTruncatedVerdict(state: ReturnType<typeof publicState>): boolean {
+	const attention = state.needsAttention;
+	return Boolean(attention && "failedReview" in attention && attention.failedReview?.verdictTruncated)
+		|| state.integration.generations.some((generation) => generation.failedReview?.verdictTruncated);
+}
+
 function inspectionNotices({ state, main, continuation }: RunResponse): string[] {
 	const lines = [
 		`Isolated request ${state.request.id}: ${state.status}; accepted: ${state.accepted}; final: ${state.final.status}; Main: ${main?.status ?? "not checked"}.`,
@@ -338,7 +395,7 @@ function inspectionNotices({ state, main, continuation }: RunResponse): string[]
 		? `Main inspection unavailable: ${boundedPublicText(main.failure)}; expected: ${JSON.stringify(main.expected)}`
 		: `Main ${main.status}: ${JSON.stringify({ expected: main.expected, actual: main.actual })}`);
 	if (state.integration.refresh) lines.push(`Integration refresh: ${state.integration.refresh.status}${state.integration.refresh.failure ? `; blockage: ${boundedPublicText(state.integration.refresh.failure)}` : ""}.`);
-	const attention = publicNeedsAttention(state);
+	const attention = publicNeedsAttention(state, PUBLIC_EVIDENCE_MAX_BYTES);
 	if (attention) lines.push(`Reported blockage: ${JSON.stringify({ scope: attention.scope, failure: attention.failure, failedCheck: "failedCheck" in attention ? attention.failedCheck : undefined, failedReview: "failedReview" in attention ? attention.failedReview : undefined })}`);
 	if (state.final.failure) lines.push(`Final blockage: ${boundedPublicText(state.final.failure)}`);
 	for (const task of state.tasks) {
@@ -404,7 +461,7 @@ function toolResult(response: RunResponse, ctx: ExtensionContext, rowsByRequest:
 	return {
 		content: [{ type: "text" as const, text }],
 		details: {
-			state: publicState(response.state, preferredTaskId),
+			state: publicState(response.state, PUBLIC_REVIEW_VERDICT_MAX_BYTES, preferredTaskId),
 			...(response.main ? { main: response.main } : {}),
 			...(response.continuation ? { continuation: response.continuation } : {}),
 		},
@@ -415,6 +472,8 @@ export interface IsolatedSurface {
 	execute(request: ExecuteRequest, signal: AbortSignal | undefined, ctx: ExtensionContext): Promise<ReturnType<typeof toolResult>>;
 	inventory(cwd: string, current?: () => boolean): Promise<IsolatedInventory>;
 	recover(cwd: string): Promise<string>;
+	prunePlan(cwd: string): Promise<PrunePlan>;
+	prune(cwd: string, items: readonly PruneItem[], allowIgnored: boolean, current: () => boolean): Promise<string>;
 	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;
@@ -487,6 +546,10 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 	pi.on("model_select", (event, ctx) => { latestCtx = { ...ctx, model: event.model } as ExtensionContext; });
 	pi.on("agent_settled", (_event, ctx) => { latestCtx = ctx; });
 
+	const pruneGuards = (root: string): PruneGuards => ({
+		ownership: async (checkouts) => await getComponents().runner.pruneOwnership(checkouts),
+		panes: async () => await listHerdrPanes(root),
+	});
 	const requireCurrent = (current: () => boolean) => {
 		if (!current() || sessionClosed) throw new Error("Session or branch changed; reopen /subagent.");
 	};
@@ -551,14 +614,17 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 			}
 			const state = response?.state ?? latestState;
 			try {
-				const details = state ? {
-					state: publicState(state, response?.continuation && "taskId" in response.continuation
-						? response.continuation.taskId : undefined),
+				const preview = state ? publicState(state, PUBLIC_EVIDENCE_MAX_BYTES, response?.continuation && "taskId" in response.continuation
+					? response.continuation.taskId : undefined) : undefined;
+				const details = preview ? {
+					state: preview,
 					...(response?.continuation ? { continuation: response.continuation } : {}),
 				} : { id };
 				pi.sendMessage({
 					customType: "pi-subagent-isolated-result",
-					content: text,
+					content: preview && hasTruncatedVerdict(preview)
+						? `${text}\n\nReview verdicts here are previews; run subagent_status for the full verdict.`
+						: text,
 					display: true,
 					details,
 				}, { triggerTurn: true, deliverAs: "followUp" });
@@ -597,7 +663,7 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 					reject(new Error(`Pi Subagent ${id} finished without a durable acknowledgement.`));
 					return;
 				}
-				deliver("terminal", `${response.text}\n\nState: ${JSON.stringify(publicState(response.state))}`, response);
+				deliver("terminal", `${response.text}\n\nState: ${JSON.stringify(publicState(response.state, PUBLIC_EVIDENCE_MAX_BYTES))}`, response);
 			},
 			(error: unknown) => {
 				finish();
@@ -628,15 +694,17 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			latestCtx = ctx;
 			const root = await lookupRoot(ctx.cwd, signal);
-			const result = toolResult(await getComponents().runner.status(params.id, root, signal), ctx, workspaceRowsByRequest);
+			const response = await getComponents().runner.status(params.id, root, signal);
+			const result = toolResult(response, ctx, workspaceRowsByRequest);
+			const content = [{ type: "text" as const, text: `${result.content[0]!.text}${failedReviewText(response.state)}` }];
 			// The projection is plain JSON; its conditional fields are typed optional rather than absent.
-			return { ...result, structuredContent: result.details as JsonValue };
+			return { ...result, content, structuredContent: result.details as JsonValue };
 		},
 	});
 	pi.registerTool({
 		name: "subagent_resume",
 		label: "Subagent resume",
-		description: "Resume one unfinished isolated request without resetting its recorded policy or correction count.",
+		description: "Resume one unfinished isolated request without resetting its recorded policy or correction count. For a retry that sends a same-worker correction, optional instruction (at most 32000 characters) is appended to that prompt as Main's instruction after the saved check or review failure; use it to name the exact fixes, including the review findings the worker must address. Other actions reject instruction.",
 		parameters: ResumeRequestParameters,
 		prepareArguments: parseResumeRequest,
 		exposure: "model-only",
@@ -748,17 +816,26 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 			leaseBusy ? "Wait for the active productive run; use subagent_status to inspect its current state. No work was taken over."
 				: "Main: inspect subagent_status for exact identities and blockers before deciding stage, promote, resume, or guarded release. No worker prompt, merge, promotion, or cleanup was replayed.",
 			];
-			const report: string[] = [];
-			let bytes = 0;
-			let omitted = 0;
-			for (const line of lines.flatMap((entry) => entry.split("\n"))) {
-				const size = Buffer.byteLength(`${line}\n`, "utf8");
-				if (bytes + size > 7_900) { omitted++; continue; }
-				report.push(line);
-				bytes += size;
-			}
-			if (omitted) report.push(`[${omitted} recovery report lines omitted; use subagent_status for exact request evidence.]`);
-			return report.join("\n");
+			return boundedReport(lines, "recovery report lines omitted; use subagent_status for exact request evidence.");
+		},
+		async prunePlan(cwd) {
+			const root = await lookupRoot(cwd);
+			return { root, items: await inspectPruneCandidates(root, cwd, pruneGuards(root)) };
+		},
+		async prune(cwd, items, allowIgnored, current) {
+			requireCurrent(current);
+			const root = await lookupRoot(cwd);
+			const { removals, checkouts } = await removePruneCandidates(root, cwd, items, allowIgnored,
+				{ ...pruneGuards(root), current: () => current() && !sessionClosed });
+			const removed = removals.filter(({ outcome }) => outcome === "removed");
+			const reconciled = removed.length
+				? await getComponents().runner.reconcilePrunedAborts(checkouts, removed.map(({ item }) => basename(item.branch))) : [];
+			const count = (outcome: string) => removals.filter((item) => item.outcome === outcome).length;
+			return boundedReport([
+				`Pi Subagent prune in ${root}: ${removed.length} removed, ${count("skipped")} skipped, ${count("failed")} failed.`,
+				...removals.map(({ outcome, item, reason }) => `${outcome}: ${item.path ?? "(no checkout)"} · ${item.branch} · ${reason}`),
+				...reconciled,
+			], "prune report lines omitted.");
 		},
 		async inspect(root, requestId) {
 			const response = await getComponents().runner.status(requestId, root);

package/extensions/result-transport.ts

@@ -1,4 +1,4 @@
-import { capEphemeralSubagentOutput } from "@henryqw/pi-subagent";
+import { capEphemeralSubagentOutput, formatDuration } from "@henryqw/pi-subagent";
 import type { WorkflowEntry, WorkflowMode } from "./workflow.ts";
 
 const EVIDENCE_PREVIEW_CODE_POINTS = 256;
@@ -22,6 +22,9 @@ export type WorkflowTransportEntry = {
 	role: WorkflowEntry["delegation"]["role"];
 	model?: string;
 	thinkingLevel?: string;
+	/** Measured session tokens; absent when usage was unavailable. */
+	tokens?: number;
+	elapsedMs?: number;
 	status: WorkflowTransportStatus;
 	assistantOutput?: string;
 	failure?: string;
@@ -76,6 +79,21 @@ export function displaySummary(text: string): string {
 	return Array.from(normalized).slice(0, 160).join("");
 }
 
+export function compactTokens(tokens: number): string {
+	return `${tokens < 1_000 ? tokens : `${(tokens / 1_000).toFixed(1).replace(/\.0$/, "")}k`} tok`;
+}
+
+/** Launched workers carry a model; workers that never launched show no usage. */
+function usageFor(entry: WorkflowTransportEntry): string {
+	if (entry.model === undefined) return "";
+	return [
+		entry.model,
+		...(entry.thinkingLevel === undefined ? [] : [`thinking ${entry.thinkingLevel}`]),
+		entry.tokens === undefined ? "tokens unknown" : compactTokens(entry.tokens),
+		...(entry.elapsedMs === undefined ? [] : [formatDuration(entry.elapsedMs)]),
+	].map((part) => ` · ${part}`).join("");
+}
+
 export type WorkflowEntryStatusPresentation = { glyph: string; fallback: string };
 
 export const ENTRY_STATUS_PRESENTATION = {
@@ -120,7 +138,7 @@ export function formatWorkflowResult(mode: WorkflowMode, entries: readonly Workf
 		...positioned.map(({ entry, position }) => {
 			const { glyph, fallback } = ENTRY_STATUS_PRESENTATION[entry.status];
 			const summary = displaySummary(sourceFor(entry) ?? "") || fallback;
-			return `${glyph} [${position}/${ordered.length}] ${entry.name} · ${entry.role} — ${summary}`;
+			return `${glyph} [${position}/${ordered.length}] ${entry.name} · ${entry.role}${usageFor(entry)} — ${summary}`;
 		}),
 		...(evidence.length ? [
 			"Results:",
@@ -146,6 +164,8 @@ export function formatWorkflowResult(mode: WorkflowMode, entries: readonly Workf
 					...(source === undefined ? {} : { summary: displaySummary(source) }),
 					...(entry.model === undefined ? {} : { model: entry.model }),
 					...(entry.thinkingLevel === undefined ? {} : { thinkingLevel: entry.thinkingLevel }),
+					...(entry.tokens === undefined ? {} : { tokens: entry.tokens }),
+					...(entry.elapsedMs === undefined ? {} : { elapsedMs: entry.elapsedMs }),
 				};
 			}),
 		},