diff --git a/.changeset/few-carrots-count.md b/.changeset/few-carrots-count.md
new file mode 100644
index 00000000..29697167
--- /dev/null
+++ b/.changeset/few-carrots-count.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": patch
+---
+
+`cartesi run --default-block` no longer accepts `pending`, which the rollups-node no longer supports. Use `latest`, `safe` or `finalized`.
diff --git a/.changeset/hot-rings-decide.md b/.changeset/hot-rings-decide.md
new file mode 100644
index 00000000..3f15cf29
--- /dev/null
+++ b/.changeset/hot-rings-decide.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": patch
+---
+
+`cartesi run`'s Build and redeploy no longer fails with "CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS: variable not defined". The CLI now passes the devnet's ApplicationFactory address to the node, which `CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS` can still override.
diff --git a/.changeset/lazy-cougars-add.md b/.changeset/lazy-cougars-add.md
new file mode 100644
index 00000000..4dcd017b
--- /dev/null
+++ b/.changeset/lazy-cougars-add.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": minor
+---
+
+`cartesi run --prt` now runs a sling node for each `[[prt.sentries]]` entry with `type = "sling"`, as container `sentry-<label>`, so claims the sentries agree with are accepted without waiting out `--claim-staging-period`. Pool sentries (devnet accounts 20 to 29) are funded with 10,000 ETH by the CLI; an entry with `private_key_file` runs on your own key, whose address becomes the sentry's, and you fund it. The sentries are stopped before a rebuild and started again for the redeployed application.
diff --git a/.changeset/mighty-otters-know.md b/.changeset/mighty-otters-know.md
new file mode 100644
index 00000000..11b2a21f
--- /dev/null
+++ b/.changeset/mighty-otters-know.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": minor
+---
+
+`cartesi send` and `cartesi deposit` now default to devnet account 8 instead of account 0, which the node uses to sign its claims. Pass `--from` to pick another account.
diff --git a/.changeset/pretty-lilies-taste.md b/.changeset/pretty-lilies-taste.md
new file mode 100644
index 00000000..3ceae051
--- /dev/null
+++ b/.changeset/pretty-lilies-taste.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": minor
+---
+
+`cartesi logs` and the shell's View logs now show the PRT sentries next to the node. Name services to pick some, e.g. `cartesi logs sentry-green`.
diff --git a/.changeset/quick-dancers-pick.md b/.changeset/quick-dancers-pick.md
new file mode 100644
index 00000000..b341b37b
--- /dev/null
+++ b/.changeset/quick-dancers-pick.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": patch
+---
+
+`CARTESI_*_FILE` key files set on the host now reach the node container as copies the node can read. Before, only the path was forwarded and the node couldn't read the file.
diff --git a/.changeset/seven-moments-prove.md b/.changeset/seven-moments-prove.md
new file mode 100644
index 00000000..3afe7349
--- /dev/null
+++ b/.changeset/seven-moments-prove.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": minor
+---
+
+Require cartesi-machine 0.22. Machines stored by 0.21 can't be loaded by 0.22: rebuild and redeploy every application.
diff --git a/.changeset/stale-clubs-end.md b/.changeset/stale-clubs-end.md
new file mode 100644
index 00000000..a76fe6d5
--- /dev/null
+++ b/.changeset/stale-clubs-end.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": minor
+---
+
+`cartesi run` now rejects a `CARTESI_BLOCKCHAIN_HTTP_ENDPOINT` the rollups-node can't use before starting anything. It must be an http(s) URL with a DNS name or IP address. The error doesn't show the value, which may hold credentials.
diff --git a/.changeset/strict-grapes-do.md b/.changeset/strict-grapes-do.md
new file mode 100644
index 00000000..720d1276
--- /dev/null
+++ b/.changeset/strict-grapes-do.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": patch
+---
+
+Use the Dave 3.0.0-alpha.6 PRT contracts. Every PRT address moves, including the devnet DaveAppFactory. The rollups contract addresses are unchanged.
diff --git a/.changeset/swift-berries-tie.md b/.changeset/swift-berries-tie.md
new file mode 100644
index 00000000..69793080
--- /dev/null
+++ b/.changeset/swift-berries-tie.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": patch
+---
+
+Keep `$` in the `CARTESI_*` variables `cartesi run` forwards to the node and in its `--fork-url`. Docker Compose read `$name` in them as a variable, so a value such as a password or an API key in a URL arrived changed.
diff --git a/.changeset/witty-crews-repeat.md b/.changeset/witty-crews-repeat.md
new file mode 100644
index 00000000..33a29a4d
--- /dev/null
+++ b/.changeset/witty-crews-repeat.md
@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": minor
+---
+
+`cartesi run --prt` now deploys the application with the PRT sentries set in `cartesi.toml`. A `[prt]` section names an optional `sentry_manager` and `[[prt.sentries]]` entries, appointed on the consensus in that order. An entry with `type = "sling"` and no `address` gets one of the CLI's sentry pool, devnet accounts 20 to 29; an entry with only an `address` is appointed and run elsewhere. Without `--prt` the section is ignored.
diff --git a/.github/workflows/cli.yaml b/.github/workflows/cli.yaml
index f8438122..caf6b7ac 100644
--- a/.github/workflows/cli.yaml
+++ b/.github/workflows/cli.yaml
@@ -3,7 +3,9 @@ on:
     pull_request:
         paths:
             - ".github/workflows/cli.yaml"
+            - ".github/workflows/sdk.yaml"
             - "apps/cli/**"
+            - "packages/sdk/**"
             - "packages/tsconfig/**"
 concurrency:
     group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name }}
@@ -13,11 +15,21 @@ permissions:
     packages: write
     pull-requests: write
 jobs:
+    sdk:
+        uses: ./.github/workflows/sdk.yaml
+        secrets: inherit
+        permissions:
+            contents: read
+            packages: write
+            id-token: write
+            actions: write
     build:
+        needs: sdk
         runs-on: ubuntu-latest
         env:
             TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
             TURBO_TEAM: ${{ vars.TURBO_TEAM }}
+            SDK_TAG: pr-${{ github.event.pull_request.number }}
         steps:
             - name: Checkout
               uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -28,6 +40,20 @@ jobs:
             - name: Set up Docker Buildx
               uses: docker/setup-buildx-action@f87e5991a6d7451dcb8d9637bfbc97413f497069 # v4.4.1
 
+            - name: Login to GitHub Container Registry
+              uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
+              with:
+                  registry: ghcr.io
+                  username: ${{ github.actor }}
+                  password: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Retag SDK images
+              run: |
+                  for image in sdk rollups-runtime rollups-database; do
+                      docker pull "ghcr.io/cartesi/$image:$SDK_TAG"
+                      docker tag "ghcr.io/cartesi/$image:$SDK_TAG" "cartesi/$image:$SDK_TAG"
+                  done
+
             - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
 
             - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
@@ -45,6 +71,9 @@ jobs:
 
             - name: Test
               run: bun test apps/cli/
+              env:
+                  CARTESI_TEST_SDK: cartesi/sdk:${{ env.SDK_TAG }}
+                  CARTESI_TEST_RUNTIME_VERSION: ${{ env.SDK_TAG }}
 
             - name: Coverage Report
               uses: 70-10/bun-coverage-report-action@6173866ce2a31456a726ff3f4c91f230bd94a9e9 # v1.0.3
diff --git a/.github/workflows/sdk.yaml b/.github/workflows/sdk.yaml
index e1da4d3f..2e19b443 100644
--- a/.github/workflows/sdk.yaml
+++ b/.github/workflows/sdk.yaml
@@ -6,12 +6,8 @@ on:
                 required: true
             DOCKERHUB_TOKEN:
                 required: true
-    pull_request:
-        paths:
-            - ".github/workflows/sdk.yaml"
-            - "packages/sdk/**"
 concurrency:
-    group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name }}
+    group: sdk-${{ github.ref }}
     cancel-in-progress: true
 permissions:
     contents: read
@@ -83,6 +79,11 @@ jobs:
                   username: ${{ secrets.DOCKERHUB_USERNAME }}
                   password: ${{ secrets.DOCKERHUB_TOKEN }}
 
+            # WIP: the run id is the script's default, the same one a local
+            # `bun run build` takes, so CI and reviewers build the same node
+            - name: Fetch rollups-node packages
+              run: ./packages/sdk/scripts/fetch-rollups-node.sh
+
             - name: Build and push
               uses: docker/bake-action@018cb6412ab401ebaa809aa5f85966b74628600f # v7.4.0
               if: ${{ !startsWith(github.ref, 'refs/tags/sdk@') }}
diff --git a/apps/cli/package.json b/apps/cli/package.json
index fb9d1d38..750c6c9e 100644
--- a/apps/cli/package.json
+++ b/apps/cli/package.json
@@ -14,7 +14,7 @@
         "/dist"
     ],
     "devDependencies": {
-        "@cartesi/wagmi-plugin": "1.0.0-alpha.7",
+        "@cartesi/wagmi-plugin": "1.0.0-alpha.9",
         "@commander-js/extra-typings": "^15.0.0",
         "@inquirer/confirm": "^6.3.3",
         "@inquirer/core": "^12.0.4",
diff --git a/apps/cli/src/commands/deposit.ts b/apps/cli/src/commands/deposit.ts
index 64d31e1a..e502960d 100644
--- a/apps/cli/src/commands/deposit.ts
+++ b/apps/cli/src/commands/deposit.ts
@@ -12,7 +12,10 @@ export const createDepositCommand = () => {
     const command = new Command("deposit")
         .description("Deposits an asset to the application")
         .configureHelp({ showGlobalOptions: true })
-        .option("--from <address>", "input sender address")
+        .option(
+            "--from <address>",
+            "input sender address (default: devnet account 8)",
+        )
         .option("--application <address>", "application address")
         .option(
             "--project-name <string>",
diff --git a/apps/cli/src/commands/deposit/erc1155.ts b/apps/cli/src/commands/deposit/erc1155.ts
index a57287bb..b40ba366 100644
--- a/apps/cli/src/commands/deposit/erc1155.ts
+++ b/apps/cli/src/commands/deposit/erc1155.ts
@@ -17,7 +17,7 @@ import {
     bigintInput,
     getInputApplicationAddress,
 } from "../../prompts.js";
-import { connect } from "../../wallet.js";
+import { connect, getDefaultSender } from "../../wallet.js";
 import type { DepositCommandOpts } from "../deposit.js";
 
 type ERC1155Token = {
@@ -75,7 +75,7 @@ export const createErc1155SingleCommand = () => {
             const account =
                 from && isAddress(from)
                     ? getAddress(from)
-                    : (await testClient.getAddresses())[0];
+                    : await getDefaultSender(testClient);
 
             const amount = amountString
                 ? BigInt(amountString)
@@ -253,7 +253,7 @@ export const createErc1155BatchCommand = () => {
             const account =
                 from && isAddress(from)
                     ? getAddress(from)
-                    : (await testClient.getAddresses())[0];
+                    : await getDefaultSender(testClient);
 
             const tokenAbi = testMultiTokenAbi;
 
diff --git a/apps/cli/src/commands/deposit/erc20.ts b/apps/cli/src/commands/deposit/erc20.ts
index 70b775ed..8ba8f3e1 100755
--- a/apps/cli/src/commands/deposit/erc20.ts
+++ b/apps/cli/src/commands/deposit/erc20.ts
@@ -22,7 +22,7 @@ import {
     bigintInput,
     getInputApplicationAddress,
 } from "../../prompts.js";
-import { connect } from "../../wallet.js";
+import { connect, getDefaultSender } from "../../wallet.js";
 import type { DepositCommandOpts } from "../deposit.js";
 
 type ERC20Token = {
@@ -93,7 +93,7 @@ export const createErc20Command = () => {
             const account =
                 from && isAddress(from)
                     ? getAddress(from)
-                    : (await testClient.getAddresses())[0];
+                    : await getDefaultSender(testClient);
 
             const token = await parseToken({
                 testClient,
diff --git a/apps/cli/src/commands/deposit/erc721.ts b/apps/cli/src/commands/deposit/erc721.ts
index 896c51e7..4aaaf7e0 100755
--- a/apps/cli/src/commands/deposit/erc721.ts
+++ b/apps/cli/src/commands/deposit/erc721.ts
@@ -23,7 +23,7 @@ import {
     bigintInput,
     getInputApplicationAddress,
 } from "../../prompts.js";
-import { connect } from "../../wallet.js";
+import { connect, getDefaultSender } from "../../wallet.js";
 import type { DepositCommandOpts } from "../deposit.js";
 
 type ERC721Token = {
@@ -93,7 +93,7 @@ export const createErc721Command = () => {
             const account =
                 from && isAddress(from)
                     ? getAddress(from)
-                    : (await testClient.getAddresses())[0];
+                    : await getDefaultSender(testClient);
 
             const token = await parseToken({
                 testClient,
diff --git a/apps/cli/src/commands/deposit/ether.ts b/apps/cli/src/commands/deposit/ether.ts
index 2b0bf6c7..ad23054d 100755
--- a/apps/cli/src/commands/deposit/ether.ts
+++ b/apps/cli/src/commands/deposit/ether.ts
@@ -5,7 +5,7 @@ import { formatUnits, getAddress, isAddress, isHex, parseUnits } from "viem";
 import { getProjectName } from "../../base.js";
 import { etherPortalAbi, etherPortalAddress } from "../../contracts.js";
 import { bigintInput, getInputApplicationAddress } from "../../prompts.js";
-import { connect } from "../../wallet.js";
+import { connect, getDefaultSender } from "../../wallet.js";
 import type { DepositCommandOpts } from "../deposit.js";
 
 export const createEtherCommand = () => {
@@ -26,7 +26,7 @@ export const createEtherCommand = () => {
             const account =
                 from && isAddress(from)
                     ? getAddress(from)
-                    : (await testClient.getAddresses())[0];
+                    : await getDefaultSender(testClient);
 
             // get dapp address from local node, or ask
             const application = await getInputApplicationAddress({
diff --git a/apps/cli/src/commands/logs.ts b/apps/cli/src/commands/logs.ts
index b103da1c..5602618e 100644
--- a/apps/cli/src/commands/logs.ts
+++ b/apps/cli/src/commands/logs.ts
@@ -1,10 +1,89 @@
 import { Command } from "@commander-js/extra-typings";
 import { execa } from "execa";
-import { getProjectName, getServiceInfo } from "../base.js";
+import { getProjectName } from "../base.js";
+import { isSentryService } from "../compose/sentry.js";
+
+/** The node's compose service, shown by default and first. */
+export const NODE_SERVICE = "rollups_node";
+
+/**
+ * The services of a running environment, as compose lists them; an exited
+ * container is still listed, so its last logs can be read.
+ */
+export const listServices = async (projectName: string): Promise<string[]> => {
+    const { stdout } = await execa("docker", [
+        "compose",
+        "--project-name",
+        projectName,
+        "ps",
+        "--services",
+        "--all",
+    ]);
+    return stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+};
+
+/**
+ * The services to show: the ones named, checked against the environment, or
+ * the node followed by every sentry.
+ * @param services the environment's services, from `listServices`
+ * @param requested the services named on the command line
+ * @throws when the node isn't there, or a named service isn't
+ */
+export const selectLogServices = (
+    services: string[],
+    requested: string[],
+): string[] => {
+    if (requested.length === 0) {
+        if (!services.includes(NODE_SERVICE)) {
+            throw new Error(`service ${NODE_SERVICE} not found`);
+        }
+        return [NODE_SERVICE, ...services.filter(isSentryService)];
+    }
+    // compose shows nothing for an unknown service, without an error
+    const unknown = requested.filter((service) => !services.includes(service));
+    if (unknown.length > 0) {
+        throw new Error(
+            `service ${unknown.join(", ")} not found; the environment has ${services.join(", ")}`,
+        );
+    }
+    return requested;
+};
+
+/**
+ * The `docker compose logs` arguments. One service is shown as it is, like
+ * `docker container logs`; more than one get compose's per-service prefix,
+ * which tells the node's lines from the sentries'.
+ */
+export const buildLogsArgs = (options: {
+    follow?: boolean;
+    projectName: string;
+    services: string[];
+    since?: string;
+    tail?: string;
+    until?: string;
+}): string[] => {
+    const { follow, projectName, services, since, tail, until } = options;
+    const args = ["compose", "--project-name", projectName, "logs"];
+    if (follow) args.push("--follow");
+    if (since) args.push("--since", since);
+    if (tail) args.push("--tail", tail);
+    if (until) args.push("--until", until);
+    if (services.length === 1) args.push("--no-log-prefix");
+    return [...args, ...services];
+};
 
 export const createLogsCommand = () => {
     return new Command("logs")
-        .description("Show logs of a local environment.")
+        .description(
+            "Show logs of a local environment: the node and its sentries, or the services named.",
+        )
+        .argument(
+            "[service...]",
+            "services to show, as cartesi run names them (default: the node and the sentries)",
+        )
         .option(
             "--project-name <string>",
             "name of project (used by docker compose and cartesi-rollups-node)",
@@ -24,26 +103,24 @@ export const createLogsCommand = () => {
             "Show logs before a timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)",
         )
         .configureHelp({ showGlobalOptions: true })
-        .action(async (options) => {
+        .action(async (requested, options) => {
             const { follow, since, tail, until } = options;
             const projectName = getProjectName(options);
-            const logOptions: string[] = [];
-            if (follow) logOptions.push("--follow");
-            if (since) logOptions.push("--since", since);
-            if (tail) logOptions.push("--tail", tail);
-            if (until) logOptions.push("--until", until);
-
-            const serviceInfo = await getServiceInfo({
-                projectName,
-                service: "rollups_node",
-            });
-            if (!serviceInfo) {
-                throw new Error(`service rollups_node not found`);
-            }
+            const services = selectLogServices(
+                await listServices(projectName),
+                requested,
+            );
 
             await execa(
                 "docker",
-                ["container", "logs", ...logOptions, serviceInfo.ID],
+                buildLogsArgs({
+                    follow,
+                    projectName,
+                    services,
+                    since,
+                    tail,
+                    until,
+                }),
                 { stdio: "inherit" },
             );
         });
diff --git a/apps/cli/src/commands/run.ts b/apps/cli/src/commands/run.ts
index 7afa2e86..c3c0e2f6 100755
--- a/apps/cli/src/commands/run.ts
+++ b/apps/cli/src/commands/run.ts
@@ -31,19 +31,30 @@ import {
 import {
     AVAILABLE_SERVICES,
     deployApplication,
+    type EnvironmentOptions,
     host,
     removeApplication,
     getDeployments,
     type RollupsDeployment,
     startEnvironment,
+    startSentries,
     stopEnvironment,
+    stopSentries,
     TERMINAL_APPLICATION_STATUSES,
     waitHealthyEnvironment,
 } from "../exec/rollups.js";
 import { keySelect } from "../prompts.js";
+import {
+    checkSentries,
+    describeSentry,
+    type ResolvedPrt,
+    resolveSentries,
+    runnableSentries,
+} from "../sentries.js";
 import type { ForkConfig } from "../types/chain.js";
 import { assertForkConfig } from "../validations.js";
-import { getWithdrawalConfig } from "../withdrawal.js";
+import { connect } from "../wallet.js";
+import { DEVNET_GUARDIAN, getWithdrawalConfig } from "../withdrawal.js";
 
 const commaSeparatedList = (value: string) => value.split(",");
 
@@ -81,28 +92,35 @@ const reportApplicationStatus = (deployment: RollupsDeployment) => {
 const shell = async (options: {
     build?: CommandUnknownOpts;
     deployment?: RollupsDeployment;
+    environment: EnvironmentOptions;
     epochLength: number;
     log?: CommandUnknownOpts;
     projectName: string;
     prt?: boolean;
     salt: number;
     sdk: string;
+    /** the sentry services running for the deployment */
+    sentryServices: string[];
     resolveWithdrawalConfig: () => WithdrawalConfig | undefined;
+    resolvePrt: () => ResolvedPrt | undefined;
     claimStagingPeriod: number;
 }) => {
     const {
         build,
+        environment,
         epochLength,
         log,
         projectName,
         prt,
         sdk,
         resolveWithdrawalConfig,
+        resolvePrt,
         claimStagingPeriod,
     } = options;
 
     let lastDeployment = options.deployment;
     let salt = options.salt;
+    let sentryServices = options.sentryServices;
     let lastStatus = lastDeployment?.status;
     let pendingReport: RollupsDeployment | undefined;
 
@@ -175,6 +193,14 @@ const shell = async (options: {
                     break;
                 }
                 case "b": {
+                    // the sentries read the machine the build replaces, and
+                    // claim for the application the redeploy removes
+                    await stopSentries({
+                        projectName,
+                        services: sentryServices,
+                    });
+                    sentryServices = [];
+
                     // build
                     await build?.parseAsync([], { from: "user" });
 
@@ -184,6 +210,11 @@ const shell = async (options: {
                         // the accounts drive may have moved with the rebuild,
                         // resolved before undeploying in case it is now invalid
                         const withdrawalConfig = resolveWithdrawalConfig();
+                        // a PRT redeploy creates a new consensus, with the
+                        // sentries as they are in the config now
+                        const prtConfig = resolvePrt();
+                        reportPrtWarnings(prtConfig, claimStagingPeriod);
+                        await fundSentries({ environment, prtConfig });
                         if (lastDeployment) {
                             await undeploy({ projectName });
                         }
@@ -193,12 +224,18 @@ const shell = async (options: {
                             hash,
                             projectName,
                             prt,
+                            prtConfig,
                             salt: numberToHex(salt++, { size: 32 }),
                             withdrawalConfig,
                             claimStagingPeriod,
                         });
                         lastStatus = lastDeployment?.status;
                         pendingReport = undefined;
+                        sentryServices = await runSentries({
+                            application: lastDeployment.address,
+                            environment,
+                            prtConfig,
+                        });
                     }
 
                     break;
@@ -234,12 +271,109 @@ const undeploy = async (options: { projectName: string }) => {
     progress.succeed(`${chalk.cyan(projectName)} undeployed`);
 };
 
+/**
+ * Warn about [prt] settings that are valid but have no effect.
+ */
+const reportPrtWarnings = (
+    prtConfig: ResolvedPrt | undefined,
+    claimStagingPeriod: number,
+) => {
+    for (const warning of prtConfig?.warnings ?? []) {
+        console.warn(chalk.yellow(`WARNING: ${warning}`));
+    }
+    if (
+        prtConfig &&
+        prtConfig.sentries.length > 0 &&
+        claimStagingPeriod === 0
+    ) {
+        console.warn(
+            chalk.yellow(
+                "WARNING: with --claim-staging-period 0 a staged claim is accepted at once, so the sentries have no effect",
+            ),
+        );
+    }
+};
+
+/**
+ * Funds the pool sentries and checks the others have ETH, once anvil is up and
+ * before the deploy they claim for.
+ */
+const fundSentries = async (options: {
+    environment: EnvironmentOptions;
+    prtConfig?: ResolvedPrt;
+}) => {
+    const { environment, prtConfig } = options;
+    if (!prtConfig || runnableSentries(prtConfig).length === 0) {
+        return;
+    }
+    const client = await connect({
+        rpcUrl: `${host}:${environment.port}/anvil`,
+    });
+    await checkSentries(client, prtConfig);
+};
+
+/**
+ * Starts the sentries the CLI runs, for the deployed application, then prints
+ * the manager and every sentry the consensus was deployed with, in ID order:
+ * a check for each one running, a note for each one appointed only.
+ * @returns the sentry services started
+ */
+const runSentries = async (options: {
+    application: Address;
+    environment: EnvironmentOptions;
+    prtConfig?: ResolvedPrt;
+}): Promise<string[]> => {
+    const { application, environment, prtConfig } = options;
+    if (!prtConfig || prtConfig.sentries.length === 0) {
+        return [];
+    }
+
+    const sentries = runnableSentries(prtConfig);
+    const progress = ora();
+    let services: string[] = [];
+    if (sentries.length > 0) {
+        progress.start(
+            `starting ${sentries.length === 1 ? "the sentry" : `${sentries.length} sentries`}...`,
+        );
+        try {
+            services = await startSentries({
+                ...environment,
+                application,
+                imageTag: environment.runtimeVersion,
+                sentries: prtConfig.sentries,
+            });
+            progress.stop();
+        } catch (error: unknown) {
+            progress.fail("the sentries failed to start");
+            throw error;
+        }
+    }
+
+    // log-symbols' blue info mark is hard to read on a dark terminal
+    const note = (text: string) =>
+        progress.stopAndPersist({ symbol: chalk.cyan("ℹ"), text });
+    if (prtConfig.sentryManager === undefined) {
+        progress.warn("sentry manager none (the sentries can't be rotated)");
+    } else {
+        note(`sentry manager ${prtConfig.sentryManager}`);
+    }
+    for (const sentry of prtConfig.sentries) {
+        if (sentry.type === undefined) {
+            note(describeSentry(sentry));
+        } else {
+            progress.succeed(describeSentry(sentry));
+        }
+    }
+    return services;
+};
+
 const deploy = async (options: {
     consensus?: Address;
     epochLength: number;
     hash: Hex;
     projectName: string;
     prt?: boolean;
+    prtConfig?: ResolvedPrt;
     salt: Hex;
     withdrawalConfig?: WithdrawalConfig;
     claimStagingPeriod: number;
@@ -250,6 +384,7 @@ const deploy = async (options: {
         hash,
         projectName,
         prt,
+        prtConfig,
         salt,
         withdrawalConfig,
         claimStagingPeriod,
@@ -267,6 +402,8 @@ const deploy = async (options: {
         projectName,
         prt,
         salt,
+        sentries: prtConfig?.sentries.map(({ address }) => address),
+        sentryManager: prtConfig?.sentryManager,
         snapshotPath: "/var/lib/cartesi-rollups-node/snapshots/image",
         withdrawalConfig,
         claimStagingPeriod,
@@ -334,7 +471,7 @@ export const createRunCommand = () => {
                 "--default-block <string>",
                 "default block to be used when fetching new blocks.",
             )
-                .choices(["latest", "safe", "pending", "finalized"])
+                .choices(["latest", "safe", "finalized"])
                 .default("latest"),
         )
         .option("--dry-run", "show the docker compose configuration", false)
@@ -443,6 +580,28 @@ export const createRunCommand = () => {
             // get application configuration (e.g. use withdrawal config if present)
             const applicationConfig = getApplicationConfig(configFiles);
 
+            // [prt] is parsed either way, so a mistake in it fails early, but
+            // the node takes sentries only on a PRT deploy. Read again on a
+            // rebuild, like the withdrawal config.
+            const resolvePrt = () => {
+                const config = getApplicationConfig(configFiles);
+                return prt && config.prt
+                    ? resolveSentries(config.prt, {
+                          guardian:
+                              config.withdrawal?.guardian ?? DEVNET_GUARDIAN,
+                      })
+                    : undefined;
+            };
+            if (applicationConfig.prt && !prt) {
+                console.log(
+                    chalk.dim("[prt] in cartesi.toml is ignored without --prt"),
+                );
+            }
+
+            // fail before starting the environment if the sentries can't be resolved
+            const prtConfig = resolvePrt();
+            reportPrtWarnings(prtConfig, claimStagingPeriod);
+
             // resolve port number, using the first free port in a range, unless explicitly set
             const port =
                 options.port ||
@@ -477,13 +636,10 @@ export const createRunCommand = () => {
             // if TTY is not attached, run on foreground (not detached)
             const detach = process.stdin.isTTY;
 
-            // run compose environment (detached)
-            const { cmd, config } = await startEnvironment({
+            const environment: EnvironmentOptions = {
                 blockTime,
                 cpus,
                 defaultBlock,
-                detach,
-                dryRun,
                 forkConfig,
                 memory,
                 port,
@@ -492,6 +648,13 @@ export const createRunCommand = () => {
                 runtimeVersion,
                 services,
                 verbose,
+            };
+
+            // run compose environment (detached)
+            const { cmd, config } = await startEnvironment({
+                ...environment,
+                detach,
+                dryRun,
             });
 
             // host address
@@ -517,20 +680,28 @@ export const createRunCommand = () => {
 
             // deploy the application
             let deployment: RollupsDeployment | undefined;
+            let sentryServices: string[] = [];
             let salt = 0;
             const hash = await getMachineHash({
                 sdk: applicationConfig.sdk,
             });
             if (hash) {
+                await fundSentries({ environment, prtConfig });
                 deployment = await deploy({
                     epochLength,
                     hash,
                     projectName,
                     prt,
+                    prtConfig,
                     salt: numberToHex(salt++, { size: 32 }),
                     claimStagingPeriod,
                     withdrawalConfig,
                 });
+                sentryServices = await runSentries({
+                    application: deployment.address,
+                    environment,
+                    prtConfig,
+                });
             } else {
                 console.warn(
                     chalk.yellow(
@@ -566,14 +737,17 @@ export const createRunCommand = () => {
                 await shell({
                     build,
                     deployment,
+                    environment,
                     epochLength,
                     log,
                     projectName,
                     prt,
                     salt,
                     sdk: applicationConfig.sdk,
+                    sentryServices,
                     claimStagingPeriod,
                     resolveWithdrawalConfig,
+                    resolvePrt,
                 });
                 await shutdown();
             } else {
diff --git a/apps/cli/src/commands/send.ts b/apps/cli/src/commands/send.ts
index 62e21ff9..debb653e 100755
--- a/apps/cli/src/commands/send.ts
+++ b/apps/cli/src/commands/send.ts
@@ -12,7 +12,7 @@ import {
 import { getProjectName } from "../base.js";
 import { inputBoxAbi, inputBoxAddress } from "../contracts.js";
 import { bytesInput, getInputApplicationAddress } from "../prompts.js";
-import { connect } from "../wallet.js";
+import { connect, getDefaultSender } from "../wallet.js";
 
 const getInput = async (
     input: string | undefined,
@@ -114,7 +114,10 @@ export const createSendCommand = () => {
     const command = new Command("send")
         .description("Send input to the application")
         .argument("[input]", "input payload")
-        .option("--from <address>", "input sender address")
+        .option(
+            "--from <address>",
+            "input sender address (default: devnet account 8)",
+        )
         .option("--application <address>", "application address")
         .addOption(
             new Option("--encoding <encoding>", "input encoding").choices([
@@ -142,7 +145,7 @@ export const createSendCommand = () => {
             const account =
                 from && isAddress(from)
                     ? getAddress(from)
-                    : (await testClient.getAddresses())[0];
+                    : await getDefaultSender(testClient);
 
             // get dapp address from local node, or ask
             const applicationAddress = await getInputApplicationAddress({
diff --git a/apps/cli/src/compose/anvil.ts b/apps/cli/src/compose/anvil.ts
index c1607fea..69688480 100644
--- a/apps/cli/src/compose/anvil.ts
+++ b/apps/cli/src/compose/anvil.ts
@@ -1,6 +1,6 @@
 import type { ForkConfig } from "../types/chain.js";
 import type { ComposeFile, Config, Service } from "../types/compose.js";
-import { DEFAULT_HEALTHCHECK } from "./common.js";
+import { DEFAULT_HEALTHCHECK, escapeComposeValue } from "./common.js";
 
 type ServiceOptions = {
     imageTag?: string;
@@ -23,7 +23,8 @@ const service = (options?: ServiceOptions): Service => {
               "--block-time",
               blockTime.toString(),
               "--fork-url",
-              forkConfig.url,
+              // the URL may hold an API key with a `$`, which compose must not interpolate
+              escapeComposeValue(forkConfig.url),
               ...(forkConfig.blockNumber !== undefined
                   ? ["--fork-block-number", forkConfig.blockNumber.toString()]
                   : []),
diff --git a/apps/cli/src/compose/common.ts b/apps/cli/src/compose/common.ts
index fe8780c2..0aef4f4b 100644
--- a/apps/cli/src/compose/common.ts
+++ b/apps/cli/src/compose/common.ts
@@ -7,3 +7,11 @@ export const DEFAULT_HEALTHCHECK: Healthcheck = {
     timeout: "1s",
     retries: 5,
 };
+
+/**
+ * Escapes a value for a compose file, which would otherwise read `$name` and
+ * `${name}` in it as variables and replace them, `$` and all.
+ * The container still gets the original value.
+ */
+export const escapeComposeValue = (value: string): string =>
+    value.replaceAll("$", () => "$$");
diff --git a/apps/cli/src/compose/node.ts b/apps/cli/src/compose/node.ts
index 4c6e45c3..00d1e9f8 100644
--- a/apps/cli/src/compose/node.ts
+++ b/apps/cli/src/compose/node.ts
@@ -1,12 +1,14 @@
 import { anvil } from "viem/chains";
 import type { CartesiEnvironmentVariables } from "../base.js";
 import {
+    applicationFactoryAddress,
     daveAppFactoryAddress,
     inputBoxAddress,
     selfHostedApplicationFactoryAddress,
 } from "../contracts.js";
 import type { ComposeFile, Config, Service } from "../types/compose.js";
-import { DEFAULT_HEALTHCHECK } from "./common.js";
+import { DEFAULT_HEALTHCHECK, escapeComposeValue } from "./common.js";
+import { type FileSecret, fileSecret, secretInitService } from "./secrets.js";
 
 /**
  * Mnemonic of the devnet test accounts, used by the node to sign transactions
@@ -19,7 +21,7 @@ export type ServiceOptions = {
     databaseHost?: string;
     databasePort?: number;
     databasePassword: string;
-    defaultBlock?: "latest" | "safe" | "pending" | "finalized";
+    defaultBlock?: "latest" | "safe" | "finalized";
     forkChainId?: number;
     logLevel?: "info" | "debug" | "warn" | "error" | "fatal";
     memory?: number;
@@ -104,8 +106,40 @@ export const getNodeAllowedVariables = (
     return allowedVars;
 };
 
+/**
+ * The allowed variables that name a file the node reads its keys from.
+ * Forwarding only the path would leave the node without the file, so each
+ * one is copied into the container instead.
+ */
+export const nodeSecretFileVariables = nodeAllowedEnvironmentVariables.filter(
+    (name) => name.endsWith("_FILE"),
+);
+
+/** Service that copies the key files for the node, and its volume. */
+const SECRET_INIT_SERVICE = "node-secret-init";
+const SECRETS_VOLUME = "node_secrets";
+
+/**
+ * Returns the key files named in the host variables, each with the variable
+ * that points the node at its copy.
+ */
+const nodeFileSecrets = (
+    cartesiVars?: CartesiEnvironmentVariables,
+): (FileSecret & { variable: string })[] => {
+    const allowedVars = getNodeAllowedVariables(cartesiVars);
+    return nodeSecretFileVariables.flatMap((variable) => {
+        const hostPath = allowedVars[variable];
+        return hostPath === undefined
+            ? []
+            : [{ variable, ...fileSecret(variable.toLowerCase(), hostPath) }];
+    });
+};
+
 // Rollups Node service
-const service = (options: ServiceOptions): Service => {
+const service = (
+    options: ServiceOptions,
+    fileSecrets: (FileSecret & { variable: string })[],
+): Service => {
     const databasePassword = options.databasePassword;
     const databaseHost = options.databaseHost ?? "database";
     const databasePort = options.databasePort ?? 5432;
@@ -130,6 +164,10 @@ const service = (options: ServiceOptions): Service => {
         CARTESI_BLOCKCHAIN_DEFAULT_BLOCK: defaultBlock,
         CARTESI_BLOCKCHAIN_HTTP_ENDPOINT: "http://anvil:8545",
         CARTESI_BLOCKCHAIN_ID: anvil.id.toString(),
+        // a deploy on an existing consensus, as the shell's redeploy does,
+        // creates only the application, through this factory
+        CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS:
+            applicationFactoryAddress,
         ...(chainDaveAppFactoryAddress && {
             CARTESI_CONTRACTS_DAVE_APP_FACTORY_ADDRESS:
                 chainDaveAppFactoryAddress,
@@ -146,10 +184,19 @@ const service = (options: ServiceOptions): Service => {
         CARTESI_SNAPSHOTS_DIR: "/var/lib/cartesi-rollups-node/snapshots",
     };
 
-    const hostVars = getNodeAllowedVariables(
-        options.cartesiEnvironmentVariables,
+    // the host values are the user's own and may hold a `$`, e.g. in a
+    // password, which compose must not interpolate
+    const hostVars = Object.fromEntries(
+        Object.entries(
+            getNodeAllowedVariables(options.cartesiEnvironmentVariables),
+        ).map(([name, value]) => [name, escapeComposeValue(value)]),
     );
 
+    // the key files reach the node as secrets, at a path inside the container
+    for (const { variable, target } of fileSecrets) {
+        hostVars[variable] = target;
+    }
+
     // Merge default and host environment variables, with host variables taking precedence
     // further to the right of the parameter list the higher the precedence
     // TODO: Here or somewhere else; Add other variables with precedence rules, e.g. command line > <config>.toml > host environment > default
@@ -161,6 +208,11 @@ const service = (options: ServiceOptions): Service => {
         depends_on: {
             database: { condition: "service_healthy" },
             anvil: { condition: "service_healthy" },
+            ...(fileSecrets.length > 0 && {
+                [SECRET_INIT_SERVICE]: {
+                    condition: "service_completed_successfully",
+                },
+            }),
         },
         deploy: {
             resources: {
@@ -185,7 +237,12 @@ const service = (options: ServiceOptions): Service => {
         environment: {
             ...environmentVariables,
         },
-        volumes: ["./.cartesi:/var/lib/cartesi-rollups-node/snapshots:ro"],
+        volumes: [
+            "./.cartesi:/var/lib/cartesi-rollups-node/snapshots:ro",
+            ...(fileSecrets.length > 0
+                ? [`${SECRETS_VOLUME}:/run/secrets:ro`]
+                : []),
+        ],
     };
 };
 
@@ -234,19 +291,33 @@ http:
     };
 };
 
-export default (options: ServiceOptions): ComposeFile => ({
-    services: {
-        proxy: {
-            configs: [
-                {
-                    source: "rollups_node_proxy",
-                    target: "/etc/traefik/conf.d/rollups-node.yaml",
-                },
-            ],
+export default (options: ServiceOptions): ComposeFile => {
+    const fileSecrets = nodeFileSecrets(options.cartesiEnvironmentVariables);
+
+    return {
+        services: {
+            proxy: {
+                configs: [
+                    {
+                        source: "rollups_node_proxy",
+                        target: "/etc/traefik/conf.d/rollups-node.yaml",
+                    },
+                ],
+            },
+            rollups_node: service(options, fileSecrets),
+            ...(fileSecrets.length > 0 && {
+                [SECRET_INIT_SERVICE]: secretInitService({
+                    imageTag: options.imageTag ?? "latest",
+                    secrets: fileSecrets,
+                    volume: SECRETS_VOLUME,
+                }),
+            }),
+        },
+        configs: {
+            rollups_node_proxy: proxy(),
         },
-        rollups_node: service(options),
-    },
-    configs: {
-        rollups_node_proxy: proxy(),
-    },
-});
+        ...(fileSecrets.length > 0 && {
+            volumes: { [SECRETS_VOLUME]: {} },
+        }),
+    };
+};
diff --git a/apps/cli/src/compose/secrets.ts b/apps/cli/src/compose/secrets.ts
new file mode 100644
index 00000000..ad1003cc
--- /dev/null
+++ b/apps/cli/src/compose/secrets.ts
@@ -0,0 +1,71 @@
+import type { Service, VolumeMount } from "../types/compose.js";
+import { escapeComposeValue } from "./common.js";
+
+/**
+ * User and group the node runs as, created in the rollups-runtime image
+ * (`packages/sdk/Dockerfile`). Named, not numbered: the init service runs in
+ * that same image, so `install` resolves the ids the image actually has.
+ */
+export const RUNTIME_USER = "cartesi";
+
+/**
+ * A host key file a service reads from `target`. A bind mount would keep the
+ * host's owner and mode, which the service's user may not be able to read,
+ * so an init service copies the file into a volume, owned by that user.
+ */
+export type FileSecret = {
+    name: string;
+    /** read-only bind mount of the host file, into the init service */
+    source: VolumeMount;
+    /** shell line that installs the copy, in the init service */
+    install: string;
+    /** path of the copy in the service that reads it */
+    target: string;
+};
+
+/**
+ * Declares a host file the runtime user reads as `/run/secrets/<name>`.
+ * @param name file name under `/run/secrets`
+ * @param hostPath absolute, or relative to the project directory
+ */
+export const fileSecret = (name: string, hostPath: string): FileSecret => ({
+    name,
+    source: {
+        type: "bind",
+        source: escapeComposeValue(hostPath),
+        target: `/src/${name}`,
+        read_only: true,
+        // a missing file must fail, not become an empty directory
+        bind: { create_host_path: false },
+    },
+    install: `install -o ${RUNTIME_USER} -g ${RUNTIME_USER} -m 0400 /src/${name} /dst/${name}`,
+    target: `/run/secrets/${name}`,
+});
+
+/**
+ * Returns the service that installs the secrets into `volume`. The services
+ * that read them wait for it to complete and mount `volume` at
+ * `/run/secrets`, read-only.
+ */
+export const secretInitService = (options: {
+    imageTag: string;
+    secrets: FileSecret[];
+    volume: string;
+}): Service => ({
+    image: `cartesi/rollups-runtime:${options.imageTag}`,
+    user: "root",
+    network_mode: "none",
+    restart: "no",
+    entrypoint: ["sh", "-ec"],
+    command: [
+        [
+            // copies of a previous run must not outlive their host files
+            "find /dst -mindepth 1 -delete",
+            ...options.secrets.map(({ install }) => install),
+        ].join("\n"),
+    ],
+    volumes: [
+        ...options.secrets.map(({ source }) => source),
+        `${options.volume}:/dst`,
+    ],
+});
diff --git a/apps/cli/src/compose/sentry.ts b/apps/cli/src/compose/sentry.ts
new file mode 100644
index 00000000..53e8ba44
--- /dev/null
+++ b/apps/cli/src/compose/sentry.ts
@@ -0,0 +1,129 @@
+import type { Address } from "viem";
+import { anvil } from "viem/chains";
+import type { ResolvedSentry } from "../sentries.js";
+import type { ComposeFile, Service } from "../types/compose.js";
+import { fileSecret, secretInitService } from "./secrets.js";
+
+/**
+ * The compose services of the sentries the CLI runs: one sling node per
+ * [[prt.sentries]] entry with `type = "sling"`. They are composed after the
+ * deploy, since each one needs the application's address.
+ */
+
+export type SentryServiceOptions = {
+    application: Address;
+    /** anvil's block time, which sets how often a sentry polls the chain */
+    blockTime: number;
+    imageTag?: string;
+    sentries: ResolvedSentry[];
+};
+
+/** The compose service of a sentry, which its label names. */
+export const sentryServiceName = (label: string) => `sentry-${label}`;
+
+/**
+ * The service that installs a sentry's key file. Named outside the sentries'
+ * `sentry-` space, since a label may hold a `-`, so no label can produce the
+ * installer's name of another sentry.
+ */
+const sentryInitServiceName = (label: string) =>
+    `secret-init-${sentryServiceName(label)}`;
+
+/** Whether a compose service is a sentry the CLI runs, as `cartesi logs` lists them. */
+export const isSentryService = (service: string): boolean =>
+    service.startsWith(sentryServiceName(""));
+
+const sentrySecretsVolume = (label: string) =>
+    `sentry_${label.replaceAll("-", "_")}_secrets`;
+
+/**
+ * The directory of the runtime image its user can write to; a recreated
+ * container starts clean, for the application it is deployed for.
+ */
+const DATA_DIR = "/var/lib/cartesi-rollups-node/snapshots";
+
+/** Where the sentry reads the built machine, the same files the node deploys. */
+const TEMPLATE_DIR = "/var/lib/cartesi-rollups-node/template";
+
+/** The key of a sentry on a devnet account, which resolution always sets. */
+const privateKeyOf = (sentry: ResolvedSentry): string => {
+    if (sentry.privateKey === undefined) {
+        throw new Error(
+            `sentry ${sentry.label} ${sentry.address} has no key to run with`,
+        );
+    }
+    return sentry.privateKey;
+};
+
+const sling = (
+    options: SentryServiceOptions,
+    sentry: ResolvedSentry,
+): ComposeFile => {
+    const { application, blockTime, imageTag = "latest" } = options;
+    const { label } = sentry;
+    const image = `cartesi/rollups-runtime:${imageTag}`;
+    const secret =
+        sentry.source.kind === "key-file"
+            ? fileSecret(sentryServiceName(label), sentry.source.path)
+            : undefined;
+
+    const service: Service = {
+        image,
+        init: true,
+        depends_on: {
+            anvil: { condition: "service_healthy" },
+            ...(secret && {
+                [sentryInitServiceName(label)]: {
+                    condition: "service_completed_successfully",
+                },
+            }),
+        },
+        // the signer never comes from the command line
+        command: ["cartesi-sling-node", "pk"],
+        environment: {
+            CARTESI_SLING_APP_ADDRESS: application,
+            CARTESI_SLING_BLOCKCHAIN_HTTP_ENDPOINT: "http://anvil:8545",
+            CARTESI_SLING_BLOCKCHAIN_ID: anvil.id.toString(),
+            CARTESI_SLING_DATA_DIR: DATA_DIR,
+            CARTESI_SLING_POLLING_INTERVAL: Math.max(1, blockTime).toString(),
+            CARTESI_SLING_TEMPLATE_PATH: `${TEMPLATE_DIR}/image`,
+            ...(secret
+                ? { CARTESI_SLING_AUTH_PRIVATE_KEY_FILE: secret.target }
+                : // a devnet account's key is public, so it can go in the environment
+                  { CARTESI_SLING_AUTH_PRIVATE_KEY: privateKeyOf(sentry) }),
+        },
+        volumes: [
+            `./.cartesi:${TEMPLATE_DIR}:ro`,
+            ...(secret
+                ? [`${sentrySecretsVolume(label)}:/run/secrets:ro`]
+                : []),
+        ],
+    };
+
+    return {
+        services: {
+            [sentryServiceName(label)]: service,
+            ...(secret && {
+                [sentryInitServiceName(label)]: secretInitService({
+                    imageTag,
+                    secrets: [secret],
+                    volume: sentrySecretsVolume(label),
+                }),
+            }),
+        },
+        ...(secret && {
+            volumes: { [sentrySecretsVolume(label)]: {} },
+        }),
+    };
+};
+
+/** The compose files of the sentries the CLI runs, one per type it knows. */
+export default (options: SentryServiceOptions): ComposeFile[] =>
+    options.sentries.flatMap((sentry) => {
+        switch (sentry.type) {
+            case "sling":
+                return [sling(options, sentry)];
+            default:
+                return [];
+        }
+    });
diff --git a/apps/cli/src/config.ts b/apps/cli/src/config.ts
index ad079583..4411a683 100644
--- a/apps/cli/src/config.ts
+++ b/apps/cli/src/config.ts
@@ -5,6 +5,7 @@ import { DuplicateLabelError } from "./config/errors.js";
 import { parseDrives } from "./config/toml/drives.js";
 import { parseMachine } from "./config/toml/machine.js";
 import { parseNvrams } from "./config/toml/nvrams.js";
+import { parseOptionalPrt } from "./config/toml/prt.js";
 import { assertKnownKeys, mergeTomlTables } from "./config/toml/tables.js";
 import { parseString } from "./config/toml/values.js";
 import { parseOptionalWithdrawal } from "./config/toml/accounts.js";
@@ -37,6 +38,7 @@ const CONFIG_KEYS: readonly string[] = [
     "drives",
     "machine",
     "nvrams",
+    "prt",
     "sdk",
     "withdrawal",
 ];
@@ -63,6 +65,7 @@ export const parse = (str: string[]): Config => {
         drives,
         machine: parseMachine(toml.machine),
         nvrams,
+        prt: parseOptionalPrt(toml.prt),
         sdk: parseString(
             toml.sdk,
             `${DEFAULT_SDK_IMAGE}:${DEFAULT_SDK_VERSION}`,
diff --git a/apps/cli/src/config/defaults.ts b/apps/cli/src/config/defaults.ts
index 67dd95b7..d227ceac 100644
--- a/apps/cli/src/config/defaults.ts
+++ b/apps/cli/src/config/defaults.ts
@@ -33,6 +33,7 @@ export const defaultConfig = (): Config => ({
     drives: { root: defaultRootDriveConfig() },
     machine: defaultMachineConfig(),
     nvrams: {},
+    prt: undefined,
     sdk: `${DEFAULT_SDK_IMAGE}:${DEFAULT_SDK_VERSION}`,
     withdrawal: undefined,
 });
diff --git a/apps/cli/src/config/errors.ts b/apps/cli/src/config/errors.ts
index 46ae0346..bdaba5d7 100644
--- a/apps/cli/src/config/errors.ts
+++ b/apps/cli/src/config/errors.ts
@@ -144,6 +144,16 @@ export class InvalidWithdrawalConfigError extends Error {
     }
 }
 
+export class InvalidPrtConfigError extends Error {
+    /**
+     * @param where the table at fault, `[prt]` by default, or an entry such as `prt.sentries[2]`
+     */
+    constructor(reason: string, where = "[prt]") {
+        super(`Invalid ${where}: ${reason}`);
+        this.name = "InvalidPrtConfigError";
+    }
+}
+
 export class UnknownConfigKeyError extends Error {
     /**
      * @param where where the keys are, e.g. "in [machine]" or "at the top level"
diff --git a/apps/cli/src/config/toml/prt.ts b/apps/cli/src/config/toml/prt.ts
new file mode 100644
index 00000000..19997ebc
--- /dev/null
+++ b/apps/cli/src/config/toml/prt.ts
@@ -0,0 +1,181 @@
+import type { TomlValue } from "smol-toml";
+import { isAddressEqual, zeroAddress } from "viem";
+import {
+    formatValue,
+    InvalidPrtConfigError,
+    InvalidTableError,
+} from "../errors.js";
+import type { PrtOptions, PrtSentry, SentryType } from "../types.js";
+import { assertKnownKeys, isTomlTable } from "./tables.js";
+import { parseRequiredAddress, parseRequiredString } from "./values.js";
+
+export const PRT_KEYS: readonly string[] = ["sentries", "sentry_manager"];
+
+export const PRT_SENTRY_KEYS: readonly string[] = [
+    "address",
+    "label",
+    "private_key_file",
+    "type",
+];
+
+export const SENTRY_TYPES: readonly SentryType[] = ["sling"];
+
+/**
+ * A label names a container, so it keeps to what a service name can hold.
+ */
+const LABEL_PATTERN = /^[a-z0-9_-]+$/;
+
+/** Where an entry is, in the 1-based order the node appoints the sentries. */
+export const sentryEntry = (index: number) => `prt.sentries[${index + 1}]`;
+
+/**
+ * The label of an entry: its own, or its 1-based position, which is also the sentry's ID on
+ * the consensus.
+ */
+export const sentryLabel = (sentry: PrtSentry, index: number): string =>
+    sentry.label ?? (index + 1).toString();
+
+const parseSentryType = (value: TomlValue, where: string): SentryType => {
+    if (
+        typeof value === "string" &&
+        SENTRY_TYPES.includes(value as SentryType)
+    ) {
+        return value as SentryType;
+    }
+    throw new InvalidPrtConfigError(
+        `type ${formatValue(value)} isn't supported, expected one of: ${SENTRY_TYPES.join(", ")}`,
+        where,
+    );
+};
+
+const parseLabel = (value: TomlValue, where: string): string => {
+    if (typeof value === "string" && LABEL_PATTERN.test(value)) {
+        return value;
+    }
+    throw new InvalidPrtConfigError(
+        `label ${formatValue(value)} must be lowercase letters, digits, - or _`,
+        where,
+    );
+};
+
+const parseSentry = (value: TomlValue, index: number): PrtSentry => {
+    const where = sentryEntry(index);
+    if (!isTomlTable(value)) {
+        throw new InvalidTableError(where, value);
+    }
+    assertKnownKeys(value, PRT_SENTRY_KEYS, `in ${where}`);
+
+    const address =
+        value.address === undefined
+            ? undefined
+            : parseRequiredAddress(value.address, "address");
+    if (address !== undefined && isAddressEqual(address, zeroAddress)) {
+        throw new InvalidPrtConfigError(
+            "address must not be the zero address",
+            where,
+        );
+    }
+    const type =
+        value.type === undefined
+            ? undefined
+            : parseSentryType(value.type, where);
+    const label =
+        value.label === undefined ? undefined : parseLabel(value.label, where);
+    const privateKeyFile =
+        value.private_key_file === undefined
+            ? undefined
+            : parseRequiredString(value.private_key_file, "private_key_file");
+
+    if (type === undefined && address === undefined) {
+        throw new InvalidPrtConfigError(
+            "set a type for the CLI to run the sentry, or an address to appoint one run elsewhere",
+            where,
+        );
+    }
+    if (privateKeyFile !== undefined && type === undefined) {
+        throw new InvalidPrtConfigError(
+            "private_key_file needs a type: the CLI only reads the key of a sentry it runs",
+            where,
+        );
+    }
+    if (privateKeyFile === "") {
+        throw new InvalidPrtConfigError(
+            "private_key_file must name a file",
+            where,
+        );
+    }
+
+    return {
+        ...(address !== undefined && { address }),
+        ...(type !== undefined && { type }),
+        ...(label !== undefined && { label }),
+        ...(privateKeyFile !== undefined && { privateKeyFile }),
+    };
+};
+
+const parseSentries = (value: TomlValue): PrtSentry[] => {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new InvalidPrtConfigError(
+            `sentries must be [[prt.sentries]] entries, got ${formatValue(value)}`,
+        );
+    }
+    const sentries = value.map(parseSentry);
+
+    // the node rejects a duplicate, and so does a container name
+    sentries.forEach((sentry, index) => {
+        const label = sentryLabel(sentry, index);
+        const sameLabel = sentries.findIndex(
+            (other, i) => i < index && sentryLabel(other, i) === label,
+        );
+        if (sameLabel >= 0) {
+            throw new InvalidPrtConfigError(
+                `label "${label}" is also the label of ${sentryEntry(sameLabel)}`,
+                sentryEntry(index),
+            );
+        }
+        if (sentry.address === undefined) {
+            return;
+        }
+        const sameAddress = sentries.findIndex(
+            (other, i) =>
+                i < index &&
+                other.address !== undefined &&
+                isAddressEqual(other.address, sentry.address as `0x${string}`),
+        );
+        if (sameAddress >= 0) {
+            throw new InvalidPrtConfigError(
+                `address ${sentry.address} is also the address of ${sentryEntry(sameAddress)}`,
+                sentryEntry(index),
+            );
+        }
+    });
+
+    return sentries;
+};
+
+/**
+ * Parses [prt], which `cartesi run --prt` uses to deploy the application's consensus with
+ * sentries. Like the other tables, it reads the keys it uses and rejects any other.
+ */
+export const parseOptionalPrt = (prt: TomlValue): PrtOptions | undefined => {
+    if (prt === undefined) {
+        return undefined;
+    }
+    if (!isTomlTable(prt)) {
+        throw new InvalidTableError("[prt]", prt);
+    }
+    assertKnownKeys(prt, PRT_KEYS, "in [prt]");
+
+    return {
+        ...(prt.sentry_manager !== undefined && {
+            sentryManager: parseRequiredAddress(
+                prt.sentry_manager,
+                "sentry_manager",
+            ),
+        }),
+        sentries: parseSentries(prt.sentries),
+    };
+};
diff --git a/apps/cli/src/config/types.ts b/apps/cli/src/config/types.ts
index 92941f04..7ccdcf6e 100644
--- a/apps/cli/src/config/types.ts
+++ b/apps/cli/src/config/types.ts
@@ -124,10 +124,37 @@ export type WithdrawalOptions = {
     account_size?: number; // in bytes, default is 32
 };
 
+/**
+ * The node the CLI runs for a PRT sentry. Only the Dave sling node exists today; a type is
+ * added once a released node can run as a sentry.
+ */
+export type SentryType = "sling";
+
+/**
+ * One [[prt.sentries]] entry: a sentry appointed on the application's DaveConsensus, in entry
+ * order. With a `type` the CLI runs a node for it; without one it is appointed only.
+ */
+export type PrtSentry = {
+    address?: Address; // required without a type; with one, the CLI's sentry pool by default
+    type?: SentryType;
+    label?: string; // names the container, default is the 1-based position
+    privateKeyFile?: string; // the sentry's own key, for a type the CLI runs; sets the address
+};
+
+/**
+ * The optional [prt] section, used by `cartesi run --prt` to deploy the application's
+ * DaveConsensus with sentries.
+ */
+export type PrtOptions = {
+    sentryManager?: Address; // may rotate sentries, default is none
+    sentries: PrtSentry[];
+};
+
 export type Config = {
     drives: Record<string, DriveConfig>;
     machine: MachineConfig;
     nvrams: Record<string, NvramConfig>;
+    prt?: PrtOptions;
     sdk: string;
     withdrawal?: WithdrawalOptions;
 };
diff --git a/apps/cli/src/exec/cartesi-machine.ts b/apps/cli/src/exec/cartesi-machine.ts
index 30571500..1fb60112 100644
--- a/apps/cli/src/exec/cartesi-machine.ts
+++ b/apps/cli/src/exec/cartesi-machine.ts
@@ -4,7 +4,7 @@ import {
     type ExecaOptionsDockerFallback,
 } from "./util.js";
 
-export const requiredVersion = new Range("^0.21.0");
+export const requiredVersion = new Range("^0.22.0");
 
 export const boot = (
     args: readonly string[],
diff --git a/apps/cli/src/exec/rollups.ts b/apps/cli/src/exec/rollups.ts
index 61219056..dd79912f 100644
--- a/apps/cli/src/exec/rollups.ts
+++ b/apps/cli/src/exec/rollups.ts
@@ -30,8 +30,14 @@ import node from "../compose/node.js";
 import passkey from "../compose/passkey.js";
 import paymaster from "../compose/paymaster.js";
 import proxy from "../compose/proxy.js";
+import sentries, {
+    type SentryServiceOptions,
+    sentryServiceName,
+} from "../compose/sentry.js";
 import type { WithdrawalConfig } from "../config.js";
 import type { ForkConfig } from "../types/chain.js";
+import type { ComposeFile } from "../types/compose.js";
+import { assertBlockchainEndpoint, assertSecretFiles } from "../validations.js";
 import type { AccountsDriveConfig } from "./cartesi-rollups-machine-tool.js";
 import { execNodeCommand } from "./node-container.js";
 
@@ -266,6 +272,74 @@ export const getLastAcceptedEpoch = async (options: {
     return parseLastAcceptedEpoch(stdout);
 };
 
+/**
+ * The sentries of an application's DaveConsensus, as `cartesi-rollups-cli
+ * contract consensus` reports them.
+ */
+export type DaveConsensusSentries = {
+    address: Address;
+    claimStagingPeriod: number;
+    sentryManager: Address;
+    sentries: { id: number; address: Address }[];
+    /** set once a tournament result is staged */
+    allSentriesAgree?: boolean;
+};
+
+type CliDaveConsensus = {
+    type: string;
+    address: string;
+    claim_staging_period: number;
+    sentry_manager: string;
+    num_sentries: number;
+    sentries: { id: number; address: string }[];
+    all_sentries_agree?: boolean;
+};
+
+/**
+ * Parse the JSON `cartesi-rollups-cli contract consensus --json` writes to
+ * stdout for a DaveConsensus
+ * @throws if the consensus is of another type
+ */
+export const parseDaveConsensus = (stdout: string): DaveConsensusSentries => {
+    const consensus = JSON.parse(stdout) as CliDaveConsensus;
+    if (consensus.type !== "DaveConsensus") {
+        throw new Error(
+            `The consensus at ${consensus.address} is a ${consensus.type}, not a DaveConsensus`,
+        );
+    }
+    return {
+        address: getAddress(consensus.address),
+        claimStagingPeriod: consensus.claim_staging_period,
+        sentryManager: getAddress(consensus.sentry_manager),
+        sentries: consensus.sentries.map(({ id, address }) => ({
+            id,
+            address: getAddress(address),
+        })),
+        allSentriesAgree: consensus.all_sentries_agree,
+    };
+};
+
+/**
+ * Read the sentries of an application's DaveConsensus from the chain
+ */
+export const getDaveConsensus = async (options: {
+    application: Address;
+    projectName: string;
+}): Promise<DaveConsensusSentries> => {
+    const { application, projectName } = options;
+    const stdout = await execNodeCommand({
+        command: [
+            "cartesi-rollups-cli",
+            "contract",
+            "consensus",
+            application,
+            "--json",
+        ],
+        projectName,
+    });
+    return parseDaveConsensus(stdout);
+};
+
 export const getApplicationDeployment = async (
     options: ComposeParams,
 ): Promise<RollupsDeployment | undefined> => {
@@ -452,12 +526,10 @@ const serviceMonitorTask = (options: {
     };
 };
 
-export const startEnvironment = async (options: {
+export type EnvironmentOptions = {
     blockTime: number;
     cpus?: number;
-    defaultBlock: "latest" | "safe" | "pending" | "finalized";
-    detach: boolean;
-    dryRun: boolean;
+    defaultBlock: "latest" | "safe" | "finalized";
     forkConfig?: ForkConfig;
     memory?: number;
     port: number;
@@ -466,13 +538,21 @@ export const startEnvironment = async (options: {
     runtimeVersion: string;
     services: string[];
     verbose: boolean;
-}) => {
+};
+
+/**
+ * Composes the environment: the compose file of the project and the variables
+ * it is rendered with. The sentries, composed only after the deploy, are added
+ * to the same file so compose sees one project.
+ */
+const composeEnvironment = (
+    options: EnvironmentOptions,
+    extraFiles: ComposeFile[] = [],
+) => {
     const {
         blockTime,
         cpus,
         defaultBlock,
-        detach,
-        dryRun,
         forkConfig,
         memory,
         port,
@@ -495,6 +575,8 @@ export const startEnvironment = async (options: {
 
     // Load all environment variables from the host that start with CARTESI_.
     const hostVars = getCartesiEnvironmentVariables();
+    assertBlockchainEndpoint(hostVars);
+    assertSecretFiles(hostVars);
 
     const files = [
         anvil({
@@ -535,21 +617,37 @@ export const startEnvironment = async (options: {
         files.push(passkey({ imageTag: runtimeVersion }));
     }
 
-    const composeArgs = ["compose", "-f", "-", "--project-directory", "."];
+    // merge files, following Docker Compose merge rules
+    const composeFile = concat([
+        { name: projectName },
+        ...files,
+        ...extraFiles,
+    ]);
+
+    return {
+        env,
+        input: stringify(composeFile, { lineWidth: 0, indent: 2 }),
+    };
+};
+
+const composeArgs = ["compose", "-f", "-", "--project-directory", "."];
+
+export const startEnvironment = async (
+    options: EnvironmentOptions & { detach: boolean; dryRun: boolean },
+) => {
+    const { detach, dryRun } = options;
+    const { env, input } = composeEnvironment(options);
 
     // run in detached mode (background)
     const upArgs = detach ? ["--detach"] : [];
 
-    // merge files, following Docker Compose merge rules
-    const composeFile = concat([{ name: projectName }, ...files]);
-
     // if only dry run, just return the config
     if (dryRun) {
         // parse, resolve and render compose file in canonical format
         const { stdout: config } = await execa(
             "docker",
             [...composeArgs, "config", "--format", "yaml"],
-            { env, input: stringify(composeFile, { lineWidth: 0, indent: 2 }) },
+            { env, input },
         );
 
         return { config };
@@ -558,7 +656,7 @@ export const startEnvironment = async (options: {
     // run compose
     const cmd = execa("docker", [...composeArgs, "up", ...upArgs], {
         env,
-        input: stringify(composeFile, { lineWidth: 0, indent: 2 }),
+        input,
     });
 
     // if detached, wait to finish
@@ -569,6 +667,56 @@ export const startEnvironment = async (options: {
     return { cmd };
 };
 
+/**
+ * Starts the sentries the CLI runs for a deployed application, in the running
+ * environment. The file sent is the environment's plus the sentry services, so
+ * compose treats them as one project and recreates only the sentries, whose
+ * application changed. Their dependencies are already running, except the init
+ * service of a key file, which runs first.
+ * @returns the names of the services started
+ */
+export const startSentries = async (
+    options: EnvironmentOptions & SentryServiceOptions,
+): Promise<string[]> => {
+    const names = options.sentries
+        .filter(({ type }) => type !== undefined)
+        .map(({ label }) => sentryServiceName(label));
+    if (names.length === 0) {
+        return [];
+    }
+    const { env, input } = composeEnvironment(options, sentries(options));
+    // --wait: a sentry that exits at once, e.g. on a bad key, fails here
+    await execa(
+        "docker",
+        [...composeArgs, "up", "--detach", "--wait", ...names],
+        { env, input },
+    );
+    return names;
+};
+
+/**
+ * Stops and removes the sentry containers, before the application they claim
+ * for is undeployed. Their secret volumes stay until the environment stops.
+ */
+export const stopSentries = async (options: {
+    projectName: string;
+    services: string[];
+}) => {
+    const { projectName, services } = options;
+    if (services.length === 0) {
+        return;
+    }
+    await execa("docker", [
+        "compose",
+        "--project-name",
+        projectName,
+        "rm",
+        "--stop",
+        "--force",
+        ...services,
+    ]);
+};
+
 /**
  * Wait for the environment to be healthy
  * @param options
@@ -686,6 +834,10 @@ export type DeployApplicationOptions = {
     projectName: string;
     prt?: boolean;
     salt?: Hex;
+    /** PRT only: the sentries appointed on the consensus, in ID order */
+    sentries?: Address[];
+    /** PRT only: the account that may rotate the sentries */
+    sentryManager?: Address;
     snapshotPath: string;
     withdrawalConfig?: WithdrawalConfig;
     claimStagingPeriod: number;
@@ -704,6 +856,8 @@ export const buildDeployApplicationArgs = (
         name,
         prt,
         salt,
+        sentries,
+        sentryManager,
         snapshotPath,
         withdrawalConfig,
         claimStagingPeriod,
@@ -725,6 +879,14 @@ export const buildDeployApplicationArgs = (
         deployArgs.push("--prt");
     }
 
+    // the node takes both only with --prt
+    if (sentryManager) {
+        deployArgs.push("--sentry-manager", sentryManager);
+    }
+    if (sentries && sentries.length > 0) {
+        deployArgs.push("--sentries", sentries.join(","));
+    }
+
     // the node takes this on the whole deploy command, PRT included
     deployArgs.push("--claim-staging-period", claimStagingPeriod.toString());
 
@@ -764,6 +926,27 @@ export const deployApplication = async (
     throw new Error("Failed to deploy application");
 };
 
+/**
+ * Assemble the `cartesi-rollups-cli app remove` arguments.
+ * Kept separate from the call so it can be tested without a node.
+ */
+export const buildRemoveApplicationArgs = (options: {
+    application: string | Address;
+    force: boolean;
+}): string[] => {
+    const { application, force } = options;
+
+    const removeArgs = [application];
+
+    if (force) {
+        // the node refuses to remove without acknowledging the work it abandons,
+        // and --yes only skips its confirmation prompt
+        removeArgs.push("--allow-abandonment", "--yes");
+    }
+
+    return removeArgs;
+};
+
 /**
  * Remove application from rollups node
  * @param options
@@ -774,7 +957,7 @@ export const removeApplication = async (options: {
     force: boolean;
     projectName: string;
 }) => {
-    const { application, force, projectName } = options;
+    const { application, projectName } = options;
 
     // disable application first so we can remove it
     await execNodeCommand({
@@ -788,14 +971,13 @@ export const removeApplication = async (options: {
         projectName,
     });
 
-    const removeArgs = [application];
-
-    if (force) {
-        removeArgs.push("--yes");
-    }
-
     return execNodeCommand({
-        command: ["cartesi-rollups-cli", "app", "remove", ...removeArgs],
+        command: [
+            "cartesi-rollups-cli",
+            "app",
+            "remove",
+            ...buildRemoveApplicationArgs(options),
+        ],
         projectName,
     });
 };
diff --git a/apps/cli/src/sentries.ts b/apps/cli/src/sentries.ts
new file mode 100644
index 00000000..6a91a6db
--- /dev/null
+++ b/apps/cli/src/sentries.ts
@@ -0,0 +1,336 @@
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import {
+    type Address,
+    type Hex,
+    isAddressEqual,
+    isHex,
+    parseEther,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { DEVNET_MNEMONIC } from "./compose/node.js";
+import {
+    InvalidPrtConfigError,
+    type PrtOptions,
+    type PrtSentry,
+    type SentryType,
+} from "./config.js";
+import { sentryEntry, sentryLabel } from "./config/toml/prt.js";
+import {
+    DEFAULT_SENDER_INDEX,
+    DEVNET_ACCOUNTS,
+    findMnemonicAccountIndex,
+    getDevnetAccount,
+} from "./wallet.js";
+
+/**
+ * The sentry pool: devnet accounts a [[prt.sentries]] entry gets when it names none. They
+ * come after the accounts anvil funds (0 to 9), which the node, the CLI and the developer use,
+ * so a pool sentry shares nonces with nothing else.
+ */
+export const SENTRY_POOL_START = 20;
+export const SENTRY_POOL_SIZE = 10;
+
+/** What `cartesi run` gives each pool sentry: what anvil gives its own accounts. */
+export const SENTRY_FUNDING = parseEther("10000");
+
+/**
+ * Devnet accounts the node signs with: the claimer (`CARTESI_AUTH_MNEMONIC_ACCOUNT_INDEX`,
+ * set by the CLI) and the PRT submitter (the node's `CARTESI_PRT_AUTH_MNEMONIC_ACCOUNT_INDEX`
+ * default).
+ */
+const NODE_CLAIMER_INDEX = 0;
+const NODE_PRT_INDEX = 6;
+
+/** Where a sentry's address came from. */
+export type SentrySource =
+    | { kind: "pool"; index: number } // a devnet account of the sentry pool
+    | { kind: "devnet"; index: number } // another devnet account, named in the entry
+    | { kind: "key-file"; path: string } // the developer's own key, read from a file
+    | { kind: "external" }; // an address of the developer's own
+
+export type ResolvedSentry = {
+    entry: number; // 1-based position, the sentry's ID on the consensus
+    label: string;
+    address: Address;
+    type?: SentryType;
+    source: SentrySource;
+    /** the key the CLI runs the sentry with; only for a devnet account, whose key is public */
+    privateKey?: Hex;
+};
+
+export type ResolvedPrt = {
+    sentryManager?: Address;
+    sentries: ResolvedSentry[];
+    warnings: string[];
+};
+
+const isPoolIndex = (index: number) =>
+    index >= SENTRY_POOL_START && index < SENTRY_POOL_START + SENTRY_POOL_SIZE;
+
+const devnetIndexOf = (address: Address): number | undefined =>
+    findMnemonicAccountIndex({
+        address,
+        max: DEVNET_ACCOUNTS,
+        mnemonic: DEVNET_MNEMONIC,
+    });
+
+const sourceOf = (address: Address): SentrySource => {
+    const index = devnetIndexOf(address);
+    if (index === undefined) {
+        return { kind: "external" };
+    }
+    return { kind: isPoolIndex(index) ? "pool" : "devnet", index };
+};
+
+const PRIVATE_KEY_PATTERN = /^(0x)?[0-9a-fA-F]{64}$/;
+
+/**
+ * Reads a sentry's key file: its first line is a 32-byte hex private key, with or without
+ * `0x`, the format the sling node reads. The key is never part of an error.
+ * @param file path as given in the config, relative to the project directory
+ */
+export const readSentryKeyFile = (file: string, where: string): Hex => {
+    let content: string;
+    try {
+        content = fs.readFileSync(path.resolve(file), "utf8");
+    } catch {
+        throw new InvalidPrtConfigError(
+            `private_key_file "${file}" can't be read`,
+            where,
+        );
+    }
+    const [firstLine = ""] = content.split("\n");
+    const key = firstLine.trim();
+    if (!PRIVATE_KEY_PATTERN.test(key)) {
+        throw new InvalidPrtConfigError(
+            `the first line of private_key_file "${file}" must be a hex private key, 64 hex digits with or without 0x`,
+            where,
+        );
+    }
+    return (isHex(key) ? key : `0x${key}`) as Hex;
+};
+
+/**
+ * Resolves an entry that brings its own key: the address is the key's, and must match
+ * `address` when both are set. The devnet accounts' keys are public and derived by the CLI,
+ * so a file holding one is a mistake.
+ */
+const resolveKeyFile = (
+    sentry: PrtSentry,
+    index: number,
+): { address: Address; source: SentrySource } => {
+    const file = sentry.privateKeyFile as string;
+    const where = sentryEntry(index);
+    const { address } = privateKeyToAccount(readSentryKeyFile(file, where));
+    const devnetIndex = devnetIndexOf(address);
+    if (devnetIndex !== undefined) {
+        throw new InvalidPrtConfigError(
+            `private_key_file "${file}" holds the key of devnet account ${devnetIndex}, which the CLI derives itself; drop the file, or set the address instead`,
+            where,
+        );
+    }
+    if (
+        sentry.address !== undefined &&
+        !isAddressEqual(sentry.address, address)
+    ) {
+        throw new InvalidPrtConfigError(
+            `private_key_file "${file}" is the key of ${address}, not ${sentry.address}`,
+            where,
+        );
+    }
+    return { address, source: { kind: "key-file", path: file } };
+};
+
+/**
+ * Gives every [[prt.sentries]] entry its address: the one it names, the one of its key file,
+ * or else the next free account of the sentry pool, in entry order. Pool accounts named by an
+ * entry are skipped, so no two sentries share an address. Needs no chain, so it runs before
+ * anything starts, `--dry-run` included.
+ * @param options.guardian the application's guardian, which a sentry shouldn't share nonces with
+ * @throws InvalidPrtConfigError when the pool runs out, a key file is unusable, or a sentry
+ * the CLI runs is an account the node signs with
+ */
+export const resolveSentries = (
+    prt: PrtOptions,
+    options: { guardian?: Address } = {},
+): ResolvedPrt => {
+    const warnings: string[] = [];
+    const named = new Set(
+        prt.sentries.flatMap(({ address }) =>
+            address === undefined ? [] : [address.toLowerCase()],
+        ),
+    );
+    let next = SENTRY_POOL_START;
+
+    const sentries = prt.sentries.map((sentry, index): ResolvedSentry => {
+        const entry = index + 1;
+        const label = sentryLabel(sentry, index);
+        if (sentry.label !== undefined && sentry.type === undefined) {
+            warnings.push(
+                `${sentryEntry(index)} has a label but no type, so the CLI runs nothing for it and the label names nothing`,
+            );
+        }
+        if (sentry.privateKeyFile !== undefined) {
+            const { address, source } = resolveKeyFile(sentry, index);
+            return { entry, label, address, type: sentry.type, source };
+        }
+        if (sentry.address !== undefined) {
+            const source = sourceOf(sentry.address);
+            if (sentry.type !== undefined && source.kind === "external") {
+                throw new InvalidPrtConfigError(
+                    `the CLI has no key for ${sentry.address}: set private_key_file to run the sentry with it, or drop the type to appoint it only`,
+                    sentryEntry(index),
+                );
+            }
+            return {
+                entry,
+                label,
+                address: sentry.address,
+                type: sentry.type,
+                source,
+                ...(sentry.type !== undefined &&
+                    source.kind !== "external" &&
+                    source.kind !== "key-file" && {
+                        privateKey: getDevnetAccount(source.index).privateKey,
+                    }),
+            };
+        }
+        while (
+            isPoolIndex(next) &&
+            named.has(getDevnetAccount(next).address.toLowerCase())
+        ) {
+            next++;
+        }
+        if (!isPoolIndex(next)) {
+            throw new InvalidPrtConfigError(
+                `needs an address: the sentry pool, devnet accounts ${SENTRY_POOL_START} to ${SENTRY_POOL_START + SENTRY_POOL_SIZE - 1}, is used up`,
+                sentryEntry(index),
+            );
+        }
+        const poolIndex = next++;
+        const { address, privateKey } = getDevnetAccount(poolIndex);
+        return {
+            entry,
+            label,
+            address,
+            type: sentry.type,
+            source: { kind: "pool", index: poolIndex },
+            privateKey,
+        };
+    });
+
+    // a key file's address is known only now
+    sentries.forEach((sentry, index) => {
+        const same = sentries.findIndex(
+            (other, i) =>
+                i < index && isAddressEqual(other.address, sentry.address),
+        );
+        if (same >= 0) {
+            throw new InvalidPrtConfigError(
+                `address ${sentry.address} is also the address of ${sentryEntry(same)}`,
+                sentryEntry(index),
+            );
+        }
+    });
+
+    // a sentry the CLI runs sends its own transactions, so it can't be an account the node
+    // sends from; sharing one with the guardian or the default sender only risks a collision
+    for (const sentry of sentries) {
+        if (sentry.type === undefined || sentry.source.kind === "pool") {
+            continue;
+        }
+        const where = sentryEntry(sentry.entry - 1);
+        if (sentry.source.kind === "devnet") {
+            if (sentry.source.index === NODE_CLAIMER_INDEX) {
+                throw new InvalidPrtConfigError(
+                    `devnet account ${NODE_CLAIMER_INDEX} signs the node's claims, so it can't also run a sentry`,
+                    where,
+                );
+            }
+            if (sentry.source.index === NODE_PRT_INDEX) {
+                throw new InvalidPrtConfigError(
+                    `devnet account ${NODE_PRT_INDEX} signs the node's PRT transactions, so it can't also run a sentry`,
+                    where,
+                );
+            }
+            if (sentry.source.index === DEFAULT_SENDER_INDEX) {
+                warnings.push(
+                    `${where} is devnet account ${DEFAULT_SENDER_INDEX}, the default sender of cartesi send and deposit; their transactions may collide`,
+                );
+            }
+        }
+        if (
+            options.guardian !== undefined &&
+            isAddressEqual(sentry.address, options.guardian)
+        ) {
+            warnings.push(
+                `${where} is the guardian of the application; its transactions may collide with an emergency withdrawal`,
+            );
+        }
+    }
+
+    if (prt.sentryManager !== undefined && sentries.length === 0) {
+        warnings.push(
+            "[prt].sentry_manager is set but there are no [[prt.sentries]]; the manager has no sentries to rotate",
+        );
+    }
+
+    return { sentryManager: prt.sentryManager, sentries, warnings };
+};
+
+/** The sentries the CLI runs a node for. */
+export const runnableSentries = (prt: ResolvedPrt): ResolvedSentry[] =>
+    prt.sentries.filter(({ type }) => type !== undefined);
+
+/**
+ * The chain calls `checkSentries` makes, so it can run against a fake client in tests.
+ */
+export type SentryClient = {
+    getBalance: (args: { address: Address }) => Promise<bigint>;
+    setBalance: (args: { address: Address; value: bigint }) => Promise<void>;
+};
+
+/**
+ * Funds the pool sentries and checks that the other sentries the CLI runs have ETH to send
+ * their claims with. Runs once anvil is healthy, before the deploy, and again before a
+ * redeploy: the balance is set, not added to, so repeating it changes nothing.
+ * @throws when a sentry of the developer's own has no ETH, which the CLI never gives it
+ */
+export const checkSentries = async (
+    client: SentryClient,
+    prt: ResolvedPrt,
+): Promise<void> => {
+    for (const sentry of runnableSentries(prt)) {
+        if (sentry.source.kind === "pool") {
+            await client.setBalance({
+                address: sentry.address,
+                value: SENTRY_FUNDING,
+            });
+            continue;
+        }
+        const balance = await client.getBalance({ address: sentry.address });
+        if (balance === 0n) {
+            throw new Error(
+                `sentry ${sentry.label} ${sentry.address} has no ETH on this devnet; fund it before cartesi run, e.g. with cast rpc anvil_setBalance`,
+            );
+        }
+    }
+};
+
+/**
+ * One line per sentry, with its full address so it can be copied into other tools.
+ */
+export const describeSentry = (sentry: ResolvedSentry): string => {
+    const { source } = sentry;
+    const origin =
+        source.kind === "pool"
+            ? `devnet account ${source.index}, funded by the CLI`
+            : source.kind === "devnet"
+              ? `devnet account ${source.index}`
+              : source.kind === "key-file"
+                ? `key in ${source.path}`
+                : "appointed only";
+    return `sentry ${chalk.cyan(sentry.label)} ${sentry.address} ${chalk.dim(`(${origin})`)}`;
+};
diff --git a/apps/cli/src/validations.ts b/apps/cli/src/validations.ts
index 83770d9a..1fab8cca 100644
--- a/apps/cli/src/validations.ts
+++ b/apps/cli/src/validations.ts
@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import { isIPv6 } from "node:net";
 import {
     createPublicClient,
     http,
@@ -17,6 +19,8 @@ import {
     etherPortalConfig,
     inputBoxConfig,
 } from "./contracts";
+import type { CartesiEnvironmentVariables } from "./base";
+import { nodeSecretFileVariables } from "./compose/node";
 import ForkChainValidationError from "./errors/ForkChainValidationError";
 import UnsupportedForkChainError from "./errors/UnsupportedForkChainError";
 import type { ForkConfig } from "./types/chain";
@@ -284,3 +288,153 @@ export const assertForkConfig = async (
 
     return true;
 };
+
+/**
+ * Asserts that each key file the host names for the node is a readable file,
+ * so a wrong path fails before any container starts. The error names the
+ * variable and the path, never the file's content.
+ */
+export const assertSecretFiles = (env: CartesiEnvironmentVariables) => {
+    for (const name of nodeSecretFileVariables) {
+        const file = env[name];
+        if (file === undefined) {
+            continue;
+        }
+        try {
+            if (!fs.statSync(file).isFile()) {
+                throw new Error("not a file");
+            }
+            fs.accessSync(file, fs.constants.R_OK);
+        } catch {
+            throw new Error(`${name} must name a readable file: "${file}"`);
+        }
+    }
+};
+
+/** Whether every `%` in `value` starts a `%XX` escape. */
+const hasValidEscapes = (value: string): boolean =>
+    !/%(?![0-9A-Fa-f]{2})/.test(value);
+
+/**
+ * Whether `name` is a host name Go's `url.Parse` accepts: no character it
+ * would have to escape, and `%XX` only for non-ASCII bytes or `%25`.
+ */
+const isValidHostName = (name: string): boolean => {
+    for (let i = 0; i < name.length; i++) {
+        const c = name[i];
+        if (c === "%") {
+            const hex = name.slice(i + 1, i + 3);
+            if (!/^[0-9A-Fa-f]{2}$/.test(hex)) {
+                return false;
+            }
+            if (Number.parseInt(hex[0], 16) < 8 && hex !== "25") {
+                return false;
+            }
+            i += 2;
+        } else if (
+            c.charCodeAt(0) < 0x80 &&
+            !/[A-Za-z0-9\-._~!$&'()*+,;="<>[\]]/.test(c)
+        ) {
+            return false;
+        }
+    }
+    return true;
+};
+
+/** Whether `host` (`name[:port]` or `[ipv6][:port]`) has a non-empty name. */
+const isValidHost = (host: string): boolean => {
+    let name: string;
+    let port: string;
+    if (host.startsWith("[")) {
+        const close = host.lastIndexOf("]");
+        if (close < 0) {
+            return false;
+        }
+        name = host.slice(1, close);
+        port = host.slice(close + 1);
+        // an IPv6 zone is escaped as %25, e.g. [fe80::1%25en0]
+        const zoneAt = name.indexOf("%25");
+        const address = zoneAt < 0 ? name : name.slice(0, zoneAt);
+        if (!isIPv6(address) || !hasValidEscapes(name)) {
+            return false;
+        }
+    } else {
+        const colonAt = host.indexOf(":");
+        if (colonAt !== host.lastIndexOf(":")) {
+            return false;
+        }
+        name = colonAt < 0 ? host : host.slice(0, colonAt);
+        port = colonAt < 0 ? "" : host.slice(colonAt);
+        if (!isValidHostName(name)) {
+            return false;
+        }
+    }
+    return name !== "" && /^(:[0-9]*)?$/.test(port);
+};
+
+/**
+ * Whether `raw` is an endpoint the rollups-node accepts: Go's `url.Parse`
+ * succeeds on it, its scheme is http or https and it has a host name. Mirrors
+ * Go rather than WHATWG `URL`, which accepts and rejects other URLs.
+ */
+export const isValidHttpEndpoint = (raw: string): boolean => {
+    // Go rejects control characters; surrounding whitespace is a mistake
+    const isControl = (c: string) => c < " " || c === "\x7f";
+    if (raw !== raw.trim() || [...raw].some(isControl)) {
+        return false;
+    }
+    const scheme = /^([A-Za-z][A-Za-z0-9+.-]*):/.exec(raw);
+    if (!scheme || !["http", "https"].includes(scheme[1].toLowerCase())) {
+        return false;
+    }
+    let rest = raw.slice(scheme[0].length);
+
+    // Go checks the escapes of the fragment, but not the query
+    const hashAt = rest.indexOf("#");
+    if (hashAt >= 0) {
+        if (!hasValidEscapes(rest.slice(hashAt + 1))) {
+            return false;
+        }
+        rest = rest.slice(0, hashAt);
+    }
+    const queryAt = rest.indexOf("?");
+    if (queryAt >= 0) {
+        rest = rest.slice(0, queryAt);
+    }
+
+    // without //, the URL has no authority and so no host
+    if (!rest.startsWith("//")) {
+        return false;
+    }
+    rest = rest.slice(2);
+    const slashAt = rest.indexOf("/");
+    const authority = slashAt < 0 ? rest : rest.slice(0, slashAt);
+    const path = slashAt < 0 ? "" : rest.slice(slashAt);
+    if (!hasValidEscapes(path)) {
+        return false;
+    }
+
+    const atAt = authority.lastIndexOf("@");
+    const userinfo = atAt < 0 ? "" : authority.slice(0, atAt);
+    if (
+        !/^[A-Za-z0-9\-._:~!$&'()*+,;=%@]*$/.test(userinfo) ||
+        !hasValidEscapes(userinfo)
+    ) {
+        return false;
+    }
+    return isValidHost(authority.slice(atAt + 1));
+};
+
+/**
+ * Asserts that a blockchain endpoint set on the host is one the rollups-node
+ * accepts, so a wrong one fails before any container starts. The error never
+ * shows the value, which may hold credentials.
+ */
+export const assertBlockchainEndpoint = (env: CartesiEnvironmentVariables) => {
+    const endpoint = env.CARTESI_BLOCKCHAIN_HTTP_ENDPOINT;
+    if (endpoint !== undefined && !isValidHttpEndpoint(endpoint)) {
+        throw new Error(
+            "CARTESI_BLOCKCHAIN_HTTP_ENDPOINT must be an http(s) URL with a DNS name or IP address (redirects are not followed)",
+        );
+    }
+};
diff --git a/apps/cli/src/wallet.ts b/apps/cli/src/wallet.ts
index 595df6b4..6f4977b8 100644
--- a/apps/cli/src/wallet.ts
+++ b/apps/cli/src/wallet.ts
@@ -3,14 +3,17 @@ import {
     type Address,
     createTestClient,
     defineChain,
+    type Hex,
     http,
     isAddressEqual,
     publicActions,
+    toHex,
     walletActions,
 } from "viem";
 import { mnemonicToAccount } from "viem/accounts";
 import { anvil } from "viem/chains";
 import { getProjectName } from "./base.js";
+import { DEVNET_MNEMONIC } from "./compose/node.js";
 import { PREFERRED_PORT } from "./config.js";
 import { getProjectPort } from "./exec/rollups.js";
 
@@ -78,3 +81,55 @@ export const findMnemonicAccountIndex = (options: {
     }
     return undefined;
 };
+
+/**
+ * How many accounts the CLI derives from the devnet mnemonic: the 10 anvil
+ * funds and unlocks, and the ones after them, up to the sentry pool's last.
+ */
+export const DEVNET_ACCOUNTS = 30;
+
+/**
+ * Returns a devnet account by its index in the mnemonic, with the key the
+ * CLI signs with on its behalf. The mnemonic is public, so the key is too.
+ */
+export const getDevnetAccount = (
+    index: number,
+): { address: Address; privateKey: Hex } => {
+    if (!Number.isInteger(index) || index < 0 || index >= DEVNET_ACCOUNTS) {
+        throw new Error(
+            `There is no devnet account ${index}, the CLI derives accounts 0 to ${DEVNET_ACCOUNTS - 1}`,
+        );
+    }
+    const account = mnemonicToAccount(DEVNET_MNEMONIC, {
+        addressIndex: index,
+    });
+    const privateKey = account.getHdKey().privateKey;
+    if (!privateKey) {
+        throw new Error(`Devnet account ${index} has no private key`);
+    }
+    return { address: account.address, privateKey: toHex(privateKey) };
+};
+
+/**
+ * Index of the devnet account that sends inputs and deposits when no `--from`
+ * is given. The node signs its claims with account 0 and the CLI uses account
+ * 1 as the guardian, so a sender of its own shares no nonces with either.
+ */
+export const DEFAULT_SENDER_INDEX = 8;
+
+/**
+ * Returns the default sender among the accounts the RPC exposes.
+ * @throws if the RPC exposes too few accounts
+ */
+export const getDefaultSender = async (client: {
+    getAddresses: () => Promise<readonly Address[]>;
+}): Promise<Address> => {
+    const addresses = await client.getAddresses();
+    const sender = addresses[DEFAULT_SENDER_INDEX];
+    if (sender === undefined) {
+        throw new Error(
+            `The RPC exposes ${addresses.length} accounts, so there is no devnet account ${DEFAULT_SENDER_INDEX} to send from; pass --from to choose the sender`,
+        );
+    }
+    return sender;
+};
diff --git a/apps/cli/tests/integration/commands/fixtures/accounts-withdrawal-layouts.ts b/apps/cli/tests/integration/commands/fixtures/accounts-withdrawal-layouts.ts
index 4b39f691..e05b8581 100644
--- a/apps/cli/tests/integration/commands/fixtures/accounts-withdrawal-layouts.ts
+++ b/apps/cli/tests/integration/commands/fixtures/accounts-withdrawal-layouts.ts
@@ -21,9 +21,6 @@ export type Layout = {
         at: number; // offset of data, the rest is zeros
         data: Buffer;
     };
-    // TODO: the machine-tool of rollups-node v2.0.0-alpha.13 only looks for the
-    // accounts drive among the flash drives, unskip once it finds nvrams too
-    skip?: boolean;
 };
 
 const scratchDrive = `
@@ -76,7 +73,6 @@ accounts_drive = true
 `,
         label: "accounts",
         device: "/dev/uio0",
-        skip: true,
     },
     {
         name: "the beginning of a larger nvram",
@@ -96,7 +92,6 @@ accounts_drive_size = "4Mi"
         label: "state",
         device: "/dev/uio1",
         accountsSize: 4 * MiB,
-        skip: true,
     },
     {
         // like a DEX, which memory-maps its state after the accounts, from an image
@@ -118,6 +113,5 @@ accounts_drive_size = "4Mi"
             at: 4 * MiB,
             data: Buffer.alloc(8 * MiB, 0xab),
         },
-        skip: true,
     },
 ];
diff --git a/apps/cli/tests/integration/commands/fixtures/accounts-withdrawal/dapp.sh b/apps/cli/tests/integration/commands/fixtures/accounts-withdrawal/dapp.sh
index fd7c9b5b..aaa2e5f6 100755
--- a/apps/cli/tests/integration/commands/fixtures/accounts-withdrawal/dapp.sh
+++ b/apps/cli/tests/integration/commands/fixtures/accounts-withdrawal/dapp.sh
@@ -106,8 +106,8 @@ handle_erc20_deposit() {
   [[ "$token" == "$trusted_token" ]] || return 1
   [[ "${amount_hex:0:49}" =~ ^0{48}[0-7]$ ]] || return 1
 
+  # a zero deposit opens an account with no balance, as one emptied by a debit would be
   amount="$(uint64_be_to_dec "${amount_hex:48:16}")"
-  (( amount > 0 )) || return 1
   credit_account "$sender" "$amount"
 }
 
diff --git a/apps/cli/tests/integration/commands/prt.test.ts b/apps/cli/tests/integration/commands/prt.test.ts
new file mode 100644
index 00000000..4d51a99e
--- /dev/null
+++ b/apps/cli/tests/integration/commands/prt.test.ts
@@ -0,0 +1,279 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { execa, type ResultPromise } from "execa";
+import fs from "fs-extra";
+import os from "node:os";
+import path from "node:path";
+import { type Address, parseEther } from "viem";
+import { erc20PortalAddress, testUsdcAddress } from "../../../src/contracts";
+import {
+    getDaveConsensus,
+    getLastAcceptedEpoch,
+} from "../../../src/exec/rollups";
+import { SENTRY_FUNDING } from "../../../src/sentries";
+import { TEST_SDK } from "../config";
+import {
+    type AnvilClient,
+    buildApplication,
+    createAnvilClient,
+    deposit,
+    devnetAccount,
+    runCli,
+    startApplication,
+    stopApplication,
+    TIMEOUT,
+    waitFor,
+} from "../devnet";
+
+/**
+ * Covers `cartesi run --prt` with sentries from [prt]: the application is
+ * deployed on a DaveConsensus with the sentries and the manager the config
+ * names, in order; the CLI funds the pool sentries and runs a sling node for
+ * each; and a claim they agree with is accepted without waiting out the
+ * staging period.
+ */
+
+const EPOCH_LENGTH = 10;
+
+// long enough that acceptance within the test can only come from the sentries
+const CLAIM_STAGING_PERIOD = 1_000_000;
+
+// a lone claim wins its root tournament by timeout after about 700 blocks on
+// the devnet clock; two epochs fit well within this
+const MAX_BLOCKS = 4_000;
+const BLOCKS_PER_STEP = 25;
+
+const fixture = path.join(__dirname, "fixtures", "accounts-withdrawal");
+const projectName = `prt-${process.pid}`;
+
+const sentryManager = devnetAccount(5);
+const sentryServices = ["sentry-1", "sentry-2"];
+
+const sentryLogs = async () => {
+    const { all } = await execa(
+        "docker",
+        [
+            "compose",
+            "-p",
+            projectName,
+            "logs",
+            "--tail",
+            "40",
+            ...sentryServices,
+        ],
+        { all: true, reject: false },
+    );
+    return all;
+};
+
+describe("prt", () => {
+    let appDir: string;
+    let cleanup: () => void;
+    let run: ResultPromise | undefined;
+    let application: Address;
+    let output: () => string;
+    let anvil: AnvilClient;
+
+    beforeAll(async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "prt-"));
+        cleanup = () => fs.removeSync(dir);
+        appDir = path.join(dir, "accounts-withdrawal");
+        await fs.copy(fixture, appDir);
+        await fs.writeFile(
+            path.join(appDir, "cartesi.toml"),
+            `sdk = "${TEST_SDK}"
+
+[machine.env]
+TRUSTED_ERC20_PORTAL = "${erc20PortalAddress}"
+TRUSTED_ERC20_TOKEN = "${testUsdcAddress}"
+ACCOUNTS_LABEL = "accounts"
+
+[drives.accounts]
+builder = "empty"
+format = "raw"
+size = "4MB"
+mount = false
+user = "dapp"
+accounts_drive = true
+
+[prt]
+sentry_manager = "${sentryManager}"
+
+[[prt.sentries]]
+type = "sling"
+
+[[prt.sentries]]
+type = "sling"
+`,
+        );
+
+        console.log("! Building the accounts-withdrawal application...");
+        const build = await buildApplication(appDir);
+        expect(build.exitCode, build.all).toBe(0);
+        console.log("✓ Built the accounts-withdrawal application");
+
+        ({ application, output, run } = await startApplication({
+            appDir,
+            epochLength: EPOCH_LENGTH,
+            extraArgs: [
+                "--prt",
+                "--claim-staging-period",
+                CLAIM_STAGING_PERIOD.toString(),
+            ],
+            projectName,
+        }));
+        anvil = await createAnvilClient(projectName);
+
+        // the sentries start after the deploy, which is what startApplication waits for
+        console.log("! Waiting for the sentries to start...");
+        await waitFor(async () => {
+            if (!output().includes("(devnet account 21, funded by the CLI)")) {
+                throw new Error("sentries not started yet");
+            }
+        });
+        console.log("✓ Sentries started");
+    }, TIMEOUT);
+
+    afterAll(() => stopApplication({ cleanup, projectName, run }), TIMEOUT);
+
+    it(
+        "should appoint the sentries of [prt] on the consensus, in order",
+        async () => {
+            const consensus = await getDaveConsensus({
+                application,
+                projectName,
+            });
+
+            expect(consensus.sentryManager).toBe(sentryManager);
+            expect(consensus.claimStagingPeriod).toBe(CLAIM_STAGING_PERIOD);
+            expect(consensus.sentries).toEqual([
+                { id: 1, address: devnetAccount(20) },
+                { id: 2, address: devnetAccount(21) },
+            ]);
+        },
+        TIMEOUT,
+    );
+
+    it(
+        "should run a sling node for each sentry, on a funded pool account",
+        async () => {
+            // the sentries are up only once the application is deployed
+            const { stdout } = await execa("docker", [
+                "compose",
+                "-p",
+                projectName,
+                "ps",
+                "--services",
+                "--status",
+                "running",
+            ]);
+            expect(stdout.split("\n")).toEqual(
+                expect.arrayContaining(sentryServices),
+            );
+
+            // set by the CLI, less the gas the sentries spent since
+            for (const index of [20, 21]) {
+                const balance = await anvil.getBalance({
+                    address: devnetAccount(index),
+                });
+                expect(balance).toBeGreaterThan(
+                    SENTRY_FUNDING - parseEther("1"),
+                );
+                expect(balance).toBeLessThanOrEqual(SENTRY_FUNDING);
+            }
+        },
+        TIMEOUT,
+    );
+
+    // printed once the sentries run, after the deploy; the check mark before
+    // each line is the terminal's, so the lines are matched without it
+    it("should print the manager and each sentry with its devnet account", () => {
+        const printed = output();
+        const deployed = printed.indexOf("contract deployed at");
+
+        expect(deployed).toBeGreaterThan(-1);
+        expect(
+            printed.indexOf(`sentry manager ${sentryManager}`),
+        ).toBeGreaterThan(deployed);
+        expect(printed).toContain(
+            `sentry 1 ${devnetAccount(20)} (devnet account 20, funded by the CLI)`,
+        );
+        expect(printed).toContain(
+            `sentry 2 ${devnetAccount(21)} (devnet account 21, funded by the CLI)`,
+        );
+    });
+
+    // the shell's View logs runs `cartesi logs --follow`, so the sentries
+    // must show there, next to the node
+    it("should show the node and the sentries in cartesi logs", async () => {
+        const { all, exitCode } = await runCli({ appDir, projectName }, [
+            "logs",
+            "--tail",
+            "5",
+        ]);
+
+        expect(exitCode).toBe(0);
+        expect(all).toContain("rollups_node-1");
+        expect(all).toContain("sentry-1-1");
+        expect(all).toContain("sentry-2-1");
+    });
+
+    it("should show one service named, without a prefix", async () => {
+        const { all, exitCode } = await runCli({ appDir, projectName }, [
+            "logs",
+            "--tail",
+            "5",
+            "sentry-1",
+        ]);
+
+        expect(exitCode).toBe(0);
+        expect(all?.trim().length).toBeGreaterThan(0);
+        expect(all).not.toContain("sentry-1-1");
+    });
+
+    it("should reject a service the environment doesn't have", async () => {
+        const { all, exitCode } = await runCli({ appDir, projectName }, [
+            "logs",
+            "sentry-3",
+        ]);
+
+        expect(exitCode).not.toBe(0);
+        expect(all).toContain("service sentry-3 not found");
+    });
+
+    // with the staging period out of reach, the node accepts a staged claim
+    // only when every sentry claimed the same result
+    it(
+        "should accept a claim the sentries agree with, within the staging period",
+        async () => {
+            await deposit(anvil, application, devnetAccount(2), 1000n);
+            const start = await anvil.getBlockNumber();
+
+            let accepted: Awaited<ReturnType<typeof getLastAcceptedEpoch>>;
+            let mined = 0;
+            while (mined < MAX_BLOCKS) {
+                await anvil.mine({ blocks: BLOCKS_PER_STEP });
+                mined += BLOCKS_PER_STEP;
+                accepted = await getLastAcceptedEpoch({
+                    application,
+                    projectName,
+                });
+                if (accepted) {
+                    break;
+                }
+                // let the node and the sentries see the blocks
+                await new Promise((resolve) => setTimeout(resolve, 500));
+            }
+            const consensus = await getDaveConsensus({
+                application,
+                projectName,
+            });
+            console.log(
+                `! Accepted epoch ${accepted?.index} after ${mined} mined blocks, from block ${start}; all sentries agree: ${consensus.allSentriesAgree}`,
+            );
+
+            expect(accepted, await sentryLogs()).toBeDefined();
+            expect(mined).toBeLessThan(CLAIM_STAGING_PERIOD);
+        },
+        TIMEOUT,
+    );
+});
diff --git a/apps/cli/tests/integration/commands/recovery.test.ts b/apps/cli/tests/integration/commands/recovery.test.ts
index 2ffb6158..9c1b634f 100644
--- a/apps/cli/tests/integration/commands/recovery.test.ts
+++ b/apps/cli/tests/integration/commands/recovery.test.ts
@@ -42,8 +42,10 @@ import {
  * The runtime must ship a rollups node with the refund command, as the
  * default SDK does.
  *
- * Inputs: alice (0), bob (1) and erin (2) are finalized in epoch 0; carol (3)
- * and dave (4) stay in the open epoch 1 and are refunded.
+ * Inputs: alice (0), bob (1), erin (2) and frank (3) are finalized in epoch 0;
+ * carol (4) and dave (5) stay in the open epoch 1 and are refunded. frank
+ * deposits nothing, leaving an account with no balance in the drive, which
+ * must not stop the other accounts from being proven.
  */
 
 const EPOCH_LENGTH = 720;
@@ -56,13 +58,21 @@ const bob = devnetAccount(2);
 const carol = devnetAccount(3);
 const dave = devnetAccount(4);
 const erin = devnetAccount(5);
+const frank = devnetAccount(6);
 
 // the guardian comes from a mnemonic the node doesn't sign with
 const guardianMnemonic =
     "legal winner thank year wave sausage worth useful legal winner thank yellow";
 const guardian = mnemonicToAccount(guardianMnemonic).address;
 
-const amounts = { alice: 100n, bob: 50n, carol: 25n, dave: 15n, erin: 10n };
+const amounts = {
+    alice: 100n,
+    bob: 50n,
+    carol: 25n,
+    dave: 15n,
+    erin: 10n,
+    frank: 0n,
+};
 
 const count = (text: string, part: string) => text.split(part).length - 1;
 
@@ -177,6 +187,7 @@ guardian = "${guardian}"
             await deposit(alice, amounts.alice);
             await deposit(bob, amounts.bob);
             await deposit(erin, amounts.erin);
+            await deposit(frank, amounts.frank);
 
             // close the first epoch and wait for its claim to be accepted
             await anvil.mine({ blocks: EPOCH_LENGTH });
@@ -193,7 +204,7 @@ guardian = "${guardian}"
             await deposit(carol, amounts.carol);
             await deposit(dave, amounts.dave);
             await waitFor(() =>
-                getNodeInput({ application, inputIndex: 4n, projectName }),
+                getNodeInput({ application, inputIndex: 5n, projectName }),
             );
         },
         TIMEOUT,
@@ -203,7 +214,7 @@ guardian = "${guardian}"
         it(
             "should pass the node's NotForeclosed error through on refund",
             async () => {
-                const refund = await cli(["refund", "3", "--yes"]);
+                const refund = await cli(["refund", "4", "--yes"]);
                 expect(refund.exitCode).not.toBe(0);
                 expect(refund.all).toContain("NotForeclosed");
             },
@@ -273,10 +284,10 @@ guardian = "${guardian}"
             "should refund a deposit that was not finalized",
             async () => {
                 expect(await usdcBalance(carol)).toBe(0n);
-                const refund = await cli(["refund", "3", "--yes", "--json"]);
+                const refund = await cli(["refund", "4", "--yes", "--json"]);
                 expect(refund.exitCode, refund.all).toBe(0);
                 expect(JSON.parse(refund.stdout)).toMatchObject({
-                    input_index: "3",
+                    input_index: "4",
                 });
                 expect(await usdcBalance(carol)).toBe(amounts.carol);
             },
@@ -288,7 +299,7 @@ guardian = "${guardian}"
             async () => {
                 const rawData = await getNodeInput({
                     application,
-                    inputIndex: 4n,
+                    inputIndex: 5n,
                     projectName,
                 });
                 const inputFile = path.join(appDir, "dave-input.hex");
@@ -296,7 +307,7 @@ guardian = "${guardian}"
                 expect(await usdcBalance(dave)).toBe(0n);
                 const refund = await cli([
                     "refund",
-                    "4",
+                    "5",
                     "--input-file",
                     inputFile,
                     "--yes",
diff --git a/apps/cli/tests/integration/commands/run.test.ts b/apps/cli/tests/integration/commands/run.test.ts
new file mode 100644
index 00000000..0ec28d48
--- /dev/null
+++ b/apps/cli/tests/integration/commands/run.test.ts
@@ -0,0 +1,218 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { execa } from "execa";
+import fs from "fs-extra";
+import os from "node:os";
+import path from "node:path";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { TEST_RUNTIME_VERSION } from "../config";
+import { cliPath } from "../devnet";
+
+/**
+ * Covers what `cartesi run` checks before it starts anything. A dry run only
+ * renders the compose configuration, so no environment is started and no
+ * application needs to be built.
+ */
+describe("run", () => {
+    let dir: string;
+
+    beforeAll(() => {
+        dir = fs.mkdtempSync(path.join(os.tmpdir(), "run-"));
+    });
+
+    afterAll(() => fs.removeSync(dir));
+
+    const dryRun = (args: string[], env?: Record<string, string>) =>
+        execa(
+            "node",
+            [
+                cliPath,
+                "run",
+                "--dry-run",
+                "--runtime-version",
+                TEST_RUNTIME_VERSION,
+                ...args,
+            ],
+            { all: true, cwd: dir, env, reject: false },
+        );
+
+    describe("--default-block", () => {
+        it("should pass a supported default block to the node", async () => {
+            const { all, exitCode } = await dryRun(["--default-block", "safe"]);
+
+            expect(exitCode, all).toBe(0);
+            expect(all).toContain("CARTESI_BLOCKCHAIN_DEFAULT_BLOCK: safe");
+        });
+
+        // the node refuses to start with 'pending', so the CLI rejects it
+        // before rendering anything
+        it("should reject pending before rendering the configuration", async () => {
+            const { all, exitCode } = await dryRun([
+                "--default-block",
+                "pending",
+            ]);
+
+            expect(exitCode).not.toBe(0);
+            expect(all).toContain(
+                "Allowed choices are latest, safe, finalized",
+            );
+            expect(all).not.toContain("CARTESI_BLOCKCHAIN_DEFAULT_BLOCK");
+        });
+    });
+
+    describe("host variables", () => {
+        // compose prints the value it would pass as `$$`, the way it reads it
+        // back; unescaped, it would have replaced `$t` with nothing
+        it("should keep the $ in a forwarded node variable", async () => {
+            const { all, exitCode } = await dryRun([], {
+                CARTESI_BLOCKCHAIN_HTTP_AUTHORIZATION: "Bearer s3cr$t",
+            });
+
+            expect(exitCode, all).toBe(0);
+            expect(all).toContain(
+                "CARTESI_BLOCKCHAIN_HTTP_AUTHORIZATION: Bearer s3cr$$t",
+            );
+        });
+    });
+
+    describe("key files", () => {
+        it("should hand the node a copy of a key file named on the host", async () => {
+            fs.writeFileSync(path.join(dir, "claimer.key"), "0xsecret\n");
+
+            const { all, exitCode } = await dryRun([], {
+                CARTESI_AUTH_PRIVATE_KEY_FILE: "claimer.key",
+            });
+
+            expect(exitCode, all).toBe(0);
+            expect(all).toContain(
+                "CARTESI_AUTH_PRIVATE_KEY_FILE: /run/secrets/cartesi_auth_private_key_file",
+            );
+            expect(all).toContain("node-secret-init:");
+            expect(all).toContain("condition: service_completed_successfully");
+            expect(all).toContain(path.join(dir, "claimer.key"));
+            expect(all).not.toContain("0xsecret");
+        });
+
+        it("should reject a missing key file before rendering", async () => {
+            const { all, exitCode } = await dryRun([], {
+                CARTESI_AUTH_PRIVATE_KEY_FILE: "missing.key",
+            });
+
+            expect(exitCode).not.toBe(0);
+            expect(all).toContain(
+                'CARTESI_AUTH_PRIVATE_KEY_FILE must name a readable file: "missing.key"',
+            );
+            expect(all).not.toContain("services:");
+        });
+    });
+
+    describe("[prt]", () => {
+        const sentries = `
+[prt]
+sentry_manager = "0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc"
+
+[[prt.sentries]]
+type = "sling"
+
+[[prt.sentries]]
+type = "sling"
+`;
+        const config = (prt: string) => {
+            const file = path.join(dir, "prt.toml");
+            fs.writeFileSync(file, prt);
+            return ["--config", file];
+        };
+
+        // the section is read even without --prt, so a mistake fails early
+        it("should reject a duplicate sentry before rendering", async () => {
+            const { all, exitCode } = await dryRun([
+                "--prt",
+                ...config(`${sentries}
+[[prt.sentries]]
+address = "0x70997970C51812dc3A010C7d01b50e0d17dc79C8"
+
+[[prt.sentries]]
+address = "0x70997970c51812dc3a010c7d01b50e0d17dc79c8"
+`),
+            ]);
+
+            expect(exitCode).not.toBe(0);
+            expect(all).toContain("prt.sentries[4]");
+            expect(all).toContain("is also the address of prt.sentries[3]");
+            expect(all).not.toContain("services:");
+        });
+
+        it("should ignore the section without --prt", async () => {
+            const { all, exitCode } = await dryRun(config(sentries));
+
+            expect(exitCode, all).toBe(0);
+            expect(all).toContain(
+                "[prt] in cartesi.toml is ignored without --prt",
+            );
+            expect(all).toContain("services:");
+        });
+
+        it("should render the configuration with --prt and sentries", async () => {
+            const { all, exitCode } = await dryRun([
+                "--prt",
+                ...config(sentries),
+            ]);
+
+            expect(exitCode, all).toBe(0);
+            expect(all).not.toContain("ignored without --prt");
+            expect(all).toContain("services:");
+        });
+
+        // a key file is read before anything starts, and never printed
+        it("should reject a key file that doesn't match the address, before rendering", async () => {
+            const named = privateKeyToAccount(generatePrivateKey());
+            const fileKey = generatePrivateKey();
+            const keyFile = path.join(dir, "sentry.key");
+            fs.writeFileSync(keyFile, `${fileKey}\n`);
+
+            const { all, exitCode } = await dryRun([
+                "--prt",
+                ...config(`
+[[prt.sentries]]
+type = "sling"
+address = "${named.address}"
+private_key_file = "${keyFile}"
+`),
+            ]);
+
+            expect(exitCode).not.toBe(0);
+            expect(all).toContain(
+                `private_key_file "${keyFile}" is the key of ${privateKeyToAccount(fileKey).address}, not ${named.address}`,
+            );
+            expect(all).not.toContain(fileKey.slice(2));
+            expect(all).not.toContain("services:");
+        });
+    });
+
+    describe("CARTESI_BLOCKCHAIN_HTTP_ENDPOINT", () => {
+        it("should forward a supported endpoint to the node", async () => {
+            const { all, exitCode } = await dryRun([], {
+                CARTESI_BLOCKCHAIN_HTTP_ENDPOINT: "https://rpc.example.com/v1",
+            });
+
+            expect(exitCode, all).toBe(0);
+            expect(all).toContain(
+                "CARTESI_BLOCKCHAIN_HTTP_ENDPOINT: https://rpc.example.com/v1",
+            );
+        });
+
+        // the node only fails once its container starts, and hides the value
+        it("should reject an unsupported endpoint without showing it", async () => {
+            const { all, exitCode } = await dryRun([], {
+                CARTESI_BLOCKCHAIN_HTTP_ENDPOINT:
+                    "wss://rpc.example.com/SECRET",
+            });
+
+            expect(exitCode).not.toBe(0);
+            expect(all).toContain(
+                "CARTESI_BLOCKCHAIN_HTTP_ENDPOINT must be an http(s) URL",
+            );
+            expect(all).not.toContain("SECRET");
+            expect(all).not.toContain("services:");
+        });
+    });
+});
diff --git a/apps/cli/tests/integration/commands/send.test.ts b/apps/cli/tests/integration/commands/send.test.ts
new file mode 100644
index 00000000..c2a1c361
--- /dev/null
+++ b/apps/cli/tests/integration/commands/send.test.ts
@@ -0,0 +1,142 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import getPort, { portNumbers } from "get-port";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+    type Address,
+    decodeFunctionData,
+    numberToHex,
+    zeroAddress,
+    zeroHash,
+} from "viem";
+import {
+    inputBoxAbi,
+    inputBoxAddress,
+    inputsAbi,
+    selfHostedApplicationFactoryAbi,
+    selfHostedApplicationFactoryAddress,
+} from "../../../src/contracts";
+import {
+    startEnvironment,
+    stopEnvironment,
+    waitHealthyEnvironment,
+} from "../../../src/exec/rollups";
+import { TEST_RUNTIME_VERSION } from "../config";
+import { createAnvilClient, devnetAccount, runCli } from "../devnet";
+
+// The InputBox only takes inputs for an application contract, but the node
+// doesn't need to run it: each case creates one with the factory, with no
+// machine behind it, and reads the sender back from the input the InputBox
+// recorded.
+describe("send", () => {
+    const projectName = `cli-send-${process.pid}`;
+    let directory: string;
+    let originalCwd: string;
+
+    beforeAll(async () => {
+        originalCwd = process.cwd();
+        directory = fs.mkdtempSync(path.join(os.tmpdir(), "send-"));
+        // compose files are written relative to the working directory
+        process.chdir(directory);
+        const port = await getPort({ port: portNumbers(16762, 16772) });
+        await startEnvironment({
+            blockTime: 1,
+            defaultBlock: "latest",
+            detach: true,
+            dryRun: false,
+            port,
+            projectName,
+            runtimeVersion: TEST_RUNTIME_VERSION,
+            services: [],
+            verbose: false,
+        });
+        await waitHealthyEnvironment({ port, projectName, services: [] });
+    }, 300_000);
+
+    afterAll(async () => {
+        try {
+            await stopEnvironment({ projectName });
+        } finally {
+            process.chdir(originalCwd);
+            fs.rmSync(directory, { recursive: true, force: true });
+        }
+    });
+
+    /** Creates an application contract the node doesn't know of. */
+    const createApplication = async (salt: number) => {
+        const anvil = await createAnvilClient(projectName);
+        const owner = devnetAccount(3);
+        const { request, result } = await anvil.simulateContract({
+            abi: selfHostedApplicationFactoryAbi,
+            account: owner,
+            address: selfHostedApplicationFactoryAddress,
+            args: [
+                owner,
+                720n,
+                0n,
+                zeroHash,
+                inputBoxAddress,
+                {
+                    guardian: zeroAddress,
+                    log2LeavesPerAccount: 0,
+                    log2MaxNumOfAccounts: 0,
+                    accountsDriveStartIndex: 0n,
+                    withdrawalOutputBuilder: zeroAddress,
+                },
+                numberToHex(salt, { size: 32 }),
+            ],
+            functionName: "deployContracts",
+        });
+        const hash = await anvil.writeContract(request);
+        await anvil.waitForTransactionReceipt({ hash });
+        return result[0];
+    };
+
+    /** Sends an input with the CLI and returns its sender. */
+    const sendInput = async (application: Address, args: string[] = []) => {
+        const { all, exitCode } = await runCli(
+            { appDir: directory, projectName },
+            [
+                "send",
+                "--application",
+                application,
+                "--encoding",
+                "string",
+                ...args,
+                "hello",
+            ],
+        );
+        expect(exitCode, all).toBe(0);
+
+        const anvil = await createAnvilClient(projectName);
+        const events = await anvil.getContractEvents({
+            abi: inputBoxAbi,
+            address: inputBoxAddress,
+            args: { appContract: application },
+            eventName: "InputAdded",
+            fromBlock: 0n,
+        });
+        expect(events).toHaveLength(1);
+        const { args: input } = decodeFunctionData({
+            abi: inputsAbi,
+            data: events[0].args.input ?? "0x",
+        });
+        return input[2];
+    };
+
+    // the node signs its claims with account 0, so inputs must not come from it
+    it("should send from devnet account 8 by default", async () => {
+        const application = await createApplication(1);
+
+        expect(await sendInput(application)).toBe(devnetAccount(8));
+    });
+
+    it("should send from the --from account", async () => {
+        const application = await createApplication(2);
+
+        expect(await sendInput(application, ["--from", devnetAccount(2)])).toBe(
+            devnetAccount(2),
+        );
+    });
+});
diff --git a/apps/cli/tests/integration/commands/undeploy.test.ts b/apps/cli/tests/integration/commands/undeploy.test.ts
new file mode 100644
index 00000000..6c4a08f3
--- /dev/null
+++ b/apps/cli/tests/integration/commands/undeploy.test.ts
@@ -0,0 +1,141 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import type { ResultPromise } from "execa";
+import fs from "fs-extra";
+import os from "node:os";
+import path from "node:path";
+import { erc20PortalAddress, testUsdcAddress } from "../../../src/contracts";
+import { type Address, numberToHex } from "viem";
+import {
+    deployApplication,
+    getDeployments,
+    removeApplication,
+} from "../../../src/exec/rollups";
+import { TEST_SDK } from "../config";
+import {
+    buildApplication,
+    startApplication,
+    stopApplication,
+    TIMEOUT,
+} from "../devnet";
+
+/**
+ * Covers the undeploy and the redeploy `cartesi run` does for a rebuilt
+ * application. The shell that rebuilds needs a terminal, so both are called
+ * the way the shell calls them, against an application of its own.
+ */
+
+const EPOCH_LENGTH = 720;
+
+const fixture = path.join(__dirname, "fixtures", "accounts-withdrawal");
+const projectName = `undeploy-${process.pid}`;
+
+describe("undeploy", () => {
+    let appDir: string;
+    let cleanup: () => void;
+    let run: ResultPromise | undefined;
+    let consensus: Address | undefined;
+
+    beforeAll(async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "undeploy-"));
+        cleanup = () => fs.removeSync(dir);
+        appDir = path.join(dir, "accounts-withdrawal");
+        await fs.copy(fixture, appDir);
+        await fs.writeFile(
+            path.join(appDir, "cartesi.toml"),
+            `sdk = "${TEST_SDK}"
+
+[machine.env]
+TRUSTED_ERC20_PORTAL = "${erc20PortalAddress}"
+TRUSTED_ERC20_TOKEN = "${testUsdcAddress}"
+ACCOUNTS_LABEL = "accounts"
+
+[drives.accounts]
+builder = "empty"
+format = "raw"
+size = "4MB"
+mount = false
+user = "dapp"
+accounts_drive = true
+`,
+        );
+
+        console.log("! Building the accounts-withdrawal application...");
+        const build = await buildApplication(appDir);
+        expect(build.exitCode, build.all).toBe(0);
+        console.log("✓ Built the accounts-withdrawal application");
+
+        ({ run } = await startApplication({
+            appDir,
+            epochLength: EPOCH_LENGTH,
+            projectName,
+        }));
+
+        // read before any case removes the application
+        const deployments = await getDeployments({ projectName });
+        consensus = deployments.find(
+            ({ name }) => name === projectName,
+        )?.consensus;
+    }, TIMEOUT);
+
+    afterAll(() => stopApplication({ cleanup, projectName, run }), TIMEOUT);
+
+    // the node refuses to remove an application unless the removal
+    // acknowledges the work it abandons
+    it(
+        "should remove the deployed application",
+        async () => {
+            await removeApplication({
+                application: projectName,
+                force: true,
+                projectName,
+            });
+
+            const deployments = await getDeployments({ projectName });
+            expect(deployments.map(({ name }) => name)).not.toContain(
+                projectName,
+            );
+        },
+        TIMEOUT,
+    );
+
+    // the shell redeploys a rebuilt machine on the consensus of the first
+    // deploy, which the node does through the application factory
+    it(
+        "should deploy an application on an existing consensus",
+        async () => {
+            expect(consensus).toBeDefined();
+            const name = `${projectName}-redeploy`;
+
+            const deployment = await deployApplication({
+                claimStagingPeriod: 0,
+                consensus,
+                epochLength: EPOCH_LENGTH,
+                name,
+                projectName,
+                salt: numberToHex(1, { size: 32 }),
+                snapshotPath: "/var/lib/cartesi-rollups-node/snapshots/image",
+            });
+
+            expect(deployment.consensus).toBe(consensus as Address);
+            const deployments = await getDeployments({ projectName });
+            expect(deployments.map(({ name }) => name)).toContain(name);
+        },
+        TIMEOUT,
+    );
+
+    // a failed removal must reach the caller, or a rebuild would deploy over
+    // an application that is still registered
+    it(
+        "should fail to remove an application that was never deployed",
+        async () => {
+            await expect(
+                removeApplication({
+                    application: "never-deployed",
+                    force: true,
+                    projectName,
+                }),
+            ).rejects.toThrow();
+        },
+        TIMEOUT,
+    );
+});
diff --git a/apps/cli/tests/integration/commands/withdrawal-layouts.test.ts b/apps/cli/tests/integration/commands/withdrawal-layouts.test.ts
index 350e7529..02ed278c 100644
--- a/apps/cli/tests/integration/commands/withdrawal-layouts.test.ts
+++ b/apps/cli/tests/integration/commands/withdrawal-layouts.test.ts
@@ -65,9 +65,7 @@ ${layout.accountsSize ? `ACCOUNTS_SIZE = "${layout.accountsSize}"` : ""}
 };
 
 layouts.forEach((layout, index) => {
-    const describeLayout = layout.skip ? describe.skip : describe;
-
-    describeLayout(`emergency withdrawal from ${layout.name}`, () => {
+    describe(`emergency withdrawal from ${layout.name}`, () => {
         const projectName = `layouts-${index}-${process.pid}`;
         let appDir: string;
         let cleanup: () => void;
diff --git a/apps/cli/tests/integration/devnet.ts b/apps/cli/tests/integration/devnet.ts
index 96b94016..21483791 100644
--- a/apps/cli/tests/integration/devnet.ts
+++ b/apps/cli/tests/integration/devnet.ts
@@ -134,13 +134,20 @@ export const deposit = async (
 /**
  * Starts the environment with `cartesi run` and waits for the application to
  * be deployed.
+ * @returns `output` reads what `cartesi run` has printed so far
  */
 export const startApplication = async (options: {
     appDir: string;
     epochLength: number;
+    /** further `cartesi run` arguments, e.g. `--prt` */
+    extraArgs?: string[];
     projectName: string;
-}): Promise<{ application: Address; run: ResultPromise }> => {
-    const { appDir, epochLength, projectName } = options;
+}): Promise<{
+    application: Address;
+    output: () => string;
+    run: ResultPromise;
+}> => {
+    const { appDir, epochLength, extraArgs = [], projectName } = options;
 
     // without a terminal the environment runs in the foreground
     console.log(`! Starting the environment ${projectName}...`);
@@ -157,6 +164,7 @@ export const startApplication = async (options: {
             epochLength.toString(),
             "--block-time",
             "1",
+            ...extraArgs,
         ],
         {
             all: true,
@@ -165,6 +173,11 @@ export const startApplication = async (options: {
         },
     );
 
+    // the process keeps running, so its output is read as it comes
+    const chunks: string[] = [];
+    run.all?.on("data", (chunk) => chunks.push(String(chunk)));
+    const output = () => chunks.join("");
+
     const application = await waitFor(async () => {
         if (run.nodeChildProcess.exitCode !== null) {
             const { all } = await run;
@@ -178,7 +191,7 @@ export const startApplication = async (options: {
     }, 600);
     console.log(`✓ Application deployed at ${application}`);
 
-    return { application, run };
+    return { application, output, run };
 };
 
 /**
diff --git a/apps/cli/tests/integration/node-startup.test.ts b/apps/cli/tests/integration/node-startup.test.ts
index 57b0dde1..e82781d5 100644
--- a/apps/cli/tests/integration/node-startup.test.ts
+++ b/apps/cli/tests/integration/node-startup.test.ts
@@ -4,6 +4,10 @@ import getPort, { portNumbers } from "get-port";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { toHex } from "viem";
+import { mnemonicToAccount } from "viem/accounts";
+import { DEVNET_MNEMONIC } from "../../src/compose/node.js";
+import { execNodeCommand } from "../../src/exec/node-container.js";
 import {
     startEnvironment,
     stopEnvironment,
@@ -17,6 +21,7 @@ import { TEST_RUNTIME_VERSION } from "./config.js";
 // is needed: the node serves /livez before any application is deployed.
 describe("rollups node startup", () => {
     const projectName = `cli-node-startup-${process.pid}`;
+    const keysProjectName = `cli-node-startup-keys-${process.pid}`;
     let port: number;
     let directory: string;
     let originalCwd: string;
@@ -32,6 +37,7 @@ describe("rollups node startup", () => {
     afterAll(async () => {
         try {
             await stopEnvironment({ projectName });
+            await stopEnvironment({ projectName: keysProjectName });
         } finally {
             process.chdir(originalCwd);
             fs.rmSync(directory, { recursive: true, force: true });
@@ -67,4 +73,91 @@ describe("rollups node startup", () => {
         // proves the signer was used and not merely that the node booted
         expect(stdout).toContain("PRT submitter identity");
     }, 300_000);
+
+    // the node runs as uid 102 and a key file is usually its owner's alone, so
+    // the CLI hands the node a copy it owns; a PRT identity of the key file's
+    // account, not the mnemonic's account 0, proves the node read it
+    it("should reach a healthy node with owner-only key files", async () => {
+        const writeKey = (name: string, addressIndex: number) => {
+            const account = mnemonicToAccount(DEVNET_MNEMONIC, {
+                addressIndex,
+            });
+            const privateKey = account.getHdKey().privateKey;
+            if (!privateKey) {
+                throw new Error(`no private key for account ${addressIndex}`);
+            }
+            const file = path.join(directory, name);
+            fs.writeFileSync(file, `${toHex(privateKey)}\n`, { mode: 0o600 });
+            return { address: account.address, file };
+        };
+        const claimer = writeKey("claimer.key", 0);
+        const prt = writeKey("prt.key", 6);
+        const keyVars = {
+            CARTESI_AUTH_KIND: "private_key_file",
+            CARTESI_AUTH_PRIVATE_KEY_FILE: claimer.file,
+            CARTESI_PRT_AUTH_KIND: "private_key_file",
+            CARTESI_PRT_AUTH_PRIVATE_KEY_FILE: prt.file,
+        };
+        const keysPort = await getPort({ port: portNumbers(16751, 16761) });
+
+        Object.assign(process.env, keyVars);
+        try {
+            await startEnvironment({
+                blockTime: 1,
+                defaultBlock: "latest",
+                detach: true,
+                dryRun: false,
+                port: keysPort,
+                projectName: keysProjectName,
+                prt: false,
+                runtimeVersion: TEST_RUNTIME_VERSION,
+                services: [],
+                verbose: false,
+            });
+        } finally {
+            for (const name of Object.keys(keyVars)) {
+                delete process.env[name];
+            }
+        }
+
+        await waitHealthyEnvironment({
+            port: keysPort,
+            projectName: keysProjectName,
+            services: [],
+        });
+
+        const { stdout } = await execa("docker", [
+            "compose",
+            "--project-name",
+            keysProjectName,
+            "logs",
+            "rollups_node",
+        ]);
+
+        expect(stdout).toMatch(
+            new RegExp(`PRT submitter identity.*${prt.address}`, "i"),
+        );
+
+        // the copy is what makes an owner-only file readable: owned by the
+        // node's user, read-only, and the host file is left as it was
+        const stat = (file: string) =>
+            execNodeCommand({
+                command: ["stat", "-c", "%U:%G %a", file],
+                projectName: keysProjectName,
+            });
+        expect(await stat("/run/secrets/cartesi_auth_private_key_file")).toBe(
+            "cartesi:cartesi 400",
+        );
+        expect(
+            await stat("/run/secrets/cartesi_prt_auth_private_key_file"),
+        ).toBe("cartesi:cartesi 400");
+
+        // the init service mounts the host files read-only and copies them,
+        // so their owner and mode don't change
+        for (const { file } of [claimer, prt]) {
+            const { uid, mode } = fs.statSync(file);
+            expect(uid).toBe(process.getuid?.() ?? uid);
+            expect(mode & 0o777).toBe(0o600);
+        }
+    }, 300_000);
 });
diff --git a/apps/cli/tests/unit/commands/logs.test.ts b/apps/cli/tests/unit/commands/logs.test.ts
new file mode 100644
index 00000000..5aa49b23
--- /dev/null
+++ b/apps/cli/tests/unit/commands/logs.test.ts
@@ -0,0 +1,104 @@
+import { describe, expect, it } from "bun:test";
+import {
+    buildLogsArgs,
+    createLogsCommand,
+    selectLogServices,
+} from "../../../src/commands/logs";
+
+describe("logs command", () => {
+    // as `docker compose ps --services --all` lists an environment with a
+    // pool sentry and a key-file sentry, whose installer has exited
+    const services = [
+        "anvil",
+        "database",
+        "proxy",
+        "rollups_node",
+        "secret-init-sentry-mine",
+        "sentry-1",
+        "sentry-mine",
+    ];
+
+    it("should take the services to show as arguments", () => {
+        const [argument] = createLogsCommand().registeredArguments;
+
+        expect(argument?.name()).toBe("service");
+        expect(argument?.variadic).toBe(true);
+        expect(argument?.required).toBe(false);
+    });
+
+    it("should show the node first, then the sentries, by default", () => {
+        expect(selectLogServices(services, [])).toEqual([
+            "rollups_node",
+            "sentry-1",
+            "sentry-mine",
+        ]);
+    });
+
+    it("should show only the node without sentries", () => {
+        expect(selectLogServices(["anvil", "rollups_node"], [])).toEqual([
+            "rollups_node",
+        ]);
+    });
+
+    it("should fail without the node", () => {
+        expect(() => selectLogServices(["anvil", "sentry-1"], [])).toThrow(
+            "service rollups_node not found",
+        );
+    });
+
+    it("should show the services named, in that order", () => {
+        expect(
+            selectLogServices(services, ["sentry-mine", "rollups_node"]),
+        ).toEqual(["sentry-mine", "rollups_node"]);
+    });
+
+    // compose shows nothing for an unknown service, without an error
+    it("should reject a service the environment doesn't have", () => {
+        expect(() =>
+            selectLogServices(services, ["sentry-1", "sentry-2"]),
+        ).toThrow(
+            "service sentry-2 not found; the environment has anvil, database, proxy, rollups_node, secret-init-sentry-mine, sentry-1, sentry-mine",
+        );
+    });
+
+    it("should pass the log options through, prefixing each service", () => {
+        expect(
+            buildLogsArgs({
+                follow: true,
+                projectName: "app",
+                services: ["rollups_node", "sentry-1"],
+                since: "42m",
+                tail: "all",
+                until: "1m",
+            }),
+        ).toEqual([
+            "compose",
+            "--project-name",
+            "app",
+            "logs",
+            "--follow",
+            "--since",
+            "42m",
+            "--tail",
+            "all",
+            "--until",
+            "1m",
+            "rollups_node",
+            "sentry-1",
+        ]);
+    });
+
+    // one service reads as `docker container logs` did
+    it("should drop the prefix for one service", () => {
+        expect(
+            buildLogsArgs({ projectName: "app", services: ["rollups_node"] }),
+        ).toEqual([
+            "compose",
+            "--project-name",
+            "app",
+            "logs",
+            "--no-log-prefix",
+            "rollups_node",
+        ]);
+    });
+});
diff --git a/apps/cli/tests/unit/commands/run.test.ts b/apps/cli/tests/unit/commands/run.test.ts
new file mode 100644
index 00000000..7ec6c9ee
--- /dev/null
+++ b/apps/cli/tests/unit/commands/run.test.ts
@@ -0,0 +1,14 @@
+import { describe, expect, it } from "bun:test";
+import { createRunCommand } from "../../../src/commands/run";
+
+describe("run command", () => {
+    // the node refuses to start with 'pending', which does not identify a
+    // mined block, so the command must not offer it
+    it("should offer only the default blocks the node supports", () => {
+        const option = createRunCommand().options.find(
+            ({ long }) => long === "--default-block",
+        );
+
+        expect(option?.argChoices).toEqual(["latest", "safe", "finalized"]);
+    });
+});
diff --git a/apps/cli/tests/unit/compose/anvil.test.ts b/apps/cli/tests/unit/compose/anvil.test.ts
new file mode 100644
index 00000000..55e704c4
--- /dev/null
+++ b/apps/cli/tests/unit/compose/anvil.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it } from "bun:test";
+import buildAnvilCompose from "../../../src/compose/anvil.js";
+
+describe("Compose anvil service", () => {
+    // compose interpolates `$name` in the file it reads, so the URL must reach
+    // it as `$$`, which compose turns back into `$`
+    it("should escape the $ in the fork url for compose", () => {
+        const compose = buildAnvilCompose({
+            forkConfig: {
+                blockNumber: 10n,
+                chainId: 11155111,
+                url: "https://rpc.example.com/v2/k$y",
+            },
+        });
+
+        expect(compose.services?.anvil?.command).toEqual([
+            "anvil",
+            "--chain-id",
+            "31337",
+            "--block-time",
+            "2",
+            "--fork-url",
+            "https://rpc.example.com/v2/k$$y",
+            "--fork-block-number",
+            "10",
+        ]);
+    });
+});
diff --git a/apps/cli/tests/unit/compose/node.test.ts b/apps/cli/tests/unit/compose/node.test.ts
index b80a8354..95e05a50 100644
--- a/apps/cli/tests/unit/compose/node.test.ts
+++ b/apps/cli/tests/unit/compose/node.test.ts
@@ -5,6 +5,7 @@ import buildNodeCompose, {
     type ServiceOptions,
 } from "../../../src/compose/node.js";
 import {
+    applicationFactoryAddress,
     inputBoxAddress,
     selfHostedApplicationFactoryAddress,
 } from "../../../src/contracts.js";
@@ -215,7 +216,7 @@ describe("Compose node service", () => {
 
             const env = compose.services?.rollups_node?.environment ?? {};
 
-            expect(Object.keys(env)).toHaveLength(11);
+            expect(Object.keys(env)).toHaveLength(12);
 
             expect(env).toHaveProperty(
                 "CARTESI_AUTH_MNEMONIC",
@@ -235,6 +236,10 @@ describe("Compose node service", () => {
                 "http://anvil:8545",
             );
             expect(env).toHaveProperty("CARTESI_BLOCKCHAIN_ID", "31337");
+            expect(env).toHaveProperty(
+                "CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS",
+                applicationFactoryAddress,
+            );
             expect(env).toHaveProperty(
                 "CARTESI_CONTRACTS_INPUT_BOX_ADDRESS",
                 inputBoxAddress,
@@ -334,6 +339,106 @@ describe("Compose node service", () => {
             expect(env).toHaveProperty("CARTESI_LOG_LEVEL", "warn");
         });
 
+        // compose interpolates `$name` in the file it reads, so a host value
+        // must reach it as `$$`, which compose turns back into `$`
+        it("should escape the $ in host variables for compose", () => {
+            const compose = buildNodeCompose({
+                ...baseOptions,
+                cartesiEnvironmentVariables: {
+                    CARTESI_BLOCKCHAIN_HTTP_ENDPOINT:
+                        "https://alice:s3cr$t@rpc.example.com/$key",
+                    CARTESI_LOG_LEVEL: "warn",
+                },
+            });
+            const env = compose.services?.rollups_node?.environment ?? {};
+
+            expect(env).toHaveProperty(
+                "CARTESI_BLOCKCHAIN_HTTP_ENDPOINT",
+                "https://alice:s3cr$$t@rpc.example.com/$$key",
+            );
+            expect(env).toHaveProperty("CARTESI_LOG_LEVEL", "warn");
+        });
+
+        // only the path would reach the container otherwise, and the node
+        // couldn't open the file
+        // a bind mount would keep the host's owner and mode, which the node's
+        // user may not read, so an init service hands the node copies it owns
+        it("should copy the key files the host names for the node", () => {
+            const compose = buildNodeCompose({
+                ...baseOptions,
+                cartesiEnvironmentVariables: {
+                    CARTESI_AUTH_KIND: "private_key_file",
+                    CARTESI_AUTH_PRIVATE_KEY_FILE: "secrets/claimer.key",
+                    CARTESI_PRT_AUTH_MNEMONIC_FILE: "/keys/prt$1",
+                },
+            });
+            const init = compose.services?.["node-secret-init"];
+            const service = compose.services?.rollups_node;
+
+            expect(init).toMatchObject({
+                image: "cartesi/rollups-runtime:latest",
+                network_mode: "none",
+                restart: "no",
+                user: "root",
+            });
+            expect(init?.command).toEqual([
+                [
+                    "find /dst -mindepth 1 -delete",
+                    "install -o cartesi -g cartesi -m 0400 /src/cartesi_auth_private_key_file /dst/cartesi_auth_private_key_file",
+                    "install -o cartesi -g cartesi -m 0400 /src/cartesi_prt_auth_mnemonic_file /dst/cartesi_prt_auth_mnemonic_file",
+                ].join("\n"),
+            ]);
+            expect(init?.volumes).toEqual([
+                {
+                    type: "bind",
+                    source: "secrets/claimer.key",
+                    target: "/src/cartesi_auth_private_key_file",
+                    read_only: true,
+                    bind: { create_host_path: false },
+                },
+                {
+                    type: "bind",
+                    source: "/keys/prt$$1",
+                    target: "/src/cartesi_prt_auth_mnemonic_file",
+                    read_only: true,
+                    bind: { create_host_path: false },
+                },
+                "node_secrets:/dst",
+            ]);
+            expect(compose.volumes).toEqual({ node_secrets: {} });
+            expect(service?.depends_on).toMatchObject({
+                "node-secret-init": {
+                    condition: "service_completed_successfully",
+                },
+            });
+            expect(service?.volumes).toContain("node_secrets:/run/secrets:ro");
+            expect(service?.environment).toMatchObject({
+                CARTESI_AUTH_KIND: "private_key_file",
+                CARTESI_AUTH_PRIVATE_KEY_FILE:
+                    "/run/secrets/cartesi_auth_private_key_file",
+                CARTESI_PRT_AUTH_MNEMONIC_FILE:
+                    "/run/secrets/cartesi_prt_auth_mnemonic_file",
+            });
+        });
+
+        it("should copy nothing when the host names no key file", () => {
+            const compose = buildNodeCompose({
+                ...baseOptions,
+                cartesiEnvironmentVariables: {
+                    CARTESI_AUTH_PRIVATE_KEY: "0xsecret",
+                },
+            });
+
+            expect(compose.services).not.toHaveProperty("node-secret-init");
+            expect(compose.volumes).toBeUndefined();
+            expect(
+                compose.services?.rollups_node?.depends_on,
+            ).not.toHaveProperty("node-secret-init");
+            expect(compose.services?.rollups_node?.volumes).toEqual([
+                "./.cartesi:/var/lib/cartesi-rollups-node/snapshots:ro",
+            ]);
+        });
+
         it("should build the database connection string from provided property", () => {
             const compose = buildNodeCompose({
                 databasePassword: "specialsecret",
diff --git a/apps/cli/tests/unit/compose/sentry.test.ts b/apps/cli/tests/unit/compose/sentry.test.ts
new file mode 100644
index 00000000..ee253211
--- /dev/null
+++ b/apps/cli/tests/unit/compose/sentry.test.ts
@@ -0,0 +1,151 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { Address } from "viem";
+import { generatePrivateKey } from "viem/accounts";
+import buildSentries, {
+    isSentryService,
+    sentryServiceName,
+} from "../../../src/compose/sentry";
+import { resolveSentries } from "../../../src/sentries";
+import { getDevnetAccount } from "../../../src/wallet";
+
+/**
+ * The compose services of the sentries the CLI runs: a sling node per
+ * `type = "sling"` entry, with its key in the environment for a devnet
+ * account, or copied by an init service for a key file.
+ */
+describe("Compose sentry services", () => {
+    const application: Address = "0x1111111111111111111111111111111111111111";
+    const ownKey = generatePrivateKey();
+    let keyFile: string;
+
+    beforeAll(() => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sentry-"));
+        keyFile = path.join(dir, "sentry.key");
+        fs.writeFileSync(keyFile, ownKey);
+    });
+
+    afterAll(() => fs.rmSync(path.dirname(keyFile), { recursive: true }));
+
+    const compose = (blockTime = 2) =>
+        buildSentries({
+            application,
+            blockTime,
+            imageTag: "devel",
+            sentries: resolveSentries({
+                sentries: [
+                    { type: "sling" },
+                    { type: "sling", label: "mine", privateKeyFile: keyFile },
+                    { address: "0x5555555555555555555555555555555555555555" },
+                ],
+            }).sentries,
+        });
+
+    it("should name the services after the labels", () => {
+        expect(sentryServiceName("mine")).toBe("sentry-mine");
+    });
+
+    it("should compose one file per sentry the CLI runs, none for an appointed one", () => {
+        const files = compose();
+
+        expect(files.map((file) => Object.keys(file.services ?? {}))).toEqual([
+            ["sentry-1"],
+            ["sentry-mine", "secret-init-sentry-mine"],
+        ]);
+    });
+
+    it("should run a sling node on the pool account's key, polling every block", () => {
+        const [file] = compose(2);
+        const service = file.services?.["sentry-1"];
+
+        expect(service?.image).toBe("cartesi/rollups-runtime:devel");
+        expect(service?.command).toEqual(["cartesi-sling-node", "pk"]);
+        expect(service?.depends_on).toEqual({
+            anvil: { condition: "service_healthy" },
+        });
+        expect(service?.environment).toEqual({
+            CARTESI_SLING_APP_ADDRESS: application,
+            CARTESI_SLING_AUTH_PRIVATE_KEY: getDevnetAccount(20).privateKey,
+            CARTESI_SLING_BLOCKCHAIN_HTTP_ENDPOINT: "http://anvil:8545",
+            CARTESI_SLING_BLOCKCHAIN_ID: "31337",
+            CARTESI_SLING_DATA_DIR: "/var/lib/cartesi-rollups-node/snapshots",
+            CARTESI_SLING_POLLING_INTERVAL: "2",
+            CARTESI_SLING_TEMPLATE_PATH:
+                "/var/lib/cartesi-rollups-node/template/image",
+        });
+        // the machine the node deploys, read-only
+        expect(service?.volumes).toEqual([
+            "./.cartesi:/var/lib/cartesi-rollups-node/template:ro",
+        ]);
+        expect(file.volumes).toBeUndefined();
+    });
+
+    it("should poll at least every second", () => {
+        const [file] = compose(0.5);
+
+        expect(file.services?.["sentry-1"]?.environment).toMatchObject({
+            CARTESI_SLING_POLLING_INTERVAL: "1",
+        });
+    });
+
+    it("should copy a key file for the sentry and point it at the copy", () => {
+        const [, file] = compose();
+        const service = file.services?.["sentry-mine"];
+        const init = file.services?.["secret-init-sentry-mine"];
+
+        expect(service?.environment).toMatchObject({
+            CARTESI_SLING_AUTH_PRIVATE_KEY_FILE: "/run/secrets/sentry-mine",
+        });
+        expect(service?.environment).not.toHaveProperty(
+            "CARTESI_SLING_AUTH_PRIVATE_KEY",
+        );
+        expect(service?.depends_on).toEqual({
+            anvil: { condition: "service_healthy" },
+            "secret-init-sentry-mine": {
+                condition: "service_completed_successfully",
+            },
+        });
+        expect(service?.volumes).toEqual([
+            "./.cartesi:/var/lib/cartesi-rollups-node/template:ro",
+            "sentry_mine_secrets:/run/secrets:ro",
+        ]);
+        expect(init?.image).toBe("cartesi/rollups-runtime:devel");
+        expect(init?.user).toBe("root");
+        expect(init?.command).toEqual([
+            `find /dst -mindepth 1 -delete\ninstall -o cartesi -g cartesi -m 0400 /src/sentry-mine /dst/sentry-mine`,
+        ]);
+        expect(init?.volumes).toEqual([
+            {
+                type: "bind",
+                source: keyFile,
+                target: "/src/sentry-mine",
+                read_only: true,
+                bind: { create_host_path: false },
+            },
+            "sentry_mine_secrets:/dst",
+        ]);
+        expect(file.volumes).toEqual({ sentry_mine_secrets: {} });
+    });
+
+    // the key never leaves the file
+    it("should not put a key file's key anywhere in the compose file", () => {
+        const [, file] = compose();
+
+        expect(JSON.stringify(file)).not.toContain(ownKey.slice(2));
+    });
+
+    // `cartesi logs` tells the sentries from the rest of the environment by
+    // name; a label holding `-` must not make the installer of another sentry
+    it("should tell a sentry's service from its key file installer", () => {
+        const [, file] = compose();
+
+        expect(
+            Object.keys(file.services ?? {}).filter(isSentryService),
+        ).toEqual(["sentry-mine"]);
+        expect(isSentryService(sentryServiceName("x-secret-init"))).toBe(true);
+        expect(isSentryService("secret-init-sentry-x-secret-init")).toBe(false);
+        expect(isSentryService("rollups_node")).toBe(false);
+    });
+});
diff --git a/apps/cli/tests/unit/config.test.ts b/apps/cli/tests/unit/config.test.ts
index e9338ac4..d0f85b89 100644
--- a/apps/cli/tests/unit/config.test.ts
+++ b/apps/cli/tests/unit/config.test.ts
@@ -16,6 +16,7 @@ import {
     InvalidEnvError,
     InvalidNumberValueError,
     InvalidNvramSizeError,
+    InvalidPrtConfigError,
     InvalidStringValueError,
     InvalidTableError,
     InvalidWithdrawalConfigError,
@@ -155,6 +156,18 @@ describe("when parsing the fixtures", () => {
                     user: undefined,
                 },
             },
+            prt: {
+                sentryManager: "0x3333333333333333333333333333333333333333",
+                sentries: [
+                    { type: "sling" },
+                    {
+                        address: "0x4444444444444444444444444444444444444444",
+                        type: "sling",
+                        label: "mine",
+                    },
+                    { address: "0x5555555555555555555555555555555555555555" },
+                ],
+            },
             withdrawal: {
                 guardian: "0x1111111111111111111111111111111111111111",
                 withdrawal_output_builder:
@@ -417,6 +430,222 @@ shared = true`,
         );
     });
 
+    /**
+     * [prt]
+     */
+    describe("when parsing [prt]", () => {
+        const prt = (config: string) => parse([config]).prt;
+        const address = (digit: string) =>
+            `0x${digit.repeat(40)}` as `0x${string}`;
+
+        it("should parse the sentries in order, with only the keys set", () => {
+            const config = `
+                [prt]
+                sentry_manager = "${address("3")}"
+
+                [[prt.sentries]]
+                type = "sling"
+
+                [[prt.sentries]]
+                type = "sling"
+                label = "mine"
+                address = "${address("4")}"
+                private_key_file = "secrets/sentry.key"
+
+                [[prt.sentries]]
+                address = "${address("5")}"
+            `;
+            expect(prt(config)).toStrictEqual({
+                sentryManager: address("3"),
+                sentries: [
+                    { type: "sling" },
+                    {
+                        address: address("4"),
+                        type: "sling",
+                        label: "mine",
+                        privateKeyFile: "secrets/sentry.key",
+                    },
+                    { address: address("5") },
+                ],
+            });
+        });
+
+        // the CLI reads a key only for a sentry it runs
+        it("should fail for a private_key_file without a type", () => {
+            expect(() =>
+                prt(
+                    `[[prt.sentries]]\naddress = "${address("4")}"\nprivate_key_file = "sentry.key"`,
+                ),
+            ).toThrowError(
+                new InvalidPrtConfigError(
+                    "private_key_file needs a type: the CLI only reads the key of a sentry it runs",
+                    "prt.sentries[1]",
+                ),
+            );
+        });
+
+        it("should fail for an empty private_key_file", () => {
+            expect(() =>
+                prt('[[prt.sentries]]\ntype = "sling"\nprivate_key_file = ""'),
+            ).toThrowError(
+                new InvalidPrtConfigError(
+                    "private_key_file must name a file",
+                    "prt.sentries[1]",
+                ),
+            );
+        });
+
+        it("should fail for a private_key_file that is not a string", () => {
+            expect(() =>
+                prt('[[prt.sentries]]\ntype = "sling"\nprivate_key_file = 1'),
+            ).toThrowError("Invalid string value: 1");
+        });
+
+        it("should accept an empty section", () => {
+            expect(prt("[prt]")).toStrictEqual({ sentries: [] });
+        });
+
+        it("should return undefined when [prt] is not defined", () => {
+            expect(parse([""]).prt).toBeUndefined();
+        });
+
+        it("should fail when the section is not a table", () => {
+            expect(() => prt("prt = 42")).toThrowError(
+                new InvalidTableError("[prt]", 42),
+            );
+        });
+
+        it("should fail when sentries is not an array of tables", () => {
+            expect(() => prt('[prt]\nsentries = "0x1234"')).toThrowError(
+                new InvalidPrtConfigError(
+                    "sentries must be [[prt.sentries]] entries, got 0x1234",
+                ),
+            );
+            expect(() => prt("[prt]\nsentries = [42]")).toThrowError(
+                new InvalidTableError("prt.sentries[1]", 42),
+            );
+        });
+
+        it("should checksum the addresses", () => {
+            const config = `
+                [[prt.sentries]]
+                address = "0x70997970c51812dc3a010c7d01b50e0d17dc79c8"
+            `;
+            expect(prt(config)?.sentries[0].address).toBe(
+                "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+            );
+        });
+
+        it.each([
+            ["sentry_manager", "[prt]"],
+            ["address", "[[prt.sentries]]"],
+        ])("should fail when %s is not a valid address", (key, table) => {
+            expect(() =>
+                prt(`${table}\n${key} = "invalid_address"`),
+            ).toThrowError(
+                new InvalidAddressValueError("invalid_address", key),
+            );
+        });
+
+        // the node refuses it, so the config does too
+        it("should fail for the zero address", () => {
+            expect(() =>
+                prt(`[[prt.sentries]]\naddress = "${address("0")}"`),
+            ).toThrowError(
+                new InvalidPrtConfigError(
+                    "address must not be the zero address",
+                    "prt.sentries[1]",
+                ),
+            );
+        });
+
+        it("should fail when two entries name the same address", () => {
+            const config = `
+                [[prt.sentries]]
+                address = "${address("4")}"
+
+                [[prt.sentries]]
+                type = "sling"
+
+                [[prt.sentries]]
+                type = "sling"
+                address = "${address("4").toLowerCase()}"
+            `;
+            expect(() => prt(config)).toThrowError(
+                new InvalidPrtConfigError(
+                    `address ${address("4")} is also the address of prt.sentries[1]`,
+                    "prt.sentries[3]",
+                ),
+            );
+        });
+
+        it("should fail for a type the CLI can't run", () => {
+            expect(() =>
+                prt('[[prt.sentries]]\ntype = "rollups-node"'),
+            ).toThrowError(
+                new InvalidPrtConfigError(
+                    "type rollups-node isn't supported, expected one of: sling",
+                    "prt.sentries[1]",
+                ),
+            );
+        });
+
+        it("should fail for an entry with neither type nor address", () => {
+            expect(() => prt('[[prt.sentries]]\nlabel = "idle"')).toThrowError(
+                new InvalidPrtConfigError(
+                    "set a type for the CLI to run the sentry, or an address to appoint one run elsewhere",
+                    "prt.sentries[1]",
+                ),
+            );
+        });
+
+        it.each(['"My Sentry"', '"a/b"', '""', "7"])(
+            "should fail for the label %s",
+            (label) => {
+                expect(() =>
+                    prt(`[[prt.sentries]]\ntype = "sling"\nlabel = ${label}`),
+                ).toThrowError(
+                    new InvalidPrtConfigError(
+                        `label ${JSON.parse(label.startsWith('"') ? label : `"${label}"`) === "" ? "" : label.replace(/"/g, "")} must be lowercase letters, digits, - or _`,
+                        "prt.sentries[1]",
+                    ),
+                );
+            },
+        );
+
+        // a label names a container, and so does the default of another entry
+        it("should fail when a label repeats another entry's default label", () => {
+            const config = `
+                [[prt.sentries]]
+                type = "sling"
+                label = "2"
+
+                [[prt.sentries]]
+                type = "sling"
+            `;
+            expect(() => prt(config)).toThrowError(
+                new InvalidPrtConfigError(
+                    'label "2" is also the label of prt.sentries[1]',
+                    "prt.sentries[2]",
+                ),
+            );
+        });
+
+        it("should fail for an unknown key in [prt]", () => {
+            expect(() => prt("[prt]\nmanager = 1")).toThrowError(
+                "Unknown key 'manager' in [prt], expected one of: sentries, sentry_manager",
+            );
+        });
+
+        it("should fail for an unknown key in an entry", () => {
+            expect(() =>
+                prt('[[prt.sentries]]\ntype = "sling"\nkey = "x"'),
+            ).toThrowError(
+                "Unknown key 'key' in prt.sentries[1], expected one of: address, label, private_key_file, type",
+            );
+        });
+    });
+
     /**
      * accounts drive validation, before the machine is built
      */
@@ -1069,7 +1298,7 @@ shared = true`,
             expect(() =>
                 parse(['[drive.root]\nbuilder = "docker"']),
             ).toThrowError(
-                "Unknown key 'drive' at the top level, expected one of: drives, machine, nvrams, sdk, withdrawal",
+                "Unknown key 'drive' at the top level, expected one of: drives, machine, nvrams, prt, sdk, withdrawal",
             );
         });
 
diff --git a/apps/cli/tests/unit/config/fixtures/full.toml b/apps/cli/tests/unit/config/fixtures/full.toml
index fabdcca9..e129a540 100644
--- a/apps/cli/tests/unit/config/fixtures/full.toml
+++ b/apps/cli/tests/unit/config/fixtures/full.toml
@@ -84,3 +84,17 @@ filename = "./seed.raw" # existing raw image with the initial contents
 guardian = "0x1111111111111111111111111111111111111111" # devnet account by default
 withdrawal_output_builder = "0x2222222222222222222222222222222222222222" # devnet builder by default, required on a fork
 account_size = 64 # bytes per account, a power of two, 32 by default
+
+[prt] # optional, read by `cartesi run --prt`: the sentries of the application's consensus
+sentry_manager = "0x3333333333333333333333333333333333333333" # may rotate sentries, default is none
+
+[[prt.sentries]] # appointed in this order, with IDs from 1
+type = "sling" # the CLI runs a Dave sling node for it; without an address it gets devnet account 20
+
+[[prt.sentries]]
+type = "sling"
+label = "mine" # names the container sentry-mine, default is the position
+address = "0x4444444444444444444444444444444444444444" # an account of your own
+
+[[prt.sentries]]
+address = "0x5555555555555555555555555555555555555555" # no type: appointed only, run elsewhere
diff --git a/apps/cli/tests/unit/config/fixtures/prt/config.toml b/apps/cli/tests/unit/config/fixtures/prt/config.toml
new file mode 100644
index 00000000..e9b9317f
--- /dev/null
+++ b/apps/cli/tests/unit/config/fixtures/prt/config.toml
@@ -0,0 +1,26 @@
+# example of an application deployed with PRT sentries by `cartesi run --prt`.
+# without --prt the section is ignored.
+
+[prt]
+# optional, may rotate sentries on the consensus. default is none
+# sentry_manager = "0x3333333333333333333333333333333333333333"
+
+# appointed on the consensus in this order, with IDs from 1. an entry with a
+# type is run by the CLI, as container sentry-<label>; one with only an
+# address is appointed and run elsewhere
+
+[[prt.sentries]]
+type = "sling" # no address: devnet account 20, the first of the CLI's sentry pool
+
+[[prt.sentries]]
+type = "sling" # devnet account 21
+label = "second" # default is the position, 2
+
+# a key of your own: the address is the key's, and you fund it
+# [[prt.sentries]]
+# type = "sling"
+# label = "mine"
+# private_key_file = "secrets/sentry.key"
+
+[[prt.sentries]]
+address = "0x5555555555555555555555555555555555555555" # appointed only
diff --git a/apps/cli/tests/unit/exec/cartesi-machine.test.ts b/apps/cli/tests/unit/exec/cartesi-machine.test.ts
index eb0c10cc..2ef48f52 100644
--- a/apps/cli/tests/unit/exec/cartesi-machine.test.ts
+++ b/apps/cli/tests/unit/exec/cartesi-machine.test.ts
@@ -9,11 +9,11 @@ import {
 const semver = (version: string) => parse(version) as SemVer;
 
 describe("requiredVersion", () => {
-    it.each(["0.21.0", "0.21.3"])("should accept %s", (version) => {
+    it.each(["0.22.0", "0.22.3"])("should accept %s", (version) => {
         expect(satisfies(version, requiredVersion)).toBeTruthy();
     });
 
-    it.each(["0.20.0", "0.20.9", "0.22.0", "1.0.0"])(
+    it.each(["0.21.0", "0.21.9", "0.23.0", "1.0.0"])(
         "should reject %s",
         (version) => {
             expect(satisfies(version, requiredVersion)).toBeFalsy();
@@ -22,11 +22,11 @@ describe("requiredVersion", () => {
 });
 
 describe("assertSupported", () => {
-    it.each(["0.21.0", "0.21.3"])("should accept %s", (version) => {
+    it.each(["0.22.0", "0.22.3"])("should accept %s", (version) => {
         expect(() => assertSupported(semver(version))).not.toThrow();
     });
 
-    it.each(["0.20.0", "0.22.0"])("should reject %s", (version) => {
+    it.each(["0.21.0", "0.23.0"])("should reject %s", (version) => {
         expect(() => assertSupported(semver(version))).toThrowError(
             new UnsupportedVersionError(semver(version)),
         );
diff --git a/apps/cli/tests/unit/exec/rollups.test.ts b/apps/cli/tests/unit/exec/rollups.test.ts
index 23268c4d..63d03f42 100644
--- a/apps/cli/tests/unit/exec/rollups.test.ts
+++ b/apps/cli/tests/unit/exec/rollups.test.ts
@@ -1,7 +1,9 @@
 import { describe, expect, it } from "bun:test";
 import {
     buildDeployApplicationArgs,
+    buildRemoveApplicationArgs,
     parseApplications,
+    parseDaveConsensus,
     parseLastAcceptedEpoch,
     parseNodeInput,
 } from "../../../src/exec/rollups";
@@ -199,6 +201,63 @@ describe("parseLastAcceptedEpoch", () => {
     });
 });
 
+describe("parseDaveConsensus", () => {
+    const consensus = (overrides: Record<string, unknown> = {}) =>
+        JSON.stringify({
+            type: "DaveConsensus",
+            address: "0xac9dde569ea502f8e002f6ff1bd4aa55386bc4e1",
+            claim_staging_period: 300,
+            is_tournament_result_staged: false,
+            current_epoch_number: 0,
+            sentry_manager: "0x9965507d1a55bcc2695c58ba16fb37d819b0a4dc",
+            num_sentries: 2,
+            sentries: [
+                {
+                    id: 1,
+                    address: "0x1111111111111111111111111111111111111111",
+                },
+                {
+                    id: 2,
+                    address: "0x2222222222222222222222222222222222222222",
+                },
+            ],
+            ...overrides,
+        });
+
+    it("should read the sentries in ID order, with checksummed addresses", () => {
+        expect(parseDaveConsensus(consensus())).toEqual({
+            address: "0xac9dDe569EA502f8e002f6Ff1Bd4AA55386Bc4E1",
+            claimStagingPeriod: 300,
+            sentryManager: "0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc",
+            sentries: [
+                {
+                    id: 1,
+                    address: "0x1111111111111111111111111111111111111111",
+                },
+                {
+                    id: 2,
+                    address: "0x2222222222222222222222222222222222222222",
+                },
+            ],
+            allSentriesAgree: undefined,
+        });
+    });
+
+    // the node reports it only while a result is staged
+    it("should read whether all sentries agree when reported", () => {
+        expect(
+            parseDaveConsensus(consensus({ all_sentries_agree: true }))
+                .allSentriesAgree,
+        ).toBe(true);
+    });
+
+    it("should reject another consensus type", () => {
+        expect(() =>
+            parseDaveConsensus(consensus({ type: "Authority" })),
+        ).toThrow("is a Authority, not a DaveConsensus");
+    });
+});
+
 describe("buildDeployApplicationArgs", () => {
     const base = {
         claimStagingPeriod: 720,
@@ -250,6 +309,44 @@ describe("buildDeployApplicationArgs", () => {
         expect(args.at(-1)).toBe("--json");
     });
 
+    // the node takes the sentries as one comma separated list, in ID order
+    it("should pass the sentries and their manager with prt", () => {
+        const args = buildDeployApplicationArgs({
+            ...base,
+            prt: true,
+            sentries: [
+                "0x1111111111111111111111111111111111111111",
+                "0x2222222222222222222222222222222222222222",
+            ],
+            sentryManager: "0x3333333333333333333333333333333333333333",
+        });
+
+        expect(args).toContain("--prt");
+        expect(args[args.indexOf("--sentries") + 1]).toBe(
+            "0x1111111111111111111111111111111111111111,0x2222222222222222222222222222222222222222",
+        );
+        expect(args[args.indexOf("--sentry-manager") + 1]).toBe(
+            "0x3333333333333333333333333333333333333333",
+        );
+    });
+
+    it("should pass neither sentries nor a manager when none are set", () => {
+        const args = buildDeployApplicationArgs({ ...base, prt: true });
+
+        expect(args).not.toContain("--sentries");
+        expect(args).not.toContain("--sentry-manager");
+    });
+
+    it("should pass no --sentries for an empty list", () => {
+        const args = buildDeployApplicationArgs({
+            ...base,
+            prt: true,
+            sentries: [],
+        });
+
+        expect(args).not.toContain("--sentries");
+    });
+
     it("should pass the withdrawal config as JSON", () => {
         const args = buildDeployApplicationArgs({
             ...base,
@@ -268,3 +365,19 @@ describe("buildDeployApplicationArgs", () => {
         );
     });
 });
+
+describe("buildRemoveApplicationArgs", () => {
+    // the node refuses `app remove` without --allow-abandonment, so a forced
+    // removal, like the shell's undeploy before a redeploy, must pass it
+    it("should acknowledge the abandoned work when forced", () => {
+        expect(
+            buildRemoveApplicationArgs({ application: "echo", force: true }),
+        ).toEqual(["echo", "--allow-abandonment", "--yes"]);
+    });
+
+    it("should leave the confirmation to the node when not forced", () => {
+        expect(
+            buildRemoveApplicationArgs({ application: "echo", force: false }),
+        ).toEqual(["echo"]);
+    });
+});
diff --git a/apps/cli/tests/unit/sentries.test.ts b/apps/cli/tests/unit/sentries.test.ts
new file mode 100644
index 00000000..45086a0d
--- /dev/null
+++ b/apps/cli/tests/unit/sentries.test.ts
@@ -0,0 +1,490 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { Address } from "viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { InvalidPrtConfigError, type PrtSentry } from "../../src/config";
+import {
+    checkSentries,
+    describeSentry,
+    readSentryKeyFile,
+    resolveSentries,
+    SENTRY_FUNDING,
+    SENTRY_POOL_SIZE,
+    SENTRY_POOL_START,
+    type SentryClient,
+} from "../../src/sentries";
+import { getDevnetAccount } from "../../src/wallet";
+import { DEVNET_GUARDIAN } from "../../src/withdrawal";
+
+const devnet = (index: number) => getDevnetAccount(index).address;
+const external: Address = "0x4444444444444444444444444444444444444444";
+const sling = (sentry: Omit<PrtSentry, "type"> = {}): PrtSentry => ({
+    type: "sling",
+    ...sentry,
+});
+
+// key files of the developer's own, never devnet accounts
+let dir: string;
+const keyFile = (content: string, name = `${Math.random()}.key`) => {
+    const file = path.join(dir, name);
+    fs.writeFileSync(file, content);
+    return file;
+};
+const ownKey = generatePrivateKey();
+const ownAddress = privateKeyToAccount(ownKey).address;
+
+beforeAll(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "sentries-"));
+});
+
+afterAll(() => fs.rmSync(dir, { recursive: true, force: true }));
+
+describe("resolveSentries", () => {
+    it("should give bare entries the pool accounts in order, with their keys", () => {
+        const { sentries } = resolveSentries({
+            sentries: [sling(), sling(), sling()],
+        });
+
+        expect(sentries.map(({ address }) => address)).toEqual([
+            devnet(20),
+            devnet(21),
+            devnet(22),
+        ]);
+        expect(sentries.map(({ source }) => source)).toEqual([
+            { kind: "pool", index: 20 },
+            { kind: "pool", index: 21 },
+            { kind: "pool", index: 22 },
+        ]);
+        expect(sentries.map(({ privateKey }) => privateKey)).toEqual([
+            getDevnetAccount(20).privateKey,
+            getDevnetAccount(21).privateKey,
+            getDevnetAccount(22).privateKey,
+        ]);
+    });
+
+    it("should start the pool after the accounts anvil funds", () => {
+        expect(SENTRY_POOL_START).toBe(20);
+        expect(SENTRY_POOL_SIZE).toBe(10);
+    });
+
+    // an entry that names a pool account keeps it, so the pool must not hand
+    // the same account to a bare entry, wherever the two are
+    it("should skip a pool account another entry names", () => {
+        const { sentries } = resolveSentries({
+            sentries: [sling(), sling({ address: devnet(21) }), sling()],
+        });
+
+        expect(sentries.map(({ address }) => address)).toEqual([
+            devnet(20),
+            devnet(21),
+            devnet(22),
+        ]);
+    });
+
+    it("should skip a pool account named later in the config", () => {
+        const { sentries } = resolveSentries({
+            sentries: [sling(), { address: devnet(20) }],
+        });
+
+        expect(sentries.map(({ address }) => address)).toEqual([
+            devnet(21),
+            devnet(20),
+        ]);
+    });
+
+    it("should fail naming the entry when the pool runs out", () => {
+        const sentries = Array.from({ length: SENTRY_POOL_SIZE + 1 }, () =>
+            sling(),
+        );
+
+        expect(() => resolveSentries({ sentries })).toThrowError(
+            new InvalidPrtConfigError(
+                "needs an address: the sentry pool, devnet accounts 20 to 29, is used up",
+                "prt.sentries[11]",
+            ),
+        );
+    });
+
+    it("should keep explicit addresses and tell devnet accounts from others", () => {
+        const { sentries } = resolveSentries({
+            sentries: [
+                sling({ address: devnet(2) }),
+                { address: devnet(25) },
+                { address: external },
+            ],
+        });
+
+        expect(
+            sentries.map(({ address, privateKey, source }) => [
+                address,
+                source,
+                privateKey,
+            ]),
+        ).toEqual([
+            [
+                devnet(2),
+                { kind: "devnet", index: 2 },
+                getDevnetAccount(2).privateKey,
+            ],
+            [devnet(25), { kind: "pool", index: 25 }, undefined],
+            [external, { kind: "external" }, undefined],
+        ]);
+    });
+
+    // the CLI can run a node only with a key it has
+    it("should fail for a type on an address the CLI has no key for", () => {
+        expect(() =>
+            resolveSentries({ sentries: [sling({ address: external })] }),
+        ).toThrowError(
+            new InvalidPrtConfigError(
+                `the CLI has no key for ${external}: set private_key_file to run the sentry with it, or drop the type to appoint it only`,
+                "prt.sentries[1]",
+            ),
+        );
+    });
+
+    it("should label entries by position unless they have a label", () => {
+        const { sentries } = resolveSentries({
+            sentries: [
+                sling(),
+                sling({ label: "mine" }),
+                { address: external },
+            ],
+        });
+
+        expect(sentries.map(({ entry, label }) => [entry, label])).toEqual([
+            [1, "1"],
+            [2, "mine"],
+            [3, "3"],
+        ]);
+    });
+
+    it("should carry the type and the manager", () => {
+        const resolved = resolveSentries({
+            sentryManager: devnet(5),
+            sentries: [sling(), { address: external }],
+        });
+
+        expect(resolved.sentryManager).toBe(devnet(5));
+        expect(resolved.sentries.map(({ type }) => type)).toEqual([
+            "sling",
+            undefined,
+        ]);
+        expect(resolved.warnings).toEqual([]);
+    });
+
+    it("should warn about a label on an entry the CLI doesn't run", () => {
+        const { warnings } = resolveSentries({
+            sentries: [{ address: external, label: "theirs" }],
+        });
+
+        expect(warnings).toEqual([
+            "prt.sentries[1] has a label but no type, so the CLI runs nothing for it and the label names nothing",
+        ]);
+    });
+
+    it("should warn about a manager with no sentries to rotate", () => {
+        const { warnings } = resolveSentries({
+            sentryManager: devnet(5),
+            sentries: [],
+        });
+
+        expect(warnings).toEqual([
+            "[prt].sentry_manager is set but there are no [[prt.sentries]]; the manager has no sentries to rotate",
+        ]);
+    });
+
+    describe("with a key file", () => {
+        it("should take the address from the key, without one in the entry", () => {
+            const file = keyFile(ownKey);
+            const { sentries } = resolveSentries({
+                sentries: [sling({ privateKeyFile: file })],
+            });
+
+            expect(sentries[0]).toEqual({
+                entry: 1,
+                label: "1",
+                address: ownAddress,
+                type: "sling",
+                source: { kind: "key-file", path: file },
+            });
+            // the key stays in the file: the init service copies it
+            expect(sentries[0].privateKey).toBeUndefined();
+        });
+
+        it("should accept an address that matches the key", () => {
+            const { sentries } = resolveSentries({
+                sentries: [
+                    sling({
+                        address: ownAddress,
+                        privateKeyFile: keyFile(ownKey),
+                    }),
+                ],
+            });
+
+            expect(sentries[0].address).toBe(ownAddress);
+        });
+
+        it("should fail for an address the key doesn't match, naming both", () => {
+            const file = keyFile(ownKey);
+
+            expect(() =>
+                resolveSentries({
+                    sentries: [
+                        sling({ address: external, privateKeyFile: file }),
+                    ],
+                }),
+            ).toThrowError(
+                new InvalidPrtConfigError(
+                    `private_key_file "${file}" is the key of ${ownAddress}, not ${external}`,
+                    "prt.sentries[1]",
+                ),
+            );
+        });
+
+        // the devnet keys are public and derived by the CLI itself
+        it("should fail for the key of a devnet account", () => {
+            const file = keyFile(getDevnetAccount(3).privateKey);
+
+            expect(() =>
+                resolveSentries({
+                    sentries: [sling({ privateKeyFile: file })],
+                }),
+            ).toThrowError(
+                new InvalidPrtConfigError(
+                    `private_key_file "${file}" holds the key of devnet account 3, which the CLI derives itself; drop the file, or set the address instead`,
+                    "prt.sentries[1]",
+                ),
+            );
+        });
+
+        // a key file's address is known only after reading it
+        it("should fail when a key file repeats the address of another entry", () => {
+            expect(() =>
+                resolveSentries({
+                    sentries: [
+                        { address: ownAddress },
+                        sling({ privateKeyFile: keyFile(ownKey) }),
+                    ],
+                }),
+            ).toThrowError(
+                new InvalidPrtConfigError(
+                    `address ${ownAddress} is also the address of prt.sentries[1]`,
+                    "prt.sentries[2]",
+                ),
+            );
+        });
+
+        it("should skip a pool account only when an entry names it", () => {
+            const { sentries } = resolveSentries({
+                sentries: [sling({ privateKeyFile: keyFile(ownKey) }), sling()],
+            });
+
+            expect(sentries.map(({ address }) => address)).toEqual([
+                ownAddress,
+                devnet(20),
+            ]);
+        });
+    });
+
+    // a sentry the CLI runs sends transactions of its own
+    describe("on an account the node or the CLI sends from", () => {
+        it.each([
+            [
+                0,
+                "devnet account 0 signs the node's claims, so it can't also run a sentry",
+            ],
+            [
+                6,
+                "devnet account 6 signs the node's PRT transactions, so it can't also run a sentry",
+            ],
+        ])("should fail for devnet account %i", (index, reason) => {
+            expect(() =>
+                resolveSentries({
+                    sentries: [sling({ address: devnet(index) })],
+                }),
+            ).toThrowError(
+                new InvalidPrtConfigError(reason, "prt.sentries[1]"),
+            );
+        });
+
+        it("should warn for the default sender of send and deposit", () => {
+            const { warnings } = resolveSentries({
+                sentries: [sling({ address: devnet(8) })],
+            });
+
+            expect(warnings).toEqual([
+                "prt.sentries[1] is devnet account 8, the default sender of cartesi send and deposit; their transactions may collide",
+            ]);
+        });
+
+        it("should warn for the guardian, devnet or not", () => {
+            expect(
+                resolveSentries(
+                    { sentries: [sling({ address: DEVNET_GUARDIAN })] },
+                    { guardian: DEVNET_GUARDIAN },
+                ).warnings,
+            ).toEqual([
+                "prt.sentries[1] is the guardian of the application; its transactions may collide with an emergency withdrawal",
+            ]);
+            expect(
+                resolveSentries(
+                    { sentries: [sling({ privateKeyFile: keyFile(ownKey) })] },
+                    { guardian: ownAddress },
+                ).warnings,
+            ).toEqual([
+                "prt.sentries[1] is the guardian of the application; its transactions may collide with an emergency withdrawal",
+            ]);
+        });
+
+        it("should accept an appointed-only entry on any account", () => {
+            const { warnings } = resolveSentries(
+                { sentries: [{ address: devnet(0) }, { address: devnet(1) }] },
+                { guardian: devnet(1) },
+            );
+
+            expect(warnings).toEqual([]);
+        });
+    });
+});
+
+describe("readSentryKeyFile", () => {
+    const bare = ownKey.slice(2);
+
+    it.each([
+        ["with 0x", ownKey],
+        ["without 0x", bare],
+        ["with a trailing newline", `${ownKey}\n`],
+        ["with surrounding whitespace", `  ${bare}\t\n`],
+        ["with more lines after the key", `${ownKey}\nsecond line\n`],
+    ])("should read a key %s", (_, content) => {
+        expect(readSentryKeyFile(keyFile(content), "prt.sentries[1]")).toBe(
+            ownKey,
+        );
+    });
+
+    it.each([
+        [
+            "a mnemonic",
+            "test test test test test test test test test test test junk",
+        ],
+        ["a short key", "0x1234"],
+        ["an empty file", ""],
+        ["a key on the second line", `\n${ownKey}`],
+    ])("should reject %s without printing it", (_, content) => {
+        const file = keyFile(content);
+
+        expect(() => readSentryKeyFile(file, "prt.sentries[1]")).toThrowError(
+            new InvalidPrtConfigError(
+                `the first line of private_key_file "${file}" must be a hex private key, 64 hex digits with or without 0x`,
+                "prt.sentries[1]",
+            ),
+        );
+    });
+
+    it("should fail for a file that can't be read", () => {
+        const file = path.join(dir, "missing.key");
+
+        expect(() => readSentryKeyFile(file, "prt.sentries[2]")).toThrowError(
+            new InvalidPrtConfigError(
+                `private_key_file "${file}" can't be read`,
+                "prt.sentries[2]",
+            ),
+        );
+    });
+});
+
+describe("checkSentries", () => {
+    const fakeClient = (balances: Record<string, bigint> = {}) => {
+        const calls: { method: string; address: Address; value?: bigint }[] =
+            [];
+        const client: SentryClient = {
+            getBalance: async ({ address }) => {
+                calls.push({ method: "getBalance", address });
+                return balances[address] ?? 0n;
+            },
+            setBalance: async ({ address, value }) => {
+                calls.push({ method: "setBalance", address, value });
+            },
+        };
+        return { calls, client };
+    };
+
+    it("should fund the pool sentries only, with what anvil gives its accounts", async () => {
+        const { calls, client } = fakeClient({ [devnet(2)]: 1n });
+        const prt = resolveSentries({
+            sentries: [
+                sling(),
+                sling({ address: devnet(2) }),
+                { address: external },
+            ],
+        });
+
+        await checkSentries(client, prt);
+
+        expect(SENTRY_FUNDING).toBe(10_000n * 10n ** 18n);
+        expect(calls).toEqual([
+            {
+                method: "setBalance",
+                address: devnet(20),
+                value: SENTRY_FUNDING,
+            },
+            { method: "getBalance", address: devnet(2) },
+        ]);
+    });
+
+    it("should fail for a sentry of the developer's own with no ETH", async () => {
+        const { client } = fakeClient();
+        const prt = resolveSentries({
+            sentries: [sling({ privateKeyFile: keyFile(ownKey) })],
+        });
+
+        expect(checkSentries(client, prt)).rejects.toThrowError(
+            `sentry 1 ${ownAddress} has no ETH on this devnet; fund it before cartesi run, e.g. with cast rpc anvil_setBalance`,
+        );
+    });
+
+    it("should do nothing without sentries to run", async () => {
+        const { calls, client } = fakeClient();
+
+        await checkSentries(
+            client,
+            resolveSentries({ sentries: [{ address: external }] }),
+        );
+
+        expect(calls).toEqual([]);
+    });
+});
+
+describe("describeSentry", () => {
+    const describe_ = (sentries: PrtSentry[], index = 0) =>
+        describeSentry(resolveSentries({ sentries }).sentries[index]);
+
+    it("should name a pool account as funded by the CLI", () => {
+        expect(describe_([sling()])).toBe(
+            `sentry 1 ${devnet(20)} (devnet account 20, funded by the CLI)`,
+        );
+    });
+
+    it("should name another devnet account", () => {
+        expect(describe_([sling({ address: devnet(2), label: "two" })])).toBe(
+            `sentry two ${devnet(2)} (devnet account 2)`,
+        );
+    });
+
+    it("should name the key file of the developer's own sentry", () => {
+        const file = keyFile(ownKey, "sentry.key");
+
+        expect(describe_([sling({ privateKeyFile: file })])).toBe(
+            `sentry 1 ${ownAddress} (key in ${file})`,
+        );
+    });
+
+    it("should tell a sentry that is appointed only", () => {
+        expect(describe_([sling(), { address: external }], 1)).toBe(
+            `sentry 2 ${external} (appointed only)`,
+        );
+    });
+});
diff --git a/apps/cli/tests/unit/validations.test.ts b/apps/cli/tests/unit/validations.test.ts
index f75188e2..6bb6f20d 100644
--- a/apps/cli/tests/unit/validations.test.ts
+++ b/apps/cli/tests/unit/validations.test.ts
@@ -1,5 +1,6 @@
 import {
     afterAll,
+    beforeAll,
     beforeEach,
     describe,
     expect,
@@ -7,6 +8,9 @@ import {
     mock,
     spyOn,
 } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import * as viem from "viem";
 import { celo, sepolia } from "viem/chains";
 import {
@@ -21,7 +25,11 @@ import {
 import ForkChainValidationError from "../../src/errors/ForkChainValidationError";
 import UnsupportedForkChainError from "../../src/errors/UnsupportedForkChainError";
 import type { ForkConfig } from "../../src/types/chain";
-import { assertForkConfig } from "../../src/validations";
+import {
+    assertBlockchainEndpoint,
+    assertForkConfig,
+    assertSecretFiles,
+} from "../../src/validations";
 
 const mockGetBlockNumber = mock().mockResolvedValue(12345n);
 const mockGetCode = mock().mockResolvedValue("0x1234");
@@ -311,4 +319,125 @@ describe("validations", () => {
             expect(mockGetCode.mock.calls[0][0].blockNumber).toBe(999n);
         });
     });
+
+    describe("assertSecretFiles", () => {
+        let dir: string;
+        let keyFile: string;
+
+        beforeAll(() => {
+            dir = fs.mkdtempSync(path.join(os.tmpdir(), "secrets-"));
+            keyFile = path.join(dir, "key");
+            fs.writeFileSync(keyFile, "0xsecret\n");
+        });
+
+        afterAll(() => fs.rmSync(dir, { recursive: true }));
+
+        it("should accept readable key files", () => {
+            expect(() =>
+                assertSecretFiles({
+                    CARTESI_AUTH_PRIVATE_KEY_FILE: keyFile,
+                    CARTESI_PRT_AUTH_MNEMONIC_FILE: keyFile,
+                }),
+            ).not.toThrow();
+        });
+
+        it("should ignore the variables that name no file", () => {
+            expect(() =>
+                assertSecretFiles({
+                    CARTESI_AUTH_PRIVATE_KEY: "0xsecret",
+                    CARTESI_SNAPSHOTS_DIR: dir,
+                }),
+            ).not.toThrow();
+        });
+
+        it("should name the variable and path of a missing file", () => {
+            const missing = path.join(dir, "missing");
+
+            expect(() =>
+                assertSecretFiles({
+                    CARTESI_PRT_AUTH_PRIVATE_KEY_FILE: missing,
+                }),
+            ).toThrow(
+                `CARTESI_PRT_AUTH_PRIVATE_KEY_FILE must name a readable file: "${missing}"`,
+            );
+        });
+
+        it("should reject a directory", () => {
+            expect(() =>
+                assertSecretFiles({ CARTESI_AUTH_MNEMONIC_FILE: dir }),
+            ).toThrow("CARTESI_AUTH_MNEMONIC_FILE must name a readable file");
+        });
+    });
+
+    // the cases of the node's own tests (internal/httpclient/client_test.go and
+    // internal/config/http_endpoints_test.go), then the edges of Go's url.Parse;
+    // all checked against the alpha.14 node binary, which only differs in
+    // accepting trailing whitespace after the path
+    describe("assertBlockchainEndpoint", () => {
+        const marker = "SECRET";
+        const expectedError =
+            "CARTESI_BLOCKCHAIN_HTTP_ENDPOINT must be an http(s) URL with a DNS name or IP address (redirects are not followed)";
+
+        it.each([
+            "http://localhost:8545",
+            "https://u:p@example.com/path?q=key",
+            "http://[::1]:8545/rpc",
+            `http://user:${marker}@provider.example:8545/a%2Fb?key=${marker}&key=second`,
+            `https://user:${marker}@provider.example:8545/a%2Fb?key=${marker}&key=second`,
+            "HTTPS://provider.example",
+            "http://provider.example:",
+            "http://[fe80::1%25en0]:8545",
+            "http://us%41er@provider.example",
+            "http://ho%c3%a9st",
+            "http://provider.example?%zz",
+        ])("should accept %p", (endpoint) => {
+            expect(() =>
+                assertBlockchainEndpoint({
+                    CARTESI_BLOCKCHAIN_HTTP_ENDPOINT: endpoint,
+                }),
+            ).not.toThrow();
+        });
+
+        it.each([
+            "",
+            `${marker}.sock`,
+            `wss://host/${marker}`,
+            `ws://host/${marker}`,
+            `ipc://host/${marker}`,
+            `file:///tmp/${marker}`,
+            `/tmp/${marker}`,
+            `https:///${marker}`,
+            `http:///${marker}`,
+            `http://:8545/${marker}`,
+            `https://:8545/${marker}`,
+            `http:${marker}`,
+            `http://host/%${marker}`,
+            `https://provider.example/%${marker}`,
+            `http://host:${marker}`,
+            `http://user:${marker}@/`,
+            `http://user:${marker}@host:8545:8545`,
+            `http://[${marker}]:8545`,
+            `http://[::1/${marker}`,
+            `http://[fe80::1%en0]/${marker}`,
+            `http://ho st/${marker}`,
+            `http://ho%20st/${marker}`,
+            `http://us er:${marker}@host`,
+            `http://host/${marker}#%zz`,
+            ` http://host/${marker}`,
+            `http://host/${marker} `,
+            `http://host/${marker}\n`,
+        ])("should reject %p without showing it", (endpoint) => {
+            const assert = () =>
+                assertBlockchainEndpoint({
+                    CARTESI_BLOCKCHAIN_HTTP_ENDPOINT: endpoint,
+                });
+
+            expect(assert).toThrow(expectedError);
+            expect(assert).not.toThrow(marker);
+        });
+
+        it("should leave the endpoint to the CLI when the host sets none", () => {
+            expect(() => assertBlockchainEndpoint({})).not.toThrow();
+        });
+    });
 });
diff --git a/apps/cli/tests/unit/wallet.test.ts b/apps/cli/tests/unit/wallet.test.ts
index 22a03f72..a02f0fb0 100644
--- a/apps/cli/tests/unit/wallet.test.ts
+++ b/apps/cli/tests/unit/wallet.test.ts
@@ -1,6 +1,14 @@
 import { describe, expect, it } from "bun:test";
 import { DEVNET_MNEMONIC } from "../../src/compose/node";
-import { findMnemonicAccountIndex } from "../../src/wallet";
+import type { Address } from "viem";
+import { mnemonicToAccount } from "viem/accounts";
+import {
+    DEFAULT_SENDER_INDEX,
+    DEVNET_ACCOUNTS,
+    findMnemonicAccountIndex,
+    getDefaultSender,
+    getDevnetAccount,
+} from "../../src/wallet";
 
 describe("findMnemonicAccountIndex", () => {
     it("should find the index of a devnet account", () => {
@@ -42,3 +50,61 @@ describe("findMnemonicAccountIndex", () => {
         ).toBeUndefined();
     });
 });
+
+describe("getDefaultSender", () => {
+    const devnetAddresses = (count: number): Address[] =>
+        Array.from(
+            { length: count },
+            (_, addressIndex) =>
+                mnemonicToAccount(DEVNET_MNEMONIC, { addressIndex }).address,
+        );
+    const client = (addresses: Address[]) => ({
+        getAddresses: async () => addresses,
+    });
+
+    it("should be devnet account 8", async () => {
+        expect(DEFAULT_SENDER_INDEX).toBe(8);
+        expect(await getDefaultSender(client(devnetAddresses(10)))).toBe(
+            "0x23618e81E3f5cdF7f54C3d65f7FBc0aBf5B21E8f",
+        );
+    });
+
+    it("should ask for --from when the RPC exposes too few accounts", async () => {
+        await expect(
+            getDefaultSender(client(devnetAddresses(8))),
+        ).rejects.toThrow(
+            "The RPC exposes 8 accounts, so there is no devnet account 8 to send from; pass --from to choose the sender",
+        );
+    });
+});
+
+describe("getDevnetAccount", () => {
+    it("should derive the address and key of a devnet account", () => {
+        const account = mnemonicToAccount(DEVNET_MNEMONIC, {
+            addressIndex: 20,
+        });
+
+        expect(getDevnetAccount(20)).toEqual({
+            address: account.address,
+            privateKey: `0x${Buffer.from(account.getHdKey().privateKey as Uint8Array).toString("hex")}`,
+        });
+    });
+
+    it("should be the account anvil funds for the first indexes", () => {
+        expect(getDevnetAccount(0).address).toBe(
+            "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        );
+        expect(getDevnetAccount(0).privateKey).toBe(
+            "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+        );
+    });
+
+    it.each([-1, 1.5, DEVNET_ACCOUNTS])(
+        "should fail for the index %s",
+        (index) => {
+            expect(() => getDevnetAccount(index)).toThrow(
+                `There is no devnet account ${index}, the CLI derives accounts 0 to ${DEVNET_ACCOUNTS - 1}`,
+            );
+        },
+    );
+});
diff --git a/bun.lock b/bun.lock
index 98f12444..bb3025ba 100644
--- a/bun.lock
+++ b/bun.lock
@@ -18,7 +18,7 @@
         "cartesi": "./dist/index.js",
       },
       "devDependencies": {
-        "@cartesi/wagmi-plugin": "1.0.0-alpha.7",
+        "@cartesi/wagmi-plugin": "1.0.0-alpha.9",
         "@commander-js/extra-typings": "^15.0.0",
         "@inquirer/confirm": "^6.3.3",
         "@inquirer/core": "^12.0.4",
@@ -113,7 +113,7 @@
 
     "@cartesi/sdk": ["@cartesi/sdk@workspace:packages/sdk"],
 
-    "@cartesi/wagmi-plugin": ["@cartesi/wagmi-plugin@1.0.0-alpha.7", "", { "dependencies": { "abitype": "^1.3.0", "modern-tar": "^0.8.4" }, "peerDependencies": { "@wagmi/cli": "^2.10.0", "viem": "^2.0.0" } }, "sha512-oVgBBMxuEd/xa5OSxToGjRf7nOA9OyjXLmCyH8V19DjZ+k9GNFFfZSDsk7bbDHtia1Vnq4nl6aNU6dU0K7po3w=="],
+    "@cartesi/wagmi-plugin": ["@cartesi/wagmi-plugin@1.0.0-alpha.9", "", { "dependencies": { "abitype": "^1.3.0", "modern-tar": "^0.8.6" }, "peerDependencies": { "@wagmi/cli": "^2.10.0", "viem": "^2.0.0" } }, "sha512-NDk3CQhgY1uowuFz9QVpj0KycSN2nxlmHRM7SxwmtOwRDpZkTlhO1IYXs1YJk92+s3grS9igP8CbpXjCkB76mw=="],
 
     "@changesets/apply-release-plan": ["@changesets/apply-release-plan@8.1.1", "", { "dependencies": { "@changesets/config": "^4.0.1", "@changesets/format": "^0.1.2", "@changesets/git": "^4.0.1", "@changesets/should-skip-package": "^1.0.0", "@changesets/types": "^7.0.0", "import-meta-resolve": "^4.2.0", "jsonc-parser": "^3.3.1", "semver": "^7.8.1" } }, "sha512-nk2Hbq3M9NeHMdaIRBDvawKrQJzXB9sGyBUE5yWnIKtvdcNCPj75zBekJYr0gTT2ecJH3eFeTrc8eisPImcv0Q=="],
 
diff --git a/packages/sdk/.gitignore b/packages/sdk/.gitignore
index 85b2aef5..a8453c9c 100644
--- a/packages/sdk/.gitignore
+++ b/packages/sdk/.gitignore
@@ -1 +1,2 @@
 build.json
+rollups-node/
diff --git a/packages/sdk/Dockerfile b/packages/sdk/Dockerfile
index 72af7b36..b37f67a7 100644
--- a/packages/sdk/Dockerfile
+++ b/packages/sdk/Dockerfile
@@ -88,7 +88,7 @@ RUN <<EOF
 mkdir -p /opt/devnet
 curl -fsSL https://github.com/cartesi/dave/releases/download/v${CARTESI_PRT_VERSION}/cartesi-rollups-prt-${CARTESI_PRT_VERSION}-anvil-${FOUNDRY_VERSION}.tar.gz \
   -o /tmp/prt-anvil.tar.gz
-echo "7e6b6a402b5e384fd6aa56387726cf4cc08783b6350b1c16a71a2e6ff454e583 /tmp/prt-anvil.tar.gz" | sha256sum --check
+echo "62500dc3558fbb1f289d99584cd8989d7b42d0c0e7e7a13b8f2d309746e9163e /tmp/prt-anvil.tar.gz" | sha256sum --check
 tar -xzO -f /tmp/prt-anvil.tar.gz state.json > /opt/devnet/anvil_state.json
 rm /tmp/prt-anvil.tar.gz
 echo ${CARTESI_PRT_VERSION} > /opt/devnet/PRT_VERSION
@@ -160,11 +160,11 @@ ARG CARTESI_PRT_VERSION
 ARG TARGETARCH
 WORKDIR /tmp
 RUN <<EOF
-curl -fsSL https://github.com/cartesi/dave/releases/download/v${CARTESI_PRT_VERSION}/cartesi-rollups-prt-${CARTESI_PRT_VERSION}-node-${TARGETARCH}.tar.gz \
+curl -fsSL https://github.com/cartesi/dave/releases/download/v${CARTESI_PRT_VERSION}/cartesi-sling-node-${CARTESI_PRT_VERSION}-${TARGETARCH}.tar.gz \
     -o ./sling-node.tar.gz;
 case "${TARGETARCH}" in
-    amd64) echo "a69beb8a96aad4eb0e7be1ac492bc6e3e312cbc105456403b14d2889c8364f68 /tmp/sling-node.tar.gz" | sha256sum --check ;;
-    arm64) echo "c19e932f6b4ac1039af8b0fac2355268397e31cae6302809cad50221d9058cba /tmp/sling-node.tar.gz" | sha256sum --check ;;
+    amd64) echo "25c04e29a1c3da2dec1cfc02413cae053b6093fe40c264348aeac69b680a0757 /tmp/sling-node.tar.gz" | sha256sum --check ;;
+    arm64) echo "a15c5df6679186f39c6e634815ecd47d696a947ad0ce66cf1f23b44d81d70b1a /tmp/sling-node.tar.gz" | sha256sum --check ;;
     *) echo "unsupported architecture: ${TARGETARCH}"; exit 1 ;;
 esac
 tar -xvzf /tmp/sling-node.tar.gz -C /usr/local/bin
@@ -207,8 +207,8 @@ RUN <<EOF
 curl -fsSL https://github.com/cartesi/machine-emulator/releases/download/v${CARTESI_MACHINE_EMULATOR_VERSION}/machine-emulator_${TARGETARCH}.deb \
     -o /tmp/machine-emulator.deb
 case "${TARGETARCH}" in
-    amd64) echo "5f13034f43454c340062c677146daabe77c587cee1bd60342c95b8ad8f1463a3  /tmp/machine-emulator.deb" | sha256sum --check ;;
-    arm64) echo "866f0bde2db53b9b8e6a6eac85e5ad4116338379fa25cdfcc5e4bf835f948bb1  /tmp/machine-emulator.deb" | sha256sum --check ;;
+    amd64) echo "906ae4cd0524ef254ea9a83712e6ad353c36123acae21628fb93c1c47955429a  /tmp/machine-emulator.deb" | sha256sum --check ;;
+    arm64) echo "212710b5ad74e469368cd5f54b006eebde1e8620833acca5be9a845cf74ab2cc  /tmp/machine-emulator.deb" | sha256sum --check ;;
     *) echo "unsupported architecture: ${TARGETARCH}"; exit 1 ;;
 esac
 apt-get install -y --no-install-recommends /tmp/machine-emulator.deb
@@ -216,15 +216,9 @@ rm /tmp/machine-emulator.deb
 cartesi-machine --version-json
 EOF
 
-# Install cartesi-rollups-node
+# Install cartesi-rollups-node (WIP: built by rollups-node CI, see scripts/fetch-rollups-node.sh)
+COPY rollups-node/cartesi-rollups-node_${TARGETARCH}.deb /tmp/cartesi-rollups-node.deb
 RUN <<EOF
-curl -fsSL https://github.com/cartesi/rollups-node/releases/download/v${CARTESI_ROLLUPS_NODE_VERSION}/cartesi-rollups-node-v${CARTESI_ROLLUPS_NODE_VERSION}_${TARGETARCH}.deb \
-    -o /tmp/cartesi-rollups-node.deb
-case "${TARGETARCH}" in
-    amd64) echo "5c75b12082bded69e589781715c74ce7ddf433a7ed2fa6f831e92315fa6dc003 /tmp/cartesi-rollups-node.deb" | sha256sum --check ;;
-    arm64) echo "ab4007baa7ea37ed58957fa94478c5f6e6999ca5234520bbfecb82e9c9c9bab3 /tmp/cartesi-rollups-node.deb" | sha256sum --check ;;
-    *) echo "unsupported architecture: ${TARGETARCH}"; exit 1 ;;
-esac
 apt-get install -y --no-install-recommends /tmp/cartesi-rollups-node.deb
 rm /tmp/cartesi-rollups-node.deb
 mkdir -p /var/lib/cartesi-rollups-node/snapshots
@@ -238,7 +232,7 @@ COPY --from=nitro /usr/local/src/nitro /usr/local/bin/
 COPY --from=nitro /usr/local/src/nitroctl /usr/local/bin/
 COPY --from=tini /usr/local/bin/tini /usr/local/bin/
 COPY --from=telegraf /usr/local/bin/telegraf /usr/local/bin/
-COPY --from=sling-node --chmod=755 /usr/local/bin/cartesi-rollups-prt-node /usr/local/bin/cartesi-rollups-prt-node
+COPY --from=sling-node --chmod=755 /usr/local/bin/cartesi-sling-node /usr/local/bin/cartesi-sling-node
 
 COPY skel/ /
 RUN <<EOF
@@ -285,7 +279,9 @@ RUN /usr/local/bin/docker-ensure-initdb.sh postgres
 ################################################################################
 # rollups-database image
 FROM ${POSTGRES_BASE_IMAGE} AS rollups-database
-COPY --from=postgresql-initdb /var/lib/postgresql/data /var/lib/postgresql/data
+# postgres 18+ keeps PGDATA at /var/lib/postgresql/<major>/docker (not .../data),
+# so copy the whole VOLUME directory; the final stage shares the same default PGDATA
+COPY --from=postgresql-initdb /var/lib/postgresql /var/lib/postgresql
 
 ################################################################################
 # alto build
@@ -314,21 +310,19 @@ EOF
 ################################################################################
 # linux kernel image stage
 FROM scratch AS kernel-image
-ARG CARTESI_IMAGE_KERNEL_VERSION
 ARG CARTESI_LINUX_KERNEL_VERSION
 
-ADD --checksum=sha256:5c900060da2db2bfa84cd39cd9cd722988c83c42225f3cac55f2d3157e48f32f \
-  https://github.com/cartesi/image-kernel/releases/download/v${CARTESI_IMAGE_KERNEL_VERSION}/linux-${CARTESI_LINUX_KERNEL_VERSION}.bin \
+ADD --checksum=sha256:ad12ad141e639fb7b8ce0477dfbb7aa7a4d178222b06e0ce9b335a1c5230f0e1 \
+  https://github.com/cartesi/linux/releases/download/v${CARTESI_LINUX_KERNEL_VERSION}/linux-${CARTESI_LINUX_KERNEL_VERSION}.bin \
   /usr/share/cartesi-machine/images/linux.bin
 
 ################################################################################
 # linux headers stage
 FROM base AS kernel-headers
-ARG CARTESI_IMAGE_KERNEL_VERSION
 ARG CARTESI_LINUX_KERNEL_VERSION
 
-ADD --checksum=sha256:e3f140a8632fcfb18218e7aea32a7d002124d3dce5ba8121ae061ab7f40a6cf4 \
-  https://github.com/cartesi/image-kernel/releases/download/v${CARTESI_IMAGE_KERNEL_VERSION}/linux-headers-${CARTESI_LINUX_KERNEL_VERSION}.tar.xz \
+ADD --checksum=sha256:0c6ef54c47e50502a00f6d3785be1f797f74c8bc2f0b3bc0f22bc26017569aa1 \
+  https://github.com/cartesi/linux/releases/download/v${CARTESI_LINUX_KERNEL_VERSION}/linux-headers-${CARTESI_LINUX_KERNEL_VERSION}.tar.xz \
   /tmp/linux-headers-${CARTESI_LINUX_KERNEL_VERSION}.tar.xz
 RUN tar -xJf "/tmp/linux-headers-${CARTESI_LINUX_KERNEL_VERSION}.tar.xz" -C /
 
diff --git a/packages/sdk/README.md b/packages/sdk/README.md
index c606639e..82a0c703 100644
--- a/packages/sdk/README.md
+++ b/packages/sdk/README.md
@@ -16,6 +16,15 @@ docker run cartesi/sdk:<version> cartesi-machine --help
 
 ## Building the image
 
+> **WIP, until the next rollups-node release:** the images install a rollups-node built by
+> rollups-node CI instead of a release. `bun run build` (here or at the repository root)
+> first runs `scripts/fetch-rollups-node.sh`, which downloads the `.deb` files of the
+> pinned run into `rollups-node/` (git-ignored) and skips the download once they are
+> there, then bakes `cartesi/sdk:devel`, `cartesi/rollups-runtime:devel` and
+> `cartesi/rollups-database:devel`. Use them with `sdk = "cartesi/sdk:devel"` in
+> `cartesi.toml` and `cartesi run --runtime-version devel`. Set `ROLLUPS_NODE_RUN_ID`
+> to take another run.
+
 To build and publish the images to the registry, you need to have the `docker` CLI installed and logged in to both `ghcr.io/cartesi` and `docker.io` registries.
 
 Then you can run the following command:
diff --git a/packages/sdk/devnet b/packages/sdk/devnet
index 960f2d6c..418adf17 100755
--- a/packages/sdk/devnet
+++ b/packages/sdk/devnet
@@ -1,3 +1,3 @@
 #!/usr/bin/env sh
 set -e
-exec anvil --load-state /usr/share/cartesi/anvil_state.json "$@"
+exec anvil --load-state /usr/share/cartesi/anvil_state.json --preserve-historical-states --max-persisted-states 86400 "$@"
diff --git a/packages/sdk/docker-bake.hcl b/packages/sdk/docker-bake.hcl
index d5bcaa8a..feb3343b 100644
--- a/packages/sdk/docker-bake.hcl
+++ b/packages/sdk/docker-bake.hcl
@@ -9,18 +9,17 @@ target "default" {
     ALTO_VERSION                      = "1.2.7"
     ALTO_PACKAGE_VERSION              = "0.0.20"
     CARTESI_BASE_IMAGE                = "docker.io/library/debian:trixie-20260918@sha256:9cc080028c43b27d2074d63a5f9caf7166d731494965616c1a6d2827a004585c"
-    CARTESI_IMAGE_KERNEL_VERSION      = "0.21.0"
-    CARTESI_LINUX_KERNEL_VERSION      = "6.5.13-ctsi-2-v0.21.0"
-    CARTESI_MACHINE_EMULATOR_VERSION  = "0.21.0"
+    CARTESI_LINUX_KERNEL_VERSION      = "6.18.56-ctsi-1"
+    CARTESI_MACHINE_EMULATOR_VERSION  = "0.22.0"
     CARTESI_PASSKEY_SERVER_VERSION    = "1.0.1"
     CARTESI_PAYMASTER_VERSION         = "0.2.0"
-    CARTESI_PRT_VERSION               = "3.0.0-alpha.5"
+    CARTESI_PRT_VERSION               = "3.0.0-alpha.6"
     CARTESI_ROLLUPS_NODE_VERSION      = "2.0.0-alpha.13"
     FOUNDRY_VERSION                   = "1.5.1"
     NITRO_VERSION                     = "c937fa4fd202074dd250086ebd92de6884968b84" # v0.8.1
     NODE_VERSION                      = "24.14.0"
     NVM_VERSION                       = "977563e97ddc66facf3a8e31c6cff01d236f09bd" # 0.40.3
-    POSTGRES_BASE_IMAGE               = "docker.io/library/postgres:17-trixie@sha256:d74eeac9a635390a49bc21bd49fccd973de707e2a53a76ac49b552b8712ec46f"
+    POSTGRES_BASE_IMAGE               = "docker.io/library/postgres:18-trixie@sha256:74935e72241653ca55e0414067e6d8763aceb8a810eb51b452253ec3dcfc4336"
     SQUASHFS_TOOLS_VERSION            = "bad1d213ab6df587d6fa0ef7286180fbf7b86167" # 4.7.4
     SU_EXEC_VERSION                   = "0.3"
     TELEGRAF_VERSION                  = "1.38.0"
diff --git a/packages/sdk/package.json b/packages/sdk/package.json
index 464fc4cf..6adfe1de 100644
--- a/packages/sdk/package.json
+++ b/packages/sdk/package.json
@@ -3,6 +3,7 @@
     "private": true,
     "version": "0.12.0-alpha.44",
     "scripts": {
-        "build": "docker buildx bake --load --metadata-file=build.json"
+        "build": "./scripts/fetch-rollups-node.sh && docker buildx bake --load --metadata-file=build.json",
+        "fetch:rollups-node": "./scripts/fetch-rollups-node.sh"
     }
 }
diff --git a/packages/sdk/scripts/fetch-rollups-node.sh b/packages/sdk/scripts/fetch-rollups-node.sh
new file mode 100755
index 00000000..5aa6adcc
--- /dev/null
+++ b/packages/sdk/scripts/fetch-rollups-node.sh
@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+# Fetch the rollups-node .deb files built by cartesi/rollups-node CI, through
+# nightly.link. WIP plumbing until the next rollups-node release.
+#
+# By default this takes the build the branch is verified against:
+# rollups-node#815 (chore/bump-version-alpha14) at e9eebb72, 2.0.0-alpha.14.
+# ROLLUPS_NODE_RUN_ID picks another run; ROLLUPS_NODE_RUN_ID=latest takes the
+# latest successful run of ROLLUPS_NODE_BRANCH (default next/2.0).
+#
+# The download is skipped when the .deb files of the same run are already in
+# place with the checksums recorded in SOURCE, so `bun run build` can call this
+# every time.
+set -euo pipefail
+
+DEFAULT_RUN_ID="41211121596"
+BRANCH="${ROLLUPS_NODE_BRANCH:-next/2.0}"
+RUN_ID="${ROLLUPS_NODE_RUN_ID:-$DEFAULT_RUN_ID}"
+BASE="https://nightly.link/cartesi/rollups-node"
+DEST="$(cd "$(dirname "$0")/.." && pwd)/rollups-node"
+
+sha256() {
+    if command -v sha256sum >/dev/null; then sha256sum "$@"; else shasum -a 256 "$@"; fi
+}
+
+if [[ "$RUN_ID" == "latest" ]]; then
+    page="$BASE/workflows/build/${BRANCH//\//%2F}"
+    RUN_ID="$(curl -fsSL "$page" | grep -oE 'actions/runs/[0-9]+/artifacts\.zip' | head -n1 | grep -oE '[0-9]+' || true)"
+    [[ -n "$RUN_ID" ]] || { echo "no successful run found at $page" >&2; exit 1; }
+fi
+
+run_url="https://github.com/cartesi/rollups-node/actions/runs/$RUN_ID"
+
+# already fetched: SOURCE names the same run, and each .deb still has the
+# checksum recorded there (compared here: macOS's sha256sum has no --check)
+fetched() {
+    [[ -f "$DEST/SOURCE" ]] && grep -qx "run: $run_url" "$DEST/SOURCE" || return 1
+    for arch in amd64 arm64; do
+        local file="cartesi-rollups-node_$arch.deb" expected actual
+        [[ -f "$DEST/$file" ]] || return 1
+        expected="$(grep " $file\$" "$DEST/SOURCE" | cut -d' ' -f1)"
+        actual="$(cd "$DEST" && sha256 "$file" | cut -d' ' -f1)"
+        [[ -n "$expected" && "$expected" == "$actual" ]] || return 1
+    done
+}
+
+if fetched; then
+    echo "rollups-node packages of run $RUN_ID already in $DEST"
+    exit 0
+fi
+
+url="$BASE/actions/runs/$RUN_ID/artifacts.zip"
+tmp="$(mktemp -d)"
+trap 'rm -rf "$tmp"' EXIT
+echo "fetching rollups-node packages of run $RUN_ID..."
+curl -fsSL "$url" -o "$tmp/artifacts.zip"
+unzip -q "$tmp/artifacts.zip" -d "$tmp/artifacts"
+
+mkdir -p "$DEST"
+rm -f "$DEST"/*.deb
+for arch in amd64 arm64; do
+    src=("$tmp"/artifacts/cartesi-rollups-node-v*_"$arch".deb)
+    [[ -f "${src[0]}" ]] || { echo "missing $arch .deb in run $RUN_ID" >&2; exit 1; }
+    cp "${src[0]}" "$DEST/cartesi-rollups-node_$arch.deb"
+done
+
+{
+    echo "run: $run_url"
+    echo "url: $url"
+    (cd "$DEST" && sha256 cartesi-rollups-node_*.deb)
+} | tee "$DEST/SOURCE"