diff --git a/storage-providers/nodes/full-nodes/basic-setup.md b/storage-providers/nodes/full-nodes/basic-setup.md
index 639735b8e..69dad2989 100644
--- a/storage-providers/nodes/full-nodes/basic-setup.md
+++ b/storage-providers/nodes/full-nodes/basic-setup.md
@@ -6,35 +6,31 @@ description: >-
 
 # Basic setup
 
-To install Lotus on your computer, follow these steps:
+For current full-node installation instructions, use the [Lotus installation documentation](https://lotus.filecoin.io/lotus/install/linux/) and the [latest Lotus release](https://github.com/filecoin-project/lotus/releases/latest). Build requirements change with Lotus releases, so check the release's `go.mod` and install notes before pinning toolchain versions.
 
-1. First, you need to download the appropriate binary file for your operating system. Go to the [official Lotus GitHub repository](https://github.com/filecoin-project/lotus) and select the latest release that is compatible with your system. You can choose from Windows, macOS, and Linux distributions.
-2. Once you have downloaded the binary file, extract the contents to a directory of your choice. For example, if you are using Linux, you can extract the contents to the `/usr/local/bin directory` by running the command:
+The source-build flow for a mainnet Lotus daemon looks like this:
 
 ```sh
-sudo tar -C /usr/local/bin -xzf lotus-1.34.1-linux-amd64.tar.gz
+git clone https://github.com/filecoin-project/lotus.git
+cd lotus
+LOTUS_RELEASE="$(git tag --list 'v*' --sort=-v:refname | grep -v '-' | head -n 1)"
+git checkout "$LOTUS_RELEASE"
+make clean lotus
+sudo make install-daemon
+lotus --version
+lotus daemon
 ```
 
-3. After extracting the contents, navigate to the `lotus` directory in your terminal. For example, if you extracted the contents to `/usr/local/bin`, you can navigate to the lotus directory by running the command:
+For Calibration testnet, build the Calibration binary instead:
 
 ```sh
-cd /usr/local/bin/lotus-1.34.1
+make clean && make calibnet-lotus
+sudo make install-daemon
+lotus --version
+lotus daemon
 ```
 
-4. Run the `lotus` binary file to start the Lotus daemon. You can do this by running the command:
-
-```sh
-./lotus daemon
-```
-
-5. This will start the Lotus daemon, which will connect to the Filecoin network and start synchronizing with other nodes on the network.
-6. Optionally, you can also run the lotus-miner binary file if you want to participate in the Filecoin mining process. You can do this by running the command:
-
-```sh
-./lotus-miner run
-```
-
-7. This will start the Lotus miner, which will use your computer’s computing power to mine new blocks on the Filecoin network.
+Storage-provider operation no longer starts with `lotus-miner run` on a laptop. Use Lotus for chain access, then follow current Curio, Boost, and PDP guidance for provider workflows. See [Install and run PDP](../../pdp/install-and-run-pdp.md), [Software components](../../architecture/lotus-components.md), and the [Curio documentation](https://docs.curiostorage.org/) for provider-specific setup.
 
 
 
diff --git a/storage-providers/nodes/lite-nodes/spin-up-a-lite-node.md b/storage-providers/nodes/lite-nodes/spin-up-a-lite-node.md
index 5044d8b31..5d0bbc295 100644
--- a/storage-providers/nodes/lite-nodes/spin-up-a-lite-node.md
+++ b/storage-providers/nodes/lite-nodes/spin-up-a-lite-node.md
@@ -36,11 +36,11 @@ To build the lite-node, you’ll need some specific software. Run the following
     sudo apt update -y
     sudo apt install mesa-opencl-icd ocl-icd-opencl-dev gcc git jq pkg-config curl clang build-essential hwloc libhwloc-dev wget -y
     ```
-2.  [Install Go](https://go.dev/doc/install) and add `/usr/local/go/bin` to your `$PATH` variable:
+2.  [Install Go](https://go.dev/doc/install) and add `/usr/local/go/bin` to your `$PATH` variable. Lotus `v1.36.0` requires Go `1.25.7`; check the current Lotus release `go.mod` before pinning a newer release:
 
     ```shell
-    wget https://go.dev/dl/go1.21.7.linux-amd64.tar.gz
-    sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.21.7.linux-amd64.tar.gz
+    wget https://go.dev/dl/go1.25.7.linux-amd64.tar.gz
+    sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.25.7.linux-amd64.tar.gz
     echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc && source ~/.bashrc
     ```
 3.  [Install Rust](https://www.rust-lang.org/tools/install), choose the standard installation option, and source the `~/.cargo/env` config file:
@@ -64,21 +64,22 @@ Before we can build the Lotus binaries, we need to follow a few pre-build steps.
     git clone https://github.com/filecoin-project/lotus.git
     cd lotus/
     ```
-2.  Retrieve the latest Lotus release version:
+2.  Retrieve the latest Lotus release version and store it in your shell:
 
     ```shell
-    git tag -l 'v*' | grep -v '-' | sort -V -r | head -n 1
+    LOTUS_RELEASE="$(git tag --list 'v*' --sort=-v:refname | grep -v '-' | head -n 1)"
+    echo "$LOTUS_RELEASE"
     ```
 
     This should output something like:
 
     ```output
-    v1.34.1
+    v1.36.0
     ```
-3.  Using the value returned from the previous command, checkout to the latest release branch:
+3.  Check out the release returned from the previous command:
 
     ```shell
-    git checkout v1.34.1
+    git checkout "$LOTUS_RELEASE"
     ```
 4. Done! You can move on to the [Build](#build-the-binary) section.
 {% endtab %}
@@ -90,21 +91,22 @@ Before we can build the Lotus binaries, we need to follow a few pre-build steps.
     git clone https://github.com/filecoin-project/lotus.git
     cd lotus
     ```
-2.  Retrieve the latest Lotus release version:
+2.  Retrieve the latest Lotus release version and store it in your shell:
 
     ```shell
-    git tag -l 'v*' | grep -v '-' | sort -V -r | head -n 1
+    LOTUS_RELEASE="$(git tag --list 'v*' --sort=-v:refname | grep -v '-' | head -n 1)"
+    echo "$LOTUS_RELEASE"
     ```
 
     This should output something like:
 
     ```output
-    v1.34.1
+    v1.36.0
     ```
-3.  Using the value returned from the previous command, checkout to the latest release branch:
+3.  Check out the release returned from the previous command:
 
     ```shell
-    git checkout v1.34.1
+    git checkout "$LOTUS_RELEASE"
     ```
 4.  Create the necessary environment variables to allow Lotus to run on M1 architecture:
 
@@ -123,21 +125,22 @@ Before we can build the Lotus binaries, we need to follow a few pre-build steps.
     git clone https://github.com/filecoin-project/lotus.git
     cd lotus
     ```
-2.  Retrieve the latest Lotus release version:
+2.  Retrieve the latest Lotus release version and store it in your shell:
 
     ```shell
-    git tag -l 'v*' | grep -v '-' | sort -V -r | head -n 1
+    LOTUS_RELEASE="$(git tag --list 'v*' --sort=-v:refname | grep -v '-' | head -n 1)"
+    echo "$LOTUS_RELEASE"
     ```
 
     This should output something like:
 
     ```output
-    v1.34.1
+    v1.36.0
     ```
-3.  Using the value returned from the previous command, checkout to the latest release branch:
+3.  Check out the release returned from the previous command:
 
     ```shell
-    git checkout v1.34.1
+    git checkout "$LOTUS_RELEASE"
     ```
 4.  If your processor was released later than an AMD Zen or Intel Ice Lake CPU, enable SHA extensions by adding these two environment variables. If in doubt, ignore this command and move on to [the next section](#build-the-binary).
 
@@ -158,13 +161,13 @@ The last thing we need to do to get our node setup is to build the package. The
 1.  Remove or delete any existing Lotus configuration files on your system:
 
     ```shell
-    mv ~/.lotus ~/.lotus-backup
+    if [ -d ~/.lotus ]; then mv ~/.lotus ~/.lotus-backup-$(date +%Y%m%d%H%M%S); fi
     ```
 2.  Make the Lotus binaries and install them:
 
     ```shell
-    make clean all
-    sudo make install
+    make clean lotus
+    sudo make install-daemon
     ```
 3.  Once the installation finishes, query the Lotus version to ensure everything is installed successfully and for the correct network:
 
@@ -175,7 +178,7 @@ The last thing we need to do to get our node setup is to build the package. The
     This will output something like:
 
     ```plaintext
-    lotus version 1.34.1+mainnet+git.1ff3b360b
+    lotus version 1.36.0+mainnet+git.<commit>
     ```
 {% endtab %}
 
@@ -183,13 +186,13 @@ The last thing we need to do to get our node setup is to build the package. The
 1.  Remove or delete any existing Lotus configuration files on your system:
 
     ```shell
-    mv ~/.lotus ~/.lotus-backup
+    if [ -d ~/.lotus ]; then mv ~/.lotus ~/.lotus-backup-$(date +%Y%m%d%H%M%S); fi
     ```
 2.  Make the Lotus binaries and install them:
 
     ```shell
-    make clean && make calibrationnet
-    sudo make install
+    make clean && make calibnet-lotus
+    sudo make install-daemon
     ```
 3.  Once the installation finishes, query the Lotus version to ensure everything is installed successfully and for the correct network:
 
@@ -200,7 +203,7 @@ The last thing we need to do to get our node setup is to build the package. The
     This will output something like:
 
     ```plaintext
-    lotus version 1.34.1+calibnet+git.1ff3b360b
+    lotus version 1.36.0+calibnet+git.<commit>
     ```
 {% endtab %}
 {% endtabs %}
@@ -327,15 +330,10 @@ To access privileged JSON-RPC methods, like creating a new wallet, we need to su
 1.  Create a new admin token and set the result to a new `LOTUS_ADMIN_KEY` environment variable:
 
     ```shell
-    lotus auth create-token --perm "admin"
+    export LOTUS_ADMIN_KEY="$(lotus auth create-token --perm admin)"
     ```
 
-    This will output something like:
-
-    ```plaintext
-    eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJBbGxvdyI6WyJyZWFkIiwid3JpdGUiLCJzaWduIiwiYWRtaW4iXX0.um-LqY7g-SDOsMheDRbQ9JIaFzus_Pan0J88VQ6ZLVE
-    ```
-2. Keep this key handy. We're going to use it in the next section.
+2. Keep this key in your shell only. Do not commit it or paste it into shared logs.
 
 ## Send requests
 
@@ -344,10 +342,10 @@ Let's run a couple of commands to see if the JSON-RPC API is set up correctly.
 1.  First, let's grab the head of the Filecoin network chain:
 
     ```shell
-    curl -X POST '127.0.0.1:1234/rpc/v0' \
+    curl -X POST 'http://127.0.0.1:1234/rpc/v0' \
     -H 'Content-Type: application/json' \
     --data '{"jsonrpc":"2.0","id":1,"method":"Filecoin.ChainHead","params":[]}' \
-    | jq 
+    | jq
     ```
 
     This will output something like:
@@ -365,12 +363,12 @@ Let's run a couple of commands to see if the JSON-RPC API is set up correctly.
           },
     ...
     ```
-2.  Next, let's try to create a new wallet. Since this is a privileged method, we need to supply our auth key `eyJhbGc...`:
+2.  Next, let's try to create a new wallet. Since this is a privileged method, we need to supply the auth key from `LOTUS_ADMIN_KEY`:
 
     ```shell
-    curl -X POST '127.0.0.1:1234/rpc/v0' \
+    curl -X POST 'http://127.0.0.1:1234/rpc/v0' \
     -H 'Content-Type: application/json' \
-    -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJBbGxvdyI6WyJyZWFkIiwid3JpdGUiLCJzaWduIiwiYWRtaW4iXX0.um-LqY7g-SDOsMheDRbQ9JIaFzus_Pan0J88VQ6ZLVE' \
+    -H "Authorization: Bearer $LOTUS_ADMIN_KEY" \
     --data '{"jsonrpc":"2.0","id":1,"method":"Filecoin.WalletNew","params":["secp256k1"]}' \
     | jq
     ```
@@ -386,14 +384,14 @@ Let's run a couple of commands to see if the JSON-RPC API is set up correctly.
     ```
 
     The result field is the public key for our address. The private key is stored within our lite-node.
-3.  Set the new address as the default wallet for our lite-node. Remember to replace the Bearer token with our auth key `eyJhbGc...` and the `"params"` value with the wallet address, `f1vuc4...`, returned from the previous command:
+3.  Set the new address as the default wallet for our lite-node. Replace `<WALLET_ADDRESS>` with the wallet address returned from the previous command:
 
     ```shell
-    curl -X POST '127.0.0.1:1234/rpc/v0' \
+    curl -X POST 'http://127.0.0.1:1234/rpc/v0' \
     -H 'Content-Type: application/json' \
-    -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJBbGxvdyI6WyJyZWFkIiwid3JpdGUiLCJzaWduIiwiYWRtaW4iXX0.um-LqY7g-SDOsMheDRbQ9JIaFzus_Pan0J88VQ6ZLVE' \
-    --data '{"jsonrpc":"2.0","id":1,"method":"Filecoin.WalletSetDefault","params":["f1vuc4eu2wgsdnce2ngygyzuxky3aqijqe7gj5qqa"]}' \
-    | jq 
+    -H "Authorization: Bearer $LOTUS_ADMIN_KEY" \
+    --data '{"jsonrpc":"2.0","id":1,"method":"Filecoin.WalletSetDefault","params":["<WALLET_ADDRESS>"]}' \
+    | jq
     ```
 
     This will output something like:
diff --git a/storage-providers/pdp/install-and-run-pdp.md b/storage-providers/pdp/install-and-run-pdp.md
index 8be340cc9..ce6271177 100644
--- a/storage-providers/pdp/install-and-run-pdp.md
+++ b/storage-providers/pdp/install-and-run-pdp.md
@@ -46,19 +46,21 @@ sudo apt update && sudo apt upgrade -y && sudo apt install -y \
 
 ***
 
-### :hammer: Install Go (v1.24.0)
+### :hammer: Install Go
+
+Current Lotus `v1.36.0` requires Go `1.25.7`, while current Curio `v1.28.1` requires Go `1.26`. This guide installs Go `1.26.0` to satisfy the full PDP stack. Re-check the relevant `go.mod` files when targeting different Lotus or Curio releases.
 
 ```sh
 sudo rm -rf /usr/local/go
-wget https://go.dev/dl/go1.24.0.linux-amd64.tar.gz
-sudo tar -C /usr/local -xzf go1.24.0.linux-amd64.tar.gz
+wget https://go.dev/dl/go1.26.0.linux-amd64.tar.gz
+sudo tar -C /usr/local -xzf go1.26.0.linux-amd64.tar.gz
 echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
 source ~/.bashrc
 go version
 ```
 
 {% hint style="success" %}
-You should see something like: `go version go1.24.0 linux/amd64`
+You should see something like: `go version go1.26.0 linux/amd64`
 {% endhint %}
 
 ***
@@ -97,7 +99,8 @@ Clone and check out Lotus:
 ```sh
 git clone https://github.com/filecoin-project/lotus.git
 cd lotus
-git checkout $(curl -s https://api.github.com/repos/filecoin-project/lotus/releases/latest | jq -r .tag_name)
+LOTUS_RELEASE="$(curl -s https://api.github.com/repos/filecoin-project/lotus/releases/latest | jq -r .tag_name)"
+git checkout "$LOTUS_RELEASE"
 ```
 
 **Build and Install for Mainnet**
@@ -111,13 +114,13 @@ lotus --version
 **Build and Install for Calibration**
 
 ```sh
-make clean && make GOFLAGS="-tags=calibnet" lotus
+make clean && make calibnet-lotus
 sudo make install-daemon
 lotus --version
 ```
 
 {% hint style="success" %}
-You should see something like: `lotus version 1.36.0+calibnet+git.154c0c3a4`
+You should see something like: `lotus version 1.36.0+calibnet+git.<commit>`
 {% endhint %}
 
 ***
@@ -278,12 +281,13 @@ echo 'net.core.rmem_default=2097152' | sudo tee -a /etc/sysctl.conf
 
 ### 🔬 Build Curio
 
-Clone the repository and switch to the latest branch:
+Clone the repository and check out the latest Curio release:
 
 ```sh
 git clone https://github.com/filecoin-project/curio.git
 cd curio
-git checkout $(curl -s https://api.github.com/repos/filecoin-project/curio/releases/latest | jq -r .tag_name)
+CURIO_RELEASE="$(curl -s https://api.github.com/repos/filecoin-project/curio/releases/latest | jq -r .tag_name)"
+git checkout "$CURIO_RELEASE"
 ```
 
 {% hint style="info" %}
@@ -325,7 +329,7 @@ curio --version
 Expected example output:
 
 ```sh
-curio version 1.24.4+calibnet+git_f954c0a_2025-04-06T15:46:32-04:00
+curio version 1.28.1+calibnet+git_<commit>
 ```
 
 ***
@@ -476,17 +480,12 @@ You can display your Lotus wallets at any time by running:
 lotus wallet list
 ```
 
-Export & convert your new delegated wallet address private key:
+Export and convert your new delegated wallet private key only when you are ready to import it into Curio. This prints sensitive key material to your terminal; do not save it in shell history, tickets, or shared logs:
 
 ```sh
 lotus wallet export <your-delegated-wallet-address> | xxd -r -p | jq -r '.PrivateKey' | base64 -d | xxd -p -c 32
 ```
 
-```sh
-# Example output:
-d4c2e3f9a716bb0e47fa91b2cf4a29870be3c5982fd6eafed71e8ac3f9c0b127
-```
-
 Browse to the **PDP** page of the Curio GUI and in the **Owner Address** section:
 
 * Select **Import Key**
@@ -518,7 +517,10 @@ If you encounter errors related to `EnableEthRPC` or `EnableIndexer`, run the fo
 {% endhint %}
 
 ```sh
-sed -i 's/^\( *\)#*EnableEthRPC = .*/\1EnableEthRPC = true/; s/^\( *\)#*EnableIndexer = .*/\1EnableIndexer = true/' ~/.lotus/config.toml
+sed -i \
+  -e 's/^\( *\)#*EnableEthRPC = .*/\1EnableEthRPC = true/' \
+  -e 's/^\( *\)#*EnableIndexer = .*/\1EnableIndexer = true/' \
+  ~/.lotus/config.toml
 ```
 
 {% hint style="info" %}