@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/src/intercom/supervisor-ui.ts

@@ -0,0 +1,244 @@
+import type { EntryRenderOptions, MessageRenderOptions, Theme } from "@selesai/code";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component } from "@earendil-works/pi-tui";
+import { safeTerminalText } from "../shared/display-text.ts";
+
+export const SUPERVISOR_REQUEST_MESSAGE_TYPE = "subagent_supervisor_request";
+export const SUPERVISOR_REPLY_ENTRY_TYPE = "subagent_supervisor_reply";
+
+export type SupervisorReason = "need_decision" | "interview_request" | "progress_update";
+
+export interface SupervisorRequestMessageDetails {
+	id?: string;
+	requestId?: string;
+	reason?: SupervisorReason;
+	expectsReply?: boolean;
+	runId?: string;
+	agent?: string;
+	childIndex?: number;
+	childTarget?: string;
+	interview?: unknown;
+	requestBody?: string;
+	replyHint?: string;
+}
+
+export interface SupervisorReplyEntryData {
+	requestId: string;
+	reason?: SupervisorReason;
+	runId: string;
+	agent: string;
+	childIndex: number;
+	childTarget?: string;
+	message: string;
+	createdAt: number;
+}
+
+interface SupervisorMessageLike {
+	content: unknown;
+	details?: unknown;
+}
+
+interface SupervisorEntryLike {
+	data?: unknown;
+}
+
+const MAX_FIELD_CHARS = 512;
+const MAX_BODY_CHARS = 8_000;
+const MAX_INTERVIEW_CHARS = 4_000;
+const MAX_RENDER_LINES = 36;
+const TRUNCATION_MARKER = "[truncated]";
+
+export function supervisorReplyHint(requestId: string): string {
+	return `subagent_supervisor({ action: "reply", replyTo: "${requestId}", message: "..." })`;
+}
+
+function boundedText(value: string, maxChars: number): string {
+	const safe = safeTerminalText(value);
+	if (safe.length <= maxChars) return safe;
+	const prefixLength = Math.max(0, maxChars - TRUNCATION_MARKER.length - 1);
+	let prefix = "";
+	for (const character of safe) {
+		if (prefix.length + character.length > prefixLength) break;
+		prefix += character;
+	}
+	return `${prefix} ${TRUNCATION_MARKER}`;
+}
+
+function displayText(value: string, maxChars: number, expanded: boolean): string {
+	return expanded ? safeTerminalText(value) : boundedText(value, maxChars);
+}
+
+function boundedField(value: unknown, fallback = "unknown"): string {
+	return boundedText(typeof value === "string" ? value : value === undefined ? fallback : String(value), MAX_FIELD_CHARS);
+}
+
+function contentText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((part) => {
+			if (!part || typeof part !== "object") return "";
+			const text = (part as { text?: unknown }).text;
+			return typeof text === "string" ? text : "";
+		})
+		.filter(Boolean)
+		.join("\n");
+}
+
+function interviewText(interview: unknown, expanded: boolean): string {
+	let serialized: string;
+	try {
+		serialized = JSON.stringify(interview, null, 2) ?? String(interview);
+	} catch {
+		serialized = "[unavailable]";
+	}
+	return displayText(serialized, MAX_INTERVIEW_CHARS, expanded);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function isSupervisorReason(value: unknown): value is SupervisorReason {
+	return value === "need_decision" || value === "interview_request" || value === "progress_update";
+}
+
+function optionalString(value: unknown): boolean {
+	return value === undefined || typeof value === "string";
+}
+
+function requestDetails(value: unknown): SupervisorRequestMessageDetails | undefined {
+	if (!isRecord(value)) return undefined;
+	if (!optionalString(value.id) || !optionalString(value.requestId) || !optionalString(value.replyHint) || !optionalString(value.requestBody) || !optionalString(value.runId) || !optionalString(value.agent) || !optionalString(value.childTarget)) return undefined;
+	if (value.reason !== undefined && !isSupervisorReason(value.reason)) return undefined;
+	if (value.expectsReply !== undefined && typeof value.expectsReply !== "boolean") return undefined;
+	if (value.childIndex !== undefined && (typeof value.childIndex !== "number" || !Number.isFinite(value.childIndex))) return undefined;
+	return value;
+}
+
+function replyData(value: unknown): SupervisorReplyEntryData | undefined {
+	if (!isRecord(value)) return undefined;
+	if (typeof value.requestId !== "string" || typeof value.runId !== "string" || typeof value.agent !== "string" || typeof value.message !== "string") return undefined;
+	if (value.reason !== undefined && !isSupervisorReason(value.reason)) return undefined;
+	if (value.childTarget !== undefined && typeof value.childTarget !== "string") return undefined;
+	if (typeof value.childIndex !== "number" || !Number.isFinite(value.childIndex) || typeof value.createdAt !== "number" || !Number.isFinite(value.createdAt)) return undefined;
+	return {
+		requestId: value.requestId,
+		...(value.reason === undefined ? {} : { reason: value.reason }),
+		runId: value.runId,
+		agent: value.agent,
+		childIndex: value.childIndex,
+		...(value.childTarget === undefined ? {} : { childTarget: value.childTarget }),
+		message: value.message,
+		createdAt: value.createdAt,
+	};
+}
+
+function withRequestId(details: SupervisorRequestMessageDetails): string {
+	return boundedField(details.requestId ?? details.id);
+}
+
+function requestHeading(reason: SupervisorReason | undefined): string {
+	if (reason === "interview_request") return "⚠ Supervisor interview request";
+	if (reason === "progress_update") return "ℹ Supervisor progress update";
+	return "⚠ Supervisor decision request";
+}
+
+function requestLines(message: SupervisorMessageLike, details: SupervisorRequestMessageDetails, expanded: boolean): string[] {
+	const requestId = withRequestId(details);
+	const lines = [
+		`Reason: ${boundedField(details.reason)}`,
+		`Run: ${boundedField(details.runId)}`,
+		`Agent: ${boundedField(details.agent)}`,
+		`Child index: ${boundedField(details.childIndex)}`,
+	];
+	if (details.childTarget) lines.push(`Child target: ${boundedField(details.childTarget)}`);
+	lines.push(`Request ID: ${requestId}`);
+	if (details.expectsReply) lines.push(`Reply with: ${displayText(details.replyHint ?? supervisorReplyHint(requestId), MAX_BODY_CHARS, expanded)}`);
+	lines.push("", "Request:", displayText((details.requestBody ?? contentText(message.content)) || "(no request body)", MAX_BODY_CHARS, expanded));
+	if (details.interview !== undefined) lines.push("", "Interview shape:", interviewText(details.interview, expanded));
+	return lines;
+}
+
+function replyLines(data: SupervisorReplyEntryData, expanded: boolean): string[] {
+	const requestId = boundedField(data.requestId);
+	const lines = [
+		...(data.reason ? [`Reason: ${boundedField(data.reason)}`] : []),
+		`Run: ${boundedField(data.runId)}`,
+		`Agent: ${boundedField(data.agent)}`,
+		`Child index: ${boundedField(data.childIndex)}`,
+	];
+	if (data.childTarget) lines.push(`Child target: ${boundedField(data.childTarget)}`);
+	lines.push(`Reply to: ${requestId}`, "", "Reply:", displayText(data.message || "(empty reply)", MAX_BODY_CHARS, expanded));
+	return lines;
+}
+
+function renderCard(lines: string[], heading: string, theme: Theme, width: number, expanded: boolean): string[] {
+	const safeWidth = Math.max(0, Math.floor(width));
+	if (safeWidth < 3) return [truncateToWidth(heading, safeWidth, "")];
+	const bodyWidth = safeWidth - 2;
+	const headerText = truncateToWidth(` ${heading} `, bodyWidth, "");
+	const headerPadding = Math.max(0, bodyWidth - visibleWidth(headerText));
+	const border = (text: string) => theme.fg("accent", text);
+	const rendered = [border(`╭${headerText}${"─".repeat(headerPadding)}╮`)];
+	let hidden = false;
+	let interiorLines = 0;
+	for (const line of lines) {
+		const wrapped = wrapTextWithAnsi(line, Math.max(1, bodyWidth));
+		for (const wrappedLine of wrapped.length > 0 ? wrapped : [""]) {
+			if (!expanded && interiorLines >= MAX_RENDER_LINES) {
+				hidden = true;
+				break;
+			}
+			const text = truncateToWidth(wrappedLine, bodyWidth, "");
+			rendered.push(border(`│${text}${" ".repeat(Math.max(0, bodyWidth - visibleWidth(text)))}│`));
+			interiorLines++;
+		}
+		if (hidden) break;
+	}
+	if (hidden) {
+		const text = truncateToWidth(TRUNCATION_MARKER, bodyWidth, "");
+		rendered.push(border(`│${text}${" ".repeat(Math.max(0, bodyWidth - visibleWidth(text)))}│`));
+	}
+	rendered.push(border(`╰${"─".repeat(bodyWidth)}╯`));
+	return rendered;
+}
+
+class SupervisorCardComponent implements Component {
+	private readonly expanded: boolean;
+	private readonly heading: string;
+	private readonly lines: string[];
+	private readonly theme: Theme;
+
+	constructor(heading: string, lines: string[], theme: Theme, expanded: boolean) {
+		this.expanded = expanded;
+		this.heading = heading;
+		this.lines = lines;
+		this.theme = theme;
+	}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		return renderCard(this.lines, this.heading, this.theme, width, this.expanded);
+	}
+}
+
+export function renderSupervisorRequest(
+	message: SupervisorMessageLike,
+	options: MessageRenderOptions,
+	theme: Theme,
+): Component | undefined {
+	const details = requestDetails(message.details);
+	if (!details) return undefined;
+	return new SupervisorCardComponent(requestHeading(details.reason), requestLines(message, details, options.expanded), theme, options.expanded);
+}
+
+export function renderSupervisorReply(
+	entry: SupervisorEntryLike,
+	options: EntryRenderOptions,
+	theme: Theme,
+): Component | undefined {
+	const data = replyData(entry.data);
+	if (!data) return undefined;
+	return new SupervisorCardComponent("↩ Supervisor reply to child", replyLines(data, options.expanded), theme, options.expanded);
+}

package/dist/extensions/pi-subagents/src/missions/workflow-state.ts

@@ -18,6 +18,12 @@ export interface MissionWorkflowState {
 	set(key: string, value: unknown): void;
 }
 
+export interface MissionWorkflowStateOptions {
+	isProcessAlive?: (pid: number) => boolean;
+	getProcessStartKey?: (pid: number) => string | undefined;
+	retryDelaysMs?: readonly number[];
+}
+
 export function missionStatePath(location: MissionStoreLocation, missionId: string): string {
 	return path.join(location.missionDir, validateMissionId(missionId), "state.json");
 }
@@ -66,13 +72,22 @@ function windowsProcessStartKey(pid: number): string | undefined {
 	}
 }
 
+let currentProcessKey: string | undefined | null = null;
+
 function processStartKey(pid: number): string | undefined {
+	// Foreign PIDs can be reused while this process lives, so resolve them afresh.
+	if (pid !== process.pid) return computeProcessStartKey(pid);
+	if (currentProcessKey === null) currentProcessKey = computeProcessStartKey(pid);
+	return currentProcessKey;
+}
+
+function computeProcessStartKey(pid: number): string | undefined {
 	if (process.platform === "linux") return linuxProcessStartKey(pid) ?? psProcessStartKey(pid);
 	if (process.platform === "win32") return windowsProcessStartKey(pid);
 	return undefined;
 }
 
-const CURRENT_PROCESS_KEY = processStartKey(process.pid);
+type StateLockOptions = Required<MissionWorkflowStateOptions>;
 
 function readStateLockOwner(lockPath: string): StateLockOwner | undefined {
 	try {
@@ -91,13 +106,13 @@ function readStateLockOwner(lockPath: string): StateLockOwner | undefined {
 	return undefined;
 }
 
-function stateLockIsStale(lockPath: string, now = Date.now()): boolean {
+function stateLockIsStale(lockPath: string, options: StateLockOptions, now = Date.now()): boolean {
 	const owner = readStateLockOwner(lockPath);
 	if (owner) {
-		if (!isProcessAlive(owner.pid)) return true;
+		if (!options.isProcessAlive(owner.pid)) return true;
 		if (owner.processKey) {
-			const currentProcessKey = owner.pid === process.pid ? CURRENT_PROCESS_KEY : processStartKey(owner.pid);
-			if (currentProcessKey) return owner.processKey !== currentProcessKey;
+			const observedProcessKey = options.getProcessStartKey(owner.pid);
+			if (observedProcessKey) return owner.processKey !== observedProcessKey;
 			if (owner.pid === process.pid) return true;
 		}
 		return false;
@@ -140,11 +155,11 @@ function waitForStateLock(delayMs: number | undefined, lockPath: string): void {
 	waitForFileSystemRetry(delayMs);
 }
 
-function reclaimStaleStateLock(lockPath: string, reclaimPath: string): boolean {
-	if (!stateLockIsStale(lockPath)) return false;
+function reclaimStaleStateLock(lockPath: string, reclaimPath: string, options: StateLockOptions): boolean {
+	if (!stateLockIsStale(lockPath, options)) return false;
 	if (!tryMakeDirectory(reclaimPath, 0o700)) return false;
 	try {
-		if (!stateLockIsStale(lockPath)) return false;
+		if (!stateLockIsStale(lockPath, options)) return false;
 		fs.rmSync(lockPath, { recursive: true, force: true });
 		return true;
 	} finally {
@@ -152,7 +167,7 @@ function reclaimStaleStateLock(lockPath: string, reclaimPath: string): boolean {
 	}
 }
 
-function withStateFileLock<T>(filePath: string, operation: () => T): T {
+function withStateFileLock<T>(filePath: string, operation: () => T, options: StateLockOptions): T {
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
 	const lockPath = `${filePath}.lock`;
 	const reclaimPath = `${lockPath}.reclaim`;
@@ -163,7 +178,7 @@ function withStateFileLock<T>(filePath: string, operation: () => T): T {
 				fs.rmSync(reclaimPath, { recursive: true, force: true });
 				continue;
 			}
-			waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+			waitForStateLock(options.retryDelaysMs[attempt], lockPath);
 			continue;
 		}
 		let acquired = false;
@@ -171,17 +186,18 @@ function withStateFileLock<T>(filePath: string, operation: () => T): T {
 			acquired = tryMakeDirectory(lockPath, 0o700);
 		} catch (error) {
 			if (isRetryableFileSystemError(error)) {
-				waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+				waitForStateLock(options.retryDelaysMs[attempt], lockPath);
 				continue;
 			}
 			throw new Error(`Failed to acquire mission state lock '${lockPath}': ${error instanceof Error ? error.message : String(error)}`);
 		}
 		if (!acquired) {
-			if (reclaimStaleStateLock(lockPath, reclaimPath)) continue;
-			waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+			if (reclaimStaleStateLock(lockPath, reclaimPath, options)) continue;
+			waitForStateLock(options.retryDelaysMs[attempt], lockPath);
 			continue;
 		}
-		owner = { pid: process.pid, token: randomUUID(), createdAt: Date.now(), ...(CURRENT_PROCESS_KEY ? { processKey: CURRENT_PROCESS_KEY } : {}) };
+		const key = options.getProcessStartKey(process.pid);
+		owner = { pid: process.pid, token: randomUUID(), createdAt: Date.now(), ...(key ? { processKey: key } : {}) };
 		try {
 			fs.writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify(owner), { encoding: "utf-8", mode: 0o600 });
 		} catch (error) {
@@ -205,8 +221,13 @@ function validateStateKey(value: unknown): string {
 	return value;
 }
 
-export function createMissionWorkflowState(location: MissionStoreLocation, missionId: string): MissionWorkflowState {
+export function createMissionWorkflowState(location: MissionStoreLocation, missionId: string, options: MissionWorkflowStateOptions = {}): MissionWorkflowState {
 	const filePath = missionStatePath(location, missionId);
+	const lockOptions: StateLockOptions = {
+		isProcessAlive: options.isProcessAlive ?? isProcessAlive,
+		getProcessStartKey: options.getProcessStartKey ?? processStartKey,
+		retryDelaysMs: options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS,
+	};
 	let loaded = false;
 	let values: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
 
@@ -254,7 +275,7 @@ export function createMissionWorkflowState(location: MissionStoreLocation, missi
 				writePrivateAtomicJson(filePath, next);
 				values = next;
 				loaded = true;
-			});
+			}, lockOptions);
 		},
 	};
 }

package/dist/extensions/pi-subagents/src/runs/background/active-async-capacity.ts

@@ -12,7 +12,7 @@ export const DEFAULT_ABANDONED_SLOT_RELEASE_AFTER_MS = 20 * 60 * 1000;
 export const MIN_ABANDONED_SLOT_RELEASE_AFTER_MS = 5 * 60 * 1000;
 export const MAX_ABANDONED_SLOT_RELEASE_AFTER_MS = 24 * 60 * 60 * 1000;
 
-export interface ActiveAsyncCapacityOwnerV1 {
+export interface ActiveAsyncCapacityOwner {
 	version: 1;
 	reservationToken: string;
 	ownerSessionId: string;
@@ -29,7 +29,7 @@ export interface ActiveAsyncCapacityOwnerV1 {
 }
 
 export interface ActiveAsyncCapacityHandle {
-	readonly owner: ActiveAsyncCapacityOwnerV1;
+	readonly owner: ActiveAsyncCapacityOwner;
 	markStarted(runnerProcessInstanceId: string): void;
 	markWorkflowStarted(): void;
 	rollback(): boolean;
@@ -44,7 +44,7 @@ interface CapacityOptions {
 	abandonedSlotReleaseAfterMs?: number | false;
 	pidLiveness?: (pid: number) => PidLiveness;
 	afterSlotRename?: (releasedDir: string) => void;
-	writeOwner?: (filePath: string, owner: ActiveAsyncCapacityOwnerV1) => void;
+	writeOwner?: (filePath: string, owner: ActiveAsyncCapacityOwner) => void;
 }
 
 export interface ActiveAsyncCapacityReleaseEvidence {
@@ -61,7 +61,7 @@ export type ActiveAsyncCapacityReleaseVerdict =
 	| { state: "not-owned"; reason: string };
 
 export interface ActiveAsyncCapacityInspection {
-	owner?: ActiveAsyncCapacityOwnerV1;
+	owner?: ActiveAsyncCapacityOwner;
 	relation: "current" | "source" | "none";
 	slotDir?: string;
 	release: ActiveAsyncCapacityReleaseVerdict;
@@ -100,9 +100,9 @@ function slotDir(poolDir: string, slot: number): string {
 	return path.join(poolDir, `slot-${slot}`);
 }
 
-function parseOwner(value: unknown): ActiveAsyncCapacityOwnerV1 | undefined {
+function parseOwner(value: unknown): ActiveAsyncCapacityOwner | undefined {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const owner = value as Partial<ActiveAsyncCapacityOwnerV1>;
+	const owner = value as Partial<ActiveAsyncCapacityOwner>;
 	if (owner.version !== 1
 		|| typeof owner.reservationToken !== "string" || !owner.reservationToken
 		|| typeof owner.ownerSessionId !== "string" || !owner.ownerSessionId
@@ -116,10 +116,10 @@ function parseOwner(value: unknown): ActiveAsyncCapacityOwnerV1 | undefined {
 	if (owner.sourceRunId !== undefined && typeof owner.sourceRunId !== "string") return undefined;
 	if (owner.runnerProcessInstanceId !== undefined && (typeof owner.runnerProcessInstanceId !== "string" || !owner.runnerProcessInstanceId)) return undefined;
 	if (owner.runnerStartedAt !== undefined && (typeof owner.runnerStartedAt !== "number" || !Number.isFinite(owner.runnerStartedAt))) return undefined;
-	return owner as ActiveAsyncCapacityOwnerV1;
+	return owner as ActiveAsyncCapacityOwner;
 }
 
-function readOwner(dir: string): ActiveAsyncCapacityOwnerV1 | undefined {
+function readOwner(dir: string): ActiveAsyncCapacityOwner | undefined {
 	try {
 		return parseOwner(JSON.parse(fs.readFileSync(path.join(dir, "owner.json"), "utf-8")));
 	} catch {
@@ -142,7 +142,7 @@ function snapshotFor(sessionId: string, limit: number | undefined, rootDir: stri
 	return { used: occupiedSlots(sessionDir(sessionId, rootDir)).length, limit: limit ?? 0 };
 }
 
-function matchingOwner(dir: string, expected: ActiveAsyncCapacityOwnerV1): ActiveAsyncCapacityOwnerV1 | undefined {
+function matchingOwner(dir: string, expected: ActiveAsyncCapacityOwner): ActiveAsyncCapacityOwner | undefined {
 	const owner = readOwner(dir);
 	return owner?.reservationToken === expected.reservationToken
 		&& owner.runId === expected.runId
@@ -176,7 +176,7 @@ function withSlotClaim<T>(dir: string, operation: () => T): { acquired: true; va
 	}
 }
 
-function removeOwnedSlot(dir: string, expected: ActiveAsyncCapacityOwnerV1, options: CapacityOptions, requireUnstarted = false, release?: ActiveAsyncCapacityReleaseVerdict): boolean {
+function removeOwnedSlot(dir: string, expected: ActiveAsyncCapacityOwner, options: CapacityOptions, requireUnstarted = false, release?: ActiveAsyncCapacityReleaseVerdict): boolean {
 	if (requireUnstarted && (expected.runnerProcessInstanceId || expected.runnerStartedAt)) return false;
 	const claimed = withSlotClaim(dir, () => {
 		const current = matchingOwner(dir, expected);
@@ -193,7 +193,7 @@ function removeOwnedSlot(dir: string, expected: ActiveAsyncCapacityOwnerV1, opti
 	return claimed.acquired && claimed.value;
 }
 
-function appendAbandonedReleaseEvent(asyncDir: string, owner: ActiveAsyncCapacityOwnerV1, evidence: ActiveAsyncCapacityReleaseEvidence, now: number): void {
+function appendAbandonedReleaseEvent(asyncDir: string, owner: ActiveAsyncCapacityOwner, evidence: ActiveAsyncCapacityReleaseEvidence, now: number): void {
 	try {
 		const eventsPath = path.join(asyncDir, "events.jsonl");
 		fs.mkdirSync(path.dirname(eventsPath), { recursive: true });
@@ -213,7 +213,7 @@ function terminalState(state: AsyncStatus["state"]): boolean {
 	return state !== "queued" && state !== "running" && state !== "paused";
 }
 
-function runnerReleaseVerdict(owner: ActiveAsyncCapacityOwnerV1, status: AsyncStatus | null, options: CapacityOptions): ActiveAsyncCapacityReleaseVerdict {
+function runnerReleaseVerdict(owner: ActiveAsyncCapacityOwner, status: AsyncStatus | null, options: CapacityOptions): ActiveAsyncCapacityReleaseVerdict {
 	if (!status) return { state: "retained", reason: "status file is missing or unreadable" };
 	if (!owner.runnerProcessInstanceId) return { state: "retained", reason: "runner process identity has not been recorded" };
 	if (status.sessionId !== owner.ownerSessionId) return { state: "retained", reason: `status session ${status.sessionId ?? "unknown"} does not match owner session ${owner.ownerSessionId}` };
@@ -262,7 +262,7 @@ function abandonedRunnerReleaseVerdict(status: AsyncStatus, proofState: string,
 	};
 }
 
-function workflowReleaseVerdict(owner: ActiveAsyncCapacityOwnerV1, status: AsyncStatus | null, liveWorkflowRunIds: ReadonlySet<string>): ActiveAsyncCapacityReleaseVerdict {
+function workflowReleaseVerdict(owner: ActiveAsyncCapacityOwner, status: AsyncStatus | null, liveWorkflowRunIds: ReadonlySet<string>): ActiveAsyncCapacityReleaseVerdict {
 	if (!status) return { state: "retained", reason: "status file is missing or unreadable" };
 	if (status.sessionId !== owner.ownerSessionId) return { state: "retained", reason: `status session ${status.sessionId ?? "unknown"} does not match owner session ${owner.ownerSessionId}` };
 	if (status.runId !== owner.runId) return { state: "retained", reason: `status run ${status.runId} does not match owner run ${owner.runId}` };
@@ -289,7 +289,7 @@ function workflowReleaseVerdict(owner: ActiveAsyncCapacityOwnerV1, status: Async
 	return { state: "releasable", reason: "workflow is terminal, controller is gone, and async children have observed proof" };
 }
 
-function ownerReleaseVerdict(owner: ActiveAsyncCapacityOwnerV1, liveWorkflowRunIds: ReadonlySet<string>, options: CapacityOptions): ActiveAsyncCapacityReleaseVerdict {
+function ownerReleaseVerdict(owner: ActiveAsyncCapacityOwner, liveWorkflowRunIds: ReadonlySet<string>, options: CapacityOptions): ActiveAsyncCapacityReleaseVerdict {
 	const status = readStatus(owner.asyncDir);
 	return owner.kind === "runner"
 		? runnerReleaseVerdict(owner, status, options)
@@ -364,7 +364,7 @@ export function getActiveAsyncCapacitySnapshot(
 	return reconcileActiveAsyncCapacity(sessionId, limit, options);
 }
 
-function createSlot(poolDir: string, owner: ActiveAsyncCapacityOwnerV1): boolean {
+function createSlot(poolDir: string, owner: ActiveAsyncCapacityOwner): boolean {
 	const destination = slotDir(poolDir, owner.slot);
 	fs.mkdirSync(poolDir, { recursive: true, mode: 0o700 });
 	try {
@@ -379,7 +379,7 @@ function createSlot(poolDir: string, owner: ActiveAsyncCapacityOwnerV1): boolean
 	return true;
 }
 
-function handleFor(owner: ActiveAsyncCapacityOwnerV1, limit: number, options: CapacityOptions, rollbackOwner?: ActiveAsyncCapacityOwnerV1): ActiveAsyncCapacityHandle {
+function handleFor(owner: ActiveAsyncCapacityOwner, limit: number, options: CapacityOptions, rollbackOwner?: ActiveAsyncCapacityOwner): ActiveAsyncCapacityHandle {
 	const rootDir = options.rootDir ?? ACTIVE_ASYNC_CAPACITY_DIR;
 	const writeOwner = options.writeOwner ?? writePrivateAtomicJson;
 	const dir = slotDir(sessionDir(owner.ownerSessionId, rootDir), owner.slot);
@@ -462,7 +462,7 @@ export function acquireActiveAsyncCapacity(
 	const poolDir = sessionDir(input.sessionId, rootDir);
 	const token = options.token?.() ?? randomUUID();
 	for (let slot = 0; slot < input.limit; slot++) {
-		const owner: ActiveAsyncCapacityOwnerV1 = {
+		const owner: ActiveAsyncCapacityOwner = {
 			version: 1,
 			reservationToken: token,
 			ownerSessionId: input.sessionId,
@@ -495,7 +495,7 @@ export function transferActiveAsyncCapacity(
 			if (!current || !status || status.runId !== input.sourceRunId || status.state === "queued" || status.state === "running") {
 				throw new Error(`Active async capacity source '${input.sourceRunId}' is not transferable.`);
 			}
-			const next: ActiveAsyncCapacityOwnerV1 = {
+			const next: ActiveAsyncCapacityOwner = {
 				...current,
 				runId: input.runId,
 				sourceRunId: input.sourceRunId,