pi-subagents 0.69.0 → 0.70.0

package/src/runs/background/owned-process-tree.ts

@@ -1,131 +0,0 @@
-import { spawnSync } from "node:child_process";
-import type { ProcessTreeTerminal } from "../../shared/types.ts";
-
-const DEFAULT_TERM_GRACE_MS = 3000;
-const DEFAULT_KILL_VERIFY_MS = 1000;
-const VERIFY_INTERVAL_MS = 25;
-
-type SignalResult = "sent" | "absent" | { diagnostic: string };
-
-function diagnostic(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function signalProcess(id: number, signal: NodeJS.Signals): SignalResult {
-	try {
-		process.kill(id, signal);
-		return "sent";
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ESRCH") return "absent";
-		return { diagnostic: diagnostic(error) };
-	}
-}
-
-function activeProcessGroupMembers(processGroupId: number): number[] | { diagnostic: string } {
-	const result = spawnSync("ps", ["-axo", "pid=,pgid=,stat="], { encoding: "utf-8" });
-	if (result.error || result.status !== 0) {
-		return { diagnostic: result.error ? diagnostic(result.error) : (result.stderr.trim() || `ps exited with ${result.status}`) };
-	}
-	const members: number[] = [];
-	for (const line of result.stdout.split("\n")) {
-		const match = /^\s*(\d+)\s+(\d+)\s+(\S+)/.exec(line);
-		if (!match || Number(match[2]) !== processGroupId || match[3]!.startsWith("Z")) continue;
-		members.push(Number(match[1]));
-	}
-	return members;
-}
-
-function knownDetachedDescendants(processGroupId: number): number[] {
-	const result = spawnSync("ps", ["-axo", "pid=,ppid=,pgid=,stat="], { encoding: "utf-8" });
-	if (result.error || result.status !== 0) return [];
-	const owned = new Set<number>();
-	const outside: { pid: number; ppid: number }[] = [];
-	for (const line of result.stdout.split("\n")) {
-		const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)/.exec(line);
-		if (!match || match[4]!.startsWith("Z")) continue;
-		const pid = Number(match[1]);
-		const ppid = Number(match[2]);
-		const pgid = Number(match[3]);
-		if (pgid === processGroupId) owned.add(pid);
-		else outside.push({ pid, ppid });
-	}
-	return outside.filter((row) => owned.has(row.ppid)).map((row) => row.pid);
-}
-
-async function waitUntilGroupTerminal(
-	processGroupId: number,
-	timeoutMs: number,
-): Promise<false | { state: "enumeration-failed" | "still-active"; diagnostic: string }> {
-	const deadline = Date.now() + timeoutMs;
-	while (true) {
-		const members = activeProcessGroupMembers(processGroupId);
-		if (Array.isArray(members) && members.length === 0) return false;
-		const remaining = deadline - Date.now();
-		if (remaining <= 0) {
-			if (!Array.isArray(members)) return { state: "enumeration-failed", diagnostic: members.diagnostic };
-			return { state: "still-active", diagnostic: `Process group ${processGroupId} still has active members: ${members.join(", ")}.` };
-		}
-		await new Promise<void>((resolve) => setTimeout(resolve, Math.min(VERIFY_INTERVAL_MS, remaining)));
-	}
-}
-
-function observed(processGroupId: number): ProcessTreeTerminal {
-	return { state: "observed", mechanism: "posix-process-group", processGroupId, verifiedAt: Date.now() };
-}
-
-function observedUnlessLiveDetached(processGroupId: number, detached: readonly number[]): ProcessTreeTerminal {
-	const live = detached.filter((pid) => {
-		const result = spawnSync("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf-8" });
-		return result.status === 0 && Boolean(result.stdout.trim()) && !result.stdout.trim().startsWith("Z");
-	});
-	if (live.length === 0) return observed(processGroupId);
-	return { state: "unknown", reason: "verification-failed", diagnostic: `Owned detached descendant(s) still active: ${live.join(", ")}.` };
-}
-
-/** Owns one writer process group and arbitrates its cleanup exactly once. */
-export interface OwnedProcessTreeController {
-	terminate(): Promise<ProcessTreeTerminal>;
-	finishAfterWriterClose(): Promise<ProcessTreeTerminal>;
-}
-
-export function createOwnedProcessTreeController(
-	pid: number,
-	options: { termGraceMs?: number; killVerifyMs?: number } = {},
-): OwnedProcessTreeController {
-	let termination: Promise<ProcessTreeTerminal> | undefined;
-	const posixGroupOwned = process.platform !== "win32";
-	const target = posixGroupOwned ? -pid : pid;
-
-	const terminate = (): Promise<ProcessTreeTerminal> => {
-		if (termination) return termination;
-		termination = (async () => {
-			if (!posixGroupOwned) {
-				signalProcess(target, "SIGTERM");
-				return { state: "unknown", reason: "unsupported-platform" };
-			}
-			const detached = knownDetachedDescendants(pid);
-			const term = signalProcess(target, "SIGTERM");
-			if (term !== "sent" && term !== "absent") {
-				return { state: "unknown", reason: "signal-failed", diagnostic: term.diagnostic };
-			}
-			const termExit = await waitUntilGroupTerminal(pid, options.termGraceMs ?? DEFAULT_TERM_GRACE_MS);
-			if (termExit === false) return observedUnlessLiveDetached(pid, detached);
-
-			const kill = signalProcess(target, "SIGKILL");
-			if (kill !== "sent" && kill !== "absent") {
-				const members = activeProcessGroupMembers(pid);
-				if (!Array.isArray(members) || members.length > 0) {
-					return { state: "unknown", reason: "signal-failed", diagnostic: kill.diagnostic };
-				}
-			}
-			const killExit = await waitUntilGroupTerminal(pid, options.killVerifyMs ?? DEFAULT_KILL_VERIFY_MS);
-			if (killExit !== false) {
-				return { state: "unknown", reason: "verification-failed", diagnostic: killExit.diagnostic };
-			}
-			return observedUnlessLiveDetached(pid, detached);
-		})();
-		return termination;
-	};
-
-	return { terminate, finishAfterWriterClose: terminate };
-}

package/src/runs/background/parallel-groups.ts

@@ -1,45 +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/src/runs/background/process-terminal.ts

@@ -1,310 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { writeAtomicJson, writePrivateAtomicJson } from "../../shared/atomic-json.ts";
-import {
-	SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
-	type AsyncStatus,
-	type CanonicalSessionTerminal,
-	type ProcessInstanceExit,
-	type ProcessTerminalReason,
-	type ProcessTerminal,
-} from "../../shared/types.ts";
-import { canonicalSessionId, inspectSessionLease } from "../shared/session-lease.ts";
-import { releaseActiveRunIndex } from "./active-run-index.ts";
-
-export interface ProcessTerminalCandidate {
-	version: 1;
-	runId: string;
-	runnerProcessInstanceId: string;
-	writers: Record<string, ProcessInstanceExit[]>;
-	expectedWriters?: Record<string, number>;
-	sessionFile?: string;
-	revivalLeaseToken?: string;
-	revivalLeaseReleaseAcknowledged?: boolean;
-}
-
-export interface RunnerCloseObservation {
-	processInstanceId: string;
-	closeObservedAt: number;
-	exitCode: number | null;
-	signal: string | null;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-function validProcessInstance(value: unknown, kind?: "runner" | "pi-writer"): value is ProcessInstanceExit {
-	if (!isRecord(value)) return false;
-	if (typeof value.processInstanceId !== "string" || value.processInstanceId.length === 0) return false;
-	if (kind ? value.kind !== kind : (value.kind !== "runner" && value.kind !== "pi-writer")) return false;
-	if (typeof value.closeObservedAt !== "number" || !Number.isFinite(value.closeObservedAt)) return false;
-	if (typeof value.exitCode !== "number" && value.exitCode !== null) return false;
-	if (typeof value.signal !== "string" && value.signal !== null) return false;
-	if (value.kind === "runner") return value.attempt === undefined;
-	if (typeof value.attempt !== "number" || !Number.isInteger(value.attempt) || value.attempt < 0 || !isRecord(value.processTree)) return false;
-	if (value.processTree.state === "observed") {
-		return value.processTree.mechanism === "posix-process-group"
-			&& typeof value.processTree.processGroupId === "number"
-			&& Number.isInteger(value.processTree.processGroupId)
-			&& value.processTree.processGroupId > 0
-			&& typeof value.processTree.verifiedAt === "number"
-			&& Number.isFinite(value.processTree.verifiedAt);
-	}
-	return value.processTree.state === "unknown"
-		&& ["unsupported-platform", "signal-failed", "verification-failed"].includes(String(value.processTree.reason))
-		&& (value.processTree.diagnostic === undefined || typeof value.processTree.diagnostic === "string");
-}
-
-function validInstance(value: unknown): value is ProcessInstanceExit {
-	return validProcessInstance(value, "pi-writer");
-}
-
-export function processTerminalCandidatePath(asyncDir: string): string {
-	return path.join(asyncDir, "process-terminal-candidate.json");
-}
-
-export function processTerminalPath(asyncDir: string): string {
-	return path.join(asyncDir, "process-terminal.json");
-}
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-export function readProcessTerminalCandidate(asyncDir: string): ProcessTerminalCandidate | undefined {
-	try {
-		const raw = JSON.parse(fs.readFileSync(processTerminalCandidatePath(asyncDir), "utf-8")) as unknown;
-		if (!isRecord(raw) || raw.version !== 1 || typeof raw.runId !== "string" || typeof raw.runnerProcessInstanceId !== "string" || !isRecord(raw.writers)) {
-			throw new Error(`Invalid process-terminal candidate in '${asyncDir}'.`);
-		}
-		const writers: Record<string, ProcessInstanceExit[]> = {};
-		for (const [index, entries] of Object.entries(raw.writers)) {
-			if (!Array.isArray(entries) || !entries.every(validInstance)) throw new Error(`Invalid writer process records for child '${index}'.`);
-			writers[index] = entries;
-		}
-		let expectedWriters: Record<string, number> | undefined;
-		if (raw.expectedWriters !== undefined) {
-			if (!isRecord(raw.expectedWriters)) throw new Error("Invalid expected writer process records.");
-			expectedWriters = {};
-			for (const [index, count] of Object.entries(raw.expectedWriters)) {
-				if (typeof count !== "number" || !Number.isInteger(count) || count < 0) throw new Error(`Invalid expected writer count for child '${index}'.`);
-				expectedWriters[index] = count;
-			}
-		}
-		if (raw.sessionFile !== undefined && typeof raw.sessionFile !== "string") throw new Error("Invalid process-terminal candidate sessionFile.");
-		if (raw.revivalLeaseToken !== undefined && typeof raw.revivalLeaseToken !== "string") throw new Error("Invalid process-terminal candidate lease token.");
-		if (raw.revivalLeaseReleaseAcknowledged !== undefined && typeof raw.revivalLeaseReleaseAcknowledged !== "boolean") throw new Error("Invalid process-terminal lease release acknowledgement.");
-		return {
-			version: 1,
-			runId: raw.runId,
-			runnerProcessInstanceId: raw.runnerProcessInstanceId,
-			writers,
-			...(expectedWriters ? { expectedWriters } : {}),
-			...(typeof raw.sessionFile === "string" && raw.sessionFile ? { sessionFile: raw.sessionFile } : {}),
-			...(typeof raw.revivalLeaseToken === "string" && raw.revivalLeaseToken ? { revivalLeaseToken: raw.revivalLeaseToken } : {}),
-			...(typeof raw.revivalLeaseReleaseAcknowledged === "boolean" ? { revivalLeaseReleaseAcknowledged: raw.revivalLeaseReleaseAcknowledged } : {}),
-		};
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
-		throw error;
-	}
-}
-
-export function writeProcessTerminalCandidate(asyncDir: string, candidate: ProcessTerminalCandidate): void {
-	writePrivateAtomicJson(processTerminalCandidatePath(asyncDir), candidate);
-}
-
-/** Establish ownership before authorizing a runner to start any child session. */
-export function initializeProcessTerminal(asyncDir: string, runId: string, runnerProcessInstanceId: string): void {
-	writeProcessTerminalCandidate(asyncDir, {
-		version: 1,
-		runId,
-		runnerProcessInstanceId,
-		writers: {},
-	});
-	writeAtomicJson(processTerminalPath(asyncDir), {
-		version: 1,
-		state: "pending",
-		runId,
-		runnerProcessInstanceId,
-	});
-}
-
-export function markProcessTerminalCandidateLeaseRelease(asyncDir: string, token: string, acknowledged: boolean): void {
-	const candidate = readProcessTerminalCandidate(asyncDir);
-	if (!candidate || candidate.revivalLeaseToken !== token) return;
-	writeProcessTerminalCandidate(asyncDir, { ...candidate, revivalLeaseReleaseAcknowledged: acknowledged });
-}
-
-function unknownProof(runId: string, runnerProcessInstanceId: string, reason: ProcessTerminalReason, diagnostic?: string): ProcessTerminal {
-	return { version: 1, state: "unknown", runId, runnerProcessInstanceId, reason, ...(diagnostic ? { diagnostic } : {}) };
-}
-
-function resumeDisposition(state: string | undefined, sessionFile: string | undefined): "resumable" | "non-resumable" | "unavailable" {
-	if (state === "stopped") return "non-resumable";
-	if (state !== "complete" && state !== "completed" && state !== "failed" && state !== "paused") return "unavailable";
-	return sessionFile && fs.existsSync(sessionFile) ? "resumable" : "unavailable";
-}
-
-function sessionProjection(candidate: ProcessTerminalCandidate, lease: ReturnType<typeof inspectSessionLease>): CanonicalSessionTerminal | undefined {
-	if (!candidate.sessionFile || lease.state !== "free") return undefined;
-	if (candidate.revivalLeaseToken && candidate.revivalLeaseReleaseAcknowledged !== true) return undefined;
-	return {
-		canonicalSessionId: canonicalSessionId(candidate.sessionFile),
-		leaseDisposition: candidate.revivalLeaseToken ? "released" : "not-held",
-		freeAtObservation: true,
-		...(candidate.revivalLeaseToken ? { canonicalSessionLeaseReleased: true } : {}),
-	};
-}
-
-function validateProof(raw: unknown, asyncDir: string, fallback?: { runId?: string; runnerProcessInstanceId?: string }): raw is ProcessTerminal {
-	if (!isRecord(raw) || raw.version !== 1 || !["pending", "observed", "unknown", "not-started"].includes(String(raw.state)) || typeof raw.runId !== "string" || !raw.runId || typeof raw.runnerProcessInstanceId !== "string" || !raw.runnerProcessInstanceId) {
-		throw new Error(`Invalid process-terminal proof in '${asyncDir}'.`);
-	}
-	if (fallback?.runId && raw.runId !== fallback.runId) throw new Error(`Process-terminal proof in '${asyncDir}' belongs to run '${raw.runId}', expected '${fallback.runId}'.`);
-	if (fallback?.runnerProcessInstanceId && raw.runnerProcessInstanceId !== fallback.runnerProcessInstanceId) throw new Error(`Process-terminal proof in '${asyncDir}' belongs to runner '${raw.runnerProcessInstanceId}', expected '${fallback.runnerProcessInstanceId}'.`);
-	if (raw.instances !== undefined && (!Array.isArray(raw.instances) || !raw.instances.every((entry) => validProcessInstance(entry)))) {
-		throw new Error(`Invalid process-terminal instances in '${asyncDir}'.`);
-	}
-	if (raw.state === "observed") {
-		if (typeof raw.observedAt !== "number" || !Number.isFinite(raw.observedAt)) throw new Error(`Observed process-terminal proof in '${asyncDir}' is missing observedAt.`);
-		if (!Array.isArray(raw.instances)) throw new Error(`Observed process-terminal proof in '${asyncDir}' is missing instances.`);
-		const runner = raw.instances.find((entry) => isRecord(entry) && entry.kind === "runner");
-		if (!validProcessInstance(runner, "runner") || runner.processInstanceId !== raw.runnerProcessInstanceId) throw new Error(`Observed process-terminal proof in '${asyncDir}' has no matching runner instance.`);
-	}
-	if (raw.resumeDisposition !== undefined && !["resumable", "non-resumable", "unavailable"].includes(String(raw.resumeDisposition))) throw new Error(`Invalid process-terminal resume disposition in '${asyncDir}'.`);
-	return true;
-}
-
-export function sanitizeProcessTerminal(value: unknown, fallback: { runId?: string; runnerProcessInstanceId?: string }, label = "status"): ProcessTerminal | undefined {
-	if (value === undefined) return undefined;
-	try {
-		validateProof(value, label, fallback);
-		return value as ProcessTerminal;
-	} catch (error) {
-		return unknownProof(fallback.runId ?? label, fallback.runnerProcessInstanceId ?? "unknown", "proof-write-failed", errorMessage(error));
-	}
-}
-
-export function readProcessTerminal(asyncDir: string, fallback?: { runId?: string; runnerProcessInstanceId?: string }): ProcessTerminal | undefined {
-	try {
-		const raw = JSON.parse(fs.readFileSync(processTerminalPath(asyncDir), "utf-8")) as unknown;
-		validateProof(raw, asyncDir, fallback);
-		return raw as ProcessTerminal;
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
-		return unknownProof(fallback?.runId ?? path.basename(asyncDir), fallback?.runnerProcessInstanceId ?? "unknown", "proof-write-failed", errorMessage(error));
-	}
-}
-
-function stepProcessTerminalProof(
-	proof: ProcessTerminal,
-	childIndex: number,
-	state: ProcessTerminal["state"],
-	records: ProcessInstanceExit[],
-	resumeDispositionValue: ProcessTerminal["resumeDisposition"],
-): ProcessTerminal {
-	const base = {
-		version: 1 as const,
-		runId: proof.runId,
-		childIndex,
-		runnerProcessInstanceId: proof.runnerProcessInstanceId,
-		...(resumeDispositionValue ? { resumeDisposition: resumeDispositionValue } : {}),
-	};
-	if (state === "observed") {
-		return { ...base, state, observedAt: proof.state === "observed" ? proof.observedAt : Date.now(), instances: records };
-	}
-	if (state === "unknown") {
-		return { ...base, state, reason: proof.state === "unknown" ? proof.reason : "writer-close-unverified" };
-	}
-	return { ...base, state };
-}
-
-function overlayStatus(asyncDir: string, proof: ProcessTerminal, candidate?: ProcessTerminalCandidate): void {
-	const statusPath = path.join(asyncDir, "status.json");
-	try {
-		const status = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as AsyncStatus;
-		status.processTerminal = proof;
-		if (status.steps) {
-			for (const [index, step] of status.steps.entries()) {
-				const records = candidate?.writers[String(index)] ?? [];
-				const expected = candidate?.expectedWriters?.[String(index)] ?? (records.length > 0 ? records.length : 0);
-				const stepState = expected === 0 ? "not-started" : proof.state === "observed" && records.length === expected ? "observed" : proof.state === "pending" ? "pending" : "unknown";
-				step.processTerminal = stepProcessTerminalProof(proof, index, stepState, records, resumeDisposition(step.status, step.sessionFile ?? candidate?.sessionFile));
-			}
-		}
-		writeAtomicJson(statusPath, status);
-	} catch {
-		// The proof sidecar remains authoritative when terminal status is unavailable.
-	}
-}
-
-export function finalizeProcessTerminal(
-	asyncDir: string,
-	runId: string,
-	runnerClose: RunnerCloseObservation,
-): ProcessTerminal {
-	const existing = readProcessTerminal(asyncDir, { runId, runnerProcessInstanceId: runnerClose.processInstanceId });
-	if (existing && fs.existsSync(processTerminalPath(asyncDir))) {
-		if (existing.state === "observed" && existing.runId === runId && existing.runnerProcessInstanceId === runnerClose.processInstanceId) return existing;
-		if (existing.state === "unknown") return existing;
-	}
-	let proof: ProcessTerminal;
-	let candidateForOverlay: ProcessTerminalCandidate | undefined;
-	try {
-		const candidate = readProcessTerminalCandidate(asyncDir);
-		candidateForOverlay = candidate;
-		if (!candidate) proof = unknownProof(runId, runnerClose.processInstanceId, "runner-candidate-missing");
-		else if (candidate.runId !== runId || candidate.runnerProcessInstanceId !== runnerClose.processInstanceId) proof = unknownProof(runId, runnerClose.processInstanceId, "runner-instance-mismatch");
-		else {
-			const allWriters = Object.values(candidate.writers).flat();
-			const status = (() => {
-				try { return JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatus; } catch { return undefined; }
-			})();
-			const session = candidate.sessionFile ? inspectSessionLease(candidate.sessionFile) : undefined;
-			const writerEntries = Object.entries(candidate.writers);
-			const expectedWriters = candidate.expectedWriters ?? Object.fromEntries(writerEntries.map(([index, records]) => [index, records.length]));
-			const expectedEntries = Object.entries(expectedWriters);
-			const expectedIndexes = new Set(expectedEntries.map(([index]) => index));
-			const writerIndexes = new Set(writerEntries.map(([index]) => index));
-			const inconsistentWriters = writerEntries.some(([index, records]) => !expectedIndexes.has(index) || records.length !== expectedWriters[index])
-				|| expectedEntries.some(([index, expected]) => !writerIndexes.has(index) && expected !== 0);
-			if (session && session.state !== "free") {
-				proof = unknownProof(runId, runnerClose.processInstanceId, session.state === "owned" ? "canonical-session-lease-active" : "canonical-session-unavailable");
-			} else if (candidate.revivalLeaseToken && candidate.revivalLeaseReleaseAcknowledged !== true) {
-				proof = unknownProof(runId, runnerClose.processInstanceId, "canonical-session-release-unverified");
-			} else if (inconsistentWriters || (allWriters.length === 0 && expectedEntries.length === 0)) {
-				proof = unknownProof(runId, runnerClose.processInstanceId, "writer-close-unverified");
-			} else if (allWriters.some((writer) => writer.kind === "pi-writer" && writer.processTree.state !== "observed")) {
-				proof = unknownProof(runId, runnerClose.processInstanceId, "process-tree-unverified");
-			} else {
-				const runner: ProcessInstanceExit = { kind: "runner", ...runnerClose };
-				const canonicalSession = session && sessionProjection(candidate, session);
-				proof = {
-					version: 1,
-					state: "observed",
-					runId,
-					runnerProcessInstanceId: runnerClose.processInstanceId,
-					observedAt: runnerClose.closeObservedAt,
-					instances: [runner, ...allWriters],
-					resumeDisposition: resumeDisposition(status?.state, candidate.sessionFile ?? status?.sessionFile),
-					...(canonicalSession ? { canonicalSession } : {}),
-				};
-			}
-		}
-	} catch (error) {
-		proof = unknownProof(runId, runnerClose.processInstanceId, "proof-write-failed", errorMessage(error));
-	}
-	let durable = false;
-	try {
-		writeAtomicJson(processTerminalPath(asyncDir), proof);
-		durable = true;
-		if (proof.state === "observed") releaseActiveRunIndex(asyncDir);
-		overlayStatus(asyncDir, proof, candidateForOverlay);
-		fs.appendFileSync(path.join(asyncDir, "events.jsonl"), `${JSON.stringify({ type: "subagent.run.process_terminal", lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION, ts: Date.now(), runId, processTerminal: proof })}\n`, "utf-8");
-	} catch {
-		// Do not emit a process-terminal event when the proof sidecar was not durable.
-	}
-	return durable ? proof : unknownProof(runId, runnerClose.processInstanceId, "proof-write-failed", "Failed to persist process-terminal proof.");
-}

package/src/runs/background/result-delivery-ownership.ts

@@ -1,45 +0,0 @@
-import type { SubagentState } from "../../shared/types.ts";
-
-const MAX_CLAIMED_PREDECESSOR_SESSIONS = 8;
-
-type ResultDeliveryState = Pick<SubagentState, "currentSessionId" | "completionOwnerId">;
-
-export interface ResultDeliveryOwnership {
-	owns(sessionId: string, completionOwnerId: unknown): boolean;
-	claimedSessionIds(): readonly string[];
-	claimPredecessor(previousSessionFile: string | undefined, previousRuntimeSessionId: string | null): boolean;
-	clear(): void;
-}
-
-export function createResultDeliveryOwnership(state: ResultDeliveryState): ResultDeliveryOwnership {
-	const claimed = new Map<string, string>();
-
-	const currentOwner = (): string | undefined => typeof state.completionOwnerId === "string" && state.completionOwnerId
-		? state.completionOwnerId
-		: undefined;
-
-	return {
-		owns(sessionId, completionOwnerId) {
-			const owner = currentOwner();
-			if (!owner || completionOwnerId !== owner) return false;
-			return sessionId === state.currentSessionId || claimed.get(sessionId) === owner;
-		},
-		claimedSessionIds() {
-			const owner = currentOwner();
-			if (!owner) return [];
-			return [...claimed].flatMap(([sessionId, claimedOwner]) => claimedOwner === owner ? [sessionId] : []);
-		},
-		claimPredecessor(previousSessionFile, previousRuntimeSessionId) {
-			const owner = currentOwner();
-			if (!owner || !previousSessionFile || !previousRuntimeSessionId) return false;
-			if (previousSessionFile !== previousRuntimeSessionId || state.currentSessionId !== previousRuntimeSessionId) return false;
-			claimed.delete(previousRuntimeSessionId);
-			claimed.set(previousRuntimeSessionId, owner);
-			while (claimed.size > MAX_CLAIMED_PREDECESSOR_SESSIONS) claimed.delete(claimed.keys().next().value!);
-			return true;
-		},
-		clear() {
-			claimed.clear();
-		},
-	};
-}