@bastani/atomic 0.9.12 → 0.9.13-alpha.2

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

@@ -1,102 +0,0 @@
-export interface CompletionSeenRecord {
-	seenAt: number;
-	signature?: string;
-}
-
-export type CompletionSeenMap = Map<string, number | CompletionSeenRecord>;
-export type CompletionSeenMatch = "miss" | "match" | "conflict";
-
-interface CompletionDataLike {
-	runId?: unknown;
-	id?: unknown;
-	agent?: unknown;
-	timestamp?: unknown;
-	sessionId?: unknown;
-	taskIndex?: unknown;
-	totalTasks?: unknown;
-	success?: unknown;
-}
-
-function asNonEmptyString(value: unknown): string | undefined {
-	if (typeof value !== "string") return undefined;
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function asFiniteNumber(value: unknown): number | undefined {
-	if (typeof value !== "number") return undefined;
-	return Number.isFinite(value) ? value : undefined;
-}
-
-export function buildCompletionKey(data: CompletionDataLike, fallback: string): string {
-	const runId = asNonEmptyString(data.runId);
-	if (runId) return `run:${runId}`;
-	const id = asNonEmptyString(data.id);
-	if (id) return `id:${id}`;
-	const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
-	const agent = asNonEmptyString(data.agent) ?? "unknown";
-	const timestamp = asFiniteNumber(data.timestamp);
-	const taskIndex = asFiniteNumber(data.taskIndex);
-	const totalTasks = asFiniteNumber(data.totalTasks);
-	const success = typeof data.success === "boolean" ? (data.success ? "1" : "0") : "?";
-	return [
-		"meta",
-		sessionId,
-		agent,
-		timestamp !== undefined ? String(timestamp) : "no-ts",
-		taskIndex !== undefined ? String(taskIndex) : "-",
-		totalTasks !== undefined ? String(totalTasks) : "-",
-		success,
-		fallback,
-	].join(":");
-}
-
-function recordTimestamp(record: number | CompletionSeenRecord): number {
-	return typeof record === "number" ? record : record.seenAt;
-}
-
-function pruneSeenMap(seen: CompletionSeenMap, now: number, ttlMs: number): void {
-	for (const [key, record] of seen.entries()) {
-		if (now - recordTimestamp(record) > ttlMs) seen.delete(key);
-	}
-}
-
-export function lookupSeenWithTtl(
-	seen: CompletionSeenMap,
-	key: string,
-	signature: string | undefined,
-	now: number,
-	ttlMs: number,
-): CompletionSeenMatch {
-	pruneSeenMap(seen, now, ttlMs);
-	const record = seen.get(key);
-	if (record === undefined) return "miss";
-	const recordedSignature = typeof record === "number" ? undefined : record.signature;
-	return recordedSignature === undefined || signature === undefined || recordedSignature === signature
-		? "match"
-		: "conflict";
-}
-
-export function hasSeenWithTtl(seen: CompletionSeenMap, key: string, now: number, ttlMs: number): boolean {
-	return lookupSeenWithTtl(seen, key, undefined, now, ttlMs) !== "miss";
-}
-
-export function recordSeen(seen: CompletionSeenMap, key: string, now: number, signature?: string): void {
-	seen.set(key, signature === undefined ? now : { seenAt: now, signature });
-}
-
-export function markSeenWithTtl(seen: CompletionSeenMap, key: string, now: number, ttlMs: number): boolean {
-	pruneSeenMap(seen, now, ttlMs);
-	if (seen.has(key)) return true;
-	seen.set(key, now);
-	return false;
-}
-
-export function getGlobalSeenMap(storeKey: string): CompletionSeenMap {
-	const globalStore = globalThis as Record<string, unknown>;
-	const existing = globalStore[storeKey];
-	if (existing instanceof Map) return existing as CompletionSeenMap;
-	const map: CompletionSeenMap = new Map();
-	globalStore[storeKey] = map;
-	return map;
-}

package/dist/builtin/subagents/src/runs/background/parallel-groups.ts

@@ -1,59 +0,0 @@
-import type { AsyncParallelGroupStatus } from "../../shared/types.ts";
-
-function isValidParallelGroup(
-	group: unknown,
-	stepCount: number,
-	chainStepCount: number,
-): group is AsyncParallelGroupStatus {
-	if (typeof group !== "object" || group === null) return false;
-	const { start, count, stepIndex } = group as Partial<AsyncParallelGroupStatus>;
-	return (
-		typeof start === "number" &&
-		typeof count === "number" &&
-		typeof stepIndex === "number" &&
-		Number.isInteger(start) &&
-		Number.isInteger(count) &&
-		Number.isInteger(stepIndex) &&
-		start >= 0 &&
-		count > 0 &&
-		stepIndex >= 0 &&
-		stepIndex < chainStepCount &&
-		start + count <= stepCount
-	);
-}
-
-export function normalizeParallelGroups(
-	groups: unknown,
-	stepCount: number,
-	chainStepCount: number,
-): AsyncParallelGroupStatus[] {
-	if (!Array.isArray(groups)) return [];
-	return groups
-		.filter((group): group is AsyncParallelGroupStatus => isValidParallelGroup(group, stepCount, chainStepCount))
-		.sort((left, right) => left.stepIndex - right.stepIndex || left.start - right.start);
-}
-
-export function flatToLogicalStepIndex(
-	flatIndex: number,
-	chainStepCount: number,
-	groups: AsyncParallelGroupStatus[],
-): number {
-	let logicalIndex = 0;
-	let cursor = 0;
-	for (const group of groups) {
-		while (cursor < group.start && logicalIndex < chainStepCount) {
-			if (cursor === flatIndex) return logicalIndex;
-			cursor++;
-			logicalIndex++;
-		}
-		if (flatIndex >= group.start && flatIndex < group.start + group.count) return group.stepIndex;
-		cursor = group.start + group.count;
-		logicalIndex = group.stepIndex + 1;
-	}
-	while (cursor <= flatIndex && logicalIndex < chainStepCount) {
-		if (cursor === flatIndex) return logicalIndex;
-		cursor++;
-		logicalIndex++;
-	}
-	return Math.max(0, chainStepCount - 1);
-}

package/dist/builtin/subagents/src/runs/background/result-delivery-processor.ts

@@ -1,300 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import {
-	attachNestedChildrenToResultChildren,
-	buildSubagentResultIntercomPayload,
-	compactNestedResultChildren,
-	deliverSubagentResultIntercomEvent,
-	resolveSubagentResultStatus,
-} from "../../intercom/result-intercom.ts";
-import type { IntercomEventBus, SubagentResultIntercomChild, SubagentState } from "../../shared/types.ts";
-import { projectNestedRegistryForRoot } from "../shared/nested-events.ts";
-import { type CompletionClaimSnapshot, deliverClaimedCompletion } from "./completion-claims.js";
-import { buildCompletionKey, lookupSeenWithTtl, recordSeen } from "./completion-dedupe.ts";
-import { deliverLocalCompletionNotification } from "./completion-notification.ts";
-import {
-	claimIdFromScheduleKey,
-	claimPublicResult,
-	claimScheduleKey,
-	type FrozenCompletionEnvelope,
-	loadResultClaim,
-	type ResultClaimFs,
-	type ResultFileClaim,
-	readClaimData,
-	removeResultClaim,
-	updateResultClaim,
-} from "./result-file-claims.js";
-import { quarantineResultFile } from "./result-quarantine.js";
-import { modernResultHasTerminalStatus, type ResultStatusFs } from "./result-status.js";
-import { buildCompletionSignature, type ResultFileData, sanitizeNestedResultChildren } from "./result-watcher-data.js";
-
-export interface ResultProcessOutcome {
-	status: "done" | "status-pending" | "delivery-retry" | "inactive";
-	entry?: string;
-}
-
-export interface ResultProcessorFs extends ResultClaimFs, Partial<ResultStatusFs> {
-	existsSync?: typeof fs.existsSync;
-	unlinkSync?: typeof fs.unlinkSync;
-	linkSync?: typeof fs.linkSync;
-	copyFileSync?: typeof fs.copyFileSync;
-	openSync?: typeof fs.openSync;
-	readSync?: typeof fs.readSync;
-	closeSync?: typeof fs.closeSync;
-}
-
-export interface ResultProcessorContext {
-	pi: { events: IntercomEventBus };
-	state: SubagentState;
-	resultsDir: string;
-	completionTtlMs: number;
-	fsApi?: ResultProcessorFs;
-	allowedStatusRoots?: string[];
-	maxStatusBytes?: number;
-	maxNoProgressFailures?: number;
-	intercomTimeoutMs?: number | false;
-	isActive: () => boolean;
-	ownsResult: (data: ResultFileData) => boolean;
-}
-
-function statusFs(fsApi: ResultProcessorFs): ResultStatusFs {
-	return {
-		realpathSync: fsApi.realpathSync ?? fs.realpathSync,
-		lstatSync: fsApi.lstatSync ?? fs.lstatSync,
-		openSync: fsApi.openSync ?? fs.openSync,
-		fstatSync: fsApi.fstatSync ?? fs.fstatSync,
-		readSync: fsApi.readSync ?? fs.readSync,
-		closeSync: fsApi.closeSync ?? fs.closeSync,
-	};
-}
-
-function readPublic(resultsDir: string, file: string, fsApi: ResultProcessorFs): ResultFileData {
-	return JSON.parse((fsApi.readFileSync ?? fs.readFileSync)(path.join(resultsDir, file), "utf-8")) as ResultFileData;
-}
-
-function markClaimState(claim: ResultFileClaim, value: CompletionClaimSnapshot, fsApi: ResultProcessorFs): void {
-	updateResultClaim(
-		claim,
-		{
-			intercomDelivered: value.intercomDelivered,
-			localDelivered: value.localDelivered,
-			noProgressFailures: value.noProgressFailures,
-			envelope: value.envelope,
-			...(value.terminalStatus === "delivered" ? { state: "delivered" as const } : {}),
-			...(value.terminalStatus === "exhausted" ? { state: "undelivered" as const } : {}),
-		},
-		fsApi,
-	);
-}
-
-function buildEnvelope(data: ResultFileData, resultPath: string, fsApi: ResultProcessorFs): FrozenCompletionEnvelope {
-	const runId = data.runId ?? data.id ?? path.basename(resultPath, ".json");
-	const explicitNested = data.nestedChildren !== undefined;
-	let nestedChildren = compactNestedResultChildren(
-		sanitizeNestedResultChildren(data.nestedChildren, resultPath, "nestedChildren"),
-	);
-	if (!nestedChildren?.length && !explicitNested)
-		nestedChildren = compactNestedResultChildren(projectNestedRegistryForRoot(runId)?.children);
-	const hasResults = Array.isArray(data.results) && data.results.length > 0;
-	const resultChildren = hasResults
-		? data.results!
-		: [{ agent: data.agent, output: data.summary, success: data.success }];
-	const normalized = attachNestedChildrenToResultChildren(
-		runId,
-		resultChildren.map((result = {}, index): SubagentResultIntercomChild => {
-			const baseOutput = result.output ?? data.summary;
-			const hasOutput = typeof baseOutput === "string" && baseOutput.trim().length > 0;
-			const output = hasOutput ? baseOutput : "(no output)";
-			const summary =
-				result.success === false && result.error
-					? `${result.error}${hasOutput ? `\n\nOutput:\n${baseOutput}` : ""}`
-					: output;
-			const sessionPath = result.sessionFile ?? (resultChildren.length === 1 ? data.sessionFile : undefined);
-			const children = sanitizeNestedResultChildren(result.children, resultPath, `results[${index}].children`);
-			return {
-				agent: result.agent ?? data.agent ?? `step-${index + 1}`,
-				status: resolveSubagentResultStatus({
-					success: result.success,
-					state: data.state === "paused" || typeof result.success !== "boolean" ? data.state : undefined,
-				}),
-				summary,
-				index,
-				artifactPath: result.artifactPaths?.outputPath,
-				...(typeof sessionPath === "string" && (fsApi.existsSync ?? fs.existsSync)(sessionPath)
-					? { sessionPath }
-					: {}),
-				...(result.intercomTarget ? { intercomTarget: result.intercomTarget } : {}),
-				...(children ? { children } : {}),
-			};
-		}),
-		nestedChildren,
-	);
-	const local: Record<string, unknown> = {
-		...data,
-		runId,
-		...(nestedChildren?.length ? { nestedChildren } : {}),
-		...(Array.isArray(data.results)
-			? {
-					results: hasResults
-						? normalized.map((child, index) => ({
-								...data.results![index],
-								agent: child.agent,
-								status: child.status,
-								summary: child.summary,
-								index: child.index,
-								artifactPath: child.artifactPath,
-								sessionPath: child.sessionPath,
-								children: child.children,
-							}))
-						: [],
-				}
-			: {}),
-	};
-	const target = data.intercomTarget?.trim();
-	const mode =
-		data.mode === "single" || data.mode === "parallel" || data.mode === "chain"
-			? data.mode
-			: resultChildren.length > 1
-				? "chain"
-				: "single";
-	return {
-		local,
-		...(target
-			? {
-					intercom: {
-						to: target,
-						runId,
-						mode,
-						source: "async",
-						children: normalized,
-						asyncId: data.id,
-						asyncDir: data.asyncDir,
-					},
-				}
-			: {}),
-	};
-}
-
-function quarantineClaim(context: ResultProcessorContext, claim: ResultFileClaim): void {
-	const fsApi = context.fsApi ?? fs;
-	updateResultClaim(claim, { state: "undelivered" }, fsApi);
-	quarantineResultFile(context.resultsDir, claim.meta.originalFile, claim.payloadPath, fsApi as typeof fs);
-	removeResultClaim(claim, fsApi);
-}
-
-export async function processResultEntry(
-	entry: string,
-	context: ResultProcessorContext,
-): Promise<ResultProcessOutcome> {
-	const fsApi = context.fsApi ?? fs;
-	let claim: ResultFileClaim | undefined;
-	const existingClaimId = claimIdFromScheduleKey(entry);
-	if (existingClaimId) {
-		claim = loadResultClaim(context.resultsDir, existingClaimId, fsApi);
-		if (!claim) return { status: "done" };
-		if (claim.meta.state === "delivered") {
-			removeResultClaim(claim, fsApi);
-			return { status: "done" };
-		}
-		if (claim.meta.state === "undelivered") {
-			quarantineClaim(context, claim);
-			return { status: "done" };
-		}
-	} else {
-		const publicPath = path.join(context.resultsDir, entry);
-		if (!(fsApi.existsSync ?? fs.existsSync)(publicPath)) return { status: "done" };
-		const preliminary = readPublic(context.resultsDir, entry, fsApi);
-		if (!context.ownsResult(preliminary)) return { status: "inactive" };
-		if (
-			!modernResultHasTerminalStatus(preliminary, statusFs(fsApi), {
-				allowedRoots: context.allowedStatusRoots,
-				maxBytes: context.maxStatusBytes,
-			})
-		)
-			return { status: "status-pending", entry };
-		claim = claimPublicResult(context.resultsDir, entry, fsApi);
-	}
-
-	const { data } = readClaimData(claim, fsApi);
-	if (!context.ownsResult(data)) return { status: "inactive" };
-	if (
-		!modernResultHasTerminalStatus(data, statusFs(fsApi), {
-			allowedRoots: context.allowedStatusRoots,
-			maxBytes: context.maxStatusBytes,
-		})
-	)
-		return { status: "status-pending", entry: claim ? claimScheduleKey(claim.id) : entry };
-	const sourceSignature = buildCompletionSignature({ source: data });
-	if (claim.meta.sourceSignature && claim.meta.sourceSignature !== sourceSignature) {
-		quarantineClaim(context, claim);
-		return { status: "done" };
-	}
-	let envelope = claim.meta.envelope;
-	if (!envelope) {
-		envelope = buildEnvelope(data, claim.payloadPath, fsApi);
-		updateResultClaim(claim, { sourceSignature, envelope }, fsApi);
-	}
-	const completionKey = buildCompletionKey(data, `result:${claim.meta.originalFile}`);
-	const claimKey = `${path.resolve(context.resultsDir)}:${completionKey}`;
-	const stableHash = createHash("sha256").update(`${claimKey}:${sourceSignature}`).digest("hex");
-	const seen = lookupSeenWithTtl(
-		context.state.completionSeen,
-		completionKey,
-		sourceSignature,
-		Date.now(),
-		context.completionTtlMs,
-	);
-	if (seen === "match") {
-		updateResultClaim(claim, { state: "delivered" }, fsApi);
-		removeResultClaim(claim, fsApi);
-		return { status: "done" };
-	}
-	if (seen === "conflict") {
-		quarantineClaim(context, claim);
-		return { status: "done" };
-	}
-	const claimResult = await deliverClaimedCompletion(
-		claimKey,
-		sourceSignature,
-		context.completionTtlMs,
-		{
-			isOwned: () => context.isActive() && context.ownsResult(data),
-			onState: (value) => markClaimState(claim!, value, fsApi),
-			intercom: envelope.intercom
-				? async (frozen) => {
-						const payload = buildSubagentResultIntercomPayload(frozen.intercom!);
-						payload.requestId = `completion-${stableHash}`;
-						return deliverSubagentResultIntercomEvent(
-							context.pi.events,
-							payload,
-							context.intercomTimeoutMs ?? 500,
-						);
-					}
-				: undefined,
-			local: async (frozen) =>
-				deliverLocalCompletionNotification(context.pi.events, frozen.local, `completion-notify-${stableHash}`),
-		},
-		context.maxNoProgressFailures,
-		{
-			envelope: claim.meta.envelope,
-			intercomDelivered: claim.meta.intercomDelivered,
-			localDelivered: claim.meta.localDelivered,
-			noProgressFailures: claim.meta.noProgressFailures,
-		},
-		envelope,
-	);
-	if (claimResult.status === "retry" || claimResult.status === "released") {
-		return context.isActive() && context.ownsResult(data)
-			? { status: "delivery-retry", entry: claimScheduleKey(claim.id) }
-			: { status: "inactive" };
-	}
-	if (claimResult.status === "conflict" || claimResult.status === "exhausted") {
-		quarantineClaim(context, claim);
-		return { status: "done" };
-	}
-	recordSeen(context.state.completionSeen, completionKey, Date.now(), sourceSignature);
-	updateResultClaim(claim, { state: "delivered" }, fsApi);
-	removeResultClaim(claim, fsApi);
-	return { status: "done" };
-}

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

@@ -1,166 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { GroupedResultIntercomMessageInput } from "../../intercom/result-intercom.ts";
-import type { ResultFileData } from "./result-watcher-data.js";
-
-const CLAIMS_DIR = ".claims";
-const CLAIM_SCHEDULE_PREFIX = "@claim/";
-
-export interface FrozenCompletionEnvelope {
-	local: Record<string, unknown>;
-	intercom?: GroupedResultIntercomMessageInput;
-}
-export interface ResultFileClaimMeta {
-	version: 1;
-	id: string;
-	originalFile: string;
-	state: "active" | "delivered" | "undelivered";
-	createdAt: number;
-	sourceSignature?: string;
-	envelope?: FrozenCompletionEnvelope;
-	intercomDelivered?: boolean;
-	localDelivered?: boolean;
-	noProgressFailures?: number;
-}
-
-export interface ResultFileClaim {
-	id: string;
-	dir: string;
-	payloadPath: string;
-	metaPath: string;
-	meta: ResultFileClaimMeta;
-}
-
-export interface ResultClaimFs {
-	mkdirSync?: typeof fs.mkdirSync;
-	renameSync?: typeof fs.renameSync;
-	readFileSync?: typeof fs.readFileSync;
-	writeFileSync?: typeof fs.writeFileSync;
-	readdirSync?: typeof fs.readdirSync;
-	rmSync?: typeof fs.rmSync;
-	rmdirSync?: typeof fs.rmdirSync;
-}
-
-function api(fsApi: ResultClaimFs) {
-	return {
-		mkdirSync: fsApi.mkdirSync ?? fs.mkdirSync,
-		renameSync: fsApi.renameSync ?? fs.renameSync,
-		readFileSync: fsApi.readFileSync ?? fs.readFileSync,
-		writeFileSync: fsApi.writeFileSync ?? fs.writeFileSync,
-		rmSync: fsApi.rmSync ?? fs.rmSync,
-		rmdirSync: fsApi.rmdirSync ?? fs.rmdirSync,
-	};
-}
-
-export function claimScheduleKey(id: string): string {
-	return `${CLAIM_SCHEDULE_PREFIX}${id}`;
-}
-
-export function claimIdFromScheduleKey(key: string): string | undefined {
-	return key.startsWith(CLAIM_SCHEDULE_PREFIX) ? key.slice(CLAIM_SCHEDULE_PREFIX.length) : undefined;
-}
-
-export function loadResultClaim(
-	resultsDir: string,
-	id: string,
-	fsApi: ResultClaimFs = fs,
-): ResultFileClaim | undefined {
-	try {
-		const dir = path.join(resultsDir, CLAIMS_DIR, id);
-		const metaPath = path.join(dir, "claim.json");
-		const payloadPath = path.join(dir, "result.json");
-		const meta = JSON.parse((fsApi.readFileSync ?? fs.readFileSync)(metaPath, "utf-8")) as ResultFileClaimMeta;
-		if (meta.version !== 1 || meta.id !== id || !path.basename(meta.originalFile)) return undefined;
-		return { id, dir, payloadPath, metaPath, meta };
-	} catch {
-		return undefined;
-	}
-}
-
-export function listResultClaims(resultsDir: string, fsApi: ResultClaimFs = fs): ResultFileClaim[] {
-	const claimsDir = path.join(resultsDir, CLAIMS_DIR);
-	try {
-		return (fsApi.readdirSync ?? fs.readdirSync)(claimsDir, { withFileTypes: true })
-			.filter((entry) => entry.isDirectory())
-			.map((entry) => loadResultClaim(resultsDir, entry.name, fsApi))
-			.filter((claim): claim is ResultFileClaim => Boolean(claim));
-	} catch {
-		return [];
-	}
-}
-
-export function claimPublicResult(
-	resultsDir: string,
-	file: string,
-	fsApi: ResultClaimFs = fs,
-	createId: () => string = randomUUID,
-): ResultFileClaim {
-	const f = api(fsApi);
-	const claimsDir = path.join(resultsDir, CLAIMS_DIR);
-	f.mkdirSync(claimsDir, { recursive: true });
-	for (let attempt = 0; attempt < 16; attempt += 1) {
-		const id = createId();
-		const dir = path.join(claimsDir, id);
-		try {
-			f.mkdirSync(dir);
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code === "EEXIST") continue;
-			throw error;
-		}
-		const metaPath = path.join(dir, "claim.json");
-		const payloadPath = path.join(dir, "result.json");
-		const meta: ResultFileClaimMeta = {
-			version: 1,
-			id,
-			originalFile: path.basename(file),
-			state: "active",
-			createdAt: Date.now(),
-		};
-		try {
-			f.writeFileSync(metaPath, `${JSON.stringify(meta)}\n`, "utf-8");
-			f.renameSync(path.join(resultsDir, file), payloadPath);
-			return { id, dir, payloadPath, metaPath, meta };
-		} catch (error) {
-			f.rmSync(dir, { recursive: true, force: true });
-			throw error;
-		}
-	}
-	throw new Error(`Unable to allocate a result claim for '${file}'`);
-}
-
-export function readClaimData(
-	claim: ResultFileClaim,
-	fsApi: ResultClaimFs = fs,
-): { raw: string; data: ResultFileData } {
-	const raw = (fsApi.readFileSync ?? fs.readFileSync)(claim.payloadPath, "utf-8");
-	return { raw, data: JSON.parse(raw) as ResultFileData };
-}
-
-export function updateResultClaim(
-	claim: ResultFileClaim,
-	patch: Partial<Omit<ResultFileClaimMeta, "version" | "id" | "originalFile" | "createdAt">>,
-	fsApi: ResultClaimFs = fs,
-): void {
-	const f = api(fsApi);
-	claim.meta = { ...claim.meta, ...patch };
-	const temporary = path.join(claim.dir, `.claim-${randomUUID()}.tmp`);
-	f.writeFileSync(temporary, `${JSON.stringify(claim.meta)}\n`, "utf-8");
-	f.renameSync(temporary, claim.metaPath);
-}
-
-export function removeResultClaim(claim: ResultFileClaim, fsApi: ResultClaimFs = fs): void {
-	const f = api(fsApi);
-	f.rmSync(claim.dir, { recursive: true, force: true });
-	try {
-		f.rmdirSync(path.dirname(claim.dir));
-	} catch {
-		/* another active claim keeps the shared directory */
-	}
-}
-
-export function recoverTerminalClaim(claim: ResultFileClaim, fsApi: ResultClaimFs = fs): "active" | "removed" {
-	if (claim.meta.state === "active") return "active";
-	removeResultClaim(claim, fsApi);
-	return "removed";
-}

package/dist/builtin/subagents/src/runs/background/result-quarantine.ts

@@ -1,77 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import {
-	type ExclusivePublicationFs,
-	errorCode,
-	publishFileExclusive,
-	unlinkIfPresent,
-} from "../../shared/exclusive-file-publication.js";
-
-interface QuarantineFs extends ExclusivePublicationFs {
-	mkdirSync: typeof fs.mkdirSync;
-	existsSync?: typeof fs.existsSync;
-	openSync?: typeof fs.openSync;
-	readSync?: typeof fs.readSync;
-	closeSync?: typeof fs.closeSync;
-}
-
-function hashFile(file: string, fsApi: QuarantineFs): string {
-	const hash = createHash("sha256");
-	const open = fsApi.openSync ?? fs.openSync;
-	const read = fsApi.readSync ?? fs.readSync;
-	const close = fsApi.closeSync ?? fs.closeSync;
-	const handle = open(file, "r");
-	try {
-		const chunk = Buffer.allocUnsafe(64 * 1024);
-		let offset = 0;
-		while (true) {
-			const count = read(handle, chunk, 0, chunk.length, offset);
-			if (count === 0) break;
-			hash.update(chunk.subarray(0, count));
-			offset += count;
-		}
-	} finally {
-		close(handle);
-	}
-	return hash.digest("hex");
-}
-
-function stableClaimId(resultPath: string): string {
-	const parent = path.dirname(resultPath);
-	if (path.basename(path.dirname(parent)) === ".claims") return path.basename(parent);
-	return createHash("sha256").update(path.resolve(resultPath)).digest("hex").slice(0, 16);
-}
-
-/** Retain one exact claimed result without overwriting or duplicating prior evidence. */
-export function quarantineResultFile(
-	resultsDir: string,
-	file: string,
-	resultPath: string,
-	fsApi: QuarantineFs = fs,
-	createId: () => string = randomUUID,
-): string {
-	const quarantineDir = path.join(resultsDir, ".undelivered");
-	fsApi.mkdirSync(quarantineDir, { recursive: true });
-	const stem = path.basename(file, path.extname(file)).replace(/[^a-zA-Z0-9._-]/g, "_");
-	const contentHash = hashFile(resultPath, fsApi);
-	const claimId = stableClaimId(resultPath);
-	for (let attempt = 0; attempt < 16; attempt += 1) {
-		const suffix = attempt === 0 ? claimId : createId();
-		const destination = path.join(quarantineDir, `${stem}-${suffix}-${contentHash.slice(0, 20)}.json`);
-		const publication = publishFileExclusive(resultPath, destination, fsApi);
-		if (publication === "exists") {
-			try {
-				if (hashFile(destination, fsApi) !== contentHash) continue;
-			} catch (error) {
-				if (errorCode(error) === "ENOENT") continue;
-				throw error;
-			}
-		}
-		// If cleanup fails, the deterministic destination remains authoritative.
-		// A retry recognizes it and retries only this unlink instead of copying again.
-		unlinkIfPresent(resultPath, fsApi);
-		return destination;
-	}
-	throw new Error(`Unable to allocate a collision-free quarantine path for '${resultPath}'`);
-}