humanish 0.137.0 → 0.139.0

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-shape.js

@@ -93,7 +93,7 @@ export function isRunOutcome(value) {
 function isRunProviderResource(value) {
     return (isRecord(value) &&
         value.schema === "humanish.provider-resource.v1" &&
-        value.provider === "e2b-desktop" &&
+        (value.provider === "e2b-desktop" || value.provider === "modal-desktop") &&
         value.kind === "sandbox" &&
         typeof value.id === "string" &&
         value.id.trim().length > 0 &&

package/dist/run/bundle.d.ts

@@ -53,7 +53,7 @@ export interface RunFeedbackCandidate {
     scenario_id: string;
     persona_id: string;
     actor: "codex-tui" | "codex-exec" | "codex-app-server" | "computer-use" | "synthetic-dry-run" | "unknown";
-    substrate: "e2b-desktop" | "local-desktop" | "e2b-terminal" | "local-filesystem" | "codex-app-server" | "unknown";
+    substrate: "e2b-desktop" | "modal-desktop" | "local-desktop" | "e2b-terminal" | "local-filesystem" | "codex-app-server" | "unknown";
     failure_owner: "harness" | "target-app" | "actor" | "environment" | "unknown";
     summary: string;
     expected: string;
@@ -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;
     };
@@ -478,7 +479,8 @@ export interface RunCostSummary {
 }
 export interface RunProviderResource {
     schema: "humanish.provider-resource.v1";
-    provider: "e2b-desktop";
+    /** The hosted desktop's provider: E2B, or Modal for `execution.target: modal-desktop`. */
+    provider: "e2b-desktop" | "modal-desktop";
     kind: "sandbox";
     /**
      * "[redacted-sandbox-id]" in runs from 0.110 on; earlier runs recorded the raw id here. The raw id

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/feedback-shape.js

@@ -66,6 +66,7 @@ function isFeedbackActor(value) {
 }
 function isFeedbackSubstrate(value) {
     return (value === "e2b-desktop" ||
+        value === "modal-desktop" ||
         value === "local-desktop" ||
         value === "e2b-terminal" ||
         value === "local-filesystem" ||

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. */

package/dist/run/reclaim.js

@@ -1,14 +1,16 @@
 // `humanish reclaim`: stop an interrupted run's sandboxes and report what happened to each. It
 // finds them three ways: the exact ids the run journaled at create time (sandbox-receipts.ndjson),
 // the ids a create in this process reported before its receipt landed (the signal handler only),
-// and E2B's list of sandboxes tagged with the run's owner tags (sandboxOwnerTags), which covers a
-// sandbox whose id never reached the run. The list is filtered server-side by the run's tags and
+// and each provider's list of sandboxes tagged with the run's owner tags (sandboxOwnerTags), which
+// covers a sandbox whose id never reached the run. Every sandbox is acted on through the provider
+// its receipt or owner line names: E2B, or Modal (src/substrates/modal/sandbox.ts). The list is filtered server-side by the run's tags and
 // each result is checked against every tag again, so it can only return this run's sandboxes; an
 // account-wide operation once destroyed unrelated infrastructure. Kills run concurrently, and
 // reclaim-receipt.json is written before the first kill and after each one, so an exit at any
-// point leaves a record of every sandbox not yet confirmed gone. `--check` asks E2B the same
-// questions and kills nothing.
+// point leaves a record of every sandbox not yet confirmed gone. `--check` asks the providers the
+// same questions and kills nothing.
 import { e2bAccount, e2bConnection } from "../substrates/e2b/connection.js";
+import { modalAccount } from "../substrates/modal/sandbox.js";
 import { E2B_DEBUG_ENV, e2bDebugMode, loadE2BDesktopModule, } from "../substrates/e2b/sdk.js";
 import { readContainedRegularFile, refusalText, RUN_ARTIFACT_MAX_BYTES, } from "./contained-output.js";
 import { discardPreflightJournal, listPreflightJournals, preflightReclaimDecision, } from "./preflight-receipts.js";
@@ -261,6 +263,45 @@ function unreadableMessage(file, refusal) {
     const kept = file === SANDBOX_RECEIPTS_ARTIFACT ? "the receipts were kept" : "the receipt was kept";
     return `${refusalText(file, refusal)}. Nothing was killed and ${kept}; check the file, then run reclaim again.`;
 }
+/**
+ * The account for each provider the run's journal names, or the message that stops reclaim when
+ * one it needs cannot be reached. A run with no record and creates in flight is an E2B run unless
+ * its owner line says otherwise, as every run was before Modal.
+ */
+async function reachProviders(receipts, owners, hooks) {
+    const env = hooks.env ?? process.env;
+    const recorded = new Set([
+        ...receipts.map((receipt) => receipt.provider),
+        ...owners.map((owner) => owner.provider),
+    ]);
+    // A create this process began counts too: its receipt and owner line may not have landed.
+    for (const provider of hooks.creates?.providers() ?? [])
+        recorded.add(provider);
+    const needsE2B = recorded.has("e2b") || (hooks.creates !== undefined && !recorded.has("modal"));
+    // E2B's SDK lists by tag as well as killing by id, so it is needed even with no receipt. Without
+    // it, an E2B receipt cannot be acted on; with no E2B receipt, only the tag search is lost.
+    const accounts = {};
+    const unavailable = {};
+    try {
+        const module = await (hooks.loadModule ?? loadE2BDesktopModule)();
+        accounts.e2b = e2bAccount(module, e2bConnection(env));
+    }
+    catch (error) {
+        unavailable.e2b = `Cannot load @e2b/desktop to reach E2B: ${redactText(toErrorMessage(error))}`;
+        if (needsE2B)
+            return unavailable.e2b;
+    }
+    // Modal is reached only for a run that recorded a Modal sandbox or owner line.
+    if (recorded.has("modal")) {
+        try {
+            accounts.modal = await (hooks.loadModalAccount ?? modalAccount)(env);
+        }
+        catch (error) {
+            return `Cannot reach Modal: ${redactText(toErrorMessage(error))}`;
+        }
+    }
+    return { accounts, unavailable, recorded, needsE2B };
+}
 /**
  * Find and stop (or, for `--check`, look up) every sandbox one directory owns: its receipts, the
  * creates this process reported, and E2B's tagged list, each once by exact id.
@@ -277,19 +318,10 @@ async function reclaimRoot(root, label, hooks, warnings) {
     const owners = parseSandboxOwners(journal, label);
     const check = hooks.check === true;
     const requestTimeoutMs = hooks.requestTimeoutMs ?? 60_000;
-    // The SDK lists by tag as well as killing by id, so it is needed even with no receipt. Without
-    // it, an E2B receipt cannot be acted on; with no E2B receipt, only the tag search is lost.
-    let e2b;
-    let moduleError;
-    try {
-        const module = await (hooks.loadModule ?? loadE2BDesktopModule)();
-        e2b = e2bAccount(module, e2bConnection(hooks.env ?? process.env));
-    }
-    catch (error) {
-        moduleError = `Cannot load @e2b/desktop to reach E2B: ${redactText(toErrorMessage(error))}`;
-        if (receipts.some((receipt) => receipt.provider === "e2b") || hooks.creates !== undefined)
-            return { kind: "module-unavailable", receiptCount: receipts.length, message: moduleError };
-    }
+    const reached = await reachProviders(receipts, owners, hooks);
+    if (typeof reached === "string")
+        return { kind: "module-unavailable", receiptCount: receipts.length, message: reached };
+    const { accounts, unavailable, recorded, needsE2B } = reached;
     // An earlier reclaim may have killed a sandbox no receipt names (the signal handler's creates
     // and tag finds). Its outcome is carried forward, so a later reclaim never erases that record.
     const earlier = check ? [] : await earlierOutcomes(root, label);
@@ -297,7 +329,7 @@ async function reclaimRoot(root, label, hooks, warnings) {
     if (!Array.isArray(earlier))
         return { kind: "unreadable", message: unreadableMessage(RECLAIM_RECEIPT_ARTIFACT, earlier) };
     const set = targetSet({
-        e2b,
+        accounts,
         check,
         requestTimeoutMs,
         earlier,
@@ -312,38 +344,53 @@ async function reclaimRoot(root, label, hooks, warnings) {
         if (replaying)
             replayed.set(sandbox.sandboxId, sandbox);
         else
-            set.add("e2b", sandbox.sandboxId, sandbox.participantId, "create", sandbox.released);
+            set.add(sandbox.provider, sandbox.sandboxId, sandbox.participantId, "create", sandbox.released);
     });
     replaying = false;
     for (const receipt of receipts) {
-        const released = receipt.provider === "e2b" && replayed.get(receipt.sandboxId)?.released;
+        const create = replayed.get(receipt.sandboxId);
+        const released = create?.provider === receipt.provider && create.released;
         set.add(receipt.provider, receipt.sandboxId, receipt.laneId, "receipt", released === true);
     }
     for (const sandbox of replayed.values())
-        set.add("e2b", sandbox.sandboxId, sandbox.participantId, "create", sandbox.released);
+        set.add(sandbox.provider, sandbox.sandboxId, sandbox.participantId, "create", sandbox.released);
     await set.start();
     if (hooks.creates !== undefined)
         await settledWithin(hooks.creates.settled, hooks.createsWaitMs);
-    // The tags the run recorded before each create, and this directory's own: a copied or moved
-    // run directory computes other tags than the ones its sandboxes carry.
-    const search = await searchTagSets(e2b, [...owners, sandboxOwnerTags(root)], {
-        requestTimeoutMs,
-        unavailable: moduleError ?? "no E2B SDK",
-    });
+    // Each provider is searched with the tags the run recorded for it before each create, and with
+    // this directory's own: a copied or moved run directory computes other tags than the ones its
+    // sandboxes carry. E2B is searched unless the journal names only Modal, as before Modal existed.
+    const providers = [
+        ...(needsE2B || !recorded.has("modal") ? ["e2b"] : []),
+        ...(accounts.modal === undefined ? [] : ["modal"]),
+    ];
+    const searches = await Promise.all(providers.map(async (provider) => {
+        const tagSets = [
+            ...owners.filter((owner) => owner.provider === provider).map((owner) => owner.tags),
+            sandboxOwnerTags(root),
+        ];
+        const result = await searchTagSets(accounts[provider], tagSets, {
+            requestTimeoutMs,
+            unavailable: unavailable[provider] ?? `no ${provider} account`,
+        });
+        return { provider, result };
+    }));
     let found = 0;
-    for (const listed of search.sandboxes) {
-        const metadata = listed.metadata ?? {};
-        const participant = metadata.participantId ?? metadata.kind ?? "unknown";
-        if (set.add("e2b", listed.sandboxId, participant, "tag"))
-            found += 1;
-    }
+    for (const { provider, result } of searches)
+        for (const listed of result.sandboxes) {
+            const metadata = listed.metadata ?? {};
+            const participant = metadata.participantId ?? metadata.kind ?? "unknown";
+            if (set.add(provider, listed.sandboxId, participant, "tag"))
+                found += 1;
+        }
+    const search = searches.find(({ result }) => result.status !== "done")?.result ?? searches[0].result;
     const tagSearch = {
         status: search.status,
         found,
         ...(search.detail === undefined ? {} : { detail: search.detail }),
     };
     if (search.status !== "done")
-        warnings.push(`Could not search E2B for sandboxes tagged with ${label}: ${search.detail ?? search.status}. A sandbox whose id never reached a receipt would not be found.`);
+        warnings.push(`Could not search for sandboxes tagged with ${label}: ${search.detail ?? search.status}. A sandbox whose id never reached a receipt would not be found.`);
     // A create that reports its id while the search or a kill is still running is killed too.
     await set.drain();
     unwatch?.();

package/dist/run/sandbox-creates.d.ts

@@ -1,5 +1,5 @@
 import type { PreparedOutputRoot } from "./contained-output.js";
-import type { SandboxOwnerTags } from "./sandbox-receipts.js";
+import type { SandboxOwnerTags, SandboxProviderId } from "./sandbox-receipts.js";
 /** Refuses a sandbox create for a run directory whose process is stopping. */
 export declare class SandboxCreateRefusedError extends Error {
     constructor();
@@ -7,6 +7,7 @@ export declare class SandboxCreateRefusedError extends Error {
 /** One sandbox a create in this process reported, and what its route did with it. */
 export interface CreatedSandbox {
     sandboxId: string;
+    provider: SandboxProviderId;
     /** The participant or subject label the receipt also records. */
     participantId: string;
     /** True once the route's own release confirmed the sandbox gone. */
@@ -32,14 +33,14 @@ export interface SandboxCreateTicket {
     settled(): void;
 }
 /** Register a create for `root`. Throws SandboxCreateRefusedError once the directory is stopping. */
-export declare function beginSandboxCreate(root: PreparedOutputRoot, participantId: string): SandboxCreateTicket;
+export declare function beginSandboxCreate(root: PreparedOutputRoot, participantId: string, provider: SandboxProviderId): SandboxCreateTicket;
 /**
- * Run `write` once per directory and return its promise to every caller. Creates that start
+ * Run `write` once per directory and provider and return its promise to every caller. Creates that start
  * together then resume in the order they called, so the order they reach the provider does not
  * depend on which file append finishes first. A write that reports failure is forgotten, so the
  * next create tries again.
  */
-export declare function recordSandboxOwnerOnce(root: PreparedOutputRoot, write: () => Promise<boolean>): Promise<void>;
+export declare function recordSandboxOwnerOnce(root: PreparedOutputRoot, provider: SandboxProviderId, write: () => Promise<boolean>): Promise<void>;
 /** What the signal handler holds after stopping a directory's creates. */
 export interface StoppedSandboxCreates {
     /**
@@ -51,6 +52,8 @@ export interface StoppedSandboxCreates {
     settled: Promise<void>;
     /** How many of those creates have not settled yet. */
     inFlight(): number;
+    /** The providers creates began on, including those whose id has not arrived. */
+    providers(): ReadonlySet<SandboxProviderId>;
 }
 /**
  * Stop `root`'s creates: any create that starts from now on is refused. Called synchronously when

package/dist/run/sandbox-creates.js

@@ -36,6 +36,8 @@ function directoryFor(root) {
         return existing;
     const created = {
         stopping: false,
+        ownerLines: new Map(),
+        providers: new Set(),
         created: new Map(),
         inFlight: new Set(),
         listeners: new Set(),
@@ -73,10 +75,11 @@ export function sandboxOwnerTags(root) {
     return { tool: "humanish", runId: path.basename(where), runKey };
 }
 /** Register a create for `root`. Throws SandboxCreateRefusedError once the directory is stopping. */
-export function beginSandboxCreate(root, participantId) {
+export function beginSandboxCreate(root, participantId, provider) {
     const directory = directoryFor(root);
     if (directory.stopping)
         throw new SandboxCreateRefusedError();
+    directory.providers.add(provider);
     let settle;
     const done = new Promise((resolve) => {
         settle = resolve;
@@ -87,7 +90,7 @@ export function beginSandboxCreate(root, participantId) {
         created(sandboxId) {
             if (directory.created.has(sandboxId))
                 return;
-            const sandbox = { sandboxId, participantId, released: false };
+            const sandbox = { sandboxId, provider, participantId, released: false };
             directory.created.set(sandboxId, sandbox);
             for (const listener of directory.listeners)
                 listener(sandbox);
@@ -104,17 +107,21 @@ export function beginSandboxCreate(root, participantId) {
     };
 }
 /**
- * Run `write` once per directory and return its promise to every caller. Creates that start
+ * Run `write` once per directory and provider and return its promise to every caller. Creates that start
  * together then resume in the order they called, so the order they reach the provider does not
  * depend on which file append finishes first. A write that reports failure is forgotten, so the
  * next create tries again.
  */
-export function recordSandboxOwnerOnce(root, write) {
-    const directory = directoryFor(root);
-    const pending = (directory.ownerLine ??= write().then((written) => {
-        if (!written && directory.ownerLine === pending)
-            delete directory.ownerLine;
-    }));
+export function recordSandboxOwnerOnce(root, provider, write) {
+    const { ownerLines } = directoryFor(root);
+    const existing = ownerLines.get(provider);
+    if (existing !== undefined)
+        return existing;
+    const pending = write().then((written) => {
+        if (!written && ownerLines.get(provider) === pending)
+            ownerLines.delete(provider);
+    });
+    ownerLines.set(provider, pending);
     return pending;
 }
 /**
@@ -136,5 +143,6 @@ export function stopSandboxCreates(root) {
         },
         settled: Promise.all(pending).then(() => undefined),
         inFlight: () => pending.filter((create) => directory.inFlight.has(create)).length,
+        providers: () => directory.providers,
     };
 }