@narumitw/pi-subagents 2.1.3 → 3.0.0

package/src/panel-failure.ts

@@ -1,56 +0,0 @@
-import type { SingleResult } from "./runner-types.js";
-
-export const PANEL_FAILURE_KINDS = [
-	"transient-launch",
-	"transient-transport",
-	"invalid-contract",
-	"semantic-stall",
-	"permission-denied",
-	"budget-exhausted",
-	"cancelled",
-	"task-failed",
-] as const;
-
-export type PanelFailureKind = (typeof PANEL_FAILURE_KINDS)[number];
-
-export interface PanelFailure {
-	reviewerId?: string;
-	kind: PanelFailureKind;
-	retryable: boolean;
-	message?: string;
-}
-
-export function classifyPanelFailure(
-	result: Partial<
-		Pick<
-			SingleResult,
-			| "launchFailed"
-			| "resultContractInvalid"
-			| "stopReason"
-			| "timedOut"
-			| "aborted"
-			| "errorMessage"
-			| "stderr"
-			| "termination"
-		>
-	>,
-): Omit<PanelFailure, "reviewerId" | "message"> {
-	if (result.launchFailed) return { kind: "transient-launch", retryable: true };
-	if (result.resultContractInvalid) return { kind: "invalid-contract", retryable: false };
-	if (result.stopReason === "semantic-stall" || result.termination?.reason === "idle_timeout") {
-		return { kind: "semantic-stall", retryable: false };
-	}
-	if (result.aborted || result.stopReason === "aborted")
-		return { kind: "cancelled", retryable: false };
-	if (result.timedOut || result.stopReason === "timeout") {
-		return { kind: "budget-exhausted", retryable: false };
-	}
-	const message = `${result.errorMessage ?? ""}\n${result.stderr ?? ""}`;
-	if (/permission|denied|not allowed|unauthori[sz]ed/iu.test(message)) {
-		return { kind: "permission-denied", retryable: false };
-	}
-	if (/transport|socket|connection reset|temporar|econnreset|eai_again/iu.test(message)) {
-		return { kind: "transient-transport", retryable: true };
-	}
-	return { kind: "task-failed", retryable: false };
-}

package/src/panel-planning.ts

@@ -1,175 +0,0 @@
-import type { AgentConfig } from "./agents/types.js";
-import { DEFAULT_MAX_CONTEXT_BYTES, truncateUtf8 } from "./limits.js";
-import type { PanelPreset } from "./panel-presets.js";
-import { type WorkItemDefinition, WorkItemLedger } from "./work-item-ledger.js";
-
-export type { PanelPreset } from "./panel-presets.js";
-
-export interface PanelReviewerRequest {
-	id: string;
-	agent: string;
-	focus?: string;
-	timeoutMs?: number;
-	idleTimeoutMs?: number;
-	maxTurns?: number;
-	maxToolCalls?: number;
-	thinkingLevel?: string;
-}
-
-export interface PanelSynthesizerRequest {
-	agent: string;
-	timeoutMs?: number;
-	idleTimeoutMs?: number;
-	maxTurns?: number;
-	maxToolCalls?: number;
-	thinkingLevel?: string;
-}
-
-export interface PanelRequestLike {
-	id?: string;
-	preset?: PanelPreset;
-	task: string;
-	context?: string;
-	reviewers: PanelReviewerRequest[];
-	synthesizer: PanelSynthesizerRequest;
-	minValidReviews?: number;
-}
-
-export interface PanelPhaseBudgets {
-	totalMs: number;
-	reviewMs: number;
-	finalizationMs: number;
-	synthesisMs: number;
-	cleanupMs: number;
-	reviewerTimeoutMs: number;
-}
-
-const MIN_PHASE_MS = 1;
-const MAX_ID_BYTES = 256;
-const MAX_FOCUS_BYTES = 8 * 1024;
-
-export function planPanelBudgets(totalMs: number, _reviewerCount: number): PanelPhaseBudgets {
-	const normalized = Math.floor(totalMs);
-	if (!Number.isSafeInteger(normalized) || normalized < 4 * MIN_PHASE_MS) {
-		throw new Error(
-			"Panel total timeout is too small to reserve review, finalization, synthesis, and cleanup phases",
-		);
-	}
-	const cleanupMs = Math.max(MIN_PHASE_MS, Math.floor(normalized * 0.05));
-	const synthesisMs = Math.max(MIN_PHASE_MS, Math.floor(normalized * 0.2));
-	const finalizationMs = Math.max(MIN_PHASE_MS, Math.floor(normalized * 0.1));
-	const reviewMs = normalized - cleanupMs - synthesisMs - finalizationMs;
-	if (reviewMs < MIN_PHASE_MS) {
-		throw new Error("Panel total timeout is too small for the review phase");
-	}
-	return {
-		totalMs: normalized,
-		reviewMs,
-		finalizationMs,
-		synthesisMs,
-		cleanupMs,
-		reviewerTimeoutMs: reviewMs,
-	};
-}
-
-export function createPanelWorkLedger(
-	panelId: string,
-	panel: PanelRequestLike,
-	agents: readonly AgentConfig[],
-): WorkItemLedger {
-	const taskPreview = truncateUtf8(panel.task, 256).text;
-	const reviewerItems: WorkItemDefinition[] = panel.reviewers.map((reviewer) => {
-		const agent = agents.find((candidate) => candidate.name === reviewer.agent);
-		return {
-			id: `review:${reviewer.id}`,
-			objective: `Panel review ${reviewer.id}: ${taskPreview}`,
-			dependencies: [],
-			inputArtifacts: [],
-			inputArtifactVersions: {},
-			requiredCapabilities: ["independent-review"],
-			requiredTools: [],
-			selectedAgentName: reviewer.agent,
-			sideEffectPolicy:
-				agent?.capabilityManifest?.authority?.filesystem === "read" ? "read-only" : "mutating",
-			readPaths: [],
-			writePaths: [],
-			ownershipKeys: [],
-			acceptanceCriteria: ["Return one valid panel-review:v1 evidence artifact"],
-		};
-	});
-	return WorkItemLedger.create({
-		workflowId: panelId,
-		items: [
-			...reviewerItems,
-			{
-				id: "synthesis",
-				objective: "Reconcile valid panel evidence while preserving objections and dissent",
-				dependencies: reviewerItems.map((item) => item.id),
-				dependencyPolicy: "settled",
-				inputArtifacts: [],
-				inputArtifactVersions: {},
-				requiredCapabilities: ["evidence-review"],
-				requiredTools: [],
-				selectedAgentName: panel.synthesizer.agent,
-				sideEffectPolicy: "read-only",
-				readPaths: [],
-				writePaths: [],
-				ownershipKeys: [],
-				acceptanceCriteria: [
-					"Preserve every blocking objection and disagreement with evidence-backed resolution state",
-				],
-				integrationOwner: true,
-			},
-		],
-	});
-}
-
-export function validatePanelRequest(panel: PanelRequestLike, maxReviewers = 64): void {
-	if (
-		panel.id !== undefined &&
-		(!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(panel.id) ||
-			Buffer.byteLength(panel.id, "utf8") > MAX_ID_BYTES)
-	) {
-		throw new Error("Panel id must use 1-256 safe identifier bytes");
-	}
-	if (!panel.task.trim()) throw new Error("Panel task must not be empty");
-	if (Buffer.byteLength(panel.task, "utf8") > DEFAULT_MAX_CONTEXT_BYTES) {
-		throw new Error("Panel task exceeds the bounded context limit");
-	}
-	if (panel.context && Buffer.byteLength(panel.context, "utf8") > DEFAULT_MAX_CONTEXT_BYTES) {
-		throw new Error("Panel shared context exceeds the bounded context limit");
-	}
-	if (panel.reviewers.length < 2) throw new Error("Panel mode requires at least two reviewers");
-	if (panel.reviewers.length > maxReviewers) {
-		throw new Error(
-			`Panel has too many reviewers (${panel.reviewers.length}); configured max is ${maxReviewers}`,
-		);
-	}
-	const ids = panel.reviewers.map((reviewer) => reviewer.id.trim());
-	if (
-		ids.some(
-			(id) =>
-				!id ||
-				Buffer.byteLength(id, "utf8") > MAX_ID_BYTES ||
-				!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(id),
-		)
-	) {
-		throw new Error("Panel reviewer ids must use 1-256 safe identifier bytes");
-	}
-	if (new Set(ids).size !== ids.length) throw new Error("Panel reviewer ids must be unique");
-	if (panel.reviewers.some((reviewer) => !reviewer.agent.trim())) {
-		throw new Error("Every panel reviewer must name an agent");
-	}
-	if (
-		panel.reviewers.some(
-			(reviewer) => reviewer.focus && Buffer.byteLength(reviewer.focus, "utf8") > MAX_FOCUS_BYTES,
-		)
-	) {
-		throw new Error("Panel reviewer focus exceeds the bounded field limit");
-	}
-	if (!panel.synthesizer.agent.trim()) throw new Error("Panel synthesizer must name an agent");
-	const minValid = panel.minValidReviews ?? 2;
-	if (!Number.isInteger(minValid) || minValid < 2 || minValid > panel.reviewers.length) {
-		throw new Error("minValidReviews must be between two and the reviewer count");
-	}
-}

package/src/panel-presets.ts

@@ -1,3 +0,0 @@
-export const PANEL_PRESETS = ["code-review", "research", "security-review", "custom"] as const;
-
-export type PanelPreset = (typeof PANEL_PRESETS)[number];

package/src/panel-prompts.ts

@@ -1,132 +0,0 @@
-import { DEFAULT_MAX_CONTEXT_BYTES, truncateUtf8 } from "./limits.js";
-import {
-	type PanelReview,
-	panelReviewInstruction,
-	panelSynthesisInstruction,
-} from "./panel-contract.js";
-import type { PanelFailure } from "./panel-failure.js";
-import type { PanelPreset } from "./panel-planning.js";
-
-const PRESET_GUIDANCE: Record<PanelPreset, string> = {
-	"code-review":
-		"Review correctness, regressions, baseline security, maintainability, tests, and integration risk.",
-	research:
-		"Assess source quality, evidence traceability, contradictory evidence, uncertainty, and unsupported claims.",
-	"security-review":
-		"Review trust boundaries, authority, injection, data exposure, unsafe side effects, and missing mitigations.",
-	custom: "Apply the shared task and your assigned focus without inventing unstated requirements.",
-};
-
-const PROMPT_SEPARATOR = "\n\n";
-const MAX_REVIEWER_SUFFIX_BYTES = 12 * 1024;
-const REVIEWER_SHARED_BYTES = DEFAULT_MAX_CONTEXT_BYTES - MAX_REVIEWER_SUFFIX_BYTES;
-
-export function buildPanelReviewerPrompt(input: {
-	panelId: string;
-	preset: PanelPreset;
-	task: string;
-	context?: string;
-	reviewerId: string;
-	focus?: string;
-}): string {
-	const shared = buildReviewerSharedBlock(input);
-	const reviewer = [
-		`Reviewer id: ${input.reviewerId}`,
-		input.focus ? `Reviewer focus:\n${input.focus}` : undefined,
-		"Work independently and do not assume another reviewer will catch or resolve a problem.",
-		`Panel review contract:\n${panelReviewInstruction(input.reviewerId)}`,
-	]
-		.filter((part): part is string => Boolean(part))
-		.join(PROMPT_SEPARATOR);
-	return joinWithRequiredSuffix(shared, reviewer);
-}
-
-export function buildPanelSynthesisPrompt(input: {
-	panelId: string;
-	task: string;
-	reviews: readonly PanelReview[];
-	failures: readonly PanelFailure[];
-}): string {
-	const validIds = input.reviews.map((review) => review.reviewerId);
-	const failedIds = input.failures
-		.map((failure) => failure.reviewerId)
-		.filter((id): id is string => Boolean(id));
-	const artifacts = input.reviews.map((review) => ({
-		reviewerId: review.reviewerId,
-		disposition: review.disposition,
-		blocking: review.blocking,
-		findings: review.findings,
-		missingChecks: review.missingChecks,
-		limitations: review.limitations,
-		provenance: review.provenance,
-	}));
-	const requiredSuffix = [
-		"Reconcile evidence without majority voting and without erasing dissent.",
-		`Panel synthesis contract:\n${panelSynthesisInstruction(validIds, failedIds)}`,
-	].join(PROMPT_SEPARATOR);
-	const fixedPrefixParts = [
-		`Panel: ${input.panelId}`,
-		"Shared task:\n",
-		`Panel evidence artifacts:\n${JSON.stringify(artifacts)}`,
-		`Failed or invalid reviewers:\n${JSON.stringify(input.failures)}`,
-	];
-	const taskBudget = Math.max(
-		0,
-		DEFAULT_MAX_CONTEXT_BYTES -
-			byteLength(fixedPrefixParts.join(PROMPT_SEPARATOR)) -
-			byteLength(PROMPT_SEPARATOR) -
-			byteLength(requiredSuffix),
-	);
-	const prefix = [
-		fixedPrefixParts[0],
-		`Shared task:\n${truncateUtf8(input.task, taskBudget).text}`,
-		fixedPrefixParts[2],
-		fixedPrefixParts[3],
-	].join(PROMPT_SEPARATOR);
-	return joinWithRequiredSuffix(prefix, requiredSuffix);
-}
-
-function buildReviewerSharedBlock(input: {
-	panelId: string;
-	preset: PanelPreset;
-	task: string;
-	context?: string;
-}): string {
-	const context = input.context || undefined;
-	const hasContext = context !== undefined;
-	const fixedParts = [
-		`Panel: ${input.panelId}`,
-		`Preset: ${input.preset}`,
-		"Shared task:\n",
-		hasContext ? "Shared context:\n" : undefined,
-		`Preset guidance:\n${PRESET_GUIDANCE[input.preset]}`,
-	].filter((part): part is string => part !== undefined);
-	const contentBudget = Math.max(
-		0,
-		REVIEWER_SHARED_BYTES - byteLength(fixedParts.join(PROMPT_SEPARATOR)),
-	);
-	const taskBudget = hasContext ? Math.floor(contentBudget / 2) : contentBudget;
-	const contextBudget = contentBudget - taskBudget;
-	return [
-		fixedParts[0],
-		fixedParts[1],
-		`Shared task:\n${truncateUtf8(input.task, taskBudget).text}`,
-		hasContext ? `Shared context:\n${truncateUtf8(context, contextBudget).text}` : undefined,
-		fixedParts.at(-1),
-	]
-		.filter((part): part is string => part !== undefined)
-		.join(PROMPT_SEPARATOR);
-}
-
-function joinWithRequiredSuffix(prefix: string, suffix: string): string {
-	const suffixBytes = byteLength(PROMPT_SEPARATOR) + byteLength(suffix);
-	if (suffixBytes > DEFAULT_MAX_CONTEXT_BYTES) {
-		throw new Error("Panel prompt contract exceeds the bounded context limit");
-	}
-	const boundedPrefix = truncateUtf8(prefix, DEFAULT_MAX_CONTEXT_BYTES - suffixBytes).text;
-	return `${boundedPrefix}${PROMPT_SEPARATOR}${suffix}`;
-}
-
-function byteLength(value: string): number {
-	return Buffer.byteLength(value, "utf8");
-}

package/src/panel-reconciliation.ts

@@ -1,57 +0,0 @@
-import type { PanelFinding, PanelReview } from "./panel-contract.js";
-import type { PanelFailure } from "./panel-failure.js";
-
-export interface PanelBlockingObjection {
-	reviewerId: string;
-	finding: PanelFinding;
-}
-
-export type PanelReconciliation =
-	| {
-			kind: "ready-for-synthesis";
-			reviews: PanelReview[];
-			failures: PanelFailure[];
-			blockingObjections: PanelBlockingObjection[];
-			verified: false;
-	  }
-	| {
-			kind: "insufficient-panel";
-			partialReviews: PanelReview[];
-			failures: PanelFailure[];
-			blockingObjections: PanelBlockingObjection[];
-			consensus: false;
-	  };
-
-export function reconcilePanel(input: {
-	reviews: PanelReview[];
-	failures: PanelFailure[];
-	minValidReviews: number;
-}): PanelReconciliation {
-	const reviews = [...input.reviews].sort((left, right) =>
-		left.reviewerId.localeCompare(right.reviewerId),
-	);
-	const failures = [...input.failures].sort((left, right) =>
-		(left.reviewerId ?? "").localeCompare(right.reviewerId ?? ""),
-	);
-	const blockingObjections = reviews.flatMap((review) =>
-		review.blocking
-			? review.findings.map((finding) => ({ reviewerId: review.reviewerId, finding }))
-			: [],
-	);
-	if (reviews.length < input.minValidReviews) {
-		return {
-			kind: "insufficient-panel",
-			partialReviews: reviews,
-			failures,
-			blockingObjections,
-			consensus: false,
-		};
-	}
-	return {
-		kind: "ready-for-synthesis",
-		reviews,
-		failures,
-		blockingObjections,
-		verified: false,
-	};
-}

package/src/panel-render.ts

@@ -1,103 +0,0 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import type { SubagentParams } from "./params.js";
-import { safeBlock, safeLine } from "./render-common.js";
-import type { SubagentDetails } from "./subagent-details.js";
-
-export function renderPanelCall(args: SubagentParams, theme: Theme): Text | undefined {
-	const panel = args.panel;
-	if (!panel) return undefined;
-	const scope = args.agentScope ?? "user";
-	let text =
-		theme.fg("toolTitle", theme.bold("subagent ")) +
-		theme.fg("accent", `panel ${panel.preset ?? "custom"} (${panel.reviewers.length} reviewers)`) +
-		theme.fg("muted", ` [${scope}]`);
-	text += `\n  ${theme.fg("dim", preview(panel.task, 80))}`;
-	for (const reviewer of panel.reviewers.slice(0, 3)) {
-		text += `\n  ${theme.fg("muted", `${safeLine(reviewer.id, "reviewer", 256)}:`)} ${theme.fg("accent", safeLine(reviewer.agent, "agent", 256))}`;
-		if (reviewer.focus) text += theme.fg("dim", ` ${preview(reviewer.focus, 40)}`);
-	}
-	if (panel.reviewers.length > 3) {
-		text += `\n  ${theme.fg("muted", `... +${panel.reviewers.length - 3} more`)}`;
-	}
-	text += `\n  ${theme.fg("muted", "synthesis → ")}${theme.fg("accent", safeLine(panel.synthesizer.agent, "agent", 256))}`;
-	return new Text(text, 0, 0);
-}
-
-export function renderPanelResult(
-	details: SubagentDetails,
-	expanded: boolean,
-	isPartial: boolean,
-	theme: Theme,
-): Text | undefined {
-	const panel = details.panel;
-	if (details.mode !== "panel" || !panel) return undefined;
-	const running = isPartial || panel.state === "running";
-	const status = running ? "running" : panel.state;
-	const color =
-		status === "completed"
-			? "success"
-			: status === "running" || status === "degraded"
-				? "warning"
-				: "error";
-	let text = `${theme.fg(color, status)} ${theme.fg("accent", safeLine(panel.preset, "panel", 128))}`;
-	text += theme.fg(
-		"muted",
-		` · valid ${panel.validReviewCount}/${panel.reviewerIds.length} · failed ${panel.failedReviewCount} · blockers ${panel.blockingObjectionCount} · dissent ${panel.dissentCount}`,
-	);
-	if (panel.synthesis) {
-		text += `\n${theme.fg("toolOutput", safeBlock(panel.synthesis.summary, "", 8 * 1024))}`;
-	} else if (panel.state === "insufficient-panel") {
-		text += `\n${theme.fg("warning", "Synthesis skipped because too few valid reviews remained.")}`;
-	}
-	if (!expanded) return new Text(text, 0, 0);
-
-	text += `\n\n${theme.fg("muted", "Shared task: ")}${theme.fg("dim", safeBlock(panel.sharedTaskPreview, "", 2 * 1024))}`;
-	text += `\n\n${theme.fg("muted", "Reviewers:")}`;
-	for (const reviewerId of panel.reviewerIds) {
-		const artifact = panel.evidence.find((candidate) => candidate.reviewerId === reviewerId);
-		const failure = panel.failures.find((candidate) => candidate.reviewerId === reviewerId);
-		const result = details.results.find(
-			(candidate) => candidate.step === panel.reviewerIds.indexOf(reviewerId) + 1,
-		);
-		const model = result?.actualModel ?? result?.model;
-		text += `\n  ${theme.fg("accent", safeLine(reviewerId, "reviewer", 256))}`;
-		if (model) text += theme.fg("muted", ` · ${safeLine(model, "", 256)}`);
-		if (artifact) {
-			text += theme.fg(
-				"muted",
-				` · ${artifact.review.disposition} · revision ${artifact.revision}`,
-			);
-			for (const finding of artifact.review.findings) {
-				text += `\n    ${theme.fg(finding.severity === "critical" || finding.severity === "high" ? "error" : "warning", `[${finding.severity}]`)} ${safeLine(finding.title, "finding", 512)}`;
-			}
-		} else if (failure) {
-			text += theme.fg("error", ` · ${safeLine(failure.kind, "failed", 128)}`);
-		}
-	}
-	if (panel.synthesis?.disagreements.length) {
-		text += `\n\n${theme.fg("muted", "Disagreements:")}`;
-		for (const disagreement of panel.synthesis.disagreements) {
-			text += `\n  ${safeLine(disagreement.summary, "disagreement", 1024)}`;
-		}
-	}
-	if (panel.synthesis?.objections.length) {
-		text += `\n\n${theme.fg("muted", "Blocking objections:")}`;
-		for (const objection of panel.synthesis.objections) {
-			text += `\n  ${safeLine(`${objection.reviewerId}/${objection.findingId}: ${objection.resolution}`, "objection", 1024)}`;
-		}
-	}
-	const limitations = panel.synthesis?.limitations ?? [];
-	if (limitations.length) {
-		text += `\n\n${theme.fg("muted", "Limitations:")}`;
-		for (const limitation of limitations) text += `\n  ${safeLine(limitation, "", 1024)}`;
-	}
-	text += `\n\n${theme.fg("muted", `Budget: review ${panel.budgets.reviewMs}ms · finalization ${panel.budgets.finalizationMs}ms · synthesis ${panel.budgets.synthesisMs}ms · cleanup ${panel.budgets.cleanupMs}ms`)}`;
-	text += `\n${theme.fg("muted", `Cleanup: ${panel.cleanupComplete ? "complete" : "pending"}`)}`;
-	return new Text(text, 0, 0);
-}
-
-function preview(value: unknown, maxLength: number): string {
-	const text = safeLine(value, "", 2 * 1024);
-	return text.length > maxLength ? `${text.slice(0, maxLength)}...` : text;
-}

package/src/parallel-limit-ui.ts

@@ -1,113 +0,0 @@
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { MAX_BLOCKING_PARALLEL_CONCURRENCY, MAX_CONFIGURABLE_PARALLEL_TASKS } from "./limits.js";
-import {
-	inspectBlockingParallelLimitSettings,
-	updateBlockingMaxParallelTasksSetting,
-} from "./settings.js";
-
-export interface BlockingParallelLimitRuntime {
-	getMaxParallelTasks(): number;
-	setMaxParallelTasks(value: number): void;
-}
-
-export function blockingParallelLimitScreen(runtime: BlockingParallelLimitRuntime) {
-	const limit = inspectBlockingParallelLimitSettings();
-	return {
-		kind: "input" as const,
-		title: "Blocking Worker Limit",
-		lines: [
-			"This applies only to requests that make Pi wait for delegated work.",
-			`Current: ${runtime.getMaxParallelTasks()} subagents per blocking request`,
-			`Allowed: 1-${MAX_CONFIGURABLE_PARALLEL_TASKS}`,
-			`Pi still starts at most ${MAX_BLOCKING_PARALLEL_CONCURRENCY} of them at once.`,
-			safeTerminalText(limit.path),
-		],
-		placeholder: "Enter a whole number",
-		action: "set-parallel-limit" as const,
-		hint: "back" as const,
-	};
-}
-
-export function applyBlockingParallelLimitSetting(
-	value: string | undefined,
-	ctx: ExtensionCommandContext,
-	runtime: BlockingParallelLimitRuntime,
-) {
-	const normalized = value?.trim() ?? "";
-	if (!/^\d+$/u.test(normalized)) {
-		notifyValidationError(ctx);
-		return { kind: "rejected" as const };
-	}
-	const next = Number(normalized);
-	if (!Number.isSafeInteger(next) || next < 1 || next > MAX_CONFIGURABLE_PARALLEL_TASKS) {
-		notifyValidationError(ctx);
-		return { kind: "rejected" as const };
-	}
-	const configured = inspectBlockingParallelLimitSettings();
-	if (configured.error) {
-		ctx.ui.notify(
-			`Subagent settings cannot be edited: ${safeTerminalText(configured.error)}`,
-			"error",
-		);
-		return { kind: "rejected" as const };
-	}
-	const previousRuntime = runtime.getMaxParallelTasks();
-	const runtimeChanged = next !== previousRuntime;
-	const settingsChanged = next !== configured.value;
-	if (!runtimeChanged && !settingsChanged) return { kind: "back" as const };
-
-	if (runtimeChanged) {
-		try {
-			runtime.setMaxParallelTasks(next);
-		} catch (error) {
-			ctx.ui.notify(
-				`Parallel-worker limit was not applied; user settings are unchanged: ${formatError(error)}`,
-				"error",
-			);
-			return { kind: "rejected" as const };
-		}
-	}
-	if (settingsChanged) {
-		try {
-			updateBlockingMaxParallelTasksSetting(next);
-		} catch (saveError) {
-			if (runtimeChanged) {
-				try {
-					runtime.setMaxParallelTasks(previousRuntime);
-				} catch (rollbackError) {
-					ctx.ui.notify(
-						`Subagent settings were not saved, and the runtime rollback failed: ${formatError(new AggregateError([saveError, rollbackError]))}`,
-						"error",
-					);
-					return { kind: "rejected" as const };
-				}
-			}
-			ctx.ui.notify(
-				"Subagent settings were not saved; the previous runtime limit was restored.",
-				"error",
-			);
-			return { kind: "rejected" as const };
-		}
-	}
-	ctx.ui.notify(
-		`${settingsChanged ? "Saved and " : ""}applied: maximum ${next} subagents per blocking request.`,
-		"info",
-	);
-	return { kind: "back" as const };
-}
-
-function notifyValidationError(ctx: ExtensionCommandContext): void {
-	ctx.ui.notify(
-		`Blocking worker limit must be a whole number from 1 to ${MAX_CONFIGURABLE_PARALLEL_TASKS}.`,
-		"warning",
-	);
-}
-
-function safeTerminalText(value: string): string {
-	// biome-ignore lint/suspicious/noControlCharactersInRegex: Escape untrusted terminal controls.
-	return value.replace(/[\u0000-\u001f\u007f-\u009f]/gu, "?");
-}
-
-function formatError(error: unknown): string {
-	return safeTerminalText(error instanceof Error ? error.message : String(error));
-}