@bastani/atomic 0.9.12 → 0.9.13-alpha.1

package/dist/builtin/subagents/src/runs/background/async-status.ts

@@ -1,411 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { formatDuration, formatModelThinking, formatTokens, shortenPath } from "../../shared/formatters.ts";
-import { formatActivityLabel, formatParallelOutcome } from "../../shared/status-format.ts";
-import type {
-	ActivityState,
-	AsyncJobStep,
-	AsyncParallelGroupStatus,
-	AsyncStatus,
-	NestedRunSummary,
-	SubagentRunMode,
-	TokenUsage,
-} from "../../shared/types.ts";
-import { readStatus } from "../../shared/utils.ts";
-import {
-	attachRootChildrenToSteps,
-	findNestedRouteForRootId,
-	projectNestedRegistryForRoot,
-} from "../shared/nested-events.ts";
-import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
-import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
-import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
-
-interface AsyncRunStepSummary {
-	index: number;
-	agent: string;
-	label?: string;
-	phase?: string;
-	outputName?: string;
-	structured?: boolean;
-	status: AsyncJobStep["status"];
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolArgs?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	recentTools?: Array<{ tool: string; args: string; endMs: number }>;
-	recentOutput?: string[];
-	turnCount?: number;
-	toolCount?: number;
-	durationMs?: number;
-	tokens?: TokenUsage;
-	skills?: string[];
-	model?: string;
-	thinking?: string;
-	fastMode?: boolean;
-	attemptedModels?: string[];
-	error?: string;
-	children?: NestedRunSummary[];
-}
-
-export interface AsyncRunSummary {
-	id: string;
-	asyncDir: string;
-	sessionId?: string;
-	state: "queued" | "running" | "complete" | "failed" | "paused";
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	toolCount?: number;
-	mode: SubagentRunMode;
-	cwd?: string;
-	startedAt: number;
-	lastUpdate?: number;
-	endedAt?: number;
-	currentStep?: number;
-	chainStepCount?: number;
-	parallelGroups?: AsyncParallelGroupStatus[];
-	steps: AsyncRunStepSummary[];
-	sessionDir?: string;
-	outputFile?: string;
-	totalTokens?: TokenUsage;
-	sessionFile?: string;
-	nestedChildren?: NestedRunSummary[];
-	nestedWarnings?: string[];
-}
-
-interface AsyncRunListOptions {
-	states?: Array<AsyncRunSummary["state"]>;
-	sessionId?: string;
-	limit?: number;
-	resultsDir?: string;
-	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
-	now?: () => number;
-	reconcile?: boolean;
-	/** Only consider run dirs whose dir or status.json changed within this window. */
-	maxAgeMs?: number;
-}
-
-function getErrorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function isNotFoundError(error: unknown): boolean {
-	return (
-		typeof error === "object" &&
-		error !== null &&
-		"code" in error &&
-		(error as NodeJS.ErrnoException).code === "ENOENT"
-	);
-}
-
-function isAsyncRunDir(root: string, entry: string): boolean {
-	const entryPath = path.join(root, entry);
-	try {
-		return fs.statSync(entryPath).isDirectory();
-	} catch (error) {
-		if (isNotFoundError(error)) return false;
-		throw new Error(`Failed to inspect async run path '${entryPath}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-}
-
-function runDirTouchedSince(asyncDir: string, cutoffMs: number): boolean {
-	try {
-		if (fs.statSync(asyncDir).mtimeMs >= cutoffMs) return true;
-	} catch {
-		return false;
-	}
-	try {
-		return fs.statSync(path.join(asyncDir, "status.json")).mtimeMs >= cutoffMs;
-	} catch {
-		return false;
-	}
-}
-
-function outputFileMtime(outputFile: string | undefined): number | undefined {
-	if (!outputFile) return undefined;
-	try {
-		return fs.statSync(outputFile).mtimeMs;
-	} catch (error) {
-		if (isNotFoundError(error)) return undefined;
-		throw new Error(`Failed to inspect async output file '${outputFile}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-}
-
-function deriveAsyncActivityState(
-	asyncDir: string,
-	status: AsyncStatus,
-): { activityState?: ActivityState; lastActivityAt?: number } {
-	if (status.state !== "running")
-		return { activityState: status.activityState, lastActivityAt: status.lastActivityAt };
-	const outputPath = status.outputFile
-		? path.isAbsolute(status.outputFile)
-			? status.outputFile
-			: path.join(asyncDir, status.outputFile)
-		: undefined;
-	const currentStep = typeof status.currentStep === "number" ? status.steps?.[status.currentStep] : undefined;
-	return {
-		activityState: status.activityState,
-		lastActivityAt:
-			status.lastActivityAt ??
-			outputFileMtime(outputPath) ??
-			currentStep?.lastActivityAt ??
-			currentStep?.startedAt ??
-			status.startedAt,
-	};
-}
-
-function statusToSummary(
-	asyncDir: string,
-	status: AsyncStatus & { cwd?: string },
-	nestedWarnings: string[] = [],
-): AsyncRunSummary {
-	if (status.sessionId !== undefined && typeof status.sessionId !== "string") {
-		throw new Error(`Invalid async status '${path.join(asyncDir, "status.json")}': sessionId must be a string.`);
-	}
-	const { activityState, lastActivityAt } = deriveAsyncActivityState(asyncDir, status);
-	const steps = status.steps ?? [];
-	const chainStepCount = status.chainStepCount ?? steps.length;
-	const parallelGroups = normalizeParallelGroups(status.parallelGroups, steps.length, chainStepCount);
-	let nestedChildren: NestedRunSummary[] = [];
-	if (nestedWarnings.length === 0) {
-		try {
-			nestedChildren = projectNestedRegistryForRoot(status.runId || path.basename(asyncDir))?.children ?? [];
-		} catch (error) {
-			nestedWarnings.push(`Nested status unavailable: ${getErrorMessage(error)}`);
-		}
-	}
-	const summarizedSteps = steps.map((step, index) => {
-		const stepActivityState = step.activityState;
-		const stepLastActivityAt = step.lastActivityAt;
-		return {
-			index,
-			agent: step.agent,
-			...(step.label ? { label: step.label } : {}),
-			...(step.phase ? { phase: step.phase } : {}),
-			...(step.outputName ? { outputName: step.outputName } : {}),
-			...(step.structured ? { structured: step.structured } : {}),
-			status: step.status,
-			...(stepActivityState ? { activityState: stepActivityState } : {}),
-			...(stepLastActivityAt ? { lastActivityAt: stepLastActivityAt } : {}),
-			...(step.currentTool ? { currentTool: step.currentTool } : {}),
-			...(step.currentToolArgs ? { currentToolArgs: step.currentToolArgs } : {}),
-			...(step.currentToolStartedAt ? { currentToolStartedAt: step.currentToolStartedAt } : {}),
-			...(step.currentPath ? { currentPath: step.currentPath } : {}),
-			...(step.recentTools ? { recentTools: step.recentTools.map((tool) => ({ ...tool })) } : {}),
-			...(step.recentOutput ? { recentOutput: [...step.recentOutput] } : {}),
-			...(step.turnCount !== undefined ? { turnCount: step.turnCount } : {}),
-			...(step.toolCount !== undefined ? { toolCount: step.toolCount } : {}),
-			...(step.durationMs !== undefined ? { durationMs: step.durationMs } : {}),
-			...(step.tokens ? { tokens: step.tokens } : {}),
-			...(step.skills ? { skills: step.skills } : {}),
-			...(step.model ? { model: step.model } : {}),
-			...(step.thinking ? { thinking: step.thinking } : {}),
-			...(step.fastMode !== undefined ? { fastMode: step.fastMode } : {}),
-			...(step.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
-			...(step.error ? { error: step.error } : {}),
-			...(step.children?.length ? { children: step.children } : {}),
-		};
-	});
-	attachRootChildrenToSteps(status.runId || path.basename(asyncDir), summarizedSteps, nestedChildren);
-	return {
-		id: status.runId || path.basename(asyncDir),
-		asyncDir,
-		...(status.sessionId ? { sessionId: status.sessionId } : {}),
-		state: status.state,
-		activityState,
-		lastActivityAt,
-		currentTool: status.currentTool,
-		currentToolStartedAt: status.currentToolStartedAt,
-		currentPath: status.currentPath,
-		turnCount: status.turnCount,
-		toolCount: status.toolCount,
-		mode: status.mode,
-		cwd: status.cwd,
-		startedAt: status.startedAt,
-		lastUpdate: status.lastUpdate,
-		endedAt: status.endedAt,
-		currentStep: status.currentStep,
-		...(status.chainStepCount !== undefined ? { chainStepCount: status.chainStepCount } : {}),
-		...(parallelGroups.length ? { parallelGroups } : {}),
-		steps: summarizedSteps,
-		...(nestedChildren.length ? { nestedChildren } : {}),
-		...(nestedWarnings.length ? { nestedWarnings } : {}),
-		...(status.sessionDir ? { sessionDir: status.sessionDir } : {}),
-		...(status.outputFile ? { outputFile: status.outputFile } : {}),
-		...(status.totalTokens ? { totalTokens: status.totalTokens } : {}),
-		...(status.sessionFile ? { sessionFile: status.sessionFile } : {}),
-	};
-}
-
-function sortRuns(runs: AsyncRunSummary[]): AsyncRunSummary[] {
-	const rank = (state: AsyncRunSummary["state"]): number => {
-		switch (state) {
-			case "running":
-				return 0;
-			case "queued":
-				return 1;
-			case "failed":
-				return 2;
-			case "paused":
-				return 2;
-			case "complete":
-				return 3;
-		}
-	};
-	return [...runs].sort((a, b) => {
-		const byState = rank(a.state) - rank(b.state);
-		if (byState !== 0) return byState;
-		const aTime = a.lastUpdate ?? a.endedAt ?? a.startedAt;
-		const bTime = b.lastUpdate ?? b.endedAt ?? b.startedAt;
-		return bTime - aTime;
-	});
-}
-
-export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions = {}): AsyncRunSummary[] {
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(asyncDirRoot).filter((entry) => isAsyncRunDir(asyncDirRoot, entry));
-	} catch (error) {
-		if (isNotFoundError(error)) return [];
-		throw new Error(`Failed to list async runs in '${asyncDirRoot}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-
-	const allowedStates = options.states ? new Set(options.states) : undefined;
-	const cutoff = options.maxAgeMs !== undefined ? (options.now?.() ?? Date.now()) - options.maxAgeMs : undefined;
-	const runs: AsyncRunSummary[] = [];
-	for (const entry of entries) {
-		const asyncDir = path.join(asyncDirRoot, entry);
-		// Recency cutoff: skip reconcile/read/parse work for long-untouched runs
-		// (two stats instead of a full per-run reconciliation at startup).
-		if (cutoff !== undefined && !runDirTouchedSince(asyncDir, cutoff)) continue;
-		const reconciliation =
-			options.reconcile === false
-				? undefined
-				: reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
-		const status = (reconciliation?.status ?? readStatus(asyncDir)) as (AsyncStatus & { cwd?: string }) | null;
-		if (!status) continue;
-		const nestedWarnings: string[] = [];
-		try {
-			const nestedRoute = findNestedRouteForRootId(status.runId || path.basename(asyncDir));
-			if (nestedRoute)
-				reconcileNestedAsyncDescendants(nestedRoute, {
-					resultsDir: options.resultsDir,
-					kill: options.kill,
-					now: options.now,
-				});
-		} catch (error) {
-			nestedWarnings.push(`Nested status unavailable: ${getErrorMessage(error)}`);
-		}
-		const summary = statusToSummary(asyncDir, status, nestedWarnings);
-		if (allowedStates && !allowedStates.has(summary.state)) continue;
-		if (options.sessionId && summary.sessionId !== options.sessionId) continue;
-		runs.push(summary);
-	}
-
-	const sorted = sortRuns(runs);
-	return options.limit !== undefined ? sorted.slice(0, options.limit) : sorted;
-}
-
-function formatActivityFacts(input: {
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	toolCount?: number;
-}): string | undefined {
-	const facts: string[] = [];
-	if (input.currentTool && input.currentToolStartedAt !== undefined)
-		facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
-	else if (input.currentTool) facts.push(`tool ${input.currentTool}`);
-	if (input.currentPath) facts.push(shortenPath(input.currentPath));
-	if (input.turnCount !== undefined) facts.push(`${input.turnCount} turns`);
-	if (input.toolCount !== undefined) facts.push(`${input.toolCount} tools`);
-	const activity = formatActivityLabel(input.lastActivityAt, input.activityState);
-	return activity || facts.length ? [activity, ...facts].filter(Boolean).join(" | ") : undefined;
-}
-
-function formatStepLine(step: AsyncRunStepSummary): string {
-	const display = step.label ? `${step.label} (${step.agent})` : step.agent;
-	const phase = step.phase ? `[${step.phase}] ` : "";
-	const parts = [`${step.index + 1}. ${phase}${display}`, step.status];
-	const activity = formatActivityFacts(step);
-	if (activity) parts.push(activity);
-	const modelThinking = formatModelThinking(step.model, step.thinking, step.fastMode);
-	if (modelThinking) parts.push(modelThinking);
-	if (step.durationMs !== undefined) parts.push(formatDuration(step.durationMs));
-	if (step.tokens) parts.push(`${formatTokens(step.tokens.total)} tok`);
-	return parts.join(" | ");
-}
-
-export function formatAsyncRunOutputPath(run: Pick<AsyncRunSummary, "asyncDir" | "outputFile">): string | undefined {
-	if (!run.outputFile) return undefined;
-	return path.isAbsolute(run.outputFile) ? run.outputFile : path.join(run.asyncDir, run.outputFile);
-}
-
-export function formatAsyncRunProgressLabel(
-	run: Pick<AsyncRunSummary, "mode" | "state" | "currentStep" | "chainStepCount" | "parallelGroups" | "steps">,
-): string {
-	const stepCount = run.steps.length || 1;
-	const chainStepCount = run.chainStepCount ?? stepCount;
-	const groups = normalizeParallelGroups(run.parallelGroups, run.steps.length, chainStepCount);
-	const activeGroup =
-		run.currentStep !== undefined
-			? groups.find((group) => run.currentStep! >= group.start && run.currentStep! < group.start + group.count)
-			: undefined;
-	if (activeGroup) {
-		const groupSteps = run.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count);
-		const groupLabel = formatParallelOutcome(groupSteps, activeGroup.count, { showRunning: run.state === "running" });
-		if (run.mode === "parallel") return groupLabel;
-		return `step ${activeGroup.stepIndex + 1}/${chainStepCount} · parallel group: ${groupLabel}`;
-	}
-	if (run.mode === "parallel")
-		return formatParallelOutcome(run.steps, stepCount, { showRunning: run.state === "running" });
-	if (run.mode === "chain" && run.currentStep !== undefined && groups.length > 0) {
-		const logicalStep = flatToLogicalStepIndex(run.currentStep, chainStepCount, groups);
-		return `step ${logicalStep + 1}/${chainStepCount}`;
-	}
-	return run.currentStep !== undefined ? `step ${run.currentStep + 1}/${stepCount}` : `steps ${stepCount}`;
-}
-
-function formatRunHeader(run: AsyncRunSummary): string {
-	const stepLabel = formatAsyncRunProgressLabel(run);
-	const cwd = run.cwd ? shortenPath(run.cwd) : shortenPath(run.asyncDir);
-	const activity = formatActivityFacts(run);
-	return `${run.id} | ${run.state}${activity ? ` | ${activity}` : ""} | ${run.mode} | ${stepLabel} | ${cwd}`;
-}
-
-export function formatAsyncRunList(runs: AsyncRunSummary[], heading = "Active async runs"): string {
-	if (runs.length === 0) return `No ${heading.toLowerCase()}.`;
-
-	const lines = [`${heading}: ${runs.length}`, ""];
-	for (const run of runs) {
-		lines.push(`- ${formatRunHeader(run)}`);
-		for (const step of run.steps) {
-			lines.push(`  ${formatStepLine(step)}`);
-			lines.push(...formatNestedRunStatusLines(step.children, { indent: "    ", maxLines: 12 }));
-		}
-		const attached = new Set(run.steps.flatMap((step) => step.children?.map((child) => child.id) ?? []));
-		const unattached = run.nestedChildren?.filter((child) => !attached.has(child.id)) ?? [];
-		lines.push(...formatNestedRunStatusLines(unattached, { indent: "  ", maxLines: 12 }));
-		for (const warning of run.nestedWarnings ?? []) lines.push(`  Warning: ${warning}`);
-		const outputPath = formatAsyncRunOutputPath(run);
-		if (outputPath) lines.push(`  output: ${shortenPath(outputPath)}`);
-		if (run.sessionFile) lines.push(`  session: ${shortenPath(run.sessionFile)}`);
-		lines.push("");
-	}
-	return lines.join("\n").trimEnd();
-}

package/dist/builtin/subagents/src/runs/background/completion-claims.ts

@@ -1,196 +0,0 @@
-import type { FrozenCompletionEnvelope } from "./result-file-claims.js";
-
-type CompletionClaimStatus = "delivered" | "retry" | "exhausted" | "conflict" | "released";
-type TerminalStatus = Extract<CompletionClaimStatus, "delivered" | "exhausted">;
-
-interface CompletionAttempt {
-	status: CompletionClaimStatus;
-	noProgressFailures: number;
-}
-
-interface CompletionFlight {
-	promise: Promise<CompletionAttempt>;
-}
-
-export interface CompletionClaimSnapshot {
-	intercomDelivered: boolean;
-	localDelivered: boolean;
-	noProgressFailures: number;
-	terminalStatus?: TerminalStatus;
-	envelope: FrozenCompletionEnvelope;
-}
-
-interface CompletionClaim extends CompletionClaimSnapshot {
-	signature: string;
-	inFlight?: CompletionFlight;
-	completedAt?: number;
-	lastTouchedAt: number;
-}
-
-export interface CompletionClaimResult extends CompletionAttempt {
-	owner: boolean;
-}
-
-export interface CompletionDeliveryPhases {
-	intercom?: (envelope: FrozenCompletionEnvelope) => Promise<boolean> | boolean;
-	local?: (envelope: FrozenCompletionEnvelope) => Promise<boolean> | boolean;
-	isOwned?: () => boolean;
-	onState?: (snapshot: CompletionClaimSnapshot) => void;
-}
-
-export interface CompletionClaimInitial {
-	intercomDelivered?: boolean;
-	localDelivered?: boolean;
-	noProgressFailures?: number;
-	terminalStatus?: TerminalStatus;
-	envelope?: FrozenCompletionEnvelope;
-}
-
-const STORE_KEY = "__atomicSubagentCompletionClaims";
-const DEFAULT_MAX_NO_PROGRESS_FAILURES = 8;
-const MAX_CLAIMS = 2048;
-
-function cloneEnvelope(envelope: FrozenCompletionEnvelope): FrozenCompletionEnvelope {
-	return JSON.parse(JSON.stringify(envelope)) as FrozenCompletionEnvelope;
-}
-
-function claims(): Map<string, CompletionClaim> {
-	const globalStore = globalThis as Record<string, unknown>;
-	const existing = globalStore[STORE_KEY];
-	if (existing instanceof Map) return existing as Map<string, CompletionClaim>;
-	const created = new Map<string, CompletionClaim>();
-	globalStore[STORE_KEY] = created;
-	return created;
-}
-
-function prune(store: Map<string, CompletionClaim>, now: number, ttlMs: number): void {
-	for (const [key, claim] of store) {
-		if (claim.completedAt !== undefined && now - claim.completedAt > ttlMs) store.delete(key);
-	}
-	if (store.size <= MAX_CLAIMS) return;
-	const disposable = [...store.entries()]
-		.filter(([, claim]) => !claim.inFlight && !claim.intercomDelivered && !claim.localDelivered)
-		.sort((a, b) => a[1].lastTouchedAt - b[1].lastTouchedAt);
-	for (const [key] of disposable) {
-		if (store.size <= MAX_CLAIMS) break;
-		store.delete(key);
-	}
-}
-
-function snapshot(claim: CompletionClaim): CompletionClaimSnapshot {
-	return {
-		intercomDelivered: claim.intercomDelivered,
-		localDelivered: claim.localDelivered,
-		noProgressFailures: claim.noProgressFailures,
-		terminalStatus: claim.terminalStatus,
-		envelope: cloneEnvelope(claim.envelope),
-	};
-}
-
-function persist(claim: CompletionClaim, callback: CompletionDeliveryPhases["onState"]): void {
-	claim.lastTouchedAt = Date.now();
-	callback?.(snapshot(claim));
-}
-
-/** Atomically owns and advances one completion across aliases and watcher replacements. */
-export async function deliverClaimedCompletion(
-	key: string,
-	signature: string,
-	ttlMs: number,
-	phases: CompletionDeliveryPhases,
-	maxNoProgressFailures = DEFAULT_MAX_NO_PROGRESS_FAILURES,
-	initial: CompletionClaimInitial = {},
-	envelope: FrozenCompletionEnvelope = { local: {} },
-): Promise<CompletionClaimResult> {
-	const store = claims();
-	const now = Date.now();
-	prune(store, now, ttlMs);
-	let claim = store.get(key);
-	if (!claim) {
-		claim = {
-			signature,
-			envelope: cloneEnvelope(initial.envelope ?? envelope),
-			intercomDelivered: initial.intercomDelivered === true,
-			localDelivered: initial.localDelivered === true,
-			noProgressFailures: initial.noProgressFailures ?? 0,
-			terminalStatus: initial.terminalStatus,
-			completedAt: initial.terminalStatus ? now : undefined,
-			lastTouchedAt: now,
-		};
-		store.set(key, claim);
-		persist(claim, phases.onState);
-	} else if (claim.signature !== signature) {
-		return { owner: false, status: "conflict", noProgressFailures: claim.noProgressFailures };
-	}
-	claim.lastTouchedAt = now;
-	if (claim.terminalStatus)
-		return { owner: false, status: claim.terminalStatus, noProgressFailures: claim.noProgressFailures };
-	if (claim.inFlight) return { owner: false, ...(await claim.inFlight.promise) };
-
-	const ownedClaim = claim;
-	const hasVisibleProgress = () => ownedClaim.intercomDelivered || ownedClaim.localDelivered;
-	const retireForOwnershipLoss = (): CompletionAttempt => {
-		if (!hasVisibleProgress()) {
-			store.delete(key);
-			return { status: "released", noProgressFailures: ownedClaim.noProgressFailures };
-		}
-		persist(ownedClaim, phases.onState);
-		return { status: "released", noProgressFailures: ownedClaim.noProgressFailures };
-	};
-	const attempt = (async (): Promise<CompletionAttempt> => {
-		let progressed = false;
-		const failed = (): CompletionAttempt => {
-			if (phases.isOwned && !phases.isOwned()) return retireForOwnershipLoss();
-			ownedClaim.noProgressFailures = progressed ? 0 : ownedClaim.noProgressFailures + 1;
-			if (ownedClaim.noProgressFailures >= Math.max(1, maxNoProgressFailures)) {
-				ownedClaim.terminalStatus = "exhausted";
-				ownedClaim.completedAt = Date.now();
-				persist(ownedClaim, phases.onState);
-				return { status: "exhausted", noProgressFailures: ownedClaim.noProgressFailures };
-			}
-			persist(ownedClaim, phases.onState);
-			return { status: "retry", noProgressFailures: ownedClaim.noProgressFailures };
-		};
-		const runPhase = async (
-			phase: ((value: FrozenCompletionEnvelope) => Promise<boolean> | boolean) | undefined,
-		): Promise<boolean | undefined> => {
-			if (!phase) return undefined;
-			if (phases.isOwned && !phases.isOwned()) return false;
-			try {
-				return await phase(cloneEnvelope(ownedClaim.envelope));
-			} catch {
-				return false;
-			}
-		};
-		if (!ownedClaim.intercomDelivered && phases.intercom) {
-			const delivered = await runPhase(phases.intercom);
-			if (!delivered) return failed();
-			ownedClaim.intercomDelivered = true;
-			progressed = true;
-			persist(ownedClaim, phases.onState);
-			if (phases.isOwned && !phases.isOwned()) return retireForOwnershipLoss();
-		}
-		if (!ownedClaim.localDelivered && phases.local) {
-			const delivered = await runPhase(phases.local);
-			if (!delivered) return failed();
-			ownedClaim.localDelivered = true;
-			progressed = true;
-			persist(ownedClaim, phases.onState);
-			if (phases.isOwned && !phases.isOwned()) return retireForOwnershipLoss();
-		}
-		ownedClaim.noProgressFailures = 0;
-		ownedClaim.terminalStatus = "delivered";
-		ownedClaim.completedAt = Date.now();
-		persist(ownedClaim, phases.onState);
-		return { status: "delivered", noProgressFailures: 0 };
-	})();
-	const flight: CompletionFlight = { promise: attempt };
-	ownedClaim.inFlight = flight;
-	try {
-		return { owner: true, ...(await flight.promise) };
-	} finally {
-		// The explicit flight handle is the ownership token; comparing resolved
-		// values would let an older attempt clear a newer in-flight claim.
-		if (ownedClaim.inFlight === flight) ownedClaim.inFlight = undefined;
-	}
-}