The Curry-Howard correspondence between natural deduction and the -calculus has provided a canonical foundation for the study of typed functional languages. Initiated by Abramsky [1994], the Proofs as Processes agenda is to establish a similar foundation for the study of concurrent languages, by researching the connection between linear logic [Girard 1987] and the -calculus [Milner et al. 1992].To date, Proofs as Processes is still a partial success. Caires and Pfenning [2010] and Wadler [2014] showed that linear propositions correspond to session types: structured communication protocols that prescribe the observable behaviour of processes [Honda 1993]. Further, Carbone et al. [2018b, , and Kokke et al. [2019] demonstrated that adopting devices from hypersequents [Avron 1991] shapes proofs (typing derivations) such that they correspond to the expected syntactic structure of processes in the -calculus. What remains is reconstructing the expected metatheory of session types and the -calculus. In particular, the hallmark of session types is session fidelity: an operational correspondence between the observable behaviours of processes and their session types, formulated via labelled transition systems. To date, this result still has to be reconstructed for Proofs as Processes, because it is unclear how a transition system for session types can arise from linear logic.In this article, we present LL, a new process calculus rooted in linear logic. The key novelty of LL is that it comes with a carefully formulated design recipe for Proofs as Processes, which is based on a dialgebraic view of labelled transition systems and their homomorphisms [Ciancia 2013]. Thanks to our recipe, LL offers the first reconstruction of the expected labelled transition systems of session types based on linear logic, which we use to establish session fidelity for Proofs as Processes. In general, we use LL to carry out the first thorough investigation of the metatheoretical properties enforced by linear logic on the observable behaviour of processes, uncovering connections with standard relations such as similarity and bisimilarity. We also prove that LL and our recipe offer a robust basis for the further exploration of Proofs as Processes, by considering different features and extensions: polymorphism, higher-order communications (code mobility), and recursion. Our higher-order extension of LL, called HO LL, operates as a higher-order linear logic that enforces linear usage of process variables.