@foldrun/core 2.12.1 → 2.13.0

package/src/runner.ts

@@ -19,7 +19,8 @@ import { cascadeLimits, toolOwners } from "./limits.ts";
 import { resolveAgentPath } from "./confine.ts";
 import { browserPodLine, podLossDecision, RERAN_ON_FULL } from "./browser-pod.ts";
 import { eventUrl } from "./webhook.ts";
-import { runStepInContainer, sizeLimits, killRunSandboxes, type StepTiming } from "./run-container.ts";
+import { runStepInContainer, resolveResources, memoryGiB, killRunSandboxes, type StepTiming } from "./run-container.ts";
+import { readResources, hasOverride } from "./resources.ts";
 import { hostSafeEnv, platformApiUrl } from "./host-env.ts";
 import { resolveModelCredential, credentialLine, accountModelBlock, isClaudeLoginToken, isModelEnvName, DECLARED_ENV_PREFIX } from "./model-credential.ts";
 import { parseJudge } from "./judge-verdict.ts";
@@ -1296,9 +1297,10 @@ export function agentContext(
   // is large — the install's configured limits — so existing agents change
   // nothing. `size: small` is the opt-in for agents that wait on APIs more
   // than they work; `size: heavy` for a rendered browser or real data in
-  // memory. Memory is a hard ceiling per class; CPU bursts uncapped and bills
-  // at the class rate, so heavy both may use more and costs more. The actuals
-  // line in any trace is the evidence for right-sizing.
+  // memory. Memory and cores are hard ceilings per class and bill at the
+  // class rate (cores capped since 26 Oct 2026), so heavy both may use more
+  // and costs more. The actuals line in any trace — busy, throttled, peak —
+  // is the evidence for right-sizing.
   const size: "small" | "large" | "heavy" =
     front.size === "small" ? "small" : front.size === "heavy" ? "heavy" : "large";
 
@@ -2311,6 +2313,16 @@ async function runStep(
     // A retry that moved the step up a class (an evicted or OOM-killed
     // attempt) wins over the agent's own `size:` for the attempts after.
     const size = step.sizeUp ?? agentSize;
+    // `resources:` over the class's figures, key by key. A value check would
+    // refuse is dropped here too (the class's figure holds) and said so, so
+    // `foldrun check` and the sandbox never disagree. After a retry moved up
+    // a class, an override never holds the step below the new class.
+    const asked = readResources(front.resources);
+    for (const p of asked.problems) push("error", `resources: ${p}`);
+    const limits = resolveResources(size, asked.value, { atLeastClass: !!step.sizeUp });
+    // What the sandbox holds while it exists — `step.holding`, what the
+    // account's compute in use sums (Settings, `foldrun usage compute`).
+    const held = { cpus: Number(limits.cpus) || 2, memGiB: memoryGiB(limits.memory) };
 
     // oauth2 secrets become live access tokens here — the one async moment
     // in secret resolution, at the last host-side point before anything is
@@ -2345,7 +2357,10 @@ async function runStep(
     const noKey = !providerLabel && !platform.platformKeyAllowed(tenant);
     const credential = providerLabel || noKey ? null : resolveModelCredential(isolatedRun() ? platformModelEnv() : process.env);
     step.credential = credential ? credential.label : noKey ? "none — this account has no model key" : `provider: ${providerLabel}`;
-    if (credential) {
+    // Core's own Docker container has no login to fall back to (below):
+    // there, "none set" is refused with what to do, not described.
+    const noCredentialInContainer = credential?.kind === "none" && process.env.FOLDRUN_RUN_ISOLATION === "container";
+    if (credential && !noCredentialInContainer) {
       const line = credentialLine(credential);
       push(line.type, line.text);
     }
@@ -2372,6 +2387,24 @@ async function runStep(
         return;
       }
     }
+    // A step in core's own Docker container (self-hosting) has no machine
+    // login to fall back to: with no credential at all it could only fail at
+    // the model, with Claude Code's own "Not logged in · Please run /login".
+    // Refused here, before a sandbox is rented, saying what to set (a
+    // self-hosted install with no key, 26 Oct 2026). A local `foldrun run`
+    // keeps the machine's login; a registered executor brings its own.
+    if (noCredentialInContainer) {
+      push(
+        "error",
+        "no model credential: this install has none and the account has no key of its own. Set ANTHROPIC_API_KEY " +
+          "(or CLAUDE_CODE_OAUTH_TOKEN from `claude setup-token`) in the platform's environment — for Docker Compose, " +
+          "self-hosting/.env, then `docker compose up -d` — or add the account's key in Settings → Model " +
+          "(`foldrun account model set <provider> --key …`)",
+      );
+      step.status = "failed";
+      save();
+      return;
+    }
     for (const w of providerWarnings) push("error", w);
     // A level that wrote a language nobody can read was skipped, not obeyed.
     for (const l of language.lines) push("info", l);
@@ -3080,6 +3113,7 @@ async function runStep(
         // executor asks this before it creates one (pod-room.ts).
         ...(stopRequested ? { stopRequested } : {}),
         size,
+        limits,
         // The pod's network, for the executor's own wall (the k8s tier's
         // network policy): a filtered pod reaches the proxy and DNS only.
         network: { level: network.level, enforced: forward?.enforce === true },
@@ -3096,6 +3130,8 @@ async function runStep(
         // saves the record, so this only updates the fields.
         checkpoint: (ref: string, consumed: number) => {
           step.sandbox = { kind: isolation!, ref, consumed, since: step.sandbox?.since ?? new Date().toISOString() };
+          // The sandbox exists: past the room gate, it now holds its figures.
+          if (consumed === 0) step.holding = held;
           if (consumed === 0) save();
         },
       });
@@ -3111,9 +3147,23 @@ async function runStep(
       // The arguments of the attempt whose outcome is current — what a
       // re-run on the full image repeats, on the same model supply.
       let lastArgs: typeof firstArgs = firstArgs;
-      const runTracked = (a: typeof firstArgs) => {
+      const runTracked = async (a: typeof firstArgs) => {
         lastArgs = a;
-        return runIsolated(a);
+        // An executor that cannot report its sandbox (Docker: no room gate,
+        // it starts at once) holds from the call; one that can says so at
+        // its first checkpoint, after any wait for room.
+        if (!platform.sandboxResumable(isolation!)) {
+          step.holding = held;
+          save();
+        }
+        try {
+          return await runIsolated(a);
+        } finally {
+          // Saved now: the clean-up after an attempt (the log drain, the
+          // lease, publishing) can take a while, and the sandbox is gone.
+          step.holding = null;
+          save();
+        }
       };
       let attemptFrom = step.events.length;
       let outcome = await runTracked(firstArgs);
@@ -3306,6 +3356,7 @@ async function runStep(
         push(
           "info",
           `resources: cpu busy ${outcome.res.busyCpuSecs?.toFixed(1) ?? "?"}s · ` +
+            (outcome.res.throttledSecs ? `throttled ${outcome.res.throttledSecs.toFixed(1)}s · ` : "") +
             `peak mem ${mb(outcome.res.peakMemBytes)}MB · ` +
             `net ${mb(outcome.res.rxBytes)}MB in / ${mb(outcome.res.txBytes)}MB out`,
         );
@@ -3326,13 +3377,8 @@ async function runStep(
       // is per core-second and per GiB-second, and what was held must come
       // from the record, never from what the config says at billing time.
       step.size = size;
-      const lim = sizeLimits(size);
-      const gib = (() => {
-        const m = lim.memory.match(/^(\d+(?:\.\d+)?)\s*(Gi?|Mi?|g|m)?/i);
-        const n = m ? Number(m[1]) : 2;
-        return (m?.[2] ?? "Gi").toLowerCase().startsWith("m") ? n / 1024 : n;
-      })();
-      step.reserved = { cpus: Number(lim.cpus) || 2, memGiB: gib };
+      if (hasOverride(asked.value)) step.resources = asked.value;
+      step.reserved = held;
     } else {
       // Same withholding as the sandbox path — the in-process step is what
       // `foldrun run --test` drives on a laptop, where there is no proxy

package/src/starter.ts

@@ -490,6 +490,7 @@ owner: ana@example.com      # who answers for it; else the workspace's, else the
 model: default              # fast | default | max
 effort: low                 # how hard to think about it
 size: large                 # small | large | heavy — the sandbox it rents
+resources: { memory: 4Gi }  # optional: cpu, memory, disk in numbers, over the size class
 tools: [web, read, ask, peers, my-folder-tool]  # built-ins and your own tools/, one list; \`ask\` lets it ask you mid-step, \`peers\` lets it message the steps running beside it
 disallowedTools: [Bash]     # subtract from what it would otherwise have
 skills: [house-style]       # from skills/

package/src/store.ts

@@ -3533,6 +3533,14 @@ export interface StepRecord {
    *  from before sizes existed — billing falls back to the flat rate. */
   size?: "small" | "large" | "heavy";
   reserved?: { cpus: number; memGiB: number } | null;
+  /** The agent's `resources:` as applied (resources.ts), when it set any:
+   *  why `reserved` differs from the class's figures. Absent before 26 Oct
+   *  2026 and on steps of an agent that wrote none. */
+  resources?: { cpu?: number; memory?: string; disk?: string };
+  /** What the step's sandbox holds while it exists — set once it is past
+   *  the room gate, cleared when the attempt ends. What an account's
+   *  compute in use sums; `reserved` is the bill's record of the same. */
+  holding?: { cpus: number; memGiB: number } | null;
   /** Token counts behind costUsd, kept so usage reports can say "how many"
    *  and not only "how much" — the price of a token changes, the count is
    *  the fact. Absent on steps recorded before this existed. */
@@ -3557,6 +3565,9 @@ export interface StepRecord {
   actual?: {
     busyCpuSecs: number | null;
     peakMemBytes: number | null;
+    /** Seconds the CPU cap (the class's cores) held the sandbox back, from
+     *  cpu.stat. Absent before 26 Oct 2026. */
+    throttledSecs?: number | null;
     rxBytes: number | null;
     txBytes: number | null;
   } | null;