@loucompanion/forge-bridge 0.1.3-dev.f66395c3ac21 → 0.1.4-dev.1ff37038366e

package/dist/runtime/host-runtime-lease.js

@@ -0,0 +1,2487 @@
+import fs from "node:fs/promises";
+import { statfsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { assertHostAttemptRootIdentity, retainHostDiagnostics } from "./host-diagnostics.js";
+import { assertHostExecutionRoot, compactHostAttemptId } from "./host-execution-root.js";
+import { PreparedRuntimeReadiness } from "./prepared-runtime-readiness.js";
+import { preparedRuntimeIdentity } from "./prepared-runtime-identity.js";
+import { resolveExistingDirectoryPath } from "../shared/path/path.js";
+import { formatBytes } from "../shared/format/format-bytes.js";
+import { redactText } from "../shared/redaction/redaction.js";
+import { StreamingProviderProcessRunner, } from "../session/provider-cli/provider-cli.process.js";
+import { createRuntimeIsolationLease, renewRuntimeIsolationLease, transitionRuntimeIsolationLease, validRuntimeIsolationLease, withRuntimeIsolationResources, } from "./runtime-isolation-lease.js";
+import { hostPortEnvironment, loadHostRuntimeContract, } from "./host-runtime-contract.js";
+import { HostPortBroker, } from "./host-port-broker.js";
+import { NodeHostRuntimeAdapter, } from "./node-host-runtime-adapter.js";
+import { AttemptProcessSupervisorRegistry } from "./attempt-process-supervisor-registry.js";
+import { attemptDatabaseCapabilityEnvironment, attemptDatabaseCapabilitySecrets, } from "./attempt-database-broker.js";
+import { AttemptNodeRuntimeLauncher } from "./attempt-node-runtime-launcher.js";
+import { HostListenerInspector } from "./host-listener-inspector.js";
+import { RecoveryStabilizedMemory, buildMemoryAdmissionDiagnostics, resolveAdaptiveMemoryReserveBytes, } from "./memory-capacity.js";
+import { PlaywrightHostRuntimeAdapter } from "./playwright-host-runtime-adapter.js";
+import { HostParallelPromotionStore, configuredLaunchPortNames, hostRuntimeContractFingerprint, hostRuntimeParallelEligible, } from "./host-runtime-promotion.js";
+import { ExactHostProcessRecovery, } from "../shared/process/host-process-recovery.js";
+import { resetGeneratedOutputs } from "./generated-output-reset.js";
+import { assertCanonicalDirectory, createCanonicalDirectory } from "./attempt-private-directory.js";
+import { readCanonicalSourceFile } from "./canonical-source-file.js";
+import { readPinnedSourceDirectory } from "./pinned-source-directory.js";
+import { architectMinimumWorkspaceEstimateBytes } from "./workspace-resource-estimator.js";
+import { createAspNetRuntimePrebuildPlan, ensureAspNetRuntimePrebuilt, resolveWorktreeCommitSha, } from "./aspnet-runtime-prebuild.js";
+const hostCapacityWaiterScanLimit = 64;
+const maximumProcessRecoveryMetadataBytes = 1024 * 1024;
+export class HostRuntimeLeaseManager {
+    stateRoot;
+    processSupervisors;
+    processRunner;
+    listenerInspector;
+    promotionStore;
+    playwrightAdapter;
+    processRecovery;
+    capacityResourceSample;
+    databaseBroker;
+    preparedReadiness;
+    active = new Map();
+    pendingRenewals = new Map();
+    acquiringAdmissions = new Set();
+    admissions = new Map();
+    singletonOwners = new Map();
+    singletonWaiters = [];
+    parallelProjectOwners = new Map();
+    parallelProjectWaiters = [];
+    capacityReservations = new Map();
+    capacityWaiters = [];
+    capacityWaiterScanCursor = 0;
+    backgroundAdmissionWaiters = [];
+    degraded = new Map();
+    knownPromotions = new Map();
+    ledgerWriteTail = Promise.resolve();
+    workspaceAvailableBytes = Number.MAX_SAFE_INTEGER;
+    portBroker;
+    nodeAdapter;
+    capacityConfiguration;
+    memoryAvailability;
+    executionRoot;
+    constructor(stateRoot, portBroker = new HostPortBroker(), nodeAdapter, processSupervisors = new AttemptProcessSupervisorRegistry(), processRunner = new StreamingProviderProcessRunner(), listenerInspector = new HostListenerInspector(), promotionStore = new HostParallelPromotionStore(stateRoot), playwrightAdapter = new PlaywrightHostRuntimeAdapter(), processRecovery = new ExactHostProcessRecovery(), capacityResourceSample, executionRoot, databaseBroker = null) {
+        this.stateRoot = stateRoot;
+        this.processSupervisors = processSupervisors;
+        this.processRunner = processRunner;
+        this.listenerInspector = listenerInspector;
+        this.promotionStore = promotionStore;
+        this.playwrightAdapter = playwrightAdapter;
+        this.processRecovery = processRecovery;
+        this.capacityResourceSample = capacityResourceSample;
+        this.databaseBroker = databaseBroker;
+        this.executionRoot = path.resolve(executionRoot ?? stateRoot);
+        if (executionRoot !== undefined)
+            assertHostExecutionRoot(this.executionRoot);
+        this.preparedReadiness = new PreparedRuntimeReadiness(this, promotionStore, (id, fence) => this.release(id, fence, true), () => new HostRuntimeAdmissionExpiredError());
+        this.portBroker = portBroker;
+        this.nodeAdapter = nodeAdapter ?? new NodeHostRuntimeAdapter(portBroker);
+        this.capacityConfiguration = loadHostCapacityConfiguration(capacityResourceSample);
+        this.memoryAvailability = new RecoveryStabilizedMemory(this.capacityConfiguration.memoryRecoverySamples, this.capacityConfiguration.memoryRecoverySampleIntervalMs);
+    }
+    async reap(options) {
+        await this.refreshKnownPromotions();
+        const recoveredAttempts = [];
+        const report = {
+            examined: 0,
+            reaped: 0,
+            processesTerminated: 0,
+            reusedPidsProtected: 0,
+            degraded: 0,
+            recoveredAttempts,
+        };
+        for (const ledger of await this.readLedgers()) {
+            const lease = ledger.runtimeLease;
+            if (lease.runnerId !== options.runnerId)
+                continue;
+            // A released ledger with its original attempt root is intentionally retained
+            // evidence that exceeded the diagnostics archive budget. It owns no runtime
+            // resources, but still requires process-identity recovery below on restart.
+            if (lease.state === "released") {
+                const attemptRoot = this.attemptRoot(lease.dispatchAttemptId);
+                const rootExists = await fs.stat(attemptRoot).then(() => true, error => {
+                    if (error.code === "ENOENT")
+                        return false;
+                    throw error;
+                });
+                if (!rootExists) {
+                    await fs.rm(this.ledgerPath(lease.dispatchAttemptId), { force: true });
+                    continue;
+                }
+            }
+            const active = this.active.get(lease.dispatchAttemptId);
+            if (active) {
+                if (active.lease.state !== "degraded")
+                    continue;
+                report.examined += 1;
+                try {
+                    const released = await this.release(lease.dispatchAttemptId, lease.fencingToken);
+                    if (released?.state === "released")
+                        report.reaped += 1;
+                    else
+                        report.degraded += 1;
+                }
+                catch {
+                    report.degraded += 1;
+                }
+                continue;
+            }
+            const staleInstance = lease.runnerInstanceId !== options.runnerInstanceId;
+            const expired = Date.parse(lease.expiresAt) <= (options.nowMs ?? Date.now());
+            if (!staleInstance && !expired && lease.state !== "released" && lease.state !== "degraded")
+                continue;
+            report.examined += 1;
+            const attemptRoot = this.attemptRoot(lease.dispatchAttemptId);
+            const attemptRootIdentity = deserializeHostAttemptRootIdentity(ledger.attemptRootIdentity);
+            let outcomes;
+            try {
+                if (!attemptRootIdentity) {
+                    throw new Error("host_runtime_reaper_invalid: original attempt-root identity is unavailable.");
+                }
+                outcomes = await this.recoverPersistedProcesses(lease, attemptRoot, attemptRootIdentity);
+            }
+            catch {
+                await this.markLedgerDegraded(ledger);
+                report.degraded += 1;
+                continue;
+            }
+            report.processesTerminated += outcomes.filter(outcome => outcome === "terminated").length;
+            report.reusedPidsProtected += outcomes.filter(outcome => outcome === "pid_reused").length;
+            if (outcomes.includes("unverifiable")) {
+                await this.markLedgerDegraded(ledger);
+                report.degraded += 1;
+                continue;
+            }
+            // The runtime has already been released. Keep the over-budget original
+            // evidence without re-copying it or reacquiring a capacity claim.
+            if (lease.state === "released")
+                continue;
+            // Every supervised tree of this previous-instance attempt is proved gone,
+            // so no provider can still act for it. Diagnostics handling below never
+            // revives a process, so the proof stands even if cleanup degrades. An
+            // attempt with no ownership record at all may have been mid-launch, so
+            // it is not reported and keeps its unknown outcome.
+            if (staleInstance && outcomes.length > 0) {
+                recoveredAttempts.push({
+                    dispatchAttemptId: lease.dispatchAttemptId,
+                    fencingToken: lease.fencingToken,
+                    runnerInstanceId: lease.runnerInstanceId,
+                });
+            }
+            try {
+                const releasing = transitionHostLeaseForCleanup(lease, "releasing");
+                await this.writeLedger(releasing, ledger.repoId, attemptRootIdentity);
+                let evidenceRetainedAtAttemptRoot = false;
+                try {
+                    await retainHostDiagnostics(this.stateRoot, attemptRoot, lease.dispatchAttemptId, attemptRootIdentity, this.executionRoot);
+                }
+                catch {
+                    // Exact process recovery above already proved that the runtime is gone.
+                    // Diagnostics retention can independently refuse a changed inventory,
+                    // an unsafe archive path, or an over-budget source. Preserve the
+                    // original attempt root and a released ledger for reconciliation, but
+                    // never turn evidence-only work back into a capacity-owning runtime.
+                    evidenceRetainedAtAttemptRoot = true;
+                }
+                if (evidenceRetainedAtAttemptRoot) {
+                    const released = transitionRuntimeIsolationLease(releasing, "released");
+                    await this.writeLedger(released, ledger.repoId, attemptRootIdentity);
+                    this.forgetDegraded(lease.dispatchAttemptId, lease.fencingToken);
+                    report.reaped += 1;
+                    continue;
+                }
+                await removeHostAttemptRoot(attemptRoot);
+                await fs.rm(this.ledgerPath(lease.dispatchAttemptId), { force: true });
+                this.forgetDegraded(lease.dispatchAttemptId, lease.fencingToken);
+                report.reaped += 1;
+            }
+            catch {
+                await this.markLedgerDegraded(ledger);
+                report.degraded += 1;
+            }
+        }
+        // Databases issued to attempts that ended without a clean release (a Bridge crash, or a
+        // drop that met a lingering session) are removed once no live lease holds them.
+        // A degraded lease may still own running processes after a restart, so its database is kept.
+        await this.databaseBroker?.reapOrphans(id => this.active.has(id) || this.degraded.has(id)).catch(() => undefined);
+        return report;
+    }
+    snapshot() {
+        this.reconcileReservationOwners();
+        const projects = new Map();
+        for (const promotion of this.knownPromotions.values()) {
+            const project = capacityProject(projects, promotion.repoId);
+            project.safetyClass = conservativeSafetyClass(project.safetyClass, "host_parallel_safe");
+            project.runtimeContractFingerprint = promotion.runtimeContractFingerprint;
+            project.runtimeContractSource = promotion.runtimeContractSource ?? null;
+            project.promotedAt = promotion.observedAt;
+        }
+        for (const [dispatchAttemptId, admission] of this.admissions) {
+            const active = this.active.get(dispatchAttemptId);
+            const project = capacityProject(projects, admission.repoId);
+            if (active) {
+                if (active.lease.state === "degraded") {
+                    project.degradedAttempts += 1;
+                    project.safetyClass = conservativeSafetyClass(project.safetyClass, "host_serial_only");
+                }
+                else {
+                    project.activeAttempts += 1;
+                    const effectiveConcurrency = effectiveHostConcurrency(active.lease, active.runtimeContract, active.executionClass);
+                    project.safetyClass = conservativeSafetyClass(project.safetyClass, effectiveConcurrency === "host_parallel_safe"
+                        ? effectiveConcurrency
+                        : admission.executionClass === "analysis_only"
+                            ? "host_parallel_safe"
+                            : admission.parallelProjectKey && admission.provisionalPromotionFingerprint
+                                ? "host_parallel_candidate"
+                                : "host_serial_only");
+                }
+            }
+            else {
+                project.reservedAttempts += 1;
+                project.safetyClass = conservativeSafetyClass(project.safetyClass, admission.executionClass === "analysis_only"
+                    ? "host_parallel_safe"
+                    : admission.provisionalPromotionFingerprint ? "host_parallel_candidate" : "host_serial_only");
+            }
+        }
+        for (const [dispatchAttemptId, degraded] of this.degraded) {
+            if (this.active.has(dispatchAttemptId) || !degraded.repoId)
+                continue;
+            const project = capacityProject(projects, degraded.repoId);
+            project.degradedAttempts += 1;
+            project.safetyClass = conservativeSafetyClass(project.safetyClass, "host_serial_only");
+        }
+        for (const waiter of this.singletonWaiters) {
+            const repoId = repoIdFromProjectSingletonKeys(waiter.keys);
+            if (!repoId)
+                continue;
+            const project = capacityProject(projects, repoId);
+            project.waitingAttempts += 1;
+            project.safetyClass = conservativeSafetyClass(project.safetyClass, "host_serial_only");
+        }
+        for (const waiter of this.parallelProjectWaiters) {
+            const repoId = repoIdFromProjectSingletonKey(waiter.key);
+            if (!repoId)
+                continue;
+            const project = capacityProject(projects, repoId);
+            project.waitingAttempts += 1;
+            project.safetyClass = conservativeSafetyClass(project.safetyClass, "host_parallel_candidate");
+        }
+        for (const waiter of this.backgroundAdmissionWaiters) {
+            const repoId = repoIdFromProjectSingletonKeys(waiter.keys);
+            if (!repoId)
+                continue;
+            const project = capacityProject(projects, repoId);
+            project.waitingAttempts += 1;
+            project.safetyClass = conservativeSafetyClass(project.safetyClass, "host_serial_only");
+        }
+        // A prepared-runtime verification remains foreground demand after its
+        // preparation admission is released and before the internal probe has
+        // acquired a normal admission. Report that barrier as waiting capacity so
+        // the server cannot mistake the transient gap for an idle host and dispatch
+        // readiness probes in a tight loop.
+        const unrepresentedPrepared = this.preparedReadiness.pendingSnapshots()
+            .filter(pending => !this.hasAttemptRepresentation(pending.probeDispatchAttemptId ?? pending.dispatchAttemptId, pending.probeFencingToken ?? pending.fencingToken));
+        for (const pending of unrepresentedPrepared) {
+            const project = capacityProject(projects, pending.repoId);
+            project.waitingAttempts += 1;
+            project.safetyClass = conservativeSafetyClass(project.safetyClass, "host_parallel_candidate");
+        }
+        const activeAttempts = [...this.active.values()]
+            .filter(active => active.lease.state !== "degraded").length;
+        const degradedAttempts = new Set([
+            ...this.degraded.keys(),
+            ...[...this.active.entries()]
+                .filter(([, active]) => active.lease.state === "degraded")
+                .map(([dispatchAttemptId]) => dispatchAttemptId),
+        ]).size;
+        const hostResources = this.hostResourceSnapshot();
+        return {
+            activeAttempts,
+            preparedWorktreeReadiness: true,
+            reservedAttempts: Math.max(0, this.admissions.size - this.active.size),
+            waitingAttempts: this.singletonWaiters.length
+                + this.parallelProjectWaiters.length
+                + this.capacityWaiters.length
+                + this.backgroundAdmissionWaiters.length
+                + unrepresentedPrepared.length,
+            degradedAttempts,
+            exclusiveReservations: this.singletonOwners.size,
+            sharedReservations: [...this.parallelProjectOwners.values()]
+                .reduce((count, owners) => count + owners.size, 0),
+            ...hostResources,
+            projects: [...projects.values()]
+                .map(project => ({
+                ...project,
+                safetyClass: project.safetyClass ?? "host_serial_only",
+            }))
+                .sort((left, right) => left.repoId.localeCompare(right.repoId)),
+        };
+    }
+    hasForegroundDemand() {
+        return this.preparedReadiness.hasPending()
+            || [...this.admissions.values()].some(admission => admission.priority === "foreground")
+            || this.singletonWaiters.some(waiter => waiter.priority === "foreground")
+            || this.parallelProjectWaiters.some(waiter => waiter.priority === "foreground")
+            || this.capacityWaiters.some(waiter => waiter.priority === "foreground");
+    }
+    async acquirePreparation(dispatch, signal) {
+        // Discovery probes already own their verification lifecycle. Analysis-only
+        // work never launches the application and must not wait for a runtime wave.
+        if (runtimeExecutionClass(dispatch) === "analysis_only" || runtimeAdmissionPriority(dispatch) === "background") {
+            return await this.acquire(dispatch, signal);
+        }
+        return await this.preparedReadiness.acquire(dispatch, signal);
+    }
+    async acquire(dispatch, signal) {
+        const sandbox = dispatch.sandbox;
+        if (!sandbox || sandbox.executionMode !== "host") {
+            throw new Error("host_runtime_lease_invalid: managed host sandbox context is required.");
+        }
+        uuidHex(sandbox.dispatchAttemptId, "dispatch attempt");
+        uuidHex(dispatch.lease.fencingToken, "fencing token");
+        const owner = {
+            dispatchAttemptId: sandbox.dispatchAttemptId,
+            fencingToken: dispatch.lease.fencingToken,
+        };
+        const existing = this.admissions.get(sandbox.dispatchAttemptId);
+        if (existing) {
+            if (existing.fencingToken !== owner.fencingToken) {
+                throw new Error("host_runtime_singleton_conflict: dispatch attempt already holds admission under a different fence.");
+            }
+            return existing.keys;
+        }
+        const executionClass = runtimeExecutionClass(dispatch);
+        const priority = runtimeAdmissionPriority(dispatch);
+        const promotion = executionClass === "managed_runtime"
+            ? await this.promotionStore.load(dispatch.repo.id)
+            : null;
+        if (promotion)
+            this.knownPromotions.set(promotion.repoId, promotion);
+        const projectKey = executionClass === "analysis_only"
+            ? projectHostAnalysisKey(dispatch.repo.id)
+            : projectHostRuntimeSingletonKey(dispatch.repo.id);
+        const useParallelAdmission = priority === "foreground"
+            && dispatch.cycleRun.phase !== "prepared_readiness"
+            && (promotion !== null || executionClass === "analysis_only");
+        let keys = useParallelAdmission ? [] : [projectKey];
+        const resources = normalizedHostResourceRequest(sandbox.requestedResources);
+        const expiresAt = this.pendingRenewals.get(sandbox.dispatchAttemptId)?.fencingToken === owner.fencingToken
+            ? this.pendingRenewals.get(sandbox.dispatchAttemptId).expiresAt
+            : dispatch.lease.expiresAt;
+        const acquisitionKey = hostRuntimeOwnerKey(owner);
+        this.acquiringAdmissions.add(acquisitionKey);
+        try {
+            try {
+                if (priority === "background") {
+                    await this.refreshWorkspaceCapacity();
+                    keys = await this.reserveBackgroundAdmission(keys, owner, resources, expiresAt, signal);
+                }
+                else if (useParallelAdmission) {
+                    await this.reserveParallelProject(projectKey, owner, expiresAt, signal, priority);
+                }
+                else {
+                    keys = await this.reserveSingletonKeys(keys, owner, expiresAt, signal, priority);
+                }
+                if (priority === "foreground") {
+                    await this.refreshWorkspaceCapacity();
+                    const capacityExpiresAt = this.pendingRenewals.get(sandbox.dispatchAttemptId)?.fencingToken === owner.fencingToken
+                        ? this.pendingRenewals.get(sandbox.dispatchAttemptId).expiresAt
+                        : expiresAt;
+                    await this.reserveHostCapacity(owner, resources, capacityExpiresAt, signal, priority);
+                }
+            }
+            catch (error) {
+                this.releaseHostCapacity(owner.dispatchAttemptId, owner.fencingToken);
+                this.releaseSingletonKeys(owner.dispatchAttemptId, owner.fencingToken);
+                this.releaseParallelProjects(owner.dispatchAttemptId, owner.fencingToken);
+                this.clearPendingRenewal(owner);
+                throw error;
+            }
+            const admittedPromotion = useParallelAdmission
+                ? promotion ?? (executionClass === "managed_runtime" && keys.length === 0
+                    ? this.knownPromotions.get(dispatch.repo.id) ?? null
+                    : null)
+                : null;
+            this.admissions.set(sandbox.dispatchAttemptId, {
+                repoId: dispatch.repo.id,
+                fencingToken: owner.fencingToken,
+                executionClass,
+                priority,
+                provisionalPromotionFingerprint: admittedPromotion?.runtimeContractFingerprint ?? null,
+                keys,
+                parallelProjectKey: useParallelAdmission ? projectKey : null,
+            });
+            return keys;
+        }
+        finally {
+            this.acquiringAdmissions.delete(acquisitionKey);
+        }
+    }
+    async reserveHostCapacity(owner, resources, expiresAt, signal, priority = "foreground") {
+        const existing = this.capacityReservations.get(owner.dispatchAttemptId);
+        if (existing) {
+            if (!sameSingletonOwner(existing.owner, owner)) {
+                throw new Error("host_runtime_capacity_conflict: dispatch attempt already holds capacity under a different fence.");
+            }
+            return;
+        }
+        if (signal?.aborted)
+            throw cancellationError(signal);
+        throwIfAdmissionExpired(expiresAt);
+        const impossibleReason = this.hostCapacityImpossibleReason(resources);
+        if (impossibleReason)
+            throw new HostRuntimeCapacityRequestImpossibleError(impossibleReason);
+        if (this.capacityWaiters.length === 0 && this.hostCapacityAvailable(resources)) {
+            this.capacityReservations.set(owner.dispatchAttemptId, { owner, resources, state: "pending" });
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                owner,
+                resources,
+                priority,
+                resolve,
+                reject,
+                signal,
+                expiresAt,
+                deadlineTimer: null,
+                capacityRecheckTimer: null,
+                abort: () => {
+                    if (!this.detachCapacityWaiter(waiter))
+                        return;
+                    this.clearPendingRenewal(owner);
+                    reject(cancellationError(signal));
+                    this.drainAdmissionWaiters();
+                },
+                expire: () => {
+                    if (!this.detachCapacityWaiter(waiter))
+                        return;
+                    this.clearPendingRenewal(owner);
+                    reject(new HostRuntimeAdmissionExpiredError());
+                    this.drainAdmissionWaiters();
+                },
+            };
+            waiter.deadlineTimer = scheduleAdmissionDeadline(expiresAt, waiter.expire);
+            // Memory, CPU and filesystem capacity can recover without one of our leases
+            // being released (for example when an unrelated host process exits). Recheck
+            // ambient capacity while queued so readiness probes and attempts do not remain
+            // stranded behind a stale low-resource sample.
+            waiter.capacityRecheckTimer = setInterval(() => this.drainCapacityWaiters(), 1_000);
+            waiter.capacityRecheckTimer.unref?.();
+            signal?.addEventListener("abort", waiter.abort, { once: true });
+            enqueueAdmissionWaiter(this.capacityWaiters, waiter);
+            this.drainCapacityWaiters();
+        });
+    }
+    async reserveBackgroundAdmission(keys, owner, resources, expiresAt, signal) {
+        if (signal?.aborted)
+            throw cancellationError(signal);
+        throwIfAdmissionExpired(expiresAt);
+        return await new Promise((resolve, reject) => {
+            const waiter = {
+                owner,
+                keys,
+                resources,
+                priority: "background",
+                resolve,
+                reject,
+                signal,
+                expiresAt,
+                deadlineTimer: null,
+                capacityRecheckTimer: null,
+                abort: () => {
+                    removeWaiter(this.backgroundAdmissionWaiters, waiter);
+                    clearAdmissionDeadline(waiter);
+                    clearCapacityRecheck(waiter);
+                    this.clearPendingRenewal(owner);
+                    reject(cancellationError(signal));
+                    this.drainAdmissionWaiters();
+                },
+                expire: () => {
+                    removeWaiter(this.backgroundAdmissionWaiters, waiter);
+                    clearCapacityRecheck(waiter);
+                    signal?.removeEventListener("abort", waiter.abort);
+                    this.clearPendingRenewal(owner);
+                    reject(new HostRuntimeAdmissionExpiredError());
+                    this.drainAdmissionWaiters();
+                },
+            };
+            waiter.deadlineTimer = scheduleAdmissionDeadline(expiresAt, waiter.expire);
+            waiter.capacityRecheckTimer = setInterval(() => this.drainAdmissionWaiters(), 1_000);
+            waiter.capacityRecheckTimer.unref?.();
+            signal?.addEventListener("abort", waiter.abort, { once: true });
+            this.backgroundAdmissionWaiters.push(waiter);
+            this.drainAdmissionWaiters();
+        });
+    }
+    hostCapacityAvailable(resources) {
+        const capacity = this.hostResourceSnapshot();
+        return capacity.availableAttempts >= resources.sandboxSlots
+            && capacity.availableMemoryBytes >= resources.memoryBytes
+            && capacity.availableCpuMillis >= resources.cpuMillis
+            && capacity.availableWorkspaceBytes >= resources.workspaceBytes;
+    }
+    hostCapacityImpossibleReason(resources) {
+        const { hardMaxAttempts, idleHostReserveBytes, cpuReserveMillis } = this.capacityConfiguration;
+        if (resources.sandboxSlots > hardMaxAttempts) {
+            return `requested ${resources.sandboxSlots} sandbox slots exceed the host maximum of ${hardMaxAttempts}.`;
+        }
+        const totalMemoryBytes = this.capacityResourceSample?.totalMemoryBytes ?? os.totalmem();
+        const maximumMemoryBytes = Math.max(0, totalMemoryBytes - idleHostReserveBytes);
+        if (resources.memoryBytes > maximumMemoryBytes) {
+            return `requested memory ${resources.memoryBytes} exceeds the host maximum of ${maximumMemoryBytes} bytes after reserve.`;
+        }
+        const totalCpuMillis = this.capacityResourceSample?.totalCpuMillis ?? os.cpus().length * 1_000;
+        const maximumCpuMillis = Math.max(0, totalCpuMillis - cpuReserveMillis);
+        if (resources.cpuMillis > maximumCpuMillis) {
+            return `requested CPU ${resources.cpuMillis} millis exceeds the host maximum of ${maximumCpuMillis} millis after reserve.`;
+        }
+        return null;
+    }
+    hostResourceSnapshot() {
+        if (!this.capacityResourceSample) {
+            try {
+                const stats = statfsSync(this.stateRoot);
+                this.workspaceAvailableBytes = Math.max(0, stats.bavail * stats.bsize);
+            }
+            catch {
+                // State root may not exist during the first capability heartbeat. The first
+                // admission creates it and refreshes the sample before reserving resources.
+            }
+        }
+        const { hardMaxAttempts, cpuReserveMillis, workspaceReserveBytes } = this.capacityConfiguration;
+        const hostReserveBytes = this.capacityReservations.size === 0
+            ? this.capacityConfiguration.idleHostReserveBytes
+            : this.capacityConfiguration.hostReserveBytes;
+        const activeReservationMemoryBytes = [...this.capacityReservations.values()]
+            .reduce((total, reservation) => total + reservation.resources.memoryBytes, 0);
+        const pendingReservationMemoryBytes = [...this.capacityReservations.values()]
+            .filter(reservation => reservation.state === "pending")
+            .reduce((total, reservation) => total + reservation.resources.memoryBytes, 0);
+        const activeReservationCpuMillis = [...this.capacityReservations.values()]
+            .reduce((total, reservation) => total + reservation.resources.cpuMillis, 0);
+        const activeReservationWorkspaceBytes = [...this.capacityReservations.values()]
+            .reduce((total, reservation) => total + reservation.resources.workspaceBytes, 0);
+        const sampledAt = new Date().toISOString();
+        const totalMemoryBytes = this.capacityResourceSample?.totalMemoryBytes ?? os.totalmem();
+        const rawAvailableMemoryBytes = this.capacityResourceSample?.availableMemoryBytes ?? os.freemem();
+        const sampledAvailableMemoryBytes = this.memoryAvailability.observe(rawAvailableMemoryBytes);
+        // raw/stabilized available memory already includes every resident host and
+        // Forge process. Keep the independent total ceiling scoped to Forge's own
+        // reservations; adding ambient use here charges it a second time and can
+        // strand work even while more than the requested memory is physically free.
+        const committedMemoryBytes = Math.min(totalMemoryBytes, activeReservationMemoryBytes);
+        const totalCpuMillis = this.capacityResourceSample?.totalCpuMillis ?? os.cpus().length * 1000;
+        const sampledWorkspaceBytes = this.capacityResourceSample?.availableWorkspaceBytes ?? this.workspaceAvailableBytes;
+        const memoryAdmission = buildMemoryAdmissionDiagnostics({
+            sampledAt,
+            totalMemoryBytes,
+            rawAvailableMemoryBytes,
+            stabilizedAvailableMemoryBytes: sampledAvailableMemoryBytes,
+            controlPlaneMemoryBytes: process.memoryUsage().rss,
+            reserveMemoryBytes: hostReserveBytes,
+            committedMemoryBytes,
+            pendingCommitmentMemoryBytes: pendingReservationMemoryBytes,
+        });
+        const availableMemoryBytes = memoryAdmission.availableForAdmissionBytes;
+        const availableCpuMillis = Math.max(0, totalCpuMillis - cpuReserveMillis - activeReservationCpuMillis);
+        const availableWorkspaceBytes = Math.max(0, sampledWorkspaceBytes - workspaceReserveBytes - activeReservationWorkspaceBytes);
+        const slotAvailability = Math.max(0, hardMaxAttempts - this.capacityReservations.size);
+        // Capability snapshots advertise whether any supported attempt can fit.
+        // The queue/admission path still checks the exact project-derived request.
+        const minimumRequest = minimumSupportedHostResourceRequest();
+        const resourceAvailability = Math.min(resourceSlots(availableMemoryBytes, minimumRequest.memoryBytes), resourceSlots(availableCpuMillis, minimumRequest.cpuMillis), resourceSlots(availableWorkspaceBytes, minimumRequest.workspaceBytes));
+        const availableAttempts = Math.max(0, Math.min(slotAvailability, resourceAvailability));
+        const unavailableReason = slotAvailability <= 0
+            ? `Host attempt capacity is full (${this.capacityReservations.size}/${hardMaxAttempts}).`
+            : availableMemoryBytes < minimumRequest.memoryBytes
+                ? "Host memory is below the admission reserve."
+                : availableCpuMillis < minimumRequest.cpuMillis
+                    ? "Host CPU capacity is below the admission reserve."
+                    : availableWorkspaceBytes < minimumRequest.workspaceBytes
+                        ? "Host workspace capacity is below the admission reserve."
+                        : null;
+        return {
+            hardMaxAttempts,
+            effectiveMaxAttempts: this.capacityReservations.size + availableAttempts,
+            availableAttempts,
+            totalMemoryBytes,
+            availableMemoryBytes,
+            hostReserveBytes,
+            availableCpuMillis,
+            availableWorkspaceBytes,
+            activeReservationMemoryBytes,
+            memoryAdmission,
+            unavailableCode: unavailableReason ? "capacity_unavailable" : null,
+            unavailableReason,
+        };
+    }
+    async refreshWorkspaceCapacity() {
+        if (this.capacityResourceSample)
+            return;
+        try {
+            await fs.mkdir(this.stateRoot, { recursive: true });
+            const stats = await fs.statfs(this.stateRoot);
+            this.workspaceAvailableBytes = Math.max(0, stats.bavail * stats.bsize);
+        }
+        catch {
+            // Keep the last trustworthy sample. Memory/CPU and the hard ceiling still
+            // protect admission when the filesystem cannot be sampled temporarily.
+        }
+    }
+    releaseHostCapacity(dispatchAttemptId, fencingToken) {
+        const reservation = this.capacityReservations.get(dispatchAttemptId);
+        if (!reservation || reservation.owner.fencingToken !== fencingToken)
+            return;
+        this.capacityReservations.delete(dispatchAttemptId);
+        this.drainAdmissionWaiters();
+    }
+    drainCapacityWaiters() {
+        for (const waiter of this.capacityWaitersForScan()) {
+            if (!this.capacityWaiters.includes(waiter))
+                continue;
+            if (waiter.signal?.aborted) {
+                this.detachCapacityWaiter(waiter);
+                this.clearPendingRenewal(waiter.owner);
+                waiter.reject(cancellationError(waiter.signal));
+                continue;
+            }
+            if (admissionExpired(waiter.expiresAt)) {
+                this.detachCapacityWaiter(waiter);
+                this.clearPendingRenewal(waiter.owner);
+                waiter.reject(new HostRuntimeAdmissionExpiredError());
+                continue;
+            }
+            const impossibleReason = this.hostCapacityImpossibleReason(waiter.resources);
+            if (impossibleReason) {
+                this.detachCapacityWaiter(waiter);
+                this.clearPendingRenewal(waiter.owner);
+                waiter.reject(new HostRuntimeCapacityRequestImpossibleError(impossibleReason));
+                continue;
+            }
+            if (!this.hostCapacityAvailable(waiter.resources))
+                continue;
+            this.detachCapacityWaiter(waiter);
+            this.capacityReservations.set(waiter.owner.dispatchAttemptId, {
+                owner: waiter.owner,
+                resources: waiter.resources,
+                state: "pending",
+            });
+            waiter.resolve();
+        }
+    }
+    capacityWaitersForScan() {
+        const head = this.capacityWaiters[0];
+        if (!head) {
+            this.capacityWaiterScanCursor = 0;
+            return [];
+        }
+        const scanCount = Math.min(hostCapacityWaiterScanLimit, this.capacityWaiters.length);
+        if (scanCount === this.capacityWaiters.length) {
+            this.capacityWaiterScanCursor = 0;
+            return this.capacityWaiters.slice();
+        }
+        // The head always gets the first opportunity, while a rotating bounded
+        // window prevents an unfit renewed head (or a very deep queue) from
+        // indefinitely hiding a later request that fits current capacity.
+        const laterCount = this.capacityWaiters.length - 1;
+        const laterScanCount = scanCount - 1;
+        const start = this.capacityWaiterScanCursor % laterCount;
+        const result = [head];
+        for (let offset = 0; offset < laterScanCount; offset += 1) {
+            result.push(this.capacityWaiters[1 + ((start + offset) % laterCount)]);
+        }
+        this.capacityWaiterScanCursor = (start + laterScanCount) % laterCount;
+        return result;
+    }
+    detachCapacityWaiter(waiter) {
+        const index = this.capacityWaiters.indexOf(waiter);
+        if (index < 0)
+            return false;
+        this.capacityWaiters.splice(index, 1);
+        clearAdmissionDeadline(waiter);
+        clearCapacityRecheck(waiter);
+        waiter.signal?.removeEventListener("abort", waiter.abort);
+        if (this.capacityWaiters.length === 0)
+            this.capacityWaiterScanCursor = 0;
+        return true;
+    }
+    async reserveSingletonKeys(keys, owner, expiresAt, signal, priority = "foreground") {
+        const owned = keys.every(key => sameSingletonOwner(this.singletonOwners.get(key), owner));
+        if (owned)
+            return keys;
+        const staleFence = [...this.singletonOwners.values()].find(existing => existing.dispatchAttemptId === owner.dispatchAttemptId
+            && existing.fencingToken !== owner.fencingToken);
+        if (staleFence) {
+            throw new Error("host_runtime_singleton_conflict: dispatch attempt already holds the singleton under a different fence.");
+        }
+        if (signal?.aborted)
+            throw cancellationError(signal);
+        throwIfAdmissionExpired(expiresAt);
+        if (this.singletonKeysAvailable(keys)) {
+            this.assignSingletonKeys(keys, owner);
+            return keys;
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                owner,
+                keys,
+                priority,
+                resolve,
+                reject,
+                signal,
+                expiresAt,
+                deadlineTimer: null,
+                abort: () => {
+                    const index = this.singletonWaiters.indexOf(waiter);
+                    if (index >= 0)
+                        this.singletonWaiters.splice(index, 1);
+                    clearAdmissionDeadline(waiter);
+                    this.clearPendingRenewal(owner);
+                    reject(cancellationError(signal));
+                    this.drainAdmissionWaiters();
+                },
+                expire: () => {
+                    const index = this.singletonWaiters.indexOf(waiter);
+                    if (index < 0)
+                        return;
+                    this.singletonWaiters.splice(index, 1);
+                    clearAdmissionDeadline(waiter);
+                    waiter.signal?.removeEventListener("abort", waiter.abort);
+                    this.clearPendingRenewal(owner);
+                    reject(new HostRuntimeAdmissionExpiredError());
+                    this.drainAdmissionWaiters();
+                },
+            };
+            enqueueAdmissionWaiter(this.singletonWaiters, waiter);
+            signal?.addEventListener("abort", waiter.abort, { once: true });
+            waiter.deadlineTimer = scheduleAdmissionDeadline(waiter.expiresAt, waiter.expire);
+            this.drainAdmissionWaiters();
+        });
+    }
+    async reserveParallelProject(key, owner, expiresAt, signal, priority = "foreground") {
+        if (this.parallelProjectOwned(key, owner))
+            return;
+        const staleFence = [...(this.parallelProjectOwners.get(key)?.values() ?? [])]
+            .find(existing => existing.dispatchAttemptId === owner.dispatchAttemptId
+            && existing.fencingToken !== owner.fencingToken);
+        if (staleFence) {
+            throw new Error("host_runtime_parallel_conflict: dispatch attempt already holds shared admission under a different fence.");
+        }
+        if (signal?.aborted)
+            throw cancellationError(signal);
+        throwIfAdmissionExpired(expiresAt);
+        if (this.parallelProjectAvailable(key, priority)) {
+            this.assignParallelProject(key, owner);
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const waiter = {
+                owner,
+                key,
+                priority,
+                resolve,
+                reject,
+                signal,
+                expiresAt,
+                deadlineTimer: null,
+                abort: () => {
+                    const index = this.parallelProjectWaiters.indexOf(waiter);
+                    if (index >= 0)
+                        this.parallelProjectWaiters.splice(index, 1);
+                    clearAdmissionDeadline(waiter);
+                    this.clearPendingRenewal(owner);
+                    reject(cancellationError(signal));
+                    this.drainAdmissionWaiters();
+                },
+                expire: () => {
+                    const index = this.parallelProjectWaiters.indexOf(waiter);
+                    if (index < 0)
+                        return;
+                    this.parallelProjectWaiters.splice(index, 1);
+                    clearAdmissionDeadline(waiter);
+                    waiter.signal?.removeEventListener("abort", waiter.abort);
+                    this.clearPendingRenewal(owner);
+                    reject(new HostRuntimeAdmissionExpiredError());
+                    this.drainAdmissionWaiters();
+                },
+            };
+            enqueueAdmissionWaiter(this.parallelProjectWaiters, waiter);
+            signal?.addEventListener("abort", waiter.abort, { once: true });
+            waiter.deadlineTimer = scheduleAdmissionDeadline(waiter.expiresAt, waiter.expire);
+            this.drainAdmissionWaiters();
+        });
+    }
+    async upgradeParallelProjectToSingleton(keys, parallelProjectKey, owner, expiresAt, signal, priority = "foreground") {
+        if (!this.parallelProjectOwned(parallelProjectKey, owner)) {
+            throw new Error("host_runtime_parallel_unreserved: matching shared project admission is required before serialization.");
+        }
+        if (signal?.aborted)
+            throw cancellationError(signal);
+        throwIfAdmissionExpired(expiresAt);
+        return await new Promise((resolve, reject) => {
+            const waiter = {
+                owner,
+                keys,
+                priority,
+                resolve,
+                reject,
+                signal,
+                expiresAt,
+                deadlineTimer: null,
+                abort: () => {
+                    const index = this.singletonWaiters.indexOf(waiter);
+                    if (index >= 0)
+                        this.singletonWaiters.splice(index, 1);
+                    clearAdmissionDeadline(waiter);
+                    this.clearPendingRenewal(owner);
+                    reject(cancellationError(signal));
+                    this.drainAdmissionWaiters();
+                },
+                expire: () => {
+                    const index = this.singletonWaiters.indexOf(waiter);
+                    if (index < 0)
+                        return;
+                    this.singletonWaiters.splice(index, 1);
+                    clearAdmissionDeadline(waiter);
+                    waiter.signal?.removeEventListener("abort", waiter.abort);
+                    this.clearPendingRenewal(owner);
+                    reject(new HostRuntimeAdmissionExpiredError());
+                    this.drainAdmissionWaiters();
+                },
+            };
+            // Queue the exclusive claim before relinquishing the shared claim. This
+            // makes the promotion downgrade atomic from the broker's perspective and
+            // prevents a background readiness probe from jumping ahead in between.
+            enqueueAdmissionWaiter(this.singletonWaiters, waiter);
+            signal?.addEventListener("abort", waiter.abort, { once: true });
+            waiter.deadlineTimer = scheduleAdmissionDeadline(waiter.expiresAt, waiter.expire);
+            this.releaseParallelProjectNoDrain(parallelProjectKey, owner);
+            this.drainAdmissionWaiters();
+        });
+    }
+    async start(dispatch, worktreePath, signal, onAdmissionCheckpoint) {
+        const sandbox = dispatch.sandbox;
+        if (!sandbox || sandbox.executionMode !== "host") {
+            throw new Error("host_runtime_lease_invalid: managed host sandbox context is required.");
+        }
+        const wasPrepared = this.preparedReadiness.has(sandbox.dispatchAttemptId);
+        const preparedProof = wasPrepared
+            ? await this.preparedReadiness.verify(dispatch, worktreePath, onAdmissionCheckpoint)
+            : undefined;
+        if (wasPrepared) {
+            signal?.throwIfAborted();
+            const admission = this.hostResourceSnapshot().memoryAdmission;
+            const requestedMemoryBytes = normalizedHostResourceRequest(sandbox.requestedResources).memoryBytes;
+            await onAdmissionCheckpoint?.({
+                code: "host_runtime_prepared_admission_waiting",
+                message: `Prepared runtime verification passed. Waiting for host admission before agent startup: ${formatBytes(requestedMemoryBytes)} requested, ${formatBytes(admission.availableForAdmissionBytes)} currently available under the host reserve.`,
+                expiresAt: dispatch.lease.expiresAt,
+            });
+            await this.acquire(dispatch, signal);
+            await onAdmissionCheckpoint?.({
+                code: "host_runtime_prepared_admission_acquired",
+                message: "Prepared runtime acquired host admission; agent startup is continuing.",
+                expiresAt: dispatch.lease.expiresAt,
+            });
+        }
+        const existing = this.active.get(sandbox.dispatchAttemptId);
+        if (existing) {
+            if (existing.lease.fencingToken !== dispatch.lease.fencingToken) {
+                throw new Error("host_runtime_lease_conflict: an active host lease has a different fence.");
+            }
+            return {
+                lease: existing.lease,
+                environment: hostRuntimeEnvironment(dispatch.session.id, existing.lease, existing.runtimeContract, existing.executionClass, existing.databaseCapability),
+                runtimeContract: existing.runtimeContract,
+                executionClass: existing.executionClass,
+            };
+        }
+        const admission = this.admissions.get(sandbox.dispatchAttemptId);
+        const owner = { dispatchAttemptId: sandbox.dispatchAttemptId, fencingToken: dispatch.lease.fencingToken };
+        if (!admission || admission.fencingToken !== owner.fencingToken) {
+            throw new Error("host_runtime_singleton_unreserved: managed host admission is required before start.");
+        }
+        const attemptHex = uuidHex(sandbox.dispatchAttemptId, "dispatch attempt");
+        const compactAttemptHex = compactHostAttemptId(sandbox.dispatchAttemptId);
+        const normalizedWorktreePath = await resolveExistingDirectoryPath(worktreePath);
+        const attemptRoot = path.join(this.executionRoot, "a", compactAttemptHex);
+        const temporaryPath = path.join(attemptRoot, "t");
+        const logPath = path.join(attemptRoot, "logs");
+        const cachePath = path.join(attemptRoot, "c");
+        const browserProfilePath = path.join(attemptRoot, "b");
+        const testOutputPath = path.join(attemptRoot, "test-output");
+        const processSupervisorMetadataPath = path.join(logPath, "attempt-process-supervisor.json");
+        const processSupervisorId = `host-${attemptHex}`;
+        const renewedExpiry = this.pendingRenewals.get(sandbox.dispatchAttemptId);
+        const expiresAt = renewedExpiry?.fencingToken === dispatch.lease.fencingToken
+            ? renewedExpiry.expiresAt
+            : dispatch.lease.expiresAt;
+        let processSupervisor = null;
+        let attemptRootIdentity = null;
+        try {
+            const runtimeContract = await loadHostRuntimeContract(normalizedWorktreePath);
+            if (runtimeContract.contract.runtime.hostConcurrency === "disabled") {
+                throw new Error("host_runtime_disabled: project runtime configuration requires Docker execution.");
+            }
+            if (wasPrepared && !preparedProof && admission.executionClass === "managed_runtime"
+                && hostRuntimeParallelEligible(runtimeContract)) {
+                throw new Error("host_runtime_prepared_source_changed: runtime became parallel-eligible after preparation; a new foreground proof is required.");
+            }
+            const runtimeContractFingerprint = hostRuntimeContractFingerprint(runtimeContract);
+            const inputCommitSha = preparedProof?.inputCommitSha
+                ?? await resolveWorktreeCommitSha(normalizedWorktreePath, sandbox.inputCommitSha);
+            if (preparedProof && (runtimeContractFingerprint !== preparedProof.runtimeContractFingerprint
+                || JSON.stringify(preparedProof) !== JSON.stringify(await preparedRuntimeIdentity(normalizedWorktreePath, signal)))) {
+                throw new Error("host_runtime_prepared_source_changed: source changed after its foreground proof; agent was not started.");
+            }
+            const promotion = admission.executionClass === "managed_runtime"
+                ? await this.promotionStore.load(dispatch.repo.id, preparedProof ?? { runtimeContractFingerprint, inputCommitSha })
+                : null;
+            const promotionMatches = hostRuntimeParallelEligible(runtimeContract)
+                && promotion?.runtimeContractFingerprint === runtimeContractFingerprint
+                && promotion.inputCommitSha === inputCommitSha;
+            if (admission.executionClass === "managed_runtime" && admission.keys.length === 0 && !promotionMatches) {
+                const projectKeys = hostRuntimeSingletonKeys(dispatch);
+                const expiresAt = this.pendingRenewals.get(sandbox.dispatchAttemptId)?.fencingToken === owner.fencingToken
+                    ? this.pendingRenewals.get(sandbox.dispatchAttemptId).expiresAt
+                    : dispatch.lease.expiresAt;
+                const parallelProjectKey = admission.parallelProjectKey;
+                admission.parallelProjectKey = null;
+                const capacityReservation = this.capacityReservations.get(owner.dispatchAttemptId);
+                if (capacityReservation && !sameSingletonOwner(capacityReservation.owner, owner)) {
+                    throw new Error("host_runtime_capacity_conflict: dispatch attempt holds capacity under a different fence.");
+                }
+                const serializedAdmission = parallelProjectKey
+                    ? this.upgradeParallelProjectToSingleton(projectKeys, parallelProjectKey, owner, expiresAt, signal, admission.priority)
+                    : this.reserveSingletonKeys(projectKeys, owner, expiresAt, signal, admission.priority);
+                // A sibling can already hold the same provisional shared project claim
+                // while waiting for this attempt's host-capacity slot. Retaining capacity
+                // while waiting for that sibling to release its shared claim creates a
+                // cycle: exclusive waits on shared, shared waits on capacity. Relinquish
+                // the capacity slot only after the exclusive waiter is queued, then
+                // reacquire it after serialization is granted.
+                if (capacityReservation) {
+                    this.releaseHostCapacity(owner.dispatchAttemptId, owner.fencingToken);
+                }
+                // The checkpoint is allowed to do I/O. Observe an early admission
+                // failure now so a slow acknowledgement cannot create an unhandled
+                // rejection before the operational promise is awaited below.
+                void serializedAdmission.catch(() => undefined);
+                // Begin the operational downgrade before publishing telemetry. A lost
+                // callback acknowledgement must not leave the attempt holding its old
+                // shared admission while every recovery probe waits behind it.
+                await onAdmissionCheckpoint?.({
+                    code: "host_runtime_serial_admission_waiting",
+                    message: "The prepared runtime contract no longer matches the parallel-readiness proof. Waiting for foreground-priority serialized admission before launch.",
+                    expiresAt,
+                });
+                admission.keys = await serializedAdmission;
+                while (admission.keys.length === 0) {
+                    const promoted = this.knownPromotions.get(dispatch.repo.id);
+                    if (!promoted) {
+                        throw new Error("host_runtime_parallel_promotion_missing: shared admission requires matching promotion evidence.");
+                    }
+                    const matching = await this.promotionStore.load(dispatch.repo.id, preparedProof ?? { runtimeContractFingerprint, inputCommitSha });
+                    if (!matching) {
+                        // Drop obsolete proof before asking for exclusive admission; otherwise
+                        // the queue can grant the same stale shared promotion indefinitely.
+                        this.releaseParallelProjectNoDrain(projectKeys[0], owner);
+                        admission.keys = await this.reserveSingletonKeys(projectKeys, owner, expiresAt, signal, admission.priority);
+                        continue;
+                    }
+                    admission.parallelProjectKey = projectKeys[0] ?? null;
+                    admission.provisionalPromotionFingerprint = promoted.runtimeContractFingerprint;
+                    break;
+                }
+                // Do not hold a capacity slot while a stale shared re-grant is still
+                // being converted to exclusive admission.
+                if (capacityReservation) {
+                    await this.reserveHostCapacity(owner, capacityReservation.resources, expiresAt, signal, admission.priority);
+                }
+            }
+            const declaredSingletonKeys = runtimeContract.contract.runtime.singletonResources
+                .map(hostRuntimeDeclaredSingletonKey);
+            const missingSingletonKeys = declaredSingletonKeys
+                .filter(key => !admission.keys.includes(key));
+            if (missingSingletonKeys.length > 0) {
+                const expiresAt = this.pendingRenewals.get(sandbox.dispatchAttemptId)?.fencingToken === owner.fencingToken
+                    ? this.pendingRenewals.get(sandbox.dispatchAttemptId).expiresAt
+                    : dispatch.lease.expiresAt;
+                const reservedSingletonKeys = await this.reserveSingletonKeys(missingSingletonKeys, owner, expiresAt, signal, admission.priority);
+                admission.keys = [...admission.keys, ...reservedSingletonKeys]
+                    .sort((left, right) => left.localeCompare(right));
+            }
+            const singletonKeys = admission.keys;
+            if (!singletonKeys.every(key => sameSingletonOwner(this.singletonOwners.get(key), owner))) {
+                throw new Error("host_runtime_singleton_unreserved: managed host singleton ownership is required before start.");
+            }
+            if (admission.parallelProjectKey && !this.parallelProjectOwned(admission.parallelProjectKey, owner)) {
+                throw new Error("host_runtime_parallel_unreserved: matching shared project admission is required before start.");
+            }
+            await createCanonicalDirectory(attemptRoot);
+            attemptRootIdentity = (await assertCanonicalDirectory(attemptRoot));
+            await Promise.all([
+                createCanonicalDirectory(temporaryPath),
+                createCanonicalDirectory(logPath),
+                createCanonicalDirectory(cachePath),
+                createCanonicalDirectory(browserProfilePath),
+                createCanonicalDirectory(testOutputPath),
+            ]);
+            await assertHostAttemptRootIdentity(attemptRoot, attemptRootIdentity);
+            await resetGeneratedOutputs(normalizedWorktreePath, testOutputPath);
+            let lease = createRuntimeIsolationLease({
+                leaseId: sandbox.executionLeaseId,
+                dispatchAttemptId: sandbox.dispatchAttemptId,
+                executionLeaseId: sandbox.executionLeaseId,
+                fencingToken: dispatch.lease.fencingToken,
+                runnerId: dispatch.execution.runnerId ?? "",
+                runnerInstanceId: sandbox.runnerInstanceId,
+                worktreeKey: dispatch.lease.worktreeKey,
+                worktreePath: normalizedWorktreePath,
+                mode: "host",
+                expiresAt,
+                resources: {
+                    memoryReservationBytes: 0,
+                    cpuMillis: 0,
+                    pids: 0,
+                    ports: [],
+                    paths: [
+                        { path: normalizedWorktreePath, role: "worktree" },
+                        { path: temporaryPath, role: "temporary" },
+                        { path: logPath, role: "logs" },
+                        { path: cachePath, role: "cache" },
+                        { path: browserProfilePath, role: "browser_profile" },
+                        { path: testOutputPath, role: "test_output" },
+                        { path: processSupervisorMetadataPath, role: "process_supervisor_metadata" },
+                    ],
+                    processSupervisorId,
+                    dockerResources: [],
+                    singletonKeys,
+                },
+            });
+            await this.writeLedger(lease, undefined, attemptRootIdentity);
+            lease = transitionRuntimeIsolationLease(lease, "starting");
+            await this.writeLedger(lease, undefined, attemptRootIdentity);
+            lease = transitionRuntimeIsolationLease(lease, "active");
+            await this.writeLedger(lease, undefined, attemptRootIdentity);
+            processSupervisor = this.processSupervisors.register({
+                processSupervisorId,
+                dispatchAttemptId: lease.dispatchAttemptId,
+                executionLeaseId: lease.executionLeaseId,
+                fencingToken: lease.fencingToken,
+                logDirectory: logPath,
+            }, this.processRunner, { signal });
+            this.active.set(sandbox.dispatchAttemptId, {
+                lease,
+                repoId: dispatch.repo.id,
+                sessionId: dispatch.session.id,
+                attemptRoot,
+                attemptRootIdentity,
+                runtimeContract,
+                runtimeContractFingerprint,
+                inputCommitSha,
+                executionClass: admission.executionClass,
+                parallelPromotionEligible: hostRuntimeParallelEligible(runtimeContract) && dispatch.cycleRun.phase !== "prepared_readiness",
+                processSupervisor,
+                adapterCleanups: [],
+                pendingAdapterLaunches: new Map(),
+                runtimeResourcesReleased: false,
+                releasing: false,
+            });
+            this.pendingRenewals.delete(sandbox.dispatchAttemptId);
+            return {
+                lease,
+                environment: hostRuntimeEnvironment(dispatch.session.id, lease, runtimeContract, admission.executionClass),
+                runtimeContract,
+                executionClass: admission.executionClass,
+            };
+        }
+        catch (error) {
+            this.pendingRenewals.delete(sandbox.dispatchAttemptId);
+            if (processSupervisor) {
+                await processSupervisor.stopAll(dispatch.lease.fencingToken, "Host runtime start rolled back.").catch(() => undefined);
+                this.processSupervisors.unregister(sandbox.dispatchAttemptId, dispatch.lease.fencingToken);
+            }
+            const attemptRemoved = await retainHostDiagnostics(this.stateRoot, attemptRoot, sandbox.dispatchAttemptId, attemptRootIdentity, this.executionRoot).then(async () => {
+                await removeHostAttemptRoot(attemptRoot);
+                return true;
+            }).catch(() => false); // A retention failure preserves the original evidence and ownership ledger.
+            if (attemptRemoved) {
+                await fs.rm(this.ledgerPath(sandbox.dispatchAttemptId), { force: true }).catch(() => undefined);
+            }
+            this.releaseSingletonKeys(sandbox.dispatchAttemptId, dispatch.lease.fencingToken);
+            this.releaseParallelProjects(sandbox.dispatchAttemptId, dispatch.lease.fencingToken);
+            this.deleteAdmission(sandbox.dispatchAttemptId, dispatch.lease.fencingToken);
+            throw error;
+        }
+    }
+    async updateLease(dispatchAttemptId, fencingToken, expiresAt) {
+        try {
+            uuidHex(dispatchAttemptId, "dispatch attempt");
+            uuidHex(fencingToken, "fencing token");
+        }
+        catch {
+            return;
+        }
+        await this.preparedReadiness.renew(dispatchAttemptId, fencingToken, expiresAt);
+        const active = this.active.get(dispatchAttemptId);
+        if (!active) {
+            if (Number.isFinite(Date.parse(expiresAt))) {
+                const pending = this.pendingRenewals.get(dispatchAttemptId);
+                if (!pending
+                    || pending.fencingToken !== fencingToken
+                    || Date.parse(expiresAt) > Date.parse(pending.expiresAt)) {
+                    this.pendingRenewals.set(dispatchAttemptId, { fencingToken, expiresAt });
+                }
+                this.renewAdmissionWaiterDeadline(dispatchAttemptId, fencingToken, expiresAt);
+            }
+            return;
+        }
+        if (active.releasing || active.lease.state === "releasing" || active.lease.state === "released")
+            return;
+        const renewed = renewRuntimeIsolationLease(active.lease, fencingToken, expiresAt);
+        if (!renewed)
+            return;
+        active.lease = renewed;
+        await this.writeLedger(renewed);
+    }
+    async startConfiguredProject(dispatchAttemptId, fencingToken, signal, onProjectCheckpoint) {
+        const active = this.active.get(dispatchAttemptId);
+        if (!active || active.lease.fencingToken !== fencingToken || active.lease.state !== "active" || active.releasing) {
+            throw new Error("host_runtime_project_unavailable: an active matching host runtime lease is required.");
+        }
+        if (active.executionClass === "analysis_only") {
+            return {
+                lease: active.lease,
+                environment: hostRuntimeEnvironment(active.sessionId, active.lease, active.runtimeContract, active.executionClass, active.databaseCapability),
+                runtimeContract: active.runtimeContract,
+                executionClass: active.executionClass,
+            };
+        }
+        const configuredPorts = active.runtimeContract.contract.runtime.ports.filter((port) => port.launch !== null);
+        if (configuredPorts.length === 0) {
+            return {
+                lease: active.lease,
+                environment: hostRuntimeEnvironment(active.sessionId, active.lease, active.runtimeContract, active.executionClass, active.databaseCapability),
+                runtimeContract: active.runtimeContract,
+                executionClass: active.executionClass,
+            };
+        }
+        const owner = hostPortOwner(active.lease);
+        const logDirectory = active.lease.resources.paths.find(entry => entry.role === "logs")?.path;
+        if (!logDirectory)
+            throw new Error("host_runtime_project_invalid: attempt log directory is unavailable.");
+        if (this.databaseBroker && !active.databaseCapability
+            && configuredPorts.some(port => /^dotnet(?:\.exe)?$/iu.test(path.basename(port.launch.command)))) {
+            // An ASP.NET runtime may require an isolated database (Forge.Api refuses to start in a
+            // managed host attempt without one). Issue it before the first launch. Release waits for
+            // an in-flight provision, so a database issued during release is still dropped.
+            const provision = this.databaseBroker.provision(dispatchAttemptId, fencingToken, signal)
+                .then(capability => {
+                active.databaseCapability = capability;
+                return capability;
+            });
+            active.databaseProvision = provision;
+            await provision;
+            if (active.releasing) {
+                throw new Error("host_runtime_project_unavailable: the host runtime lease was released during database provisioning.");
+            }
+            await onProjectCheckpoint?.({
+                code: "host_runtime_database_provisioned",
+                message: `Provisioned isolated attempt database ${active.databaseCapability.databaseName} on the native test cluster.`,
+                data: { database: active.databaseCapability.databaseName },
+            });
+        }
+        // Runtime output is persisted to attempt logs; the database login it may print is redacted.
+        const capabilitySecrets = attemptDatabaseCapabilitySecrets(active.databaseCapability?.connectionString);
+        const launcher = new AttemptNodeRuntimeLauncher(active.processSupervisor, owner, logDirectory, this.listenerInspector, capabilitySecrets);
+        for (const configuredPort of configuredPorts) {
+            const workingDirectory = await containedWorkingDirectory(active.lease.worktreePath, configuredPort.launch.workingDirectory);
+            const buildEnvironment = {
+                ...configuredPort.launch.environment,
+                ...hostRuntimeEnvironment(active.sessionId, active.lease, active.runtimeContract, active.executionClass, active.databaseCapability),
+            };
+            const prebuild = createAspNetRuntimePrebuildPlan({
+                command: configuredPort.launch.command,
+                args: configuredPort.launch.args,
+                cwd: workingDirectory,
+                worktreePath: active.lease.worktreePath,
+                environment: buildEnvironment,
+                inputCommitSha: active.inputCommitSha,
+                runtimeContractFingerprint: active.runtimeContractFingerprint,
+            });
+            if (prebuild) {
+                await onProjectCheckpoint?.({
+                    code: "host_runtime_build_started",
+                    message: `Preparing the ASP.NET runtime for commit ${active.inputCommitSha.slice(0, 12)} before binding its assigned port.`,
+                    data: { input_commit_sha: active.inputCommitSha, project_path: prebuild.projectPath },
+                });
+                const build = await ensureAspNetRuntimePrebuilt(prebuild, async (plan, buildSignal) => await executeAspNetRuntimeBuild(active.processSupervisor, logDirectory, plan, buildSignal, capabilitySecrets), signal);
+                await onProjectCheckpoint?.({
+                    code: build.cacheHit ? "host_runtime_build_cached" : "host_runtime_build_completed",
+                    message: build.cacheHit
+                        ? `Reused the verified ASP.NET build for commit ${active.inputCommitSha.slice(0, 12)}.`
+                        : `ASP.NET runtime build completed for commit ${active.inputCommitSha.slice(0, 12)}; launching without another build.`,
+                    data: {
+                        input_commit_sha: active.inputCommitSha,
+                        build_fingerprint: build.fingerprint,
+                        receipt_path: build.receiptPath,
+                    },
+                });
+            }
+            await this.launchNodeRuntime(dispatchAttemptId, fencingToken, configuredPort.name, {
+                command: configuredPort.launch.command,
+                args: configuredPort.launch.args,
+                cwd: workingDirectory,
+                environment: {
+                    ...buildEnvironment,
+                },
+            }, launcher, signal);
+        }
+        const promotedLease = await this.promoteVerifiedRuntime(active, active.lease);
+        const runtimeEnvironment = hostRuntimeEnvironment(active.sessionId, promotedLease, active.runtimeContract, active.executionClass, active.databaseCapability);
+        const playwright = active.runtimeContract.contract.runtime.playwright;
+        if (!playwright) {
+            return {
+                lease: promotedLease,
+                environment: runtimeEnvironment,
+                runtimeContract: active.runtimeContract,
+                executionClass: active.executionClass,
+            };
+        }
+        const playwrightPort = promotedLease.resources.ports.find(port => port.name === playwright.baseUrlPort);
+        const playwrightPortConfig = active.runtimeContract.contract.runtime.ports
+            .find(port => port.name === playwright.baseUrlPort);
+        if (!playwrightPort || !playwrightPortConfig?.baseUrlEnv) {
+            throw new Error("host_runtime_playwright_unavailable: the configured verified base URL is unavailable.");
+        }
+        if (playwrightPort.hostIp !== "127.0.0.1") {
+            throw new Error("host_runtime_playwright_unavailable: Playwright requires an IPv4 loopback listener.");
+        }
+        const baseUrl = hostPortEnvironment(playwrightPortConfig, playwrightPort.hostIp, playwrightPort.hostPort)[playwrightPortConfig.baseUrlEnv];
+        if (!baseUrl)
+            throw new Error("host_runtime_playwright_unavailable: the configured base URL could not be rendered.");
+        const pathFor = (role) => promotedLease.resources.paths.find(entry => entry.role === role)?.path ?? "";
+        const preparedPlaywright = await this.playwrightAdapter.prepare(playwright, {
+            worktreePath: promotedLease.worktreePath,
+            temporaryDirectory: pathFor("temporary"),
+            testOutputDirectory: pathFor("test_output"),
+            browserProfileDirectory: pathFor("browser_profile"),
+            baseUrl,
+            ownershipToken: uuidHex(promotedLease.dispatchAttemptId, "dispatch attempt"),
+        });
+        return {
+            lease: promotedLease,
+            environment: { ...runtimeEnvironment, ...preparedPlaywright.environment },
+            runtimeContract: active.runtimeContract,
+            executionClass: active.executionClass,
+        };
+    }
+    providerProcessRunner(dispatchAttemptId, fencingToken) {
+        const active = this.active.get(dispatchAttemptId);
+        if (!active || active.lease.fencingToken !== fencingToken || active.releasing)
+            return null;
+        return new AttemptSupervisedProviderProcessRunner(active.processSupervisor, hostPortOwner(active.lease), this.listenerInspector, active.executionClass === "analysis_only", () => this.markCapacityReservationRunning(dispatchAttemptId, fencingToken));
+    }
+    markCapacityReservationRunning(dispatchAttemptId, fencingToken) {
+        const reservation = this.capacityReservations.get(dispatchAttemptId);
+        if (reservation?.owner.fencingToken === fencingToken)
+            reservation.state = "running";
+    }
+    providerMemoryTelemetry(dispatchAttemptId, fencingToken) {
+        const active = this.active.get(dispatchAttemptId);
+        if (!active || active.lease.fencingToken !== fencingToken || active.releasing)
+            return null;
+        return active.processSupervisor.providerMemoryTelemetry();
+    }
+    async promoteVerifiedRuntime(active, runtimeLease) {
+        if (!active.parallelPromotionEligible)
+            return runtimeLease;
+        const verifiedPortNames = runtimeLease.resources.ports.map(port => port.name).sort((left, right) => left.localeCompare(right));
+        const requiredPortNames = configuredLaunchPortNames(active.runtimeContract);
+        if (requiredPortNames.length !== verifiedPortNames.length
+            || requiredPortNames.some((name, index) => name !== verifiedPortNames[index])) {
+            return runtimeLease;
+        }
+        const projectKey = projectHostRuntimeSingletonKey(active.repoId);
+        const promotedLease = withRuntimeIsolationResources(runtimeLease, {
+            ...runtimeLease.resources,
+            singletonKeys: runtimeLease.resources.singletonKeys.filter(key => key !== projectKey),
+        });
+        await this.writeLedger(promotedLease);
+        active.lease = promotedLease;
+        try {
+            const promotion = await this.promotionStore.observe(active.repoId, active.runtimeContract, runtimeLease.dispatchAttemptId, verifiedPortNames, active.inputCommitSha);
+            this.knownPromotions.set(promotion.repoId, promotion);
+            const owner = {
+                dispatchAttemptId: runtimeLease.dispatchAttemptId,
+                fencingToken: runtimeLease.fencingToken,
+            };
+            if (!this.parallelProjectOwned(projectKey, owner)) {
+                this.convertSingletonToParallelProject(projectKey, owner, promotion);
+            }
+            const admission = this.admissions.get(runtimeLease.dispatchAttemptId);
+            if (admission?.fencingToken === runtimeLease.fencingToken) {
+                this.admissions.set(runtimeLease.dispatchAttemptId, {
+                    ...admission,
+                    keys: promotedLease.resources.singletonKeys,
+                    provisionalPromotionFingerprint: promotion.runtimeContractFingerprint,
+                    parallelProjectKey: projectKey,
+                });
+            }
+            return promotedLease;
+        }
+        catch {
+            await this.invalidatePromotion(active.repoId).catch(() => undefined);
+            active.lease = runtimeLease;
+            await this.writeLedger(runtimeLease);
+            return runtimeLease;
+        }
+    }
+    async launchNodeRuntime(dispatchAttemptId, fencingToken, portName, command, launcher, signal) {
+        const active = this.active.get(dispatchAttemptId);
+        if (!active || active.lease.fencingToken !== fencingToken || active.lease.state !== "active" || active.releasing) {
+            throw new Error("host_runtime_adapter_unavailable: an active matching host runtime lease is required.");
+        }
+        const portConfig = active.runtimeContract.contract.runtime.ports.find(port => port.name === portName);
+        if (!portConfig)
+            throw new Error(`host_runtime_adapter_invalid: configured port '${portName}' was not found.`);
+        if (active.lease.resources.ports.some(port => port.name === portName) || active.pendingAdapterLaunches.has(portName)) {
+            throw new Error(`host_runtime_adapter_conflict: configured port '${portName}' is already active.`);
+        }
+        const controller = linkedAbortController(signal);
+        let retainedByActiveRuntime = false;
+        const operation = (async () => {
+            const owner = hostPortOwner(active.lease);
+            const launched = await this.nodeAdapter.launch(owner, portConfig, command, launcher, controller.signal);
+            let cleaned = false;
+            const cleanup = async () => {
+                if (cleaned)
+                    return;
+                await launcher.stop(launched.value);
+                await this.portBroker.release(launched.reservation.reservationId, owner);
+                cleaned = true;
+                unlinkAbortController(controller, signal);
+            };
+            active.adapterCleanups.push(cleanup);
+            try {
+                if (active.releasing)
+                    throw new Error("host_runtime_adapter_cancelled: host runtime release started during launch.");
+                const runtimeLease = withRuntimeIsolationResources(active.lease, {
+                    ...active.lease.resources,
+                    ports: [...active.lease.resources.ports, {
+                            name: launched.reservation.name,
+                            protocol: launched.reservation.protocol,
+                            hostIp: launched.reservation.hostIp,
+                            hostPort: launched.reservation.hostPort,
+                            targetPort: launched.reservation.targetPort,
+                        }],
+                });
+                await this.writeLedger(runtimeLease);
+                active.lease = runtimeLease;
+                retainedByActiveRuntime = true;
+                return { ...launched, runtimeLease };
+            }
+            catch (error) {
+                try {
+                    await cleanup();
+                    removeCleanup(active.adapterCleanups, cleanup);
+                }
+                catch {
+                    // Preserve the cleanup and broker claim for the fenced release retry.
+                }
+                throw error;
+            }
+        })();
+        active.pendingAdapterLaunches.set(portName, { controller, promise: operation });
+        try {
+            return await operation;
+        }
+        finally {
+            active.pendingAdapterLaunches.delete(portName);
+            if (!retainedByActiveRuntime)
+                unlinkAbortController(controller, signal);
+        }
+    }
+    async release(dispatchAttemptId, fencingToken, preservePreparation = false) {
+        if (!preservePreparation)
+            this.preparedReadiness.cancel(dispatchAttemptId, fencingToken);
+        const active = this.active.get(dispatchAttemptId);
+        if (!preservePreparation)
+            this.pendingRenewals.delete(dispatchAttemptId);
+        if (!active) {
+            this.cancelAdmissionWaiters(dispatchAttemptId, fencingToken, "Managed host admission was released before acquisition.");
+            this.releaseSingletonKeys(dispatchAttemptId, fencingToken);
+            this.releaseParallelProjects(dispatchAttemptId, fencingToken);
+            this.deleteAdmission(dispatchAttemptId, fencingToken);
+            return null;
+        }
+        if (active.lease.fencingToken !== fencingToken)
+            return null;
+        active.releasing = true;
+        for (const pending of active.pendingAdapterLaunches.values()) {
+            pending.controller.abort("Host runtime release cancelled the pending adapter launch.");
+        }
+        await Promise.allSettled([...active.pendingAdapterLaunches.values()].map(pending => pending.promise));
+        await active.databaseProvision?.catch(() => undefined);
+        let releasing = transitionRuntimeIsolationLease(active.lease, "releasing");
+        active.lease = releasing;
+        await this.writeLedger(releasing);
+        try {
+            if (!active.runtimeResourcesReleased) {
+                await active.processSupervisor.stopAll(fencingToken, "Host runtime lease released.");
+                await releaseAdapterResources(active.adapterCleanups);
+                if (active.databaseCapability && this.databaseBroker) {
+                    // A database the broker cannot drop now is reaped later; it must not hold host capacity.
+                    await this.databaseBroker.release(dispatchAttemptId, fencingToken).catch(() => "retained");
+                }
+                active.runtimeResourcesReleased = true;
+                // Runtime admission protects live processes, listeners, ports, and their
+                // memory commitment. Once exact process and adapter cleanup succeeds,
+                // diagnostics retention remains retryable evidence work and must not keep
+                // consuming host capacity or blocking the next project dispatch.
+                this.processSupervisors.unregister(dispatchAttemptId, fencingToken);
+                this.releaseSingletonKeys(dispatchAttemptId, fencingToken);
+                this.releaseParallelProjects(dispatchAttemptId, fencingToken);
+                this.deleteAdmission(dispatchAttemptId, fencingToken);
+            }
+            let evidenceRetainedAtAttemptRoot = false;
+            try {
+                const diagnosticsPath = await retainHostDiagnostics(this.stateRoot, active.attemptRoot, dispatchAttemptId, active.attemptRootIdentity, this.executionRoot);
+                releasing = withRuntimeIsolationResources(releasing, {
+                    ...releasing.resources,
+                    paths: [...releasing.resources.paths.filter(entry => entry.role !== "diagnostics_archive"),
+                        { role: "diagnostics_archive", path: diagnosticsPath }],
+                });
+            }
+            catch {
+                // Runtime teardown is already proven above. Diagnostics archival is
+                // deliberately non-destructive and may refuse a changed or unsupported
+                // attempt-root inventory. Preserve that root and its released ledger for
+                // operator inspection/reconciliation without converting completed
+                // teardown into a capacity-owning degraded runtime.
+                evidenceRetainedAtAttemptRoot = true;
+            }
+            if (!evidenceRetainedAtAttemptRoot)
+                await removeHostAttemptRoot(active.attemptRoot);
+            const released = transitionRuntimeIsolationLease(releasing, "released");
+            // Publish the terminal in-memory state before its serialized write. Any writer
+            // that already captured this active owner must observe the terminal fence and
+            // cannot recreate a nonterminal ledger after release completes.
+            active.lease = released;
+            await this.writeLedger(released);
+            if (!evidenceRetainedAtAttemptRoot) {
+                await fs.rm(this.ledgerPath(dispatchAttemptId), { force: true });
+            }
+            releasing = released;
+            this.active.delete(dispatchAttemptId);
+            this.processSupervisors.unregister(dispatchAttemptId, fencingToken);
+            this.releaseSingletonKeys(dispatchAttemptId, fencingToken);
+            this.releaseParallelProjects(dispatchAttemptId, fencingToken);
+            this.deleteAdmission(dispatchAttemptId, fencingToken);
+            return releasing;
+        }
+        catch (error) {
+            const degraded = transitionRuntimeIsolationLease(releasing, "degraded");
+            active.lease = degraded;
+            await this.writeLedger(degraded).catch(() => undefined);
+            throw new HostRuntimeLeaseCleanupError(degraded, error);
+        }
+    }
+    async readLedgers() {
+        const root = path.join(this.stateRoot, "runtime-ledger", "host");
+        const entries = await fs.readdir(root, { withFileTypes: true }).catch(error => {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        });
+        const ledgers = [];
+        for (const entry of entries) {
+            if (!entry.isFile() || !/^[0-9a-f]{32}\.json$/u.test(entry.name))
+                continue;
+            try {
+                const value = JSON.parse(await fs.readFile(path.join(root, entry.name), "utf8"));
+                if (!validHostRuntimeLedger(value))
+                    continue;
+                const expectedName = `${uuidHex(value.runtimeLease.dispatchAttemptId, "dispatch attempt")}.json`;
+                if (entry.name !== expectedName)
+                    continue;
+                ledgers.push(value);
+            }
+            catch {
+                // An invalid ledger has no trustworthy ownership identity and is never reaped.
+            }
+        }
+        return ledgers;
+    }
+    async recoverPersistedProcesses(lease, attemptRoot, attemptRootIdentity) {
+        const logsRoot = path.join(attemptRoot, "logs");
+        const expectedAttemptRoot = path.resolve(this.attemptRoot(lease.dispatchAttemptId));
+        if (path.resolve(attemptRoot) !== expectedAttemptRoot) {
+            throw new Error("host_runtime_reaper_invalid: attempt path is outside the fenced attempt root.");
+        }
+        await assertHostAttemptRootIdentity(attemptRoot, attemptRootIdentity);
+        const rootEntries = await readPinnedSourceDirectory(attemptRoot, attemptRootIdentity);
+        const logsEntry = rootEntries.find(entry => entry.name === "logs");
+        if (!logsEntry)
+            return [];
+        if (logsEntry.kind !== "directory") {
+            throw new Error("host_runtime_reaper_invalid: process ownership log path is not an ordinary directory.");
+        }
+        const entries = await readPinnedSourceDirectory(logsRoot, logsEntry.identity);
+        const outcomes = [];
+        for (const entry of entries) {
+            if (entry.kind !== "file" || !/^process-supervisor\.[a-z][a-z0-9_-]{0,31}\.\d+\.json$/u.test(entry.name))
+                continue;
+            const metadataPath = path.join(logsRoot, entry.name);
+            const value = JSON.parse((await readCanonicalSourceFile(metadataPath, maximumProcessRecoveryMetadataBytes, entry.identity)).toString("utf8"));
+            if (!validHostProcessSupervisorMetadata(value, lease)) {
+                throw new Error("host_runtime_reaper_invalid: process ownership metadata did not match the runtime lease.");
+            }
+            outcomes.push(await this.processRecovery.recover(value));
+        }
+        return outcomes;
+    }
+    async markLedgerDegraded(ledger) {
+        const lease = ledger.runtimeLease;
+        if (lease.state === "released")
+            return;
+        const degraded = transitionHostLeaseForCleanup(lease, "degraded");
+        const repoId = ledger.repoId ?? repoIdFromProjectSingletonKeys(lease.resources.singletonKeys);
+        this.rememberDegraded(degraded, repoId);
+        await this.writeLedger(degraded, repoId ?? undefined, deserializeHostAttemptRootIdentity(ledger.attemptRootIdentity)).catch(() => undefined);
+    }
+    rememberDegraded(lease, repoId) {
+        this.degraded.set(lease.dispatchAttemptId, { lease, repoId });
+        if (!repoId)
+            return;
+        const owner = { dispatchAttemptId: lease.dispatchAttemptId, fencingToken: lease.fencingToken };
+        const projectKey = projectHostRuntimeSingletonKey(repoId);
+        const existing = this.singletonOwners.get(projectKey);
+        if (!existing || sameSingletonOwner(existing, owner))
+            this.singletonOwners.set(projectKey, owner);
+    }
+    forgetDegraded(dispatchAttemptId, fencingToken) {
+        if (this.degraded.get(dispatchAttemptId)?.lease.fencingToken !== fencingToken)
+            return;
+        this.degraded.delete(dispatchAttemptId);
+        this.releaseSingletonKeys(dispatchAttemptId, fencingToken);
+        this.releaseParallelProjects(dispatchAttemptId, fencingToken);
+    }
+    attemptRoot(dispatchAttemptId) {
+        return path.join(this.executionRoot, "a", compactHostAttemptId(dispatchAttemptId));
+    }
+    writeLedger(runtimeLease, explicitRepoId, explicitAttemptRootIdentity) {
+        const activeOwner = this.active.get(runtimeLease.dispatchAttemptId);
+        const write = this.ledgerWriteTail.then(() => {
+            if (activeOwner?.lease.fencingToken === runtimeLease.fencingToken
+                && activeOwner.lease.state === "released"
+                && runtimeLease.state !== "released") {
+                return;
+            }
+            return this.writeLedgerAtomic(runtimeLease, explicitRepoId, explicitAttemptRootIdentity);
+        });
+        this.ledgerWriteTail = write.catch(() => undefined);
+        return write;
+    }
+    async writeLedgerAtomic(runtimeLease, explicitRepoId, explicitAttemptRootIdentity) {
+        const root = path.join(this.stateRoot, "runtime-ledger", "host");
+        await ensurePrivateDirectory(root);
+        const target = this.ledgerPath(runtimeLease.dispatchAttemptId);
+        const temporary = `${target}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+        try {
+            const handle = await fs.open(temporary, "wx", 0o600);
+            try {
+                const repoId = explicitRepoId
+                    ?? this.active.get(runtimeLease.dispatchAttemptId)?.repoId
+                    ?? this.admissions.get(runtimeLease.dispatchAttemptId)?.repoId
+                    ?? this.degraded.get(runtimeLease.dispatchAttemptId)?.repoId
+                    ?? undefined;
+                const attemptRootIdentity = explicitAttemptRootIdentity
+                    ?? this.active.get(runtimeLease.dispatchAttemptId)?.attemptRootIdentity
+                    ?? undefined;
+                const ledger = {
+                    schemaVersion: 1,
+                    ...(repoId ? { repoId } : {}),
+                    ...(attemptRootIdentity
+                        ? { attemptRootIdentity: serializeHostAttemptRootIdentity(attemptRootIdentity) }
+                        : {}),
+                    runtimeLease,
+                };
+                await handle.writeFile(`${JSON.stringify(ledger)}\n`);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await fs.rename(temporary, target);
+        }
+        catch (error) {
+            await fs.rm(temporary, { force: true }).catch(() => undefined);
+            throw new Error(`host_runtime_ledger_write_failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+    }
+    ledgerPath(dispatchAttemptId) {
+        const attemptHex = uuidHex(dispatchAttemptId, "dispatch attempt");
+        return path.join(this.stateRoot, "runtime-ledger", "host", `${attemptHex}.json`);
+    }
+    singletonKeysAvailable(keys) {
+        return keys.every(key => !this.singletonOwners.has(key) && !this.parallelProjectOwners.has(key));
+    }
+    assignSingletonKeys(keys, owner) {
+        for (const key of keys)
+            this.singletonOwners.set(key, owner);
+    }
+    releaseSingletonKeys(dispatchAttemptId, fencingToken) {
+        for (const [key, owner] of this.singletonOwners) {
+            if (owner.dispatchAttemptId === dispatchAttemptId && owner.fencingToken === fencingToken) {
+                this.singletonOwners.delete(key);
+            }
+        }
+        this.drainAdmissionWaiters();
+    }
+    convertSingletonToParallelProject(key, owner, promotion) {
+        if (!sameSingletonOwner(this.singletonOwners.get(key), owner)) {
+            throw new Error("host_runtime_parallel_promotion_stale: matching exclusive project admission is required.");
+        }
+        this.assignParallelProject(key, owner);
+        this.singletonOwners.delete(key);
+        for (let index = 0; index < this.singletonWaiters.length;) {
+            const waiter = this.singletonWaiters[index];
+            if (waiter.priority !== "foreground" || waiter.keys.length !== 1 || waiter.keys[0] !== key) {
+                index += 1;
+                continue;
+            }
+            this.singletonWaiters.splice(index, 1);
+            clearAdmissionDeadline(waiter);
+            waiter.signal?.removeEventListener("abort", waiter.abort);
+            this.assignParallelProject(key, waiter.owner);
+            this.knownPromotions.set(promotion.repoId, promotion);
+            waiter.resolve([]);
+        }
+        this.drainAdmissionWaiters();
+    }
+    parallelProjectOwned(key, owner) {
+        return sameSingletonOwner(this.parallelProjectOwners.get(key)?.get(owner.dispatchAttemptId), owner);
+    }
+    parallelProjectAvailable(key, priority = "foreground") {
+        return !this.singletonOwners.has(key)
+            && !this.singletonWaiters.some(waiter => waiter.keys.includes(key)
+                && (priority === "background" || waiter.priority === "foreground"));
+    }
+    assignParallelProject(key, owner) {
+        const owners = this.parallelProjectOwners.get(key) ?? new Map();
+        owners.set(owner.dispatchAttemptId, owner);
+        this.parallelProjectOwners.set(key, owners);
+    }
+    releaseParallelProjectNoDrain(key, owner) {
+        const owners = this.parallelProjectOwners.get(key);
+        if (!sameSingletonOwner(owners?.get(owner.dispatchAttemptId), owner))
+            return;
+        owners.delete(owner.dispatchAttemptId);
+        if (owners.size === 0)
+            this.parallelProjectOwners.delete(key);
+    }
+    releaseParallelProjects(dispatchAttemptId, fencingToken) {
+        const owner = { dispatchAttemptId, fencingToken };
+        for (const key of [...this.parallelProjectOwners.keys()]) {
+            this.releaseParallelProjectNoDrain(key, owner);
+        }
+        this.drainAdmissionWaiters();
+    }
+    deleteAdmission(dispatchAttemptId, fencingToken) {
+        if (this.admissions.get(dispatchAttemptId)?.fencingToken === fencingToken) {
+            this.admissions.delete(dispatchAttemptId);
+        }
+        this.releaseHostCapacity(dispatchAttemptId, fencingToken);
+    }
+    renewAdmissionWaiterDeadline(dispatchAttemptId, fencingToken, expiresAt) {
+        for (const waiter of [
+            ...this.singletonWaiters,
+            ...this.parallelProjectWaiters,
+            ...this.capacityWaiters,
+            ...this.backgroundAdmissionWaiters,
+        ]) {
+            if (!sameSingletonOwner(waiter.owner, { dispatchAttemptId, fencingToken })
+                || Date.parse(expiresAt) <= Date.parse(waiter.expiresAt))
+                continue;
+            waiter.expiresAt = expiresAt;
+            clearAdmissionDeadline(waiter);
+            waiter.deadlineTimer = scheduleAdmissionDeadline(waiter.expiresAt, waiter.expire);
+        }
+    }
+    clearPendingRenewal(owner) {
+        if (this.pendingRenewals.get(owner.dispatchAttemptId)?.fencingToken === owner.fencingToken) {
+            this.pendingRenewals.delete(owner.dispatchAttemptId);
+        }
+    }
+    cancelAdmissionWaiters(dispatchAttemptId, fencingToken, reason) {
+        const owner = { dispatchAttemptId, fencingToken };
+        for (const waiters of [
+            this.singletonWaiters,
+            this.parallelProjectWaiters,
+            this.capacityWaiters,
+            this.backgroundAdmissionWaiters,
+        ]) {
+            for (let index = waiters.length - 1; index >= 0; index -= 1) {
+                const waiter = waiters[index];
+                if (!sameSingletonOwner(waiter.owner, owner))
+                    continue;
+                waiters.splice(index, 1);
+                clearAdmissionDeadline(waiter);
+                if ("capacityRecheckTimer" in waiter)
+                    clearCapacityRecheck(waiter);
+                waiter.signal?.removeEventListener("abort", waiter.abort);
+                waiter.reject(new Error(`host_runtime_admission_cancelled: ${reason}`));
+            }
+        }
+        this.drainAdmissionWaiters();
+    }
+    drainSingletonWaiters() {
+        for (let index = 0; index < this.singletonWaiters.length;) {
+            const waiter = this.singletonWaiters[index];
+            if (waiter.signal?.aborted) {
+                this.singletonWaiters.splice(index, 1);
+                clearAdmissionDeadline(waiter);
+                waiter.signal.removeEventListener("abort", waiter.abort);
+                this.clearPendingRenewal(waiter.owner);
+                waiter.reject(cancellationError(waiter.signal));
+                continue;
+            }
+            if (admissionExpired(waiter.expiresAt)) {
+                this.singletonWaiters.splice(index, 1);
+                clearAdmissionDeadline(waiter);
+                waiter.signal?.removeEventListener("abort", waiter.abort);
+                this.clearPendingRenewal(waiter.owner);
+                waiter.reject(new HostRuntimeAdmissionExpiredError());
+                continue;
+            }
+            if (!this.singletonKeysAvailable(waiter.keys)) {
+                index += 1;
+                continue;
+            }
+            this.singletonWaiters.splice(index, 1);
+            clearAdmissionDeadline(waiter);
+            waiter.signal?.removeEventListener("abort", waiter.abort);
+            this.assignSingletonKeys(waiter.keys, waiter.owner);
+            waiter.resolve(waiter.keys);
+        }
+    }
+    drainParallelProjectWaiters() {
+        for (let index = 0; index < this.parallelProjectWaiters.length;) {
+            const waiter = this.parallelProjectWaiters[index];
+            if (waiter.signal?.aborted) {
+                this.parallelProjectWaiters.splice(index, 1);
+                clearAdmissionDeadline(waiter);
+                waiter.signal.removeEventListener("abort", waiter.abort);
+                this.clearPendingRenewal(waiter.owner);
+                waiter.reject(cancellationError(waiter.signal));
+                continue;
+            }
+            if (admissionExpired(waiter.expiresAt)) {
+                this.parallelProjectWaiters.splice(index, 1);
+                clearAdmissionDeadline(waiter);
+                waiter.signal?.removeEventListener("abort", waiter.abort);
+                this.clearPendingRenewal(waiter.owner);
+                waiter.reject(new HostRuntimeAdmissionExpiredError());
+                continue;
+            }
+            if (!this.parallelProjectAvailable(waiter.key, waiter.priority)) {
+                index += 1;
+                continue;
+            }
+            this.parallelProjectWaiters.splice(index, 1);
+            clearAdmissionDeadline(waiter);
+            waiter.signal?.removeEventListener("abort", waiter.abort);
+            this.assignParallelProject(waiter.key, waiter.owner);
+            waiter.resolve();
+        }
+    }
+    drainBackgroundAdmissionWaiters() {
+        if (this.hasForegroundDemand())
+            return;
+        for (let index = 0; index < this.backgroundAdmissionWaiters.length;) {
+            const waiter = this.backgroundAdmissionWaiters[index];
+            if (waiter.signal?.aborted) {
+                this.backgroundAdmissionWaiters.splice(index, 1);
+                clearAdmissionDeadline(waiter);
+                clearCapacityRecheck(waiter);
+                waiter.signal.removeEventListener("abort", waiter.abort);
+                this.clearPendingRenewal(waiter.owner);
+                waiter.reject(cancellationError(waiter.signal));
+                continue;
+            }
+            if (admissionExpired(waiter.expiresAt)) {
+                this.backgroundAdmissionWaiters.splice(index, 1);
+                clearAdmissionDeadline(waiter);
+                clearCapacityRecheck(waiter);
+                waiter.signal?.removeEventListener("abort", waiter.abort);
+                this.clearPendingRenewal(waiter.owner);
+                waiter.reject(new HostRuntimeAdmissionExpiredError());
+                continue;
+            }
+            if (!this.singletonKeysAvailable(waiter.keys) || !this.hostCapacityAvailable(waiter.resources)) {
+                index += 1;
+                continue;
+            }
+            this.backgroundAdmissionWaiters.splice(index, 1);
+            clearAdmissionDeadline(waiter);
+            clearCapacityRecheck(waiter);
+            waiter.signal?.removeEventListener("abort", waiter.abort);
+            this.assignSingletonKeys(waiter.keys, waiter.owner);
+            this.capacityReservations.set(waiter.owner.dispatchAttemptId, {
+                owner: waiter.owner,
+                resources: waiter.resources,
+                state: "pending",
+            });
+            waiter.resolve(waiter.keys);
+        }
+    }
+    async refreshKnownPromotions() {
+        const promotions = await this.promotionStore.list();
+        this.knownPromotions.clear();
+        for (const promotion of promotions)
+            this.knownPromotions.set(promotion.repoId, promotion);
+    }
+    async invalidatePromotion(repoId, scope = "all") {
+        await this.promotionStore.invalidate(repoId, scope);
+        this.knownPromotions.delete(repoId.trim().toLowerCase());
+    }
+    drainAdmissionWaiters() {
+        this.reconcileReservationOwners();
+        this.drainSingletonWaiters();
+        this.drainParallelProjectWaiters();
+        this.drainCapacityWaiters();
+        this.drainBackgroundAdmissionWaiters();
+    }
+    reconcileReservationOwners() {
+        for (const [key, owner] of this.singletonOwners) {
+            if (!this.reservationOwnerIsLive(owner))
+                this.singletonOwners.delete(key);
+        }
+        for (const [key, owners] of this.parallelProjectOwners) {
+            for (const [dispatchAttemptId, owner] of owners) {
+                const awaitingExclusiveUpgrade = this.singletonWaiters.some(waiter => waiter.keys.includes(key) && sameSingletonOwner(waiter.owner, owner));
+                // A parallel owner cannot legitimately keep the shared claim after the
+                // same fenced attempt has queued its exclusive downgrade. Reconcile the
+                // half-upgraded state before testing singleton availability so one missed
+                // release cannot make an attempt wait behind itself until lease expiry.
+                if (awaitingExclusiveUpgrade || !this.reservationOwnerIsLive(owner)) {
+                    owners.delete(dispatchAttemptId);
+                }
+            }
+            if (owners.size === 0)
+                this.parallelProjectOwners.delete(key);
+        }
+    }
+    reservationOwnerIsLive(owner) {
+        if (this.acquiringAdmissions.has(hostRuntimeOwnerKey(owner)))
+            return true;
+        if (this.admissions.get(owner.dispatchAttemptId)?.fencingToken === owner.fencingToken)
+            return true;
+        if (this.active.get(owner.dispatchAttemptId)?.lease.fencingToken === owner.fencingToken)
+            return true;
+        if (this.degraded.get(owner.dispatchAttemptId)?.lease.fencingToken === owner.fencingToken)
+            return true;
+        if (sameSingletonOwner(this.capacityReservations.get(owner.dispatchAttemptId)?.owner, owner))
+            return true;
+        return [
+            ...this.singletonWaiters,
+            ...this.parallelProjectWaiters,
+            ...this.capacityWaiters,
+            ...this.backgroundAdmissionWaiters,
+        ].some(waiter => sameSingletonOwner(waiter.owner, owner));
+    }
+    hasAttemptRepresentation(dispatchAttemptId, fencingToken) {
+        return this.reservationOwnerIsLive({ dispatchAttemptId, fencingToken });
+    }
+}
+class AttemptSupervisedProviderProcessRunner {
+    supervisor;
+    owner;
+    listenerInspector;
+    enforceNoListeners;
+    onProcessTreeStarted;
+    constructor(supervisor, owner, listenerInspector, enforceNoListeners, onProcessTreeStarted) {
+        this.supervisor = supervisor;
+        this.owner = owner;
+        this.listenerInspector = listenerInspector;
+        this.enforceNoListeners = enforceNoListeners;
+        this.onProcessTreeStarted = onProcessTreeStarted;
+    }
+    async run(request, handlers = {}, signal) {
+        const baselineListeners = this.enforceNoListeners
+            ? new Set(await this.listenerInspector.inspectLoopbackListeners())
+            : new Set();
+        const child = await this.supervisor.startChildReady("provider", request, handlers, signal, { maxStartAttempts: request.stdin === undefined ? 1 : 3, retryDelayMs: 100 });
+        this.onProcessTreeStarted();
+        if (!this.enforceNoListeners)
+            return await child.result;
+        let settled = false;
+        let inspectionFailure;
+        const monitor = (async () => {
+            while (!settled) {
+                try {
+                    const ports = (await this.listenerInspector.inspectOwnedLoopbackListeners(child, this.owner))
+                        .filter(port => !baselineListeners.has(port));
+                    if (ports.length > 0) {
+                        inspectionFailure = new Error(`host_analysis_listener_violation: analysis-only provider opened undeclared loopback listener(s): ${ports.join(", ")}.`);
+                        await child.stop(this.owner.fencingToken).catch(() => undefined);
+                        return;
+                    }
+                }
+                catch (error) {
+                    inspectionFailure = error;
+                    await child.stop(this.owner.fencingToken).catch(() => undefined);
+                    return;
+                }
+                await waitForAnalysisInspection(250, signal).catch(error => {
+                    if (!settled && !signal?.aborted)
+                        inspectionFailure = error;
+                });
+            }
+        })();
+        try {
+            const result = await child.result;
+            settled = true;
+            await monitor;
+            if (inspectionFailure)
+                throw inspectionFailure;
+            return result;
+        }
+        catch (error) {
+            settled = true;
+            await monitor.catch(() => undefined);
+            if (inspectionFailure)
+                throw inspectionFailure;
+            throw error;
+        }
+    }
+}
+function waitForAnalysisInspection(milliseconds, signal) {
+    if (signal?.aborted)
+        return Promise.reject(cancellationError(signal));
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        }, milliseconds);
+        const abort = () => {
+            clearTimeout(timer);
+            reject(cancellationError(signal));
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+    });
+}
+export class HostRuntimeLeaseCleanupError extends Error {
+    lease;
+    constructor(lease, cause) {
+        super(`host_runtime_cleanup_degraded: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+        this.lease = lease;
+        this.name = "HostRuntimeLeaseCleanupError";
+    }
+}
+export class HostRuntimeAdmissionExpiredError extends Error {
+    constructor() {
+        super("host_runtime_admission_expired: dispatch lease expired while waiting for managed host admission.");
+        this.name = "HostRuntimeAdmissionExpiredError";
+    }
+}
+export class HostRuntimeCapacityRequestImpossibleError extends Error {
+    constructor(reason) {
+        super(`host_runtime_capacity_request_impossible: ${reason}`);
+        this.name = "HostRuntimeCapacityRequestImpossibleError";
+    }
+}
+export function hostRuntimeEventResources(lease, runtimeContract, executionClass = "managed_runtime") {
+    const requestedHostConcurrency = runtimeContract?.contract.runtime.hostConcurrency ?? "serial";
+    const configuredLaunches = runtimeContract?.contract.runtime.ports.filter(port => port.launch !== null) ?? [];
+    const verifiedLaunches = configuredLaunches.filter(configured => lease.resources.ports.some(port => port.name === configured.name));
+    const effectiveConcurrency = effectiveHostConcurrency(lease, runtimeContract, executionClass);
+    return {
+        agentContainer: null,
+        sidecarContainers: [],
+        networks: [],
+        volumes: [],
+        publishedPorts: lease.resources.ports,
+        hostConcurrency: effectiveConcurrency,
+        requestedHostConcurrency,
+        hostParallelPromotion: effectiveConcurrency === "host_parallel_safe"
+            ? executionClass === "analysis_only" ? "analysis_profile_enforced" : "observed_probe_passed"
+            : requestedHostConcurrency !== "parallel"
+                ? "not_requested"
+                : configuredLaunches.length > 0 && verifiedLaunches.length === configuredLaunches.length
+                    ? "pending_live_parallel_proof"
+                    : "pending_adapter_probe",
+        verifiedRuntimePorts: verifiedLaunches.map(port => port.name),
+        runtimeContractSource: runtimeContract?.source ?? "default",
+        executionClass,
+        requestedPorts: runtimeContract?.contract.runtime.ports.map(port => port.name) ?? [],
+        singletonKeys: lease.resources.singletonKeys,
+        processSupervisorId: lease.resources.processSupervisorId,
+        runtimeLease: lease,
+    };
+}
+export function hostRuntimeSingletonKeys(dispatch) {
+    return [projectHostRuntimeSingletonKey(dispatch.repo.id)];
+}
+function hostRuntimeEnvironment(sessionId, lease, runtimeContract, executionClass, databaseCapability) {
+    const pathFor = (role) => lease.resources.paths.find(entry => entry.role === role)?.path ?? "";
+    const environment = {
+        FORGE_SESSION_ID: sessionId,
+        FORGE_RUNTIME_MODE: "host",
+        FORGE_RESOURCE_LEASE_ID: lease.leaseId,
+        FORGE_DISPATCH_ATTEMPT_ID: lease.dispatchAttemptId,
+        FORGE_E2E_OWNERSHIP_MODE: "attempt",
+        FORGE_E2E_OWNERSHIP_TOKEN: uuidHex(lease.dispatchAttemptId, "dispatch attempt"),
+        FORGE_EXECUTION_LEASE_ID: lease.executionLeaseId,
+        FORGE_FENCING_TOKEN: lease.fencingToken,
+        FORGE_WORKSPACE: lease.worktreePath,
+        FORGE_WORKTREE_PATH: lease.worktreePath,
+        FORGE_TMPDIR: pathFor("temporary"),
+        FORGE_LOG_DIR: pathFor("logs"),
+        FORGE_CACHE_DIR: pathFor("cache"),
+        FORGE_BROWSER_PROFILE_DIR: pathFor("browser_profile"),
+        FORGE_TEST_OUTPUT_DIR: pathFor("test_output"),
+        // Project-authored ASP.NET code must not fall back to the durable Forge
+        // database when no brokered attempt database exists. The API policy treats
+        // this marker as a fail-closed isolation requirement.
+        FORGE_ATTEMPT_DATABASE_POLICY: "isolated_only",
+        FORGE_ATTEMPT_DATABASE_SCHEMA: `forge_attempt_${uuidHex(lease.dispatchAttemptId, "dispatch attempt")}`,
+        FORGE_ATTEMPT_DATABASE_READINESS_PATH: path.join(pathFor("logs"), "attempt-database-readiness.json"),
+        FORGE_PROCESS_SUPERVISOR_ID: lease.resources.processSupervisorId ?? "",
+        FORGE_PROCESS_SUPERVISOR_METADATA_PATH: pathFor("process_supervisor_metadata"),
+        FORGE_HOST_CONCURRENCY: effectiveHostConcurrency(lease, runtimeContract, executionClass),
+        FORGE_HOST_CONCURRENCY_REQUESTED: runtimeContract.contract.runtime.hostConcurrency,
+        FORGE_RUNTIME_EXECUTION_CLASS: executionClass,
+        FORGE_HOST_RUNTIME_CONTRACT_SOURCE: runtimeContract.source,
+        FORGE_SINGLETON_KEYS: lease.resources.singletonKeys.join(","),
+        TMPDIR: pathFor("temporary"),
+        TMP: pathFor("temporary"),
+        TEMP: pathFor("temporary"),
+        XDG_CACHE_HOME: pathFor("cache"),
+        NPM_CONFIG_CACHE: path.join(pathFor("cache"), "npm"),
+    };
+    if (lease.resources.singletonKeys.length === 0)
+        delete environment.FORGE_SINGLETON_KEYS;
+    if (databaseCapability)
+        environment[attemptDatabaseCapabilityEnvironment] = databaseCapability.connectionString;
+    const resolvedBaseUrls = [];
+    for (const assigned of lease.resources.ports) {
+        const configured = runtimeContract.contract.runtime.ports.find(port => port.name === assigned.name);
+        if (!configured || assigned.hostIp !== "127.0.0.1")
+            continue;
+        Object.assign(environment, hostPortEnvironment(configured, assigned.hostIp, assigned.hostPort));
+        const normalizedName = assigned.name.toUpperCase().replaceAll(/[^A-Z0-9]/gu, "_");
+        environment[`FORGE_${normalizedName}_PORT`] = String(assigned.hostPort);
+        if (configured.baseUrlEnv && configured.format) {
+            const baseUrl = hostPortEnvironment(configured, assigned.hostIp, assigned.hostPort)[configured.baseUrlEnv];
+            if (baseUrl) {
+                environment[`FORGE_${normalizedName}_URL`] = baseUrl;
+                resolvedBaseUrls.push(baseUrl);
+            }
+        }
+    }
+    if (environment.FORGE_API_URL)
+        environment.FORGE_E2E_API_URL = environment.FORGE_API_URL;
+    if (environment.FORGE_WEB_URL)
+        environment.FORGE_E2E_WEB_URL = environment.FORGE_WEB_URL;
+    if (resolvedBaseUrls.length === 1)
+        environment.FORGE_BASE_URL = resolvedBaseUrls[0];
+    return environment;
+}
+async function executeAspNetRuntimeBuild(supervisor, logDirectory, plan, signal, exactSecrets = []) {
+    const childName = `runtime-build-${plan.fingerprint.slice(-12)}`;
+    const stdoutLogPath = path.join(logDirectory, `${childName}.stdout.log`);
+    const stderrLogPath = path.join(logDirectory, `${childName}.stderr.log`);
+    let stdoutTail = "";
+    let stderrTail = "";
+    const append = async (target, line) => {
+        await fs.appendFile(target, `${redactText(line, exactSecrets)}\n`, { encoding: "utf8", mode: 0o600 });
+    };
+    const child = await supervisor.startChildReady(childName, {
+        command: plan.command,
+        args: plan.args,
+        cwd: plan.cwd,
+        env: plan.environment,
+        captureOutput: false,
+    }, {
+        onStdoutLine: async (line) => {
+            stdoutTail = appendRuntimeBuildTail(stdoutTail, redactText(line, exactSecrets));
+            await append(stdoutLogPath, line);
+        },
+        onStderrLine: async (line) => {
+            stderrTail = appendRuntimeBuildTail(stderrTail, redactText(line, exactSecrets));
+            await append(stderrLogPath, line);
+        },
+    }, signal, { maxStartAttempts: 2, retryDelayMs: 250 });
+    const result = await child.result;
+    return {
+        exitCode: result.exitCode,
+        stdoutTail: appendRuntimeBuildTail(stdoutTail, redactText(result.stdout, exactSecrets)),
+        stderrTail: appendRuntimeBuildTail(stderrTail, redactText(result.stderr, exactSecrets)),
+        stdoutLogPath,
+        stderrLogPath,
+    };
+}
+function appendRuntimeBuildTail(current, value) {
+    if (!value)
+        return current;
+    return `${current}${current ? "\n" : ""}${value}`.slice(-4_000);
+}
+function effectiveHostConcurrency(lease, runtimeContract, executionClass = "managed_runtime") {
+    if (executionClass === "analysis_only") {
+        const analysisSingletonHeld = lease.resources.singletonKeys.length > 0;
+        return analysisSingletonHeld ? "host_serial_only" : "host_parallel_safe";
+    }
+    if (!runtimeContract || !hostRuntimeParallelEligible(runtimeContract))
+        return "host_serial_only";
+    const requiredPorts = configuredLaunchPortNames(runtimeContract);
+    const everyPortVerified = requiredPorts.length > 0
+        && requiredPorts.every(name => lease.resources.ports.some(port => port.name === name));
+    const projectSingletonHeld = lease.resources.singletonKeys.some(key => key.endsWith(":host-runtime"));
+    return everyPortVerified && !projectSingletonHeld ? "host_parallel_safe" : "host_serial_only";
+}
+function projectHostRuntimeSingletonKey(repoId) {
+    return `project:${repoId.toLowerCase()}:host-runtime`;
+}
+function projectHostAnalysisKey(repoId) {
+    return `project:${repoId.toLowerCase()}:host-analysis`;
+}
+function hostRuntimeDeclaredSingletonKey(resource) {
+    return `runtime:${resource}`;
+}
+function runtimeExecutionClass(dispatch) {
+    return dispatch.runtimeIntent?.executionClass === "analysis_only"
+        && dispatch.runtimeIntent.applicationRuntimeRequired === false
+        ? "analysis_only"
+        : "managed_runtime";
+}
+function runtimeAdmissionPriority(dispatch) {
+    return dispatch.execution.lane.trim().toLowerCase() === "runtime_readiness"
+        || dispatch.cycleRun.phase.trim().toLowerCase() === "readiness_probe"
+        ? "background"
+        : "foreground";
+}
+function enqueueAdmissionWaiter(waiters, waiter) {
+    if (waiter.priority === "background") {
+        waiters.push(waiter);
+        return;
+    }
+    const backgroundIndex = waiters.findIndex(candidate => candidate.priority === "background");
+    if (backgroundIndex < 0)
+        waiters.push(waiter);
+    else
+        waiters.splice(backgroundIndex, 0, waiter);
+}
+function defaultHostResourceRequest() {
+    const workerMemoryLimitBytes = configuredInteger("FORGE_HOST_DEFAULT_WORKER_MEMORY_LIMIT_BYTES", 2 * 1024 ** 3, 128 * 1024 ** 2, 512 * 1024 ** 3);
+    const runtimeOverheadBytes = 128 * 1024 ** 2;
+    return {
+        sandboxSlots: 1,
+        cpuMillis: 2000,
+        workerMemoryLimitBytes,
+        serviceMemoryLimitBytes: 0,
+        runtimeOverheadBytes,
+        memoryBytes: workerMemoryLimitBytes + runtimeOverheadBytes,
+        workspaceBytes: 10 * 1024 ** 3,
+        pids: 512,
+        buildSlots: 1,
+    };
+}
+function minimumSupportedHostResourceRequest() {
+    return {
+        sandboxSlots: 1,
+        cpuMillis: 1000,
+        workerMemoryLimitBytes: 1024 ** 3,
+        serviceMemoryLimitBytes: 0,
+        runtimeOverheadBytes: 128 * 1024 ** 2,
+        memoryBytes: 1152 * 1024 ** 2,
+        workspaceBytes: architectMinimumWorkspaceEstimateBytes,
+        pids: 256,
+        buildSlots: 0,
+    };
+}
+function normalizedHostResourceRequest(resources) {
+    const defaults = defaultHostResourceRequest();
+    const workerMemoryLimitBytes = positiveResourceValue(resources?.workerMemoryLimitBytes, defaults.workerMemoryLimitBytes);
+    const serviceMemoryLimitBytes = nonNegativeResourceValue(resources?.serviceMemoryLimitBytes, defaults.serviceMemoryLimitBytes);
+    const runtimeOverheadBytes = nonNegativeResourceValue(resources?.runtimeOverheadBytes, defaults.runtimeOverheadBytes);
+    return {
+        sandboxSlots: positiveResourceValue(resources?.sandboxSlots, defaults.sandboxSlots),
+        cpuMillis: positiveResourceValue(resources?.cpuMillis, defaults.cpuMillis),
+        workerMemoryLimitBytes,
+        serviceMemoryLimitBytes,
+        runtimeOverheadBytes,
+        memoryBytes: workerMemoryLimitBytes + serviceMemoryLimitBytes + runtimeOverheadBytes,
+        workspaceBytes: positiveResourceValue(resources?.workspaceBytes, defaults.workspaceBytes),
+        pids: positiveResourceValue(resources?.pids, defaults.pids),
+        buildSlots: nonNegativeResourceValue(resources?.buildSlots, defaults.buildSlots),
+    };
+}
+function positiveResourceValue(value, fallback) {
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function nonNegativeResourceValue(value, fallback) {
+    return Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+}
+function configuredInteger(name, fallback, minimum, maximum) {
+    const parsed = Number.parseInt(process.env[name] ?? "", 10);
+    return Number.isFinite(parsed) ? Math.max(minimum, Math.min(maximum, parsed)) : fallback;
+}
+function loadHostCapacityConfiguration(capacityResourceSample) {
+    const sampledCpuCount = capacityResourceSample
+        ? Math.max(1, Math.floor(capacityResourceSample.totalCpuMillis / 1_000))
+        : os.cpus().length;
+    const totalMemoryBytes = capacityResourceSample?.totalMemoryBytes ?? os.totalmem();
+    const reserveFloorBytes = configuredInteger("FORGE_HOST_MEMORY_RESERVE_FLOOR_BYTES", 1024 ** 3, 512 * 1024 ** 2, 128 * 1024 ** 3);
+    const reserveCeilingBytes = configuredInteger("FORGE_HOST_MEMORY_RESERVE_CEILING_BYTES", 4 * 1024 ** 3, reserveFloorBytes, 128 * 1024 ** 3);
+    const hostReserveBytes = resolveAdaptiveMemoryReserveBytes(totalMemoryBytes, {
+        explicitBytes: configuredOptionalInteger("FORGE_HOST_MEMORY_RESERVE_BYTES", 512 * 1024 ** 2, 128 * 1024 ** 3),
+        floorBytes: reserveFloorBytes,
+        ceilingBytes: reserveCeilingBytes,
+        percent: configuredNumber("FORGE_HOST_MEMORY_RESERVE_PERCENT", 12.5, 1, 50),
+    });
+    const minimumIdleReserveBytes = Math.min(hostReserveBytes, reserveFloorBytes);
+    return {
+        hardMaxAttempts: configuredInteger("FORGE_HOST_MAX_CONCURRENT_ATTEMPTS", Math.max(1, Math.min(8, Math.floor(sampledCpuCount / 2))), 1, 32),
+        hostReserveBytes,
+        idleHostReserveBytes: configuredInteger("FORGE_HOST_IDLE_MEMORY_RESERVE_BYTES", minimumIdleReserveBytes, 512 * 1024 ** 2, hostReserveBytes),
+        cpuReserveMillis: configuredInteger("FORGE_HOST_CPU_RESERVE_MILLIS", 1000, 0, 32_000),
+        workspaceReserveBytes: configuredInteger("FORGE_HOST_WORKSPACE_RESERVE_BYTES", 10 * 1024 ** 3, 1024 ** 3, Number.MAX_SAFE_INTEGER),
+        memoryRecoverySamples: configuredInteger("FORGE_HOST_MEMORY_RECOVERY_SAMPLES", 2, 1, 10),
+        memoryRecoverySampleIntervalMs: configuredInteger("FORGE_HOST_MEMORY_RECOVERY_SAMPLE_INTERVAL_MS", 1_000, 100, 30_000),
+    };
+}
+function configuredOptionalInteger(name, minimum, maximum) {
+    const raw = process.env[name];
+    if (raw === undefined || raw.trim().length === 0)
+        return null;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) ? Math.max(minimum, Math.min(maximum, parsed)) : null;
+}
+function configuredNumber(name, fallback, minimum, maximum) {
+    const parsed = Number(process.env[name] ?? "");
+    return Number.isFinite(parsed) && parsed > 0
+        ? Math.max(minimum, Math.min(maximum, parsed))
+        : fallback;
+}
+function resourceSlots(available, requested) {
+    if (requested <= 0)
+        return Number.MAX_SAFE_INTEGER;
+    return Math.max(0, Math.floor(available / requested));
+}
+function removeWaiter(waiters, waiter) {
+    const index = waiters.indexOf(waiter);
+    if (index >= 0)
+        waiters.splice(index, 1);
+}
+function capacityProject(projects, repoId) {
+    const normalized = repoId.trim().toLowerCase();
+    const existing = projects.get(normalized);
+    if (existing)
+        return existing;
+    const created = {
+        repoId: normalized,
+        safetyClass: null,
+        activeAttempts: 0,
+        reservedAttempts: 0,
+        waitingAttempts: 0,
+        degradedAttempts: 0,
+        runtimeContractFingerprint: null,
+        runtimeContractSource: null,
+        promotedAt: null,
+    };
+    projects.set(normalized, created);
+    return created;
+}
+function conservativeSafetyClass(left, right) {
+    if (!left)
+        return right;
+    const rank = {
+        host_serial_only: 0,
+        host_parallel_candidate: 1,
+        host_parallel_safe: 2,
+    };
+    return rank[right] < rank[left] ? right : left;
+}
+function repoIdFromProjectSingletonKeys(keys) {
+    return keys.map(repoIdFromProjectSingletonKey).find((value) => value !== null) ?? null;
+}
+function repoIdFromProjectSingletonKey(key) {
+    const prefix = "project:";
+    const suffix = [":host-runtime", ":host-analysis"].find(candidate => key.endsWith(candidate));
+    return key.startsWith(prefix) && suffix
+        ? key.slice(prefix.length, -suffix.length)
+        : null;
+}
+function sameSingletonOwner(left, right) {
+    return left?.dispatchAttemptId === right.dispatchAttemptId && left.fencingToken === right.fencingToken;
+}
+function hostRuntimeOwnerKey(owner) {
+    return `${owner.dispatchAttemptId}:${owner.fencingToken}`;
+}
+function hostPortOwner(lease) {
+    const processSupervisorId = lease.resources.processSupervisorId;
+    if (!processSupervisorId) {
+        throw new Error("host_runtime_adapter_invalid: process supervisor identity is required.");
+    }
+    return {
+        dispatchAttemptId: lease.dispatchAttemptId,
+        executionLeaseId: lease.executionLeaseId,
+        fencingToken: lease.fencingToken,
+        processSupervisorId,
+    };
+}
+function linkedAbortController(signal) {
+    const controller = new AbortController();
+    if (signal?.aborted) {
+        controller.abort(signal.reason);
+    }
+    else {
+        signal?.addEventListener("abort", () => controller.abort(signal.reason), { once: true, signal: controller.signal });
+    }
+    return controller;
+}
+function unlinkAbortController(controller, _signal) {
+    if (!controller.signal.aborted)
+        controller.abort("Host adapter launch settled.");
+}
+function removeCleanup(cleanups, cleanup) {
+    const index = cleanups.indexOf(cleanup);
+    if (index >= 0)
+        cleanups.splice(index, 1);
+}
+async function releaseAdapterResources(cleanups) {
+    const pending = cleanups.splice(0);
+    const failed = [];
+    let firstError;
+    for (const cleanup of pending.reverse()) {
+        try {
+            await cleanup();
+        }
+        catch (error) {
+            firstError ??= error;
+            failed.unshift(cleanup);
+        }
+    }
+    cleanups.push(...failed);
+    if (firstError !== undefined)
+        throw firstError;
+}
+async function removeHostAttemptRoot(attemptRoot) {
+    await fs.rm(attemptRoot, {
+        recursive: true,
+        force: true,
+        maxRetries: 10,
+        retryDelay: 100,
+    });
+}
+function cancellationError(signal) {
+    return new Error(String(signal?.reason ?? "Dispatch cancelled while waiting for host runtime singleton ownership."));
+}
+function validHostRuntimeLedger(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const ledger = value;
+    return ledger.schemaVersion === 1
+        && (ledger.repoId === undefined || /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/iu.test(ledger.repoId))
+        && (ledger.attemptRootIdentity === undefined
+            || validSerializedHostAttemptRootIdentity(ledger.attemptRootIdentity))
+        && validRuntimeIsolationLease(ledger.runtimeLease)
+        && ledger.runtimeLease.mode === "host";
+}
+function validSerializedHostAttemptRootIdentity(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const identity = value;
+    return /^-?\d{1,64}$/u.test(identity.dev) && /^-?\d{1,64}$/u.test(identity.ino);
+}
+function serializeHostAttemptRootIdentity(identity) {
+    return { dev: identity.dev.toString(), ino: identity.ino.toString() };
+}
+function deserializeHostAttemptRootIdentity(identity) {
+    return identity && validSerializedHostAttemptRootIdentity(identity)
+        ? { dev: BigInt(identity.dev), ino: BigInt(identity.ino) }
+        : null;
+}
+function validHostProcessSupervisorMetadata(value, lease) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const metadata = value;
+    return metadata.schemaVersion === 1
+        && /^host-[0-9a-f]{32}$/u.test(metadata.supervisorId)
+        && (metadata.strategy === "windows_job_object" || metadata.strategy === "unix_process_group")
+        && Number.isSafeInteger(metadata.rootPid)
+        && metadata.rootPid > 0
+        && Number.isFinite(Date.parse(metadata.rootCreatedAt))
+        && (metadata.rootIdentity == null
+            || (typeof metadata.rootIdentity === "string" && metadata.rootIdentity.length <= 256))
+        && /^[0-9a-f]{64}$/u.test(metadata.commandDigest)
+        && containedMetadataWorktreePath(lease.worktreePath, metadata.worktreePath)
+        && metadata.runtimeLeaseId === lease.executionLeaseId
+        && metadata.dispatchAttemptId === lease.dispatchAttemptId
+        && metadata.fencingToken === lease.fencingToken
+        && Number.isSafeInteger(metadata.bridgePid)
+        && metadata.bridgePid > 0;
+}
+function containedMetadataWorktreePath(worktreePath, metadataWorktreePath) {
+    const relative = path.relative(path.resolve(worktreePath), path.resolve(metadataWorktreePath));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function transitionHostLeaseForCleanup(lease, state) {
+    if (lease.state === state || lease.state === "released")
+        return lease;
+    return transitionRuntimeIsolationLease(lease, state);
+}
+function throwIfAdmissionExpired(expiresAt) {
+    if (admissionExpired(expiresAt))
+        throw new HostRuntimeAdmissionExpiredError();
+}
+function admissionExpired(expiresAt) {
+    const deadline = Date.parse(expiresAt);
+    return !Number.isFinite(deadline) || deadline <= Date.now();
+}
+function scheduleAdmissionDeadline(expiresAt, expire) {
+    const delay = Math.max(0, Date.parse(expiresAt) - Date.now());
+    const timer = setTimeout(expire, Math.min(delay, 2_147_483_647));
+    timer.unref?.();
+    return timer;
+}
+function clearAdmissionDeadline(waiter) {
+    if (waiter.deadlineTimer)
+        clearTimeout(waiter.deadlineTimer);
+    waiter.deadlineTimer = null;
+}
+function clearCapacityRecheck(waiter) {
+    if (waiter.capacityRecheckTimer)
+        clearInterval(waiter.capacityRecheckTimer);
+    waiter.capacityRecheckTimer = null;
+}
+async function ensurePrivateDirectory(directory) {
+    await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32")
+        await fs.chmod(directory, 0o700);
+}
+async function containedWorkingDirectory(worktreePath, configuredDirectory) {
+    const [realWorktree, realDirectory] = await Promise.all([
+        fs.realpath(worktreePath),
+        fs.realpath(path.resolve(worktreePath, configuredDirectory)),
+    ]);
+    const relative = path.relative(realWorktree, realDirectory);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("host_runtime_project_invalid: launch working directory must remain inside the prepared worktree.");
+    }
+    return realDirectory;
+}
+function uuidHex(value, label) {
+    const normalized = value.replaceAll("-", "").toLowerCase();
+    if (!/^[0-9a-f]{32}$/u.test(normalized)) {
+        throw new Error(`host_runtime_lease_invalid: ${label} id must be a full UUID.`);
+    }
+    return normalized;
+}