humanish 0.137.0 → 0.138.0

package/CHANGELOG.md

@@ -8,6 +8,17 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.138.0: A terminal study can run on Modal (2026-10-19)
+
+humanish 0.138.0 can run a terminal study's shell on Modal as well as E2B. Set
+`execution.target: modal-terminal` and `execution.runtimeAuth: openai-env`, sign in with
+`modal token new`, and install the optional `modal` package beside humanish. The sandbox runs as a
+non-root user with sudo, as on E2B, lives up to Modal's 24 hours, is journaled and reclaimed by id
+like an E2B sandbox, and is priced at Modal's sandbox rate. Desktop studies still run on E2B or a
+local VM.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.138.0)
+
 ## 0.137.0: Each browser participant can record its requests (2026-10-16)
 
 humanish 0.137.0 can record the requests each hosted browser participant makes. With

package/dist/cli/commands/runs.js

@@ -203,12 +203,12 @@ export function registerRuntimeCommands(parent, io) {
 export function registerReclaimCommand(parent, io) {
     parent
         .command("reclaim")
-        .description("Kill an interrupted run's sandboxes: the exact ids journaled in its sandbox-receipts.ndjson, and any sandbox E2B lists with this run's owner tags (a sandbox whose id never reached a receipt). It lists only sandboxes that match every tag of this run. --check asks E2B whether each still exists and kills nothing. Needs E2B_API_KEY in the environment or in --dotenv.")
+        .description("Kill an interrupted run's sandboxes: the exact ids journaled in its sandbox-receipts.ndjson, and any sandbox the run's provider lists with this run's owner tags (a sandbox whose id never reached a receipt). It lists only sandboxes that match every tag of this run. --check asks the provider whether each still exists and kills nothing. Needs E2B_API_KEY, or MODAL_TOKEN_ID and MODAL_TOKEN_SECRET for a run on Modal, in the environment or in --dotenv.")
         .summary("Stop or check an interrupted run's sandboxes.")
         .option("--cwd <path>", CWD_OPTION_DESCRIPTION, ".")
         .option("--run <id>", RUN_OPTION_DESCRIPTION, "latest")
         .addOption(new Option("--preflight", "Reclaim sandboxes left by interrupted `humanish study check` probes (journaled in .humanish/preflight) instead of a run's.").conflicts("run"))
-        .option("--check", "Ask E2B whether each sandbox still exists; kill nothing and write nothing. Exits 0 only when all are gone.")
+        .option("--check", "Ask the provider whether each sandbox still exists; kill nothing and write nothing. Exits 0 only when all are gone.")
         .option("--dotenv <path>", DOTENV_OPTION_DESCRIPTION)
         .addOption(envFileAliasOption())
         .option("--json", JSON_OPTION_DESCRIPTION)

package/dist/cli/doctor.js

@@ -96,6 +96,7 @@ export async function doctor(cwdInput, options = {}) {
     const checks = [
         ...(await projectChecks(projectRoot)),
         await desktopSdkCheck(setup),
+        ...(setup?.keys.includes("MODAL_TOKEN_ID") === true ? [await modalSdkCheck()] : []),
         sandboxCeilingCheck(env),
         concurrentSandboxesCheck(env),
         terminalSurfaceCheck(),
@@ -239,6 +240,25 @@ async function desktopSdkCheck(setup) {
                 : missingDesktopSdkMessage(humanishInstall()),
     };
 }
+/** The optional `modal` peer, reported only for a study that runs on Modal, which needs it. */
+async function modalSdkCheck() {
+    const present = await safeCheck(async () => {
+        try {
+            await import("modal");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    return {
+        name: "modal sdk",
+        ok: present,
+        message: present
+            ? "optional peer modal is installed; provider access is not tested"
+            : `optional peer modal is absent, and this study runs on Modal. ${desktopPeerAdvice(humanishInstall(), "modal").advice}`,
+    };
+}
 /**
  * The stakeholder surface. Reported as capability, never as a gate: the TUI is optional,
  * and `doctor` is itself mostly run by agents through a pipe, where a TTY requirement says
@@ -288,6 +308,10 @@ async function probeDoctorKeys(cwd, env, study, keyDeps, dotenv) {
     if (study) {
         const { resolveStudyManifest } = await import("../study/discover.js");
         const resolved = await resolveStudyManifest(cwd, study);
+        // A study on Modal reads the Modal token pair, which no other study needs.
+        if (resolved.ok && resolved.config.execution?.target === "modal-terminal")
+            for (const name of ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"])
+                keyNames.add(name);
         if (resolved.ok && resolved.config.comms?.email?.kind === "real") {
             const { receivingRequiredKey } = await import("../comms/setup.js");
             receivingKey = await receivingRequiredKey(cwd, resolved.config.comms.email.connection);

package/dist/keys/key-resolution.js

@@ -7,6 +7,7 @@
 //      examples document;
 //   3. the owning vendor's native store, where one exists:
 //        E2B_API_KEY  <- ~/.e2b/config.json (written by `e2b auth login`);
+//        MODAL_TOKEN_ID, MODAL_TOKEN_SECRET <- ~/.modal.toml (written by `modal token new`);
 //        GH_TOKEN     <- `gh auth token` (the gh CLI's credential chain);
 //   4. the humanish user-level store `$XDG_CONFIG_HOME/humanish/keys.env`, written only by
 //      `humanish keys set` (0600, prompted or --stdin), the fallback for vendors that ship
@@ -20,6 +21,7 @@ import { spawn } from "node:child_process";
 import { chmodSync, closeSync, constants as fsConstants, existsSync, ftruncateSync, lstatSync, mkdirSync, openSync, readFileSync, writeSync, } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
+import { parse as parseToml } from "smol-toml";
 import { loadEnvFile } from "./env-file.js";
 import { cli } from "../cli/invocation.js";
 import { humanishConfigFile } from "../cli/user-config.js";
@@ -48,6 +50,14 @@ const PROVIDER_KEYS = [
         listed: { order: 1, use: "hosted desktops" },
         doctor: true,
     },
+    {
+        name: "MODAL_TOKEN_ID",
+        vendor: "modal",
+        login: "modal token new",
+    },
+    { name: "MODAL_TOKEN_SECRET", login: "modal token new" },
+    // Which Modal environment sandboxes are created in; not a secret, but it names the account.
+    { name: "MODAL_ENVIRONMENT" },
     { name: "ANTHROPIC_API_KEY", vendor: "anthropic" },
     {
         name: "GH_TOKEN",
@@ -81,6 +91,36 @@ export function userKeyStorePath(env, deps = {}) {
 function e2bConfigPath(deps) {
     return path.join(deps.homeDir ?? homedir(), ".e2b", "config.json");
 }
+/**
+ * The token pair and environment of the Modal CLI's profile, as Modal picks it: MODAL_PROFILE
+ * when set, else the profile marked `active`, else the only profile. Null when there is none.
+ */
+function readModalProfile(env, deps) {
+    try {
+        const file = env.MODAL_CONFIG_PATH?.trim() || path.join(deps.homeDir ?? homedir(), ".modal.toml");
+        if (!isRegularFile(file))
+            return null;
+        const profiles = [];
+        for (const [name, values] of Object.entries(parseToml(readFileSync(file, "utf8"))))
+            if (values !== null && typeof values === "object" && !Array.isArray(values))
+                profiles.push([name, values]);
+        const named = env.MODAL_PROFILE?.trim();
+        const profile = named
+            ? profiles.find(([name]) => name === named)?.[1]
+            : (profiles.find(([, values]) => values.active === true)?.[1] ??
+                (profiles.length === 1 ? profiles[0]?.[1] : undefined));
+        const text = (value) => typeof value === "string" && value.trim() !== "" ? value.trim() : undefined;
+        const tokenId = text(profile?.token_id);
+        const tokenSecret = text(profile?.token_secret);
+        if (tokenId === undefined || tokenSecret === undefined)
+            return null;
+        const environment = text(profile?.environment);
+        return { tokenId, tokenSecret, ...(environment === undefined ? {} : { environment }) };
+    }
+    catch {
+        return null;
+    }
+}
 /** Default exec: bounded, quiet, stdin closed; null on any failure. Never throws. */
 function defaultExecText(command, args, timeoutMs, env) {
     return new Promise((resolve) => {
@@ -205,7 +245,18 @@ export async function discoverProviderKeys(args) {
         if (teamKey !== null)
             fill("E2B_API_KEY", teamKey, "~/.e2b/config.json (e2b auth login)");
     }
-    // Rung 3b: the gh CLI's credential chain. Only consulted when neither GitHub env name is
+    // Rung 3b: the modal CLI's profile. Both tokens come from the same profile or neither does.
+    if (fillable("MODAL_TOKEN_ID") && fillable("MODAL_TOKEN_SECRET")) {
+        const profile = readModalProfile(env, deps);
+        if (profile !== null) {
+            const source = "~/.modal.toml (modal token new)";
+            fill("MODAL_TOKEN_ID", profile.tokenId, source);
+            fill("MODAL_TOKEN_SECRET", profile.tokenSecret, source);
+            if (profile.environment !== undefined && fillable("MODAL_ENVIRONMENT"))
+                fill("MODAL_ENVIRONMENT", profile.environment, source);
+        }
+    }
+    // Rung 3c: the gh CLI's credential chain. Only consulted when neither GitHub env name is
     // present; fills GH_TOKEN (the name humanish reads first). gh runs without any provider key in
     // its environment, so the keys the rungs above just filled stay in this process.
     if (fillable("GH_TOKEN") && fillable("GITHUB_TOKEN")) {
@@ -265,7 +316,7 @@ export function describeMissingKeys(names, env) {
     const strict = env.HUMANISH_STRICT_KEYS?.trim() === "1";
     const chain = strict
         ? "key discovery is disabled (HUMANISH_STRICT_KEYS=1); only process env and --dotenv are read"
-        : `also checked ${PROJECT_OVERLAY_RELATIVE}, ~/.e2b/config.json, gh auth token, and ${path.join("~", ".config", "humanish", "keys.env")}`;
+        : `also checked ${PROJECT_OVERLAY_RELATIVE}, ~/.e2b/config.json, ~/.modal.toml, gh auth token, and ${path.join("~", ".config", "humanish", "keys.env")}`;
     return `${chain}. Fill: ${hints}.`;
 }
 /**

package/dist/routes/terminal/live-sandbox.d.ts

@@ -26,6 +26,8 @@ export interface LiveSandboxInputs {
     verdictNonce: string;
     maxMinutes: number;
     e2bApiKey: string;
+    /** The run's env; a Modal run reads its Modal credentials from it. */
+    env: Readonly<Record<string, string | undefined>>;
     runPaths: StartedRun["paths"];
     metadata: ReturnType<typeof buildSandboxMetadata>;
     /** The run's warnings. Steps append to them. */

package/dist/routes/terminal/live-sandbox.js

@@ -11,6 +11,7 @@ import { extractLocalActorVerdict, normalizeLocalActorTranscript, } from "../../
 import { NODE_BOOTSTRAP_COMMAND, NODE_BOOTSTRAP_TIMEOUT_MS } from "../../subject/node-bootstrap.js";
 import { observeDesktopResources, } from "../../substrates/e2b/desktop-resources.js";
 import { acquireE2BShellSandbox } from "../../substrates/e2b/sandbox.js";
+import { loadModalShellModule } from "../../substrates/modal/sandbox.js";
 import { e2bAccount } from "../../substrates/e2b/connection.js";
 import { E2BDesktopStartupError, loadE2BDesktopModule, } from "../../substrates/e2b/sdk.js";
 import { shellQuote } from "../../substrates/shell.js";
@@ -60,7 +61,10 @@ export class LiveTerminalSandbox {
         const { requestTimeoutMs, sandboxTimeoutMs } = this;
         // Declared egress allowlist, or undefined for the historical unrestricted default.
         const egressAllow = plan.egressAllow;
-        const sandboxModule = await (deps.desktopModule ?? loadE2BDesktopModule)();
+        const provider = plan.sandboxProvider;
+        const providerName = provider === "modal" ? "Modal" : "E2B";
+        const sandboxModule = await (deps.desktopModule ??
+            (provider === "modal" ? () => loadModalShellModule(this.inputs.env) : loadE2BDesktopModule))();
         await validatePreparedRunArtifactPaths(runPaths);
         // No sandbox-global env in either mode. In openai-egress, only this host-side SDK request
         // carries the real runtime key; participant commands receive an inert placeholder. The proxy
@@ -83,6 +87,7 @@ export class LiveTerminalSandbox {
         this.account = e2bAccount(sandboxModule, options);
         const acquired = await acquireE2BShellSandbox({
             module: sandboxModule,
+            provider,
             options,
             retry: {
                 // A failed first attempt may have allocated a sandbox whose id never reached this run;
@@ -103,8 +108,8 @@ export class LiveTerminalSandbox {
         this.sandboxId = sandboxId;
         this.createdAtMs = now();
         await validatePreparedRunArtifactPaths(runPaths);
-        recordLifecycle("terminal-lab.sandbox.created", `E2B shell sandbox ${sandboxId} created with allowlisted metadata and kill-on-timeout, and with no sandbox-wide environment variables.`);
-        const sandboxResources = await observeDesktopResources(sandbox);
+        recordLifecycle("terminal-lab.sandbox.created", `${providerName} shell sandbox ${sandboxId} created with allowlisted metadata and kill-on-timeout, and with no sandbox-wide environment variables.`);
+        const sandboxResources = await observeDesktopResources(sandbox, undefined, provider === "modal" ? "modal.create" : "e2b.getInfo");
         this.resources = sandboxResources;
         if ("reason" in sandboxResources) {
             warnings.push(`Sandbox resource size unavailable (${sandboxResources.reason}); its compute cost remains unpriced.`);

package/dist/routes/terminal/plan.js

@@ -9,6 +9,7 @@ import { isNonEmpty, planBase } from "../../study/plan-base.js";
 import { studyUrlCredentialReason } from "../../study/url-credentials.js";
 import { desktopMediaValidationReason, networkCaptureValidationReason, taskProtocolValidationReason, } from "../../study/validation.js";
 import { ceilingAdvice } from "../../substrates/e2b/lifetime.js";
+import { MODAL_MAX_SANDBOX_MS, MODAL_TOKEN_ID_ENV, MODAL_TOKEN_SECRET_ENV, } from "../../substrates/modal/sdk.js";
 import { NODE_BOOTSTRAP_TIMEOUT_MS } from "../../subject/node-bootstrap.js";
 import { terminalSandboxTimeoutMs } from "./lifetime.js";
 import { isExactRuntimeVersion, TERMINAL_RUNTIME_VERSION_TIMEOUT_MS } from "./runtime.js";
@@ -34,6 +35,10 @@ export function planTerminalStudy(config, input) {
     const runtimeAuth = config.execution?.runtimeAuth;
     if (runtimeAuth !== undefined && runtimeAuth !== "openai-egress" && runtimeAuth !== "openai-env")
         return refuse("HUMANISH_TERMINAL_CREDENTIAL_DENIED", "`execution.runtimeAuth` must be openai-egress or openai-env. Leave it out for openai-egress, which keeps the OpenAI key outside the sandbox.");
+    const sandboxProvider = config.execution?.target === "modal-terminal" ? "modal" : "e2b";
+    const modal = sandboxProvider === "modal" ? modalRefusal(config) : undefined;
+    if (modal !== undefined)
+        return refuse(modal.code, modal.message);
     const analysis = resolveAutomaticAnalysis(config.review?.analysis);
     if (!analysis.ok)
         return refuse("HUMANISH_STUDY_ANALYSIS_INVALID", analysis.message);
@@ -64,6 +69,7 @@ export function planTerminalStudy(config, input) {
     const shared = {
         ...base,
         route: "terminal",
+        sandboxProvider,
         actor: descriptor.id,
         product: { ...product, publicSurfaces: surfaces },
         ...(actor?.persona === undefined ? {} : { personaId: actor.persona }),
@@ -107,14 +113,16 @@ export function planTerminalStudy(config, input) {
     // The sandbox's timeout covers the steps before the codex command, maxMinutes and the teardown
     // buffer, and E2B refuses a sandbox past the plan's ceiling. Refuse here, with the arithmetic,
     // rather than after the plan prints, from a provider 400 that names neither knob.
-    const ceiling = input.sandboxCeiling;
+    const ceiling = sandboxProvider === "modal"
+        ? { ok: true, ms: MODAL_MAX_SANDBOX_MS, source: "default" }
+        : input.sandboxCeiling;
     if (!ceiling.ok)
         return refuse("HUMANISH_TERMINAL_CAPS_INVALID", ceiling.message, descriptor.id);
     const productInstall = shared.product.install !== undefined;
     const sandboxTimeoutMs = terminalSandboxTimeoutMs({ maxMinutes, productInstall });
     if (sandboxTimeoutMs > ceiling.ms) {
         const headroomMinutes = (sandboxTimeoutMs - maxMinutes * 60_000) / 60_000;
-        return refuse("HUMANISH_TERMINAL_CAPS_INVALID", `caps.maxMinutes ${maxMinutes} derives a ${sandboxTimeoutMs / 60_000}m sandbox deadline, and a sandbox may not live longer than ${ceiling.ms / 60_000}m. The deadline is maxMinutes plus ${headroomMinutes}m: the Node bootstrap (${NODE_BOOTSTRAP_TIMEOUT_MS / 60_000}m), the runtime version check (${TERMINAL_RUNTIME_VERSION_TIMEOUT_MS / 60_000}m)${productInstall ? `, the product setup (${PRODUCT_SETUP_TIMEOUT_MS / 60_000}m)` : ""} and the teardown buffer (${TERMINAL_SANDBOX_TIMEOUT_BUFFER_MS / 60_000}m). Lower caps.maxMinutes to at most ${ceiling.ms / 60_000 - headroomMinutes}.${ceilingAdvice(sandboxTimeoutMs)} No sandbox was created and the runtime key was not used.`, descriptor.id);
+        return refuse("HUMANISH_TERMINAL_CAPS_INVALID", `caps.maxMinutes ${maxMinutes} derives a ${sandboxTimeoutMs / 60_000}m sandbox deadline, and a sandbox may not live longer than ${ceiling.ms / 60_000}m. The deadline is maxMinutes plus ${headroomMinutes}m: the Node bootstrap (${NODE_BOOTSTRAP_TIMEOUT_MS / 60_000}m), the runtime version check (${TERMINAL_RUNTIME_VERSION_TIMEOUT_MS / 60_000}m)${productInstall ? `, the product setup (${PRODUCT_SETUP_TIMEOUT_MS / 60_000}m)` : ""} and the teardown buffer (${TERMINAL_SANDBOX_TIMEOUT_BUFFER_MS / 60_000}m). Lower caps.maxMinutes to at most ${ceiling.ms / 60_000 - headroomMinutes}.${sandboxProvider === "modal" ? " Modal ends every sandbox after 24 hours." : ceilingAdvice(sandboxTimeoutMs)} No sandbox was created and the runtime key was not used.`, descriptor.id);
     }
     return {
         ok: true,
@@ -122,10 +130,45 @@ export function planTerminalStudy(config, input) {
             ...shared,
             dryRun: false,
             caps: { ...caps, maxUsd, maxMinutes },
-            requirements: [
-                { kind: "key", name: "E2B_API_KEY" },
-                { kind: "key-one-of", names: ["CODEX_API_KEY", "OPENAI_API_KEY"] },
-            ],
+            requirements: liveRequirements(sandboxProvider),
         },
     };
 }
+/** The sandbox provider's keys, then the runtime key the agent's command gets. */
+function liveRequirements(provider) {
+    return [
+        ...(provider === "modal"
+            ? [
+                { kind: "key", name: MODAL_TOKEN_ID_ENV },
+                { kind: "key", name: MODAL_TOKEN_SECRET_ENV },
+            ]
+            : [{ kind: "key", name: "E2B_API_KEY" }]),
+        { kind: "key-one-of", names: ["CODEX_API_KEY", "OPENAI_API_KEY"] },
+    ];
+}
+/** What a terminal study on Modal cannot have that one on E2B can. */
+function modalRefusal(config) {
+    // E2B adds the key to requests at its egress proxy for each sandbox. Modal does that only from a
+    // Secret stored in the operator's workspace, so humanish does not place the key there itself.
+    if (config.execution?.runtimeAuth !== "openai-env")
+        return {
+            code: "HUMANISH_TERMINAL_CREDENTIAL_DENIED",
+            message: "On Modal, humanish cannot keep the OpenAI key outside the sandbox: Modal adds a key to outbound requests only from a Secret stored in your Modal workspace. Set `execution.runtimeAuth: openai-env`, which passes the key to the codex command only, or use `execution.target: e2b-terminal`.",
+        };
+    const egress = modalEgressReason(config.execution?.egressAllow);
+    return egress === undefined
+        ? undefined
+        : { code: "HUMANISH_TERMINAL_SUBJECT_INVALID", message: egress };
+}
+const CIDR = /^[0-9a-f:.]+\/\d{1,3}$/i;
+/**
+ * Why a declared egress allowlist cannot run on Modal, or undefined when it can. Modal limits
+ * egress to listed domains or CIDR ranges; an entry that is neither, such as a bare IP address,
+ * has no Modal form.
+ */
+function modalEgressReason(egressAllow) {
+    const unsupported = (egressAllow ?? []).filter((entry) => !CIDR.test(entry) && !/^(\*\.)?([a-z0-9-]+\.)+[a-z0-9-]*[a-z][a-z0-9-]*$/i.test(entry));
+    return unsupported.length === 0
+        ? undefined
+        : `Modal limits egress to domain names and CIDR ranges, and \`execution.egressAllow\` lists ${unsupported.map((entry) => `"${entry}"`).join(", ")}. Write a bare address as a /32 range, or use \`execution.target: e2b-terminal\`.`;
+}

package/dist/routes/terminal/session.js

@@ -95,6 +95,7 @@ export async function runLiveTerminalSession(args) {
         verdictNonce,
         maxMinutes,
         e2bApiKey,
+        env,
         runPaths,
         metadata: buildSandboxMetadata({ studyId: plan.studyId, recordId: "sim-001", runId }),
         warnings,
@@ -160,7 +161,13 @@ async function prepareLivePrompt(args) {
     // anything persists (a key has no detectable "shape" if it is an arbitrary token); redactText is
     // the second pass for secret-shaped content. Applied pre-truncation so a cut can never split a
     // value past the scrubber.
-    const secrets = new RunSecrets([runtimeEnv.keyValue, env.E2B_API_KEY?.trim() ?? ""]);
+    // The sandbox provider's credentials too: a provider error that quotes one reaches the run.
+    const secrets = new RunSecrets([
+        runtimeEnv.keyValue,
+        env.E2B_API_KEY?.trim() ?? "",
+        env.MODAL_TOKEN_ID?.trim() ?? "",
+        env.MODAL_TOKEN_SECRET?.trim() ?? "",
+    ]);
     const sanitize = (text) => redactText(secrets.scrub(text));
     const persona = terminalPersonaRef(terminalPersona, promptDigest, secrets.scrub);
     return {

package/dist/run/bundle.d.ts

@@ -441,7 +441,8 @@ export interface RunCostLine {
             cpuCount: number;
             memoryMiB: number;
         };
-        resourceSource?: "e2b.getInfo";
+        /** E2B's report of the allocation, or the size humanish asked Modal for. */
+        resourceSource?: "e2b.getInfo" | "modal.create";
         resourceUnavailableReason?: "metadata_unavailable" | "metadata_invalid" | "metadata_timeout";
         usdPerSecond?: number;
     };

package/dist/run/cost-summary.js

@@ -1,4 +1,4 @@
-import { estimateActorCostForExecution, estimateAllocatedDesktopCost, estimateDesktopCost, round6, } from "./pricing.js";
+import { estimateActorCostForExecution, estimateAllocatedDesktopCost, estimateDesktopCost, MODAL_SANDBOX_RESOURCE_RATE, round6, } from "./pricing.js";
 import {} from "./bundle.js";
 export function buildRunCostSummary(args) {
     const breakdown = [...modelCostLines(args.participants), ...desktopCostLines(args)];
@@ -76,8 +76,11 @@ function desktopCostLines(args) {
     const breakdown = [];
     for (const usage of args.desktops ?? []) {
         const observation = usage.observation;
-        const resources = observation && "resources" in observation ? observation.resources : undefined;
-        const estimate = estimateAllocatedDesktopCost(usage.minutes, resources);
+        const observed = observation && "resources" in observation ? observation : undefined;
+        const resources = observed?.resources;
+        const estimate = observed?.source === "modal.create"
+            ? estimateAllocatedDesktopCost(usage.minutes, resources, MODAL_SANDBOX_RESOURCE_RATE)
+            : estimateAllocatedDesktopCost(usage.minutes, resources);
         breakdown.push({
             kind: "desktop-minutes",
             ...(usage.participantId === undefined ? {} : { laneId: usage.participantId }),
@@ -88,7 +91,9 @@ function desktopCostLines(args) {
             desktop: {
                 minutes: estimate.minutes,
                 durationBasis: "host-acquired-to-cleanup",
-                ...(resources === undefined ? {} : { resources, resourceSource: "e2b.getInfo" }),
+                ...(observed === undefined
+                    ? {}
+                    : { resources: observed.resources, resourceSource: observed.source }),
                 ...(observation && "reason" in observation
                     ? { resourceUnavailableReason: observation.reason }
                     : {}),

package/dist/run/pricing.d.ts

@@ -50,6 +50,12 @@ export interface DesktopResourceRate {
     usdPerGiBSecond: number;
     asOf: string;
     source: string;
+    /** The sizes the public sheet prices; a size outside them stays unpriced. Absent: any size. */
+    sheet?: {
+        cpuCounts: readonly number[];
+        minMemoryMiB: number;
+        maxMemoryMiB: number;
+    };
 }
 /**
  * The token-derived cost estimate for one actor trace. `estimatedCostUsd: null` = declared absent
@@ -104,6 +110,11 @@ export interface DesktopCostEstimate {
     usdPerSecond?: number;
 }
 export declare const MODEL_RATES: Record<string, ModelRate>;
+/**
+ * Modal's Sandbox rate, per vCPU: Modal prices a physical core, $0.00003942 a second, and counts
+ * it as two vCPU. Modal prices every size the same way.
+ */
+export declare const MODAL_SANDBOX_RESOURCE_RATE: DesktopResourceRate;
 /**
  * The refusal for a spend cap on a model this table cannot price. It names the priced models,
  * since an npm install cannot edit this file.

package/dist/run/pricing.js

@@ -91,6 +91,19 @@ const DESKTOP_RESOURCE_RATE = {
     asOf: "2026-09-05",
     // A source label rather than an executable URL; runtime URL redaction protects E2B streams.
     source: "e2b.dev/pricing",
+    // The public Hobby/Pro sheet stops at 8 CPU / 8 GiB; larger allocations may have negotiated
+    // prices, so their resource evidence is kept without extrapolating a standard rate to them.
+    sheet: { cpuCounts: [1, 2, 4, 6, 8], minMemoryMiB: 512, maxMemoryMiB: 8192 },
+};
+/**
+ * Modal's Sandbox rate, per vCPU: Modal prices a physical core, $0.00003942 a second, and counts
+ * it as two vCPU. Modal prices every size the same way.
+ */
+export const MODAL_SANDBOX_RESOURCE_RATE = {
+    usdPerCpuSecond: 0.00003942 / 2,
+    usdPerGiBSecond: 0.00000667,
+    asOf: "2026-10-19",
+    source: "modal.com/pricing",
 };
 // Planning assumption behind the public estimateDesktopCost helper: stock desktops observed on
 // 2026-09-05 had 8 vCPU / 8 GiB. This is the largest CPU/RAM combination on that public sheet, not
@@ -131,11 +144,11 @@ export function estimateAllocatedDesktopCost(minutes, resources, rate = DESKTOP_
             minutes: round6(minutes),
         };
     }
-    // The public Hobby/Pro sheet stops at 8 CPU / 8 GiB; larger allocations may have negotiated
-    // prices. Retain the resource evidence without extrapolating a standard rate to them.
-    if (![1, 2, 4, 6, 8].includes(resources.cpuCount) ||
-        resources.memoryMiB < 512 ||
-        resources.memoryMiB > 8192 ||
+    const { sheet } = rate;
+    if ((sheet !== undefined &&
+        (!sheet.cpuCounts.includes(resources.cpuCount) ||
+            resources.memoryMiB < sheet.minMemoryMiB ||
+            resources.memoryMiB > sheet.maxMemoryMiB)) ||
         !Number.isFinite(rate.usdPerCpuSecond) ||
         rate.usdPerCpuSecond < 0 ||
         !Number.isFinite(rate.usdPerGiBSecond) ||

package/dist/run/reclaim-outcomes.d.ts

@@ -1,5 +1,8 @@
 import { type E2BTagSearch } from "../substrates/e2b/sandbox.js";
 import type { E2BAccount } from "../substrates/e2b/connection.js";
+import { type SandboxProviderId } from "./sandbox-receipts.js";
+/** The account reclaim reaches each provider through; absent when it could not be set up. */
+export type ProviderAccounts = Partial<Record<SandboxProviderId, E2BAccount>>;
 import { type ContainedRefusal, type PreparedOutputRoot } from "./contained-output.js";
 export declare const RECLAIM_RESULT_SCHEMA = "humanish.reclaim-result.v1";
 export declare const RECLAIM_RECEIPT_ARTIFACT = "reclaim-receipt.json";
@@ -50,7 +53,7 @@ export interface Target {
  * kills leaves a record of each one not yet confirmed gone.
  */
 export declare function targetSet(options: {
-    e2b: E2BAccount | undefined;
+    accounts: ProviderAccounts;
     check: boolean;
     requestTimeoutMs: number;
     earlier: ReclaimOutcome[];

package/dist/run/reclaim-outcomes.js

@@ -4,6 +4,7 @@
 // receipt writer. src/run/reclaim.ts decides what to find; this module records what happened.
 import { REDACTED_SANDBOX_ID, redactText, sandboxIdDigest, toErrorMessage, } from "../evidence/redaction.js";
 import { destroyE2BSandbox, findE2BSandboxesByTags, inspectE2BSandbox, } from "../substrates/e2b/sandbox.js";
+import { isSandboxProviderId } from "./sandbox-receipts.js";
 import { readContainedRegularFile, RUN_ARTIFACT_MAX_BYTES, writeContainedOutputFile, } from "./contained-output.js";
 import { scrubSandboxIds } from "./sandbox-ids.js";
 import { isRecord } from "./type-guards.js";
@@ -15,7 +16,7 @@ export const RECLAIM_RECEIPT_ARTIFACT = "reclaim-receipt.json";
  * kills leaves a record of each one not yet confirmed gone.
  */
 export function targetSet(options) {
-    const { e2b, check, requestTimeoutMs, earlier, persist } = options;
+    const { accounts, check, requestTimeoutMs, earlier, persist } = options;
     const targets = new Map();
     const work = [];
     const queued = [];
@@ -25,7 +26,7 @@ export function targetSet(options) {
         const seen = new Set(current.map((outcome) => outcome.sandboxIdDigest));
         return [...current, ...carried.filter((outcome) => !seen.has(outcome.sandboxIdDigest))];
     };
-    const act = (target) => actOn(e2b, target, { check, requestTimeoutMs }).then((settled) => {
+    const act = (target) => actOn(accounts, target, { check, requestTimeoutMs }).then((settled) => {
         target.outcome = settled;
         void persist.write(snapshot(), "unknown");
     });
@@ -95,17 +96,18 @@ export async function searchTagSets(e2b, tagSets, options) {
     };
 }
 /** Kill (or look up) one sandbox, and say what happened in reclaim's vocabulary. */
-async function actOn(e2b, target, options) {
+async function actOn(accounts, target, options) {
     const { outcome, provider, rawId } = target;
-    if (provider !== "e2b" || e2b === undefined)
+    const account = isSandboxProviderId(provider) ? accounts[provider] : undefined;
+    if (account === undefined)
         return {
             ...outcome,
             state: "unsupported-provider",
             detail: `provider ${JSON.stringify(provider)} is not supported by this humanish version; nothing was attempted, and that provider's own timeout is the backstop`,
         };
     const attempt = options.check
-        ? await inspectE2BSandbox(e2b, rawId, options)
-        : await destroyE2BSandbox(e2b, rawId, options);
+        ? await inspectE2BSandbox(account, rawId, options)
+        : await destroyE2BSandbox(account, rawId, options);
     const { detail: _previous, ...rest } = outcome;
     // A provider error that quotes the id is scrubbed; the raw id stays in sandbox-receipts.ndjson.
     return "detail" in attempt

package/dist/run/reclaim.d.ts

@@ -1,3 +1,4 @@
+import { type E2BAccount } from "../substrates/e2b/connection.js";
 import { type E2BDesktopModule } from "../substrates/e2b/sdk.js";
 import { type StoppedSandboxCreates } from "./sandbox-creates.js";
 import { RECLAIM_RECEIPT_ARTIFACT, RECLAIM_RESULT_SCHEMA, type ReclaimOutcome, type ReclaimState, type ReclaimTagSearch } from "./reclaim-outcomes.js";
@@ -33,13 +34,15 @@ export interface ReclaimResult {
 export interface ReclaimHooks {
     /** Tests inject a fake @e2b/desktop module; default loads the real one. */
     loadModule?: () => Promise<E2BDesktopModule>;
+    /** Tests inject a fake Modal account; default reads the Modal credentials from `env`. */
+    loadModalAccount?: (env: Readonly<Record<string, string | undefined>>) => Promise<E2BAccount>;
     /**
      * The env whose E2B_API_KEY and E2B_DOMAIN every E2B call carries. Defaults to process.env, where
      * the CLI put the run's key before the run started.
      */
     env?: Readonly<Record<string, string | undefined>>;
     requestTimeoutMs?: number;
-    /** Ask E2B whether each sandbox still exists, and kill nothing. */
+    /** Ask the provider whether each sandbox still exists, and kill nothing. */
     check?: boolean;
     /** The signal handler's view of this run's creates: the ids they reported, and those still
      *  in flight, whose sandboxes are killed as their ids arrive. */