@henryqw/pi-subagent 18.0.1 → 22.0.0

package/extensions/result-transport.ts

@@ -1,10 +1,4 @@
-import type { Usage } from "@earendil-works/pi-ai";
-import {
-	addUsage,
-	capEphemeralSubagentOutput,
-	type EphemeralSubagentResult,
-	type WorktreePayload,
-} from "@henryqw/pi-subagent";
+import { capEphemeralSubagentOutput } from "@henryqw/pi-subagent";
 import type { WorkflowEntry, WorkflowMode } from "./workflow.ts";
 
 const EVIDENCE_PREVIEW_CODE_POINTS = 256;
@@ -18,17 +12,11 @@ type TransportEntryBase = {
 	role: WorkflowEntry["delegation"]["role"];
 	model?: string;
 	thinkingLevel?: string;
-	worktreePayload?: WorktreePayload;
-	usage?: Usage;
 };
 
 export type WorkflowTransportEntry =
 	| TransportEntryBase & { status: "pending" | "skipped"; assistantOutput?: never; failure?: never }
-	| TransportEntryBase & {
-		status: "running" | "succeeded";
-		assistantOutput: EphemeralSubagentResult["output"];
-		failure?: never;
-	}
+	| TransportEntryBase & { status: "running" | "succeeded"; assistantOutput: string; failure?: never }
 	| TransportEntryBase & { status: "failed" | "rejected"; assistantOutput?: never; failure: string };
 
 export type WorkflowTransportEntryDetails = {
@@ -40,7 +28,6 @@ export type WorkflowTransportEntryDetails = {
 	summary?: string;
 	model?: string;
 	thinkingLevel?: string;
-	worktree?: WorktreePayload;
 };
 
 export type WorkflowTransportDetails = {
@@ -52,17 +39,14 @@ export type BackgroundWorkflowTransportDetails = WorkflowTransportDetails & {
 	taskId: string;
 	outcome: "completed" | "failed" | "aborted";
 	recovery?: true;
-	usage?: Usage;
 };
 
 export type WorkflowTransport = {
 	text: string;
 	details: WorkflowTransportDetails;
-	usage?: Usage;
 	failed: boolean;
 };
 
-type TransportKind = "result" | "update" | "background" | "abort";
 type Evidence = { heading: string; preview: string; remainder: string };
 
 function compareEntries(left: WorkflowTransportEntry, right: WorkflowTransportEntry): number {
@@ -80,25 +64,18 @@ function workflowTitle(mode: WorkflowMode): string {
 	return "Delegation chain";
 }
 
-function statusCounts(entries: readonly WorkflowTransportEntry[], kind: TransportKind): string[] {
+function statusCounts(entries: readonly WorkflowTransportEntry[]): string[] {
 	const count = (statuses: WorkflowTransportStatus[]) => entries.filter(({ status }) => statuses.includes(status)).length;
-	const labels = kind === "update"
-		? [["running"], ["succeeded"], ["failed", "rejected"], ["pending"], ["skipped"]] as const
-		: [["failed", "rejected"], ["succeeded"], ["skipped"]] as const;
-	const words = kind === "update" ? ["running", "completed", "failed", "queued", "skipped"] : ["failed", "completed", "skipped"];
-	return labels.flatMap((statuses, index) => {
+	return ([
+		[["failed", "rejected"], "failed"],
+		[["succeeded"], "completed"],
+		[["skipped"], "skipped"],
+	] as const).flatMap(([statuses, word]) => {
 		const total = count([...statuses]);
-		return total ? [`${total} ${words[index]}`] : [];
+		return total ? [`${total} ${word}`] : [];
 	});
 }
 
-function heading(mode: WorkflowMode, entries: readonly WorkflowTransportEntry[], kind: TransportKind, failed: boolean): string {
-	const title = kind === "background" ? `Background ${workflowTitle(mode).toLowerCase()}` : workflowTitle(mode);
-	if (kind === "update") return [title, ...statusCounts(entries, kind)].join(" · ");
-	const outcome = kind === "abort" ? "stopped" : failed ? "failed" : "completed";
-	return [`${title} ${outcome}`, ...statusCounts(entries, kind)].join(" · ");
-}
-
 export function displaySummary(text: string): string {
 	const line = text.split(/\r?\n/).find((candidate) => candidate.trim()) ?? "";
 	const normalized = line.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").trim().replace(/^[-*+]\s+/, "").split(/\s+/).join(" ");
@@ -136,37 +113,24 @@ function evidenceFor(entry: WorkflowTransportEntry, position: number, total: num
 	};
 }
 
-function formatWorkflowTransport(
-	mode: WorkflowMode,
-	entries: readonly WorkflowTransportEntry[],
-	kind: TransportKind,
-): WorkflowTransport {
+export function formatWorkflowResult(mode: WorkflowMode, entries: readonly WorkflowTransportEntry[]): WorkflowTransport {
 	const ordered = [...entries].sort(compareEntries);
-	if (kind !== "update" && ordered.some(({ status }) => status === "pending" || status === "running")) {
+	if (ordered.some(({ status }) => status === "pending" || status === "running")) {
 		throw new TypeError("Final workflow transport requires terminal entry states.");
 	}
 	const failed = ordered.some(({ status }) => status === "failed" || status === "rejected");
 	const positioned = ordered.map((entry, index) => ({ entry, position: index + 1 }));
-	const recoveries = positioned.flatMap(({ entry, position }) => {
-		const worktree = entry.worktreePayload;
-		return worktree === undefined || worktree.outcome === "pruned" ? [] : [{ entry, position, worktree }];
-	});
-	const evidence = kind === "update" ? [] : positioned.flatMap(({ entry, position }) => {
+	const evidence = positioned.flatMap(({ entry, position }) => {
 		const value = evidenceFor(entry, position, ordered.length);
 		return value ? [value] : [];
 	});
 	const lines = [
-		heading(mode, ordered, kind, failed),
+		[`${workflowTitle(mode)} ${failed ? "failed" : "completed"}`, ...statusCounts(ordered)].join(" · "),
 		...positioned.map(({ entry, position }) => {
 			const { glyph, fallback } = presentWorkflowEntryStatus(entry.status);
 			const summary = displaySummary(sourceFor(entry) ?? "") || fallback;
 			return `${glyph} [${position}/${ordered.length}] ${entry.name} · ${entry.role} — ${summary}`;
 		}),
-		...(recoveries.length ? [
-			"Recovery:",
-			...recoveries.map(({ entry, position, worktree }) =>
-				`- [${position}/${ordered.length}] ${entry.name} · worktree ${JSON.stringify(worktree.path)} · branch ${JSON.stringify(worktree.branch)}`),
-		] : []),
 		...(evidence.length ? [
 			"Results:",
 			...evidence.flatMap(({ heading, preview }) => [heading, preview]),
@@ -176,8 +140,6 @@ function formatWorkflowTransport(
 			] : []),
 		] : []),
 	];
-	let usage: Usage | undefined;
-	for (const entry of ordered) if (entry.usage) usage = addUsage(usage, entry.usage);
 	return {
 		text: capEphemeralSubagentOutput(lines.join("\n")),
 		details: {
@@ -193,61 +155,9 @@ function formatWorkflowTransport(
 					...(source === undefined ? {} : { summary: displaySummary(source) }),
 					...(entry.model === undefined ? {} : { model: entry.model }),
 					...(entry.thinkingLevel === undefined ? {} : { thinkingLevel: entry.thinkingLevel }),
-					...(entry.worktreePayload === undefined ? {} : { worktree: { ...entry.worktreePayload } }),
 				};
 			}),
 		},
-		...(usage === undefined ? {} : { usage }),
 		failed,
 	};
 }
-
-export function formatWorkflowResult(
-	mode: WorkflowMode,
-	entries: readonly WorkflowTransportEntry[],
-): WorkflowTransport {
-	return formatWorkflowTransport(mode, entries, "result");
-}
-
-export function formatWorkflowUpdate(
-	mode: WorkflowMode,
-	entries: readonly WorkflowTransportEntry[],
-): WorkflowTransport {
-	return formatWorkflowTransport(mode, entries, "update");
-}
-
-export function formatBackgroundWorkflowResult(
-	mode: WorkflowMode,
-	entries: readonly WorkflowTransportEntry[],
-): WorkflowTransport {
-	return formatWorkflowTransport(mode, entries, "background");
-}
-
-export class WorkflowFailureError extends Error {
-	override name = "WorkflowFailureError";
-	readonly details: WorkflowTransportDetails;
-	readonly usage?: Usage;
-	readonly failed = true;
-
-	constructor(mode: WorkflowMode, entries: readonly WorkflowTransportEntry[]) {
-		const transport = formatWorkflowResult(mode, entries);
-		if (!transport.failed) throw new TypeError("WorkflowFailureError requires a failed or rejected entry.");
-		super(transport.text);
-		this.details = transport.details;
-		this.usage = transport.usage;
-	}
-}
-
-export class WorkflowAbortedError extends Error {
-	override name = "AbortError";
-	readonly details: WorkflowTransportDetails;
-	readonly usage?: Usage;
-	readonly failed = true;
-
-	constructor(mode: WorkflowMode, entries: readonly WorkflowTransportEntry[], cause: unknown) {
-		const transport = formatWorkflowTransport(mode, entries, "abort");
-		super(transport.text, { cause });
-		this.details = transport.details;
-		this.usage = transport.usage;
-	}
-}

package/extensions/role-tools.ts

@@ -4,7 +4,7 @@ import { isToolCallEventType, type ExtensionAPI } from "@earendil-works/pi-codin
 import {
 	CHILD_EXCLUDED_TOOL_NAMES,
 	EXECUTION_BUDGET_ENV,
-	PI_ORCHESTRATOR_PROCESS_LEASE,
+	PI_SUBAGENT_PROCESS_LEASE,
 	ROLE_TOOL_POLICY_FLAG,
 	type EphemeralSubagentExecutionBudget,
 } from "@henryqw/pi-subagent";
@@ -12,7 +12,7 @@ import {
 const childExcludedTools: ReadonlySet<string> = new Set(CHILD_EXCLUDED_TOOL_NAMES);
 const WARNING_RATIO = 0.8;
 const WARNING_MESSAGE_TYPE = "pi-subagent-execution-budget";
-const PROCESS_LEASE_ERROR = `${PI_ORCHESTRATOR_PROCESS_LEASE} must be a nonempty NUL/newline-free absolute path naming a regular non-symlink file owned by the current uid with mode 0600.`;
+const PROCESS_LEASE_ERROR = `${PI_SUBAGENT_PROCESS_LEASE} must be a nonempty NUL/newline-free absolute path naming a regular non-symlink file owned by the current uid with mode 0600.`;
 const FINAL_HANDOFF_MESSAGE = {
 	customType: "pi-subagent-final-handoff",
 	content: "**Final handoff required.** Tools are disabled. If your assigned task or Role requires exact output, reply only with that output instead; it takes precedence over this decision packet. Otherwise, reply only with this decision packet:\n\n**Status:** completed | blocked | incomplete\n**Outcome:** one sentence describing what is now true\n**Evidence:** up to three concrete findings, changes, or checks; include an attempted approach only when it prevents Main from repeating failed work\n**Blocker:** none or the exact blocker\n**Risk:** none or one material risk\n**Suggested next:** none or one concrete action",
@@ -64,14 +64,14 @@ function executionBudget(value: string | undefined): EphemeralSubagentExecutionB
 	if (Object.keys(budget).some((key) => !["maxTurns", "maxMs", "startedAt", "maxTokens"].includes(key))
 		|| !("maxTurns" in budget) || !("maxMs" in budget) || !("startedAt" in budget)
 		|| !Number.isSafeInteger(budget.maxTurns) || (budget.maxTurns as number) < 1
-		|| typeof budget.maxMs !== "number" || !Number.isFinite(budget.maxMs) || budget.maxMs <= 0
+		|| (budget.maxMs !== null && (typeof budget.maxMs !== "number" || !Number.isFinite(budget.maxMs) || budget.maxMs <= 0))
 		|| !Number.isSafeInteger(budget.startedAt) || (budget.startedAt as number) < 0
 		|| !maxTokensValid) {
 		throw new Error(`${EXECUTION_BUDGET_ENV} must be a JSON execution budget.`);
 	}
 	return {
 		maxTurns: budget.maxTurns as number,
-		maxMs: budget.maxMs,
+		maxMs: budget.maxMs as number | null,
 		startedAt: budget.startedAt as number,
 		...(budget.maxTokens === undefined ? {} : { maxTokens: budget.maxTokens as number }),
 	};
@@ -94,11 +94,11 @@ function messageTokens(message: unknown): number | undefined {
 }
 
 function joinBudgetParts(parts: string[]): string {
-	return `${parts.slice(0, -1).join(", ")}${parts.length > 2 ? "," : ""} and ${parts.at(-1)}`;
+	return parts.length === 1 ? parts[0]! : `${parts.slice(0, -1).join(", ")}${parts.length > 2 ? "," : ""} and ${parts.at(-1)}`;
 }
 
 export default function roleTools(pi: ExtensionAPI): void {
-	const processLease = process.env[PI_ORCHESTRATOR_PROCESS_LEASE];
+	const processLease = process.env[PI_SUBAGENT_PROCESS_LEASE];
 	if (processLease !== undefined) validateProcessLease(processLease);
 	pi.registerFlag(ROLE_TOOL_POLICY_FLAG, {
 		description: "Internal Pi Subagent Role tool policy",
@@ -133,7 +133,7 @@ export default function roleTools(pi: ExtensionAPI): void {
 while : 2>/dev/null <&"$__pi_subagent_process_lease_fd" || : 2>/dev/null >&"$__pi_subagent_process_lease_fd"; do
 	__pi_subagent_process_lease_fd=$((__pi_subagent_process_lease_fd + 1))
 done
-eval 'exec '"$__pi_subagent_process_lease_fd"'>>"$${PI_ORCHESTRATOR_PROCESS_LEASE}"' || exit $?
+eval 'exec '"$__pi_subagent_process_lease_fd"'>>"$${PI_SUBAGENT_PROCESS_LEASE}"' || exit $?
 unset __pi_subagent_process_lease_fd
 ${event.input.command}`;
 		});
@@ -166,18 +166,18 @@ ${event.input.command}`;
 		const elapsedMs = Math.max(0, Date.now() - budget.startedAt);
 		const turnWarningDue = !turnWarningSent && completedTurns >= warningTurn;
 		const tokenWarningDue = warningTokens !== undefined && !tokenWarningSent && completedTokens >= warningTokens;
-		const runtimeWarningDue = !runtimeWarningSent && elapsedMs >= budget.maxMs * WARNING_RATIO;
+		const runtimeWarningDue = budget.maxMs !== null && !runtimeWarningSent && elapsedMs >= budget.maxMs * WARNING_RATIO;
 		if (!turnWarningDue && !tokenWarningDue && !runtimeWarningDue) return;
 		if (turnWarningDue) turnWarningSent = true;
 		if (tokenWarningDue) tokenWarningSent = true;
 		if (runtimeWarningDue) runtimeWarningSent = true;
 		const remainingTurns = Math.max(0, budget.maxTurns - completedTurns);
-		const remainingMinutes = Math.max(0, Math.ceil((budget.maxMs - elapsedMs) / 60_000));
-		const maxMinutes = budget.maxMs / 60_000;
+		const runtimeRemaining = budget.maxMs === null ? []
+			: [`approximately ${Math.max(0, Math.ceil((budget.maxMs - elapsedMs) / 60_000))} of ${budget.maxMs / 60_000} minutes`];
 		const parts = [
 			`${remainingTurns} of ${budget.maxTurns} turns`,
 			...(budget.maxTokens === undefined ? [] : [`${Math.max(0, budget.maxTokens - completedTokens)} of ${budget.maxTokens} tokens`]),
-			`approximately ${remainingMinutes} of ${maxMinutes} minutes`,
+			...runtimeRemaining,
 		];
 		pi.sendMessage({
 			customType: WARNING_MESSAGE_TYPE,

package/extensions/subagent-command.ts

@@ -0,0 +1,167 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/** Read-only branch records; the adapter groups all tabs of a direct workflow. */
+export interface DirectTask {
+	id: string;
+	name: string;
+	status: string;
+	tabs: readonly { entryId: string; name: string; tabId: string; paneId: string; sessionFile: string }[];
+}
+
+export interface IsolatedTask {
+	id: string;
+	name: string;
+	status: string;
+	kind: string;
+}
+export interface IsolatedRequest {
+	id: string;
+	name: string;
+	status: string;
+	tasks: readonly IsolatedTask[];
+}
+export interface IsolatedInventory {
+	root: string;
+	requests: readonly IsolatedRequest[];
+	invalidIds: readonly string[];
+}
+
+/** Mutation adapters MUST check current() synchronously alongside their live ownership
+ * validation and queue operation. They must not await between those operations. */
+export interface SubagentCommandAdapter {
+	direct(ctx: ExtensionContext): readonly DirectTask[];
+	isolated(cwd: string): Promise<IsolatedInventory>;
+	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;
+	drain(root: string, requestId: string, taskId: string, current: () => boolean): readonly string[];
+	/** Session start/shutdown epoch; prevents same-session reload after an awaited dialog. */
+	epoch(): number;
+}
+
+const clean = (text: string, max = 110, multiline = false): string => [...text.replace(multiline ? /[\u0000-\u0009\u000b-\u001f\u007f-\u009f]/g : /[\u0000-\u001f\u007f-\u009f]/g, " ")].slice(0, max).join("");
+const errorText = (error: unknown): string => clean(error instanceof Error ? error.message : String(error), 500);
+const completed = (status: string) => ["completed", "success", "failed", "failure", "aborted", "integrated"].includes(status);
+const priority = (status: string) => /attention|blocked|retained|failed/i.test(status) ? 0 : completed(status) ? 2 : 1;
+
+type Pick<T> = { label: string; value: T };
+async function choose<T>(ctx: ExtensionContext, title: string, items: readonly Pick<T>[]): Promise<T | undefined> {
+	// Numeric suffixes are UI-only. Never parse display text into an identity.
+	const labels = items.map((item, index) => `${clean(item.label, 145)} [${index + 1}]`);
+	const selected = await ctx.ui.select(title, labels);
+	const index = labels.indexOf(selected ?? "");
+	return index < 0 ? undefined : items[index]!.value;
+}
+
+export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentCommandAdapter): void {
+	pi.registerCommand("subagent", {
+		description: "Inspect direct and isolated work; send or edit pending isolated instructions",
+		handler: async (args, ctx) => {
+			if (args.trim()) throw new Error("Usage: /subagent (no arguments)");
+			if (!ctx.hasUI) throw new Error("/subagent requires interactive UI (TUI or RPC); use the subagent agent tools in non-interactive mode.");
+			const manager = ctx.sessionManager;
+			const session = manager.getSessionId();
+			const file = manager.getSessionFile();
+			const branch = manager.getBranch().map((entry) => entry.id);
+			// A branch may grow during a dialog, but navigating to a descendant that
+			// already existed when it opened must not retarget its pending actions.
+			const existing = new Set(manager.getEntries().map((entry) => entry.id));
+			const epoch = adapter.epoch();
+			const current = () => {
+				if (adapter.epoch() !== epoch || manager.getSessionId() !== session || manager.getSessionFile() !== file) return false;
+				const now = manager.getBranch();
+				return now.length >= branch.length && branch.every((id, index) => now[index]?.id === id)
+					&& now.slice(branch.length).every((entry) => !existing.has(entry.id));
+			};
+			const valid = () => {
+				if (current()) return true;
+				ctx.ui.notify("Session or branch changed; reopen /subagent in the current context.", "warning");
+				return false;
+			};
+			let history = false;
+			for (;;) {
+				if (!valid()) return;
+				// Direct recovery is independent of Git and isolated config/inventory failures.
+				const direct = adapter.direct(ctx);
+				let inventory: IsolatedInventory | undefined;
+				let unavailable: string | undefined;
+				try { inventory = await adapter.isolated(ctx.cwd); }
+				catch (error) { unavailable = errorText(error); }
+				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" };
+				const selections: Pick<Selection>[] = [
+					...direct.filter((task) => history || !completed(task.status)).map((task) => ({ label: `Direct · ${task.name} · ${task.status} · ${task.id}`, value: { kind: "direct" as const, task } })),
+					...(inventory?.requests ?? []).filter((request) => history || !completed(request.status) || /retained/i.test(request.status)).map((request) => ({ label: `Isolated · ${request.name} · ${request.status} · ${request.id}`, value: { kind: "isolated" as const, request, root: inventory!.root } })),
+					{ label: "Refresh", value: { kind: "refresh" as const } },
+					{ label: history ? "Active work" : "Completed / history (including retained work)", value: { kind: "history" as const } },
+					{ label: "Close", value: { kind: "close" as const } },
+				];
+				const taskChoices = selections.splice(0, selections.length - 3);
+				const rank = ({ value }: Pick<Selection>) => value.kind === "direct" ? priority(value.task.status)
+					: value.kind === "isolated" ? priority(value.request.status) : 3;
+				taskChoices.sort((a, b) => rank(a) - rank(b));
+				selections.unshift(...taskChoices);
+				if (!unavailable && !direct.length && !inventory?.requests.length && !inventory?.invalidIds.length) ctx.ui.notify("No direct tasks recorded on this session branch or isolated requests in this checkout. Ask Main to start delegation.", "info");
+				const selected = await choose(ctx, history ? "Subagent · completed / history" : "Subagent · current work", selections);
+				if (!valid() || !selected || selected.kind === "close") return;
+				if (selected.kind === "refresh") continue;
+				if (selected.kind === "history") { history = !history; continue; }
+				if (selected.kind === "direct") {
+					ctx.ui.notify(`Direct workflow ${clean(selected.task.name)} (${JSON.stringify(selected.task.id)}) · ${clean(selected.task.status)}`, "info");
+					for (const tab of selected.task.tabs) {
+						ctx.ui.notify(`Task ${JSON.stringify(tab.entryId)} · agent ${JSON.stringify(tab.name)} · tab ${JSON.stringify(tab.tabId)} · pane ${JSON.stringify(tab.paneId)} · session ${JSON.stringify(tab.sessionFile)}`, "info");
+					}
+					continue;
+				}
+				const { root, request } = selected;
+				for (;;) {
+					if (!valid()) return;
+					type Action = "inspect" | "send" | "edit" | "back";
+					const eligible = request.tasks.filter((task) => task.kind === "changeset" && adapter.canFollowup(root, request.id, task.id));
+					const actions: Pick<Action>[] = [
+						{ label: "Inspect status and recovery", value: "inspect" },
+						...(eligible.length ? [{ label: "Send follow-up instructions", value: "send" as const }, { label: "Edit queued instructions (withdraw ALL pending; Cancel leaves withdrawn)", value: "edit" as const }] : []),
+						{ label: "Back / refresh", value: "back" },
+					];
+					const action = await choose(ctx, `Isolated · ${clean(request.name)} · ${request.id}`, actions);
+					if (!valid() || !action) return;
+					if (action === "back") break;
+					if (action === "inspect") {
+						try {
+							const notices = await adapter.inspect(root, request.id);
+							if (valid()) for (const notice of notices) ctx.ui.notify(notice, "info");
+						}
+						catch (error) { if (valid()) ctx.ui.notify(`Inspection failed: ${errorText(error)}`, "error"); }
+						continue;
+					}
+					const live = request.tasks.filter((task) => task.kind === "changeset" && adapter.canFollowup(root, request.id, task.id));
+					if (!live.length) { ctx.ui.notify("No locally active unsealed changeset remains. Refresh to see current status.", "warning"); continue; }
+					const task = await choose(ctx, `Select task for ${action === "edit" ? "withdrawal and edit" : "follow-up"}`, live.map((item) => ({ label: `${item.name} · ${item.status} · ${item.id}`, value: item })));
+					if (!valid() || !task) return;
+					let prefill = "";
+					if (action === "edit") {
+						try {
+							const withdrawn = adapter.drain(root, request.id, task.id, current);
+							if (!withdrawn.length) { ctx.ui.notify("No pending instructions remain for this task; already-claimed instructions cannot be recalled.", "info"); continue; }
+							prefill = withdrawn.join("\n\n");
+						} catch (error) { if (valid()) ctx.ui.notify(`Cannot withdraw: ${errorText(error)}`, "error"); continue; }
+					}
+					for (;;) {
+						const text = await ctx.ui.editor(action === "edit" ? "Edit withdrawn instructions · submit ONE replacement; Cancel leaves originals withdrawn" : "Send follow-up instructions", prefill);
+						if (!valid() || text === undefined) return;
+						try {
+							ctx.ui.notify(adapter.enqueue(root, request.id, task.id, text, current), "info");
+							break;
+						} catch (error) {
+							if (!valid()) return;
+							ctx.ui.notify(`Not queued: ${errorText(error)}. Submitted text will reopen in this editor for editing or copying; Cancel does not queue it.`, "error");
+							prefill = text;
+						}
+					}
+				}
+			}
+		},
+	});
+}