@narumitw/pi-subagents 2.1.4 → 3.0.0

package/src/timeout-checkpoint.ts

@@ -1,305 +0,0 @@
-import { redactPrivateText } from "./context.js";
-import { DEFAULT_MAX_CONTEXT_BYTES, truncateUtf8 } from "./limits.js";
-
-export const TIMEOUT_CHECKPOINT_VERSION = "pi-subagents:checkpoint:v1" as const;
-export const TURN_TERMINATION_VERSION = "pi-subagents:termination:v1" as const;
-
-const DEFAULT_CHECKPOINT_BYTES = 16 * 1024;
-const MAX_ITEMS = 10;
-const MAX_ITEM_BYTES = 2 * 1024;
-const MAX_PENDING_TOOLS = 50;
-const MUTATING_TOOLS = new Set(["bash", "edit", "write"]);
-const FILE_TOOLS = new Set(["edit", "write"]);
-
-export type TurnTerminationReason =
-	| "work_timeout"
-	| "idle_timeout"
-	| "turn_limit"
-	| "tool_call_limit"
-	| "orchestration_timeout";
-
-export interface CompletedToolEvidence {
-	toolName: string;
-	output: string;
-	isError: boolean;
-}
-
-export interface TimeoutCheckpoint {
-	version: typeof TIMEOUT_CHECKPOINT_VERSION;
-	task: string;
-	partialOutput?: string;
-	assistantNotes: string[];
-	completedTools: CompletedToolEvidence[];
-	changedFiles: string[];
-	sideEffectsMayHaveOccurred: boolean;
-	truncated: boolean;
-}
-
-export interface TurnFinalizationReport {
-	attempted: boolean;
-	status: "completed" | "failed" | "timed_out" | "skipped";
-	durationMs: number;
-	error?: string;
-}
-
-export interface TurnTerminationReport {
-	version: typeof TURN_TERMINATION_VERSION;
-	reason: TurnTerminationReason;
-	limit: number;
-	checkpoint: TimeoutCheckpoint;
-	finalization: TurnFinalizationReport;
-}
-
-export interface TimeoutProgressJournalOptions {
-	maxBytes?: number;
-}
-
-interface PendingToolCall {
-	name: string;
-	path?: string;
-}
-
-export class TimeoutProgressJournal {
-	private readonly assistantNotes: string[] = [];
-	private readonly completedTools: CompletedToolEvidence[] = [];
-	private readonly changedFiles = new Set<string>();
-	private readonly pendingTools = new Map<string, PendingToolCall>();
-	private readonly maxBytes: number;
-	private sideEffectsMayHaveOccurred = false;
-	private truncated = false;
-
-	constructor(options: TimeoutProgressJournalOptions = {}) {
-		const requested = options.maxBytes ?? DEFAULT_CHECKPOINT_BYTES;
-		if (
-			!Number.isSafeInteger(requested) ||
-			requested < 512 ||
-			requested > DEFAULT_MAX_CONTEXT_BYTES
-		) {
-			throw new Error(
-				`Timeout checkpoint limit must be an integer between 512 and ${DEFAULT_MAX_CONTEXT_BYTES}`,
-			);
-		}
-		this.maxBytes = requested;
-	}
-
-	recordAssistantText(text: string): void {
-		const bounded = boundedPrivate(text, MAX_ITEM_BYTES);
-		if (!bounded) return;
-		this.assistantNotes.push(bounded);
-		this.trimItems(this.assistantNotes);
-	}
-
-	recordToolCall(id: string, name: string, args: Record<string, unknown> = {}): void {
-		const toolName = boundedPrivate(name, 256);
-		if (!toolName) return;
-		const path = toolPath(args);
-		this.pendingTools.set(id, { name: toolName, path });
-		while (this.pendingTools.size > MAX_PENDING_TOOLS) {
-			const oldest = this.pendingTools.keys().next().value;
-			if (typeof oldest !== "string") break;
-			this.pendingTools.delete(oldest);
-			this.truncated = true;
-		}
-		if (MUTATING_TOOLS.has(toolName)) this.sideEffectsMayHaveOccurred = true;
-	}
-
-	recordToolResult(
-		id: string,
-		name: string,
-		result: { content?: unknown; isError?: unknown },
-	): void {
-		const pending = this.pendingTools.get(id);
-		this.pendingTools.delete(id);
-		const toolName = boundedPrivate(pending?.name || name, 256);
-		if (!toolName) return;
-		if (pending?.path && FILE_TOOLS.has(toolName)) this.changedFiles.add(pending.path);
-		const output = boundedPrivate(textContent(result.content), MAX_ITEM_BYTES);
-		this.completedTools.push({
-			toolName,
-			output: output || "(no text output)",
-			isError: result.isError === true,
-		});
-		this.trimItems(this.completedTools);
-	}
-
-	checkpoint(task: string, partialOutput?: string): TimeoutCheckpoint {
-		const checkpoint: TimeoutCheckpoint = {
-			version: TIMEOUT_CHECKPOINT_VERSION,
-			task: boundedPrivate(task, 4 * 1024),
-			partialOutput: partialOutput ? boundedPrivate(partialOutput, 4 * 1024) : undefined,
-			assistantNotes: [...this.assistantNotes],
-			completedTools: this.completedTools.map((item) => ({ ...item })),
-			changedFiles: [...this.changedFiles].slice(-MAX_ITEMS),
-			sideEffectsMayHaveOccurred: this.sideEffectsMayHaveOccurred,
-			truncated: this.truncated || this.changedFiles.size > MAX_ITEMS,
-		};
-		return fitCheckpoint(checkpoint, this.maxBytes);
-	}
-
-	private trimItems(items: unknown[]): void {
-		if (items.length <= MAX_ITEMS) return;
-		items.splice(0, items.length - MAX_ITEMS);
-		this.truncated = true;
-	}
-}
-
-export function formatTurnTerminationMessage(
-	reason: TurnTerminationReason,
-	limit: number,
-	prefix = "Subagent",
-): string {
-	switch (reason) {
-		case "work_timeout":
-			return `${prefix} timed out after ${limit}ms`;
-		case "orchestration_timeout":
-			return `${prefix} orchestration deadline expired after ${limit}ms`;
-		case "idle_timeout":
-			return `${prefix} made no completed progress for ${limit}ms`;
-		case "turn_limit":
-			return `${prefix} reached the ${limit}-turn limit before producing a final answer`;
-		case "tool_call_limit":
-			return `${prefix} exceeded the ${limit}-tool-call limit`;
-	}
-}
-
-export function copyTurnTerminationReport(report: TurnTerminationReport): TurnTerminationReport {
-	return {
-		...report,
-		checkpoint: {
-			...report.checkpoint,
-			assistantNotes: [...report.checkpoint.assistantNotes],
-			completedTools: report.checkpoint.completedTools.map((item) => ({ ...item })),
-			changedFiles: [...report.checkpoint.changedFiles],
-		},
-		finalization: { ...report.finalization },
-	};
-}
-
-export function formatTimeoutCheckpoint(checkpoint: TimeoutCheckpoint): string {
-	const sections = [
-		checkpoint.partialOutput ? `Partial output:\n${checkpoint.partialOutput}` : undefined,
-		checkpoint.assistantNotes.length > 0
-			? `Assistant checkpoints:\n${checkpoint.assistantNotes.map((note) => `- ${note}`).join("\n")}`
-			: undefined,
-		checkpoint.completedTools.length > 0
-			? `Completed tool evidence:\n${checkpoint.completedTools
-					.map((item) => `- ${item.toolName}${item.isError ? " (error)" : ""}: ${item.output}`)
-					.join("\n")}`
-			: undefined,
-		checkpoint.changedFiles.length > 0
-			? `Changed files: ${checkpoint.changedFiles.join(", ")}`
-			: undefined,
-		checkpoint.sideEffectsMayHaveOccurred
-			? "Side effects may have occurred before termination."
-			: undefined,
-		checkpoint.truncated ? "Checkpoint evidence was truncated." : undefined,
-	].filter((value): value is string => Boolean(value));
-	return truncateUtf8(
-		sections.join("\n\n") || "No completed evidence was captured.",
-		DEFAULT_MAX_CONTEXT_BYTES,
-	).text;
-}
-
-export function journalMessages(
-	journal: TimeoutProgressJournal,
-	messages: readonly unknown[],
-): void {
-	for (const message of messages) {
-		if (!message || typeof message !== "object" || Array.isArray(message)) continue;
-		const value = message as Record<string, unknown>;
-		if (value.role === "assistant" && Array.isArray(value.content)) {
-			for (const part of value.content) {
-				if (!part || typeof part !== "object" || Array.isArray(part)) continue;
-				const item = part as Record<string, unknown>;
-				if (item.type === "text" && typeof item.text === "string") {
-					journal.recordAssistantText(item.text);
-				} else if (
-					item.type === "toolCall" &&
-					typeof item.id === "string" &&
-					typeof item.name === "string"
-				) {
-					journal.recordToolCall(
-						item.id,
-						item.name,
-						isRecord(item.arguments) ? item.arguments : {},
-					);
-				}
-			}
-		} else if (value.role === "toolResult") {
-			journal.recordToolResult(
-				typeof value.toolCallId === "string" ? value.toolCallId : "",
-				typeof value.toolName === "string" ? value.toolName : "tool",
-				{ content: value.content, isError: value.isError },
-			);
-		}
-	}
-}
-
-function fitCheckpoint(checkpoint: TimeoutCheckpoint, maxBytes: number): TimeoutCheckpoint {
-	const copy: TimeoutCheckpoint = {
-		...checkpoint,
-		assistantNotes: [...checkpoint.assistantNotes],
-		completedTools: checkpoint.completedTools.map((item) => ({ ...item })),
-		changedFiles: [...checkpoint.changedFiles],
-	};
-	while (serializedBytes(copy) > maxBytes) {
-		copy.truncated = true;
-		if (copy.assistantNotes.length > 0) copy.assistantNotes.shift();
-		else if (copy.completedTools.length > 0) copy.completedTools.shift();
-		else if (copy.changedFiles.length > 0) copy.changedFiles.shift();
-		else if (copy.partialOutput) {
-			copy.partialOutput =
-				shrinkCheckpointText(copy.partialOutput, Math.floor(maxBytes / 4), 128) || undefined;
-		} else if (copy.task) {
-			copy.task = shrinkCheckpointText(copy.task, Math.floor(maxBytes / 8), 64);
-		} else break;
-	}
-	return copy;
-}
-
-function shrinkCheckpointText(
-	value: string,
-	preferredMaxBytes: number,
-	minimumBytes: number,
-): string {
-	const currentBytes = Buffer.byteLength(value, "utf8");
-	if (currentBytes <= minimumBytes) return "";
-	const nextMaxBytes = Math.min(
-		currentBytes - 1,
-		preferredMaxBytes,
-		Math.max(minimumBytes, Math.floor(currentBytes / 2)),
-	);
-	return truncateUtf8(value, nextMaxBytes).text;
-}
-
-function serializedBytes(value: unknown): number {
-	return Buffer.byteLength(JSON.stringify(value), "utf8");
-}
-
-function boundedPrivate(value: string, maxBytes: number): string {
-	return truncateUtf8(redactPrivateText(value).trim(), maxBytes).text;
-}
-
-function textContent(value: unknown): string {
-	if (typeof value === "string") return value;
-	if (!Array.isArray(value)) return "";
-	return value
-		.flatMap((part) => {
-			if (!part || typeof part !== "object" || Array.isArray(part)) return [];
-			const item = part as Record<string, unknown>;
-			return item.type === "text" && typeof item.text === "string" ? [item.text] : [];
-		})
-		.join("\n");
-}
-
-function toolPath(args: Record<string, unknown>): string | undefined {
-	for (const key of ["path", "file_path"]) {
-		const value = args[key];
-		if (typeof value === "string" && value.trim()) return boundedPrivate(value, 1024);
-	}
-	return undefined;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}

package/src/timeout-finalization.ts

@@ -1,75 +0,0 @@
-import { redactPrivateText } from "./context.js";
-import { DEFAULT_MAX_CONTEXT_BYTES, truncateUtf8 } from "./limits.js";
-import { appendResultInstruction, type SubagentResultFormat } from "./result-contract.js";
-import type { RecentActivityItem } from "./runner-types.js";
-import {
-	formatTimeoutCheckpoint,
-	type TimeoutCheckpoint,
-	type TurnTerminationReason,
-} from "./timeout-checkpoint.js";
-
-export const DEFAULT_TIMEOUT_FINALIZATION_MS = 45_000;
-
-export interface TimeoutFinalizationEvidence {
-	task: string;
-	partialOutput?: string;
-	recentActivity?: readonly RecentActivityItem[];
-	checkpoint?: TimeoutCheckpoint;
-	terminationReason?: TurnTerminationReason;
-	resultFormat?: SubagentResultFormat;
-}
-
-export function resolveTimeoutFinalizationMs(workTimeoutMs: number, override?: number): number {
-	const requested = override ?? Math.min(workTimeoutMs, DEFAULT_TIMEOUT_FINALIZATION_MS);
-	if (!Number.isFinite(requested) || requested < 1) {
-		throw new Error("Timeout finalization deadline must be a positive finite number");
-	}
-	return Math.min(Math.floor(requested), DEFAULT_TIMEOUT_FINALIZATION_MS);
-}
-
-export function buildTimeoutFinalizationPrompt(
-	evidence: TimeoutFinalizationEvidence,
-	maxBytes = DEFAULT_MAX_CONTEXT_BYTES,
-): string {
-	const activity = (evidence.recentActivity ?? [])
-		.slice(-10)
-		.map((item) =>
-			item.type === "text"
-				? `- Assistant note: ${redactPrivateText(item.text)}`
-				: `- Tool activity: ${redactPrivateText(item.name)}`,
-		)
-		.join("\n");
-	const prompt = [
-		terminationHeading(evidence.terminationReason),
-		"Do not continue investigating, call tools, modify files, or retry the original task.",
-		"Return a concise summary of only verified findings and completed evidence already available.",
-		"Explicitly label unfinished or unverified areas.",
-		`Original task:\n${redactPrivateText(evidence.task)}`,
-		evidence.partialOutput
-			? `Partial assistant output:\n${redactPrivateText(evidence.partialOutput)}`
-			: "Partial assistant output: (none)",
-		evidence.checkpoint
-			? `Deterministic progress checkpoint:\n${formatTimeoutCheckpoint(evidence.checkpoint)}`
-			: undefined,
-		activity ? `Recent bounded activity:\n${activity}` : "Recent bounded activity: (none)",
-	]
-		.filter((value): value is string => Boolean(value))
-		.join("\n\n");
-	return truncateUtf8(appendResultInstruction(prompt, evidence.resultFormat, maxBytes), maxBytes)
-		.text;
-}
-
-function terminationHeading(reason: TurnTerminationReason | undefined): string {
-	switch (reason) {
-		case "idle_timeout":
-			return "The idle deadline expired and the active work was aborted.";
-		case "turn_limit":
-			return "The assistant-turn budget was exhausted and the active work was aborted.";
-		case "tool_call_limit":
-			return "The tool-call budget was exhausted and the active work was aborted.";
-		case "orchestration_timeout":
-			return "The orchestration deadline expired and the active work was aborted.";
-		default:
-			return "Work deadline expired and the active work was aborted.";
-	}
-}

package/src/tool-schema-compatibility.ts

@@ -1,73 +0,0 @@
-import { type TObject, type TObjectOptions, type TProperties, type TSchema, Type } from "typebox";
-
-const LLAMA_CPP_MAX_REPETITION_THRESHOLD = 2_000;
-
-/**
- * Remove large nested string repetitions that llama.cpp cannot compile into GBNF.
- *
- * Runtime normalization and validation continue to bound these inputs.
- * See https://github.com/ggml-org/llama.cpp/issues/25746.
- */
-export function grammarSafeToolObject<Properties extends TProperties>(
-	properties: Properties,
-	options?: TObjectOptions,
-): TObject<Properties> {
-	return makeGrammarSafeToolSchema(Type.Object(properties, options));
-}
-
-function makeGrammarSafeToolSchema<Schema extends TSchema>(schema: Schema): Schema {
-	return cloneSchema(schema, 0) as Schema;
-}
-
-function cloneSchema(schema: unknown, depth: number): unknown {
-	if (!isRecord(schema)) return schema;
-	const clone = cloneWithDescriptors(schema);
-	if (
-		depth > 1 &&
-		clone.type === "string" &&
-		typeof clone.maxLength === "number" &&
-		clone.maxLength >= LLAMA_CPP_MAX_REPETITION_THRESHOLD
-	) {
-		delete clone.maxLength;
-	}
-	if (isRecord(clone.properties)) {
-		clone.properties = mapSchemas(clone.properties, depth + 1);
-	}
-	if (clone.items !== undefined) {
-		clone.items = Array.isArray(clone.items)
-			? clone.items.map((item) => cloneSchema(item, depth + 1))
-			: cloneSchema(clone.items, depth + 1);
-	}
-	if (Array.isArray(clone.prefixItems)) {
-		clone.prefixItems = clone.prefixItems.map((item) => cloneSchema(item, depth + 1));
-	}
-	for (const keyword of ["allOf", "anyOf", "oneOf"] as const) {
-		if (Array.isArray(clone[keyword])) {
-			clone[keyword] = clone[keyword].map((item) => cloneSchema(item, depth));
-		}
-	}
-	if (isRecord(clone.patternProperties)) {
-		clone.patternProperties = mapSchemas(clone.patternProperties, depth + 1);
-	}
-	if (isRecord(clone.additionalProperties)) {
-		clone.additionalProperties = cloneSchema(clone.additionalProperties, depth + 1);
-	}
-	return clone;
-}
-
-function mapSchemas(schemas: Record<string, unknown>, depth: number): Record<string, unknown> {
-	return Object.fromEntries(
-		Object.entries(schemas).map(([name, schema]) => [name, cloneSchema(schema, depth)]),
-	);
-}
-
-function cloneWithDescriptors(value: Record<string, unknown>): Record<string, unknown> {
-	return Object.defineProperties(
-		Object.create(Object.getPrototypeOf(value)),
-		Object.getOwnPropertyDescriptors(value),
-	) as Record<string, unknown>;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/transport-types.ts

@@ -1,74 +0,0 @@
-import type { SubagentThinkingLevel } from "./agents/types.js";
-
-export const PI_SUBAGENTS_RPC_PROTOCOL = "pi-subagents:v1" as const;
-
-export type EffectiveSubagentTransportKind = "subprocess" | "in-process" | "rpc";
-
-export type TransportProgressPhase =
-	| "queued"
-	| "starting"
-	| "ready"
-	| "accepted"
-	| "running"
-	| "finalizing"
-	| "retrying"
-	| "compacting"
-	| "settled"
-	| "failed"
-	| "interrupted";
-
-export interface TransportUsage {
-	input: number;
-	output: number;
-	cacheRead: number;
-	cacheWrite: number;
-	totalTokens: number;
-	cost: number;
-	turns: number;
-}
-
-export interface TransportTiming {
-	queuedAt?: number;
-	startedAt?: number;
-	transportStartedAt?: number;
-	readyAt?: number;
-	promptAcceptedAt?: number;
-	firstActivityAt?: number;
-	settledAt?: number;
-	completionDeliveredAt?: number;
-}
-
-export interface TransportTelemetry {
-	transport?: EffectiveSubagentTransportKind;
-	selectionReason?: string;
-	protocol?: typeof PI_SUBAGENTS_RPC_PROTOCOL;
-	phase: TransportProgressPhase;
-	queuePosition?: number;
-	updatedAt: number;
-	timing: TransportTiming;
-	provider?: string;
-	model?: string;
-	thinkingLevel?: SubagentThinkingLevel;
-	usage?: TransportUsage;
-	budgetSource?: {
-		timeout: "runtime" | "explicit";
-		idleTimeout: "runtime" | "explicit";
-		turnLimit: "runtime" | "explicit";
-		toolCallLimit: "runtime" | "explicit";
-	};
-	failurePhase?: TransportProgressPhase;
-}
-
-export type TransportProgressCallback = (progress: TransportTelemetry) => void;
-
-export function emptyTransportUsage(): TransportUsage {
-	return {
-		input: 0,
-		output: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		totalTokens: 0,
-		cost: 0,
-		turns: 0,
-	};
-}

package/src/transport-ui.ts

@@ -1,135 +0,0 @@
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import type { SubagentTransportKind } from "./agents/types.js";
-import { safeTerminalLine as safeTerminalText } from "./safe-text.js";
-import { inspectStatefulTransportSettings, updateStatefulTransportSetting } from "./settings.js";
-import type { StatefulSubagentRuntimeStatus } from "./stateful.js";
-
-const TRANSPORT_OPTIONS: Array<{
-	value: SubagentTransportKind;
-	label: string;
-	description: string;
-}> = [
-	{
-		value: "subprocess",
-		label: "Fresh process",
-		description:
-			"Start a separate Pi process for every turn. Most compatible, but slower for follow-ups.",
-	},
-	{
-		value: "in-process",
-		label: "Inside Pi",
-		description:
-			"Run built-in tools inside Pi for faster follow-ups. Shares Pi's memory and crash boundary.",
-	},
-	{
-		value: "rpc",
-		label: "Persistent process (RPC)",
-		description:
-			"Keep one separate Pi process per background subagent so follow-ups preserve history.",
-	},
-	{
-		value: "auto",
-		label: "Automatic · Recommended",
-		description: "Let Pi choose a compatible method for each subagent and its tools.",
-	},
-];
-
-export interface TransportUiRuntime {
-	getRuntimeStatus(): StatefulSubagentRuntimeStatus;
-}
-
-export function transportSettingsScreen(runtime: TransportUiRuntime) {
-	const configured = inspectStatefulTransportSettings();
-	const current = runtime.getRuntimeStatus();
-	return {
-		kind: "actions" as const,
-		title: configured.error
-			? "Background Agent Transport · Read only"
-			: "Background Agent Transport",
-		lines: [
-			"Advanced: choose how Pi hosts background subagents.",
-			`Current session: ${transportLabel(current.transport)}`,
-			`Configured after reload: ${transportLabel(configured.value)} (${configured.source})`,
-			"Separate processes do not restrict filesystem or network access.",
-			"Persistent process (RPC) supports built-in Pi tools and does not load child extensions.",
-			...(configured.error
-				? [
-						`Settings cannot be edited: ${safeTerminalText(configured.error)}`,
-						`Repair ${safeTerminalText(configured.path)} and retry.`,
-					]
-				: []),
-		],
-		items: [
-			...(configured.error
-				? []
-				: TRANSPORT_OPTIONS.map((option) => ({
-						id: option.value,
-						label: option.label,
-						description: option.description,
-						action: "set-transport" as const,
-					}))),
-			{ id: "back", label: "Back", action: "back" as const },
-		],
-		hint: "back" as const,
-	};
-}
-
-export async function applyTransportSetting(
-	value: string,
-	ctx: ExtensionCommandContext,
-	runtime: TransportUiRuntime,
-	signal: AbortSignal,
-	isCurrent: () => boolean,
-) {
-	if (!isTransport(value)) return { kind: "rejected" as const };
-	const before = inspectStatefulTransportSettings();
-	if (before.error) return { kind: "rejected" as const };
-	if (value === before.value) return { kind: "stay" as const };
-	const status = runtime.getRuntimeStatus();
-	if (status.retainedAgents > 0) {
-		ctx.ui.notify(
-			`Cannot change transport while ${status.retainedAgents} subagent${status.retainedAgents === 1 ? " is" : "s are"} saved for follow-up. Clear Current subagents first.`,
-			"warning",
-		);
-		return { kind: "rejected" as const };
-	}
-	const option = TRANSPORT_OPTIONS.find((candidate) => candidate.value === value);
-	const confirmed = await ctx.ui.confirm(
-		`Use ${transportLabel(value)} after reload?`,
-		`${option?.description ?? ""}\n\nThis saves the setting but does not reload Pi automatically.`,
-		{ signal },
-	);
-	if (signal.aborted || !isCurrent()) return { kind: "close" as const };
-	if (!confirmed) return { kind: "rejected" as const };
-	const after = inspectStatefulTransportSettings();
-	if (after.error || after.value !== before.value || after.source !== before.source) {
-		ctx.ui.notify("Transport settings changed while confirming; review again.", "warning");
-		return { kind: "rejected" as const };
-	}
-	if (runtime.getRuntimeStatus().retainedAgents > 0) {
-		ctx.ui.notify(
-			"New subagents were saved for follow-up while confirming. Clear them before changing transport.",
-			"warning",
-		);
-		return { kind: "rejected" as const };
-	}
-	try {
-		updateStatefulTransportSetting(value);
-		ctx.ui.notify(`Saved ${transportLabel(value)}. Run /reload when ready.`, "info");
-		return { kind: "stay" as const };
-	} catch (error) {
-		ctx.ui.notify(
-			`Transport was not saved; the previous setting remains: ${safeTerminalText(error instanceof Error ? error.message : String(error))}`,
-			"error",
-		);
-		return { kind: "rejected" as const };
-	}
-}
-
-export function transportLabel(value: SubagentTransportKind): string {
-	return TRANSPORT_OPTIONS.find((option) => option.value === value)?.label ?? value;
-}
-
-function isTransport(value: string): value is SubagentTransportKind {
-	return ["subprocess", "in-process", "rpc", "auto"].includes(value);
-}