@loucompanion/forge-bridge 0.1.3-dev.fbe15023cdfe → 0.1.4-dev.bfa11ebe98c6

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

@@ -1,5 +1,14 @@
 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 { 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";
@@ -8,10 +17,18 @@ import { NodeHostRuntimeAdapter, } from "./node-host-runtime-adapter.js";
 import { AttemptProcessSupervisorRegistry } from "./attempt-process-supervisor-registry.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;
@@ -20,18 +37,30 @@ export class HostRuntimeLeaseManager {
     promotionStore;
     playwrightAdapter;
     processRecovery;
+    capacityResourceSample;
+    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;
-    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()) {
+    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) {
         this.stateRoot = stateRoot;
         this.processSupervisors = processSupervisors;
         this.processRunner = processRunner;
@@ -39,22 +68,46 @@ export class HostRuntimeLeaseManager {
         this.promotionStore = promotionStore;
         this.playwrightAdapter = playwrightAdapter;
         this.processRecovery = processRecovery;
+        this.capacityResourceSample = capacityResourceSample;
+        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")
@@ -78,9 +131,13 @@ export class HostRuntimeLeaseManager {
                 continue;
             report.examined += 1;
             const attemptRoot = this.attemptRoot(lease.dispatchAttemptId);
+            const attemptRootIdentity = deserializeHostAttemptRootIdentity(ledger.attemptRootIdentity);
             let outcomes;
             try {
-                outcomes = await this.recoverPersistedProcesses(lease, attemptRoot);
+                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);
@@ -94,10 +151,45 @@ export class HostRuntimeLeaseManager {
                 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);
-                await fs.rm(attemptRoot, { recursive: true, force: true });
+                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;
@@ -110,6 +202,7 @@ export class HostRuntimeLeaseManager {
         return report;
     }
     snapshot() {
+        this.reconcileReservationOwners();
         const projects = new Map();
         for (const promotion of this.knownPromotions.values()) {
             const project = capacityProject(projects, promotion.repoId);
@@ -168,6 +261,26 @@ export class HostRuntimeLeaseManager {
             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([
@@ -176,14 +289,21 @@ export class HostRuntimeLeaseManager {
                 .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,
+            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,
@@ -192,6 +312,21 @@ export class HostRuntimeLeaseManager {
                 .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") {
@@ -211,6 +346,7 @@ export class HostRuntimeLeaseManager {
             return existing.keys;
         }
         const executionClass = runtimeExecutionClass(dispatch);
+        const priority = runtimeAdmissionPriority(dispatch);
         const promotion = executionClass === "managed_runtime"
             ? await this.promotionStore.load(dispatch.repo.id)
             : null;
@@ -219,37 +355,353 @@ export class HostRuntimeLeaseManager {
         const projectKey = executionClass === "analysis_only"
             ? projectHostAnalysisKey(dispatch.repo.id)
             : projectHostRuntimeSingletonKey(dispatch.repo.id);
-        let keys = promotion || executionClass === "analysis_only" ? [] : [projectKey];
+        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 {
-            if (promotion || executionClass === "analysis_only") {
-                await this.reserveParallelProject(projectKey, owner, expiresAt, signal);
+            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);
+                }
             }
-            else {
-                keys = await this.reserveSingletonKeys(keys, owner, expiresAt, signal);
+            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;
         }
-        catch (error) {
-            this.clearPendingRenewal(owner);
-            throw error;
+        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;
         }
-        const admittedPromotion = promotion
-            ?? (executionClass === "managed_runtime" && keys.length === 0
-                ? this.knownPromotions.get(dispatch.repo.id) ?? null
-                : null);
-        this.admissions.set(sandbox.dispatchAttemptId, {
-            repoId: dispatch.repo.id,
-            fencingToken: owner.fencingToken,
-            executionClass,
-            provisionalPromotionFingerprint: admittedPromotion?.runtimeContractFingerprint ?? null,
-            keys,
-            parallelProjectKey: admittedPromotion || executionClass === "analysis_only" ? projectKey : null,
+        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();
         });
-        return keys;
     }
-    async reserveSingletonKeys(keys, owner, expiresAt, signal) {
+    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;
@@ -269,6 +721,7 @@ export class HostRuntimeLeaseManager {
             const waiter = {
                 owner,
                 keys,
+                priority,
                 resolve,
                 reject,
                 signal,
@@ -295,13 +748,13 @@ export class HostRuntimeLeaseManager {
                     this.drainAdmissionWaiters();
                 },
             };
-            this.singletonWaiters.push(waiter);
+            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) {
+    async reserveParallelProject(key, owner, expiresAt, signal, priority = "foreground") {
         if (this.parallelProjectOwned(key, owner))
             return;
         const staleFence = [...(this.parallelProjectOwners.get(key)?.values() ?? [])]
@@ -313,7 +766,7 @@ export class HostRuntimeLeaseManager {
         if (signal?.aborted)
             throw cancellationError(signal);
         throwIfAdmissionExpired(expiresAt);
-        if (this.parallelProjectAvailable(key)) {
+        if (this.parallelProjectAvailable(key, priority)) {
             this.assignParallelProject(key, owner);
             return;
         }
@@ -321,6 +774,7 @@ export class HostRuntimeLeaseManager {
             const waiter = {
                 owner,
                 key,
+                priority,
                 resolve,
                 reject,
                 signal,
@@ -347,17 +801,85 @@ export class HostRuntimeLeaseManager {
                     this.drainAdmissionWaiters();
                 },
             };
-            this.parallelProjectWaiters.push(waiter);
+            enqueueAdmissionWaiter(this.parallelProjectWaiters, waiter);
             signal?.addEventListener("abort", waiter.abort, { once: true });
             waiter.deadlineTimer = scheduleAdmissionDeadline(waiter.expiresAt, waiter.expire);
             this.drainAdmissionWaiters();
         });
     }
-    async start(dispatch, worktreePath, signal) {
+    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) {
@@ -376,12 +898,13 @@ export class HostRuntimeLeaseManager {
             throw new Error("host_runtime_singleton_unreserved: managed host admission is required before start.");
         }
         const attemptHex = uuidHex(sandbox.dispatchAttemptId, "dispatch attempt");
-        const normalizedWorktreePath = path.resolve(worktreePath);
-        const attemptRoot = path.join(this.stateRoot, "host-attempts", attemptHex);
-        const temporaryPath = path.join(attemptRoot, "tmp");
+        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, "cache");
-        const browserProfilePath = path.join(attemptRoot, "browser-profile");
+        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}`;
@@ -390,50 +913,86 @@ export class HostRuntimeLeaseManager {
             ? renewedExpiry.expiresAt
             : dispatch.lease.expiresAt;
         let processSupervisor = null;
+        let attemptRootIdentity = null;
         try {
-            let runtimeContract;
-            try {
-                runtimeContract = await loadHostRuntimeContract(normalizedWorktreePath);
-            }
-            catch (error) {
-                if (admission.executionClass === "managed_runtime" && admission.provisionalPromotionFingerprint) {
-                    await this.invalidatePromotion(dispatch.repo.id).catch(() => undefined);
-                }
-                throw error;
-            }
+            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)
+                ? await this.promotionStore.load(dispatch.repo.id, preparedProof ?? { runtimeContractFingerprint, inputCommitSha })
                 : null;
             const promotionMatches = hostRuntimeParallelEligible(runtimeContract)
-                && promotion?.runtimeContractFingerprint === runtimeContractFingerprint;
+                && promotion?.runtimeContractFingerprint === runtimeContractFingerprint
+                && promotion.inputCommitSha === inputCommitSha;
             if (admission.executionClass === "managed_runtime" && admission.keys.length === 0 && !promotionMatches) {
-                await this.invalidatePromotion(dispatch.repo.id);
                 const projectKeys = hostRuntimeSingletonKeys(dispatch);
-                if (admission.parallelProjectKey) {
-                    this.releaseParallelProjectNoDrain(admission.parallelProjectKey, owner);
-                    admission.parallelProjectKey = null;
-                }
                 const expiresAt = this.pendingRenewals.get(sandbox.dispatchAttemptId)?.fencingToken === owner.fencingToken
                     ? this.pendingRenewals.get(sandbox.dispatchAttemptId).expiresAt
                     : dispatch.lease.expiresAt;
-                admission.keys = await this.reserveSingletonKeys(projectKeys, owner, expiresAt, signal);
+                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.");
                     }
-                    if (promoted.runtimeContractFingerprint !== runtimeContractFingerprint) {
+                    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);
-                        await this.invalidatePromotion(dispatch.repo.id);
-                        admission.keys = await this.reserveSingletonKeys(projectKeys, owner, expiresAt, signal);
+                        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
@@ -444,7 +1003,7 @@ export class HostRuntimeLeaseManager {
                 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);
+                const reservedSingletonKeys = await this.reserveSingletonKeys(missingSingletonKeys, owner, expiresAt, signal, admission.priority);
                 admission.keys = [...admission.keys, ...reservedSingletonKeys]
                     .sort((left, right) => left.localeCompare(right));
             }
@@ -455,13 +1014,16 @@ export class HostRuntimeLeaseManager {
             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([
-                ensurePrivateDirectory(temporaryPath),
-                ensurePrivateDirectory(logPath),
-                ensurePrivateDirectory(cachePath),
-                ensurePrivateDirectory(browserProfilePath),
-                ensurePrivateDirectory(testOutputPath),
+                createCanonicalDirectory(temporaryPath),
+                createCanonicalDirectory(logPath),
+                createCanonicalDirectory(cachePath),
+                createCanonicalDirectory(browserProfilePath),
+                createCanonicalDirectory(testOutputPath),
             ]);
+            await assertHostAttemptRootIdentity(attemptRoot, attemptRootIdentity);
             await resetGeneratedOutputs(normalizedWorktreePath, testOutputPath);
             let lease = createRuntimeIsolationLease({
                 leaseId: sandbox.executionLeaseId,
@@ -493,11 +1055,11 @@ export class HostRuntimeLeaseManager {
                     singletonKeys,
                 },
             });
-            await this.writeLedger(lease);
+            await this.writeLedger(lease, undefined, attemptRootIdentity);
             lease = transitionRuntimeIsolationLease(lease, "starting");
-            await this.writeLedger(lease);
+            await this.writeLedger(lease, undefined, attemptRootIdentity);
             lease = transitionRuntimeIsolationLease(lease, "active");
-            await this.writeLedger(lease);
+            await this.writeLedger(lease, undefined, attemptRootIdentity);
             processSupervisor = this.processSupervisors.register({
                 processSupervisorId,
                 dispatchAttemptId: lease.dispatchAttemptId,
@@ -510,13 +1072,16 @@ export class HostRuntimeLeaseManager {
                 repoId: dispatch.repo.id,
                 sessionId: dispatch.session.id,
                 attemptRoot,
+                attemptRootIdentity,
                 runtimeContract,
                 runtimeContractFingerprint,
+                inputCommitSha,
                 executionClass: admission.executionClass,
-                parallelPromotionEligible: hostRuntimeParallelEligible(runtimeContract),
+                parallelPromotionEligible: hostRuntimeParallelEligible(runtimeContract) && dispatch.cycleRun.phase !== "prepared_readiness",
                 processSupervisor,
                 adapterCleanups: [],
                 pendingAdapterLaunches: new Map(),
+                runtimeResourcesReleased: false,
                 releasing: false,
             });
             this.pendingRenewals.delete(sandbox.dispatchAttemptId);
@@ -533,8 +1098,13 @@ export class HostRuntimeLeaseManager {
                 await processSupervisor.stopAll(dispatch.lease.fencingToken, "Host runtime start rolled back.").catch(() => undefined);
                 this.processSupervisors.unregister(sandbox.dispatchAttemptId, dispatch.lease.fencingToken);
             }
-            await fs.rm(attemptRoot, { recursive: true, force: true }).catch(() => undefined);
-            await fs.rm(this.ledgerPath(sandbox.dispatchAttemptId), { force: true }).catch(() => undefined);
+            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);
@@ -549,6 +1119,7 @@ export class HostRuntimeLeaseManager {
         catch {
             return;
         }
+        await this.preparedReadiness.renew(dispatchAttemptId, fencingToken, expiresAt);
         const active = this.active.get(dispatchAttemptId);
         if (!active) {
             if (Number.isFinite(Date.parse(expiresAt))) {
@@ -562,13 +1133,15 @@ export class HostRuntimeLeaseManager {
             }
             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) {
+    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.");
@@ -597,13 +1170,44 @@ export class HostRuntimeLeaseManager {
         const launcher = new AttemptNodeRuntimeLauncher(active.processSupervisor, owner, logDirectory, this.listenerInspector);
         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),
+            };
+            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), 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: {
-                    ...configuredPort.launch.environment,
-                    ...hostRuntimeEnvironment(active.sessionId, active.lease, active.runtimeContract, active.executionClass),
+                    ...buildEnvironment,
                 },
             }, launcher, signal);
         }
@@ -637,6 +1241,7 @@ export class HostRuntimeLeaseManager {
             testOutputDirectory: pathFor("test_output"),
             browserProfileDirectory: pathFor("browser_profile"),
             baseUrl,
+            ownershipToken: uuidHex(promotedLease.dispatchAttemptId, "dispatch attempt"),
         });
         return {
             lease: promotedLease,
@@ -649,7 +1254,18 @@ export class HostRuntimeLeaseManager {
         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");
+        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)
@@ -668,12 +1284,15 @@ export class HostRuntimeLeaseManager {
         await this.writeLedger(promotedLease);
         active.lease = promotedLease;
         try {
-            const promotion = await this.promotionStore.observe(active.repoId, active.runtimeContract, runtimeLease.dispatchAttemptId, verifiedPortNames);
+            const promotion = await this.promotionStore.observe(active.repoId, active.runtimeContract, runtimeLease.dispatchAttemptId, verifiedPortNames, active.inputCommitSha);
             this.knownPromotions.set(promotion.repoId, promotion);
-            this.convertSingletonToParallelProject(projectKey, {
+            const owner = {
                 dispatchAttemptId: runtimeLease.dispatchAttemptId,
                 fencingToken: runtimeLease.fencingToken,
-            }, promotion);
+            };
+            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, {
@@ -757,9 +1376,12 @@ export class HostRuntimeLeaseManager {
                 unlinkAbortController(controller, signal);
         }
     }
-    async release(dispatchAttemptId, fencingToken) {
+    async release(dispatchAttemptId, fencingToken, preservePreparation = false) {
+        if (!preservePreparation)
+            this.preparedReadiness.cancel(dispatchAttemptId, fencingToken);
         const active = this.active.get(dispatchAttemptId);
-        this.pendingRenewals.delete(dispatchAttemptId);
+        if (!preservePreparation)
+            this.pendingRenewals.delete(dispatchAttemptId);
         if (!active) {
             this.cancelAdmissionWaiters(dispatchAttemptId, fencingToken, "Managed host admission was released before acquisition.");
             this.releaseSingletonKeys(dispatchAttemptId, fencingToken);
@@ -778,13 +1400,48 @@ export class HostRuntimeLeaseManager {
         active.lease = releasing;
         await this.writeLedger(releasing);
         try {
-            await active.processSupervisor.stopAll(fencingToken, "Host runtime lease released.");
-            await releaseAdapterResources(active.adapterCleanups);
-            await fs.rm(active.attemptRoot, { recursive: true, force: true });
-            releasing = transitionRuntimeIsolationLease(releasing, "released");
-            active.lease = releasing;
-            await this.writeLedger(releasing);
-            await fs.rm(this.ledgerPath(dispatchAttemptId), { force: true });
+            if (!active.runtimeResourcesReleased) {
+                await active.processSupervisor.stopAll(fencingToken, "Host runtime lease released.");
+                await releaseAdapterResources(active.adapterCleanups);
+                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);
@@ -825,23 +1482,27 @@ export class HostRuntimeLeaseManager {
         }
         return ledgers;
     }
-    async recoverPersistedProcesses(lease, attemptRoot) {
+    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.");
         }
-        const entries = await fs.readdir(logsRoot, { withFileTypes: true }).catch(error => {
-            if (error.code === "ENOENT")
-                return [];
-            throw error;
-        });
+        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.isFile() || !/^process-supervisor\.[a-z][a-z0-9_-]{0,31}\.\d+\.json$/u.test(entry.name))
+            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 fs.readFile(metadataPath, "utf8"));
+            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.");
             }
@@ -856,7 +1517,7 @@ export class HostRuntimeLeaseManager {
         const degraded = transitionHostLeaseForCleanup(lease, "degraded");
         const repoId = ledger.repoId ?? repoIdFromProjectSingletonKeys(lease.resources.singletonKeys);
         this.rememberDegraded(degraded, repoId);
-        await this.writeLedger(degraded, repoId ?? undefined).catch(() => undefined);
+        await this.writeLedger(degraded, repoId ?? undefined, deserializeHostAttemptRootIdentity(ledger.attemptRootIdentity)).catch(() => undefined);
     }
     rememberDegraded(lease, repoId) {
         this.degraded.set(lease.dispatchAttemptId, { lease, repoId });
@@ -876,13 +1537,26 @@ export class HostRuntimeLeaseManager {
         this.releaseParallelProjects(dispatchAttemptId, fencingToken);
     }
     attemptRoot(dispatchAttemptId) {
-        return path.join(this.stateRoot, "host-attempts", uuidHex(dispatchAttemptId, "dispatch attempt"));
+        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 writeLedger(runtimeLease, explicitRepoId) {
+    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()}.tmp`;
+        const temporary = `${target}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
         try {
             const handle = await fs.open(temporary, "wx", 0o600);
             try {
@@ -891,9 +1565,15 @@ export class HostRuntimeLeaseManager {
                     ?? 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`);
@@ -906,7 +1586,7 @@ export class HostRuntimeLeaseManager {
         }
         catch (error) {
             await fs.rm(temporary, { force: true }).catch(() => undefined);
-            throw error;
+            throw new Error(`host_runtime_ledger_write_failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
     }
     ledgerPath(dispatchAttemptId) {
@@ -936,7 +1616,7 @@ export class HostRuntimeLeaseManager {
         this.singletonOwners.delete(key);
         for (let index = 0; index < this.singletonWaiters.length;) {
             const waiter = this.singletonWaiters[index];
-            if (waiter.keys.length !== 1 || waiter.keys[0] !== key) {
+            if (waiter.priority !== "foreground" || waiter.keys.length !== 1 || waiter.keys[0] !== key) {
                 index += 1;
                 continue;
             }
@@ -952,9 +1632,10 @@ export class HostRuntimeLeaseManager {
     parallelProjectOwned(key, owner) {
         return sameSingletonOwner(this.parallelProjectOwners.get(key)?.get(owner.dispatchAttemptId), owner);
     }
-    parallelProjectAvailable(key) {
+    parallelProjectAvailable(key, priority = "foreground") {
         return !this.singletonOwners.has(key)
-            && !this.singletonWaiters.some(waiter => waiter.keys.includes(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();
@@ -980,9 +1661,15 @@ export class HostRuntimeLeaseManager {
         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]) {
+        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;
@@ -998,13 +1685,20 @@ export class HostRuntimeLeaseManager {
     }
     cancelAdmissionWaiters(dispatchAttemptId, fencingToken, reason) {
         const owner = { dispatchAttemptId, fencingToken };
-        for (const waiters of [this.singletonWaiters, this.parallelProjectWaiters]) {
+        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}`));
             }
@@ -1060,7 +1754,7 @@ export class HostRuntimeLeaseManager {
                 waiter.reject(new HostRuntimeAdmissionExpiredError());
                 continue;
             }
-            if (!this.parallelProjectAvailable(waiter.key)) {
+            if (!this.parallelProjectAvailable(waiter.key, waiter.priority)) {
                 index += 1;
                 continue;
             }
@@ -1071,19 +1765,103 @@ export class HostRuntimeLeaseManager {
             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) {
-        await this.promotionStore.invalidate(repoId);
+    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 {
@@ -1091,14 +1869,20 @@ class AttemptSupervisedProviderProcessRunner {
     owner;
     listenerInspector;
     enforceNoListeners;
-    constructor(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;
@@ -1106,7 +1890,8 @@ class AttemptSupervisedProviderProcessRunner {
         const monitor = (async () => {
             while (!settled) {
                 try {
-                    const ports = await this.listenerInspector.inspectOwnedLoopbackListeners(child, this.owner);
+                    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);
@@ -1170,6 +1955,12 @@ export class HostRuntimeAdmissionExpiredError extends Error {
         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) ?? [];
@@ -1209,6 +2000,8 @@ function hostRuntimeEnvironment(sessionId, lease, runtimeContract, executionClas
         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,
@@ -1218,6 +2011,12 @@ function hostRuntimeEnvironment(sessionId, lease, runtimeContract, executionClas
         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),
@@ -1257,6 +2056,45 @@ function hostRuntimeEnvironment(sessionId, lease, runtimeContract, executionClas
         environment.FORGE_BASE_URL = resolvedBaseUrls[0];
     return environment;
 }
+async function executeAspNetRuntimeBuild(supervisor, logDirectory, plan, signal) {
+    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, `${line}\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, line);
+            await append(stdoutLogPath, line);
+        },
+        onStderrLine: async (line) => {
+            stderrTail = appendRuntimeBuildTail(stderrTail, line);
+            await append(stderrLogPath, line);
+        },
+    }, signal, { maxStartAttempts: 2, retryDelayMs: 250 });
+    const result = await child.result;
+    return {
+        exitCode: result.exitCode,
+        stdoutTail: appendRuntimeBuildTail(stdoutTail, result.stdout),
+        stderrTail: appendRuntimeBuildTail(stderrTail, result.stderr),
+        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;
@@ -1285,6 +2123,125 @@ function runtimeExecutionClass(dispatch) {
         ? "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);
@@ -1327,6 +2284,9 @@ function repoIdFromProjectSingletonKey(key) {
 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) {
@@ -1375,6 +2335,14 @@ async function releaseAdapterResources(cleanups) {
     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."));
 }
@@ -1384,9 +2352,25 @@ function validHostRuntimeLedger(value) {
     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;
@@ -1435,6 +2419,11 @@ function clearAdmissionDeadline(waiter) {
         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")