diff --git a/apps/dispatcher/src/run-end.test.ts b/apps/dispatcher/src/run-end.test.ts
index 2c3d882..247bd86 100644
--- a/apps/dispatcher/src/run-end.test.ts
+++ b/apps/dispatcher/src/run-end.test.ts
@@ -9,7 +9,7 @@ const EXPIRES = 1_800_003_600;
 
 const ports = () => {
   const kill = vi.fn(async () => {});
-  const end = vi.fn(async (_: { executionId: string; expiresAt: number }) => {});
+  const end = vi.fn<(input: { executionId: string; expiresAt: number }) => Promise<void>>(async () => {});
   return {
     kill,
     end,
diff --git a/runs/contextful-cache-warm.test.ts b/runs/contextful-cache-warm.test.ts
index 667ce8a..1cbb9b6 100644
--- a/runs/contextful-cache-warm.test.ts
+++ b/runs/contextful-cache-warm.test.ts
@@ -3,7 +3,7 @@ import { Cause, Effect, Exit } from "effect";
 import { describe, expect } from "vitest";
 import { makeCFRuntimeTest } from "@fractalboxdev/flare-dispatch-core/testing";
 import { compileCacheCommand } from "@fractalboxdev/flare-dispatch-core/primitives";
-import { contextfulCacheWarm, WARM_PART } from "./contextful-cache-warm";
+import { contextfulCacheWarm, WARM_CHILDREN, WARM_PART } from "./contextful-cache-warm";
 import { lightLabelsKey, stageCommand } from "./contextful-gate";
 
 const REPO = "fractalboxdev/contextful";
@@ -29,6 +29,17 @@ const keyed = {
 };
 const cacheConfig = { "compile-cache.endpoint": ENDPOINT, "compile-cache.token": TOKEN };
 const head = { branchHeads: { [`${REPO}:main`]: SHA } };
+/** The compile groups a tree with `stages --parts --compile-groups` lists, per tier. */
+const PR_GROUPS = ["workspace.compile", "workspace.cli-1", "workspace.cli-formal", "workspace.foundation", "evaluate.cli"];
+const NIGHTLY_GROUPS = ["features.binary-all"];
+const FOLDS = "suite.cli workspace.cli-formal evaluate.cli\nsuite.foundation workspace.foundation evaluate.foundation\n";
+const listing = {
+  "--compile-groups --tier pr": { stdout: `${PR_GROUPS.join("\n")}\n`, exitCode: 0 },
+  "--compile-groups --tier nightly": { stdout: `${NIGHTLY_GROUPS.join("\n")}\n`, exitCode: 0 },
+  "stages --folds": { stdout: FOLDS, exitCode: 0 },
+};
+/** A part's compile-only command, as a gate part runs it under the cache wrapper. */
+const warmed = (part: string) => compileCacheCommand(stageCommand(part, BEFORE, prebuilt, { compileOnly: true }), REPO);
 const push = {
   ref: "refs/heads/main",
   before: BEFORE,
@@ -66,10 +77,14 @@ describe("contextful-cache-warm", () => {
     expect(contextfulCacheWarm.supersede?.(unranked)).toEqual({ group: `contextful-cache-warm:${REPO}:main`, order: 0 });
   });
 
-  it.effect("compiles the gate's compile part exactly as a gate part runs it, in one container", () => {
-    const { layer, handles } = makeCFRuntimeTest({ sandboxProgram: keyed, config: cacheConfig, github: head });
+  it.effect("falls back to the gate's compile part, exactly as a gate part runs it, when the tree lists no compile groups", () => {
+    const { layer, handles } = makeCFRuntimeTest({
+      sandboxProgram: { ...keyed, "--compile-groups": { exitCode: 2, stderr: "error: unexpected argument '--compile-groups' found\n\nUsage: contextful-ci stages" } },
+      config: cacheConfig,
+      github: head,
+    });
     return Effect.gen(function* () {
-      expect(yield* contextfulCacheWarm.run(input)).toEqual({ part: WARM_PART, exitCode: 0 });
+      expect(yield* contextfulCacheWarm.run(input)).toEqual({ parts: [{ part: WARM_PART, exitCode: 0 }], unstarted: [] });
       expect(WARM_PART).toBe("workspace.compile");
       const command = compileCacheCommand(stageCommand(WARM_PART, BEFORE, prebuilt), REPO);
       const warm = handles.sandbox.execs.filter((exec) => exec.command === command);
@@ -88,7 +103,82 @@ describe("contextful-cache-warm", () => {
       github: head,
     });
     return Effect.gen(function* () {
-      expect(yield* contextfulCacheWarm.run(input)).toEqual({ part: WARM_PART, exitCode: 101 });
+      expect(yield* contextfulCacheWarm.run(input)).toEqual({ parts: [{ part: WARM_PART, exitCode: 101 }], unstarted: [] });
+    }).pipe(Effect.provide(layer));
+  });
+
+  it.effect("spreads the compile groups over at most WARM_CHILDREN children of its own run and joins them", () => {
+    const { layer, handles } = makeCFRuntimeTest({
+      sandboxProgram: { ...keyed, ...listing },
+      config: cacheConfig,
+      github: head,
+      childRuns: { statuses: Object.fromEntries([0, 1, 2, 3].map((i) => [`contextful-cache-warm:${i}`, i === 2 ? "failure" : "success"])) },
+    });
+    return Effect.gen(function* () {
+      const groups = [...PR_GROUPS, ...NIGHTLY_GROUPS];
+      const out = yield* contextfulCacheWarm.run(input);
+      expect(WARM_CHILDREN).toBe(4);
+      const spawned = handles.childRuns.spawned;
+      expect(spawned).toHaveLength(WARM_CHILDREN);
+      expect(spawned.every((child) => child.run === "contextful-cache-warm")).toBe(true);
+      const chunks = spawned.map((child) => (child.input as { groups: string[] }).groups);
+      expect(chunks.flat().sort()).toEqual([...groups].sort());
+      expect(chunks[0]).toEqual([groups[0], groups[4]]);
+      expect(spawned.map((child) => child.input)).toEqual(chunks.map((parts) => ({ ...input, groups: parts })));
+      expect(out).toEqual({ parts: [], unstarted: [], children: chunks.map((parts, i) => ({ parts, status: i === 2 ? "failure" : "success" })) });
+      // The parent compiles nothing itself, and gives its container and slot to the children.
+      expect(handles.sandbox.execs.filter((exec) => exec.command.includes("--compile-only"))).toHaveLength(0);
+      expect(handles.sandbox.execs.filter((exec) => exec.command.includes("gate --predecessors"))).toHaveLength(0);
+      expect(handles.sandbox.destroyed).toHaveLength(1);
+      expect(handles.childRuns.admissionHandoffs).toBe(1);
+      // A child joins no supersession group: the parent's cancels the whole tree.
+      expect(contextfulCacheWarm.supersede?.({ ...input, groups: chunks[0]! })).toBeUndefined();
+      expect(contextfulCacheWarm.compileCache?.({ ...input, groups: chunks[0]! })).toBe("base");
+      expect(contextfulCacheWarm.joinsChildren).toBe(true);
+    }).pipe(Effect.provide(layer));
+  });
+
+  it.effect("a child compiles each of its groups in order, compile-only, past a failing one", () => {
+    const { layer, handles } = makeCFRuntimeTest({
+      sandboxProgram: { ...keyed, ...listing, "--stage workspace.cli-1 ": { exitCode: 101 } },
+      config: cacheConfig,
+      github: head,
+    });
+    return Effect.gen(function* () {
+      const groups = ["workspace.compile", "workspace.cli-1", "features.binary-all"];
+      const out = yield* contextfulCacheWarm.run({ ...input, groups });
+      expect(out).toEqual({
+        parts: [
+          { part: "workspace.compile", exitCode: 0 },
+          { part: "workspace.cli-1", exitCode: 101 },
+          { part: "features.binary-all", exitCode: 0 },
+        ],
+        unstarted: [],
+      });
+      const commands = handles.sandbox.execs.map((exec) => exec.command).filter((command) => command.includes("--compile-only"));
+      expect(commands).toEqual(groups.map(warmed));
+      for (const exec of handles.sandbox.execs.filter((e) => e.command.includes("--compile-only"))) {
+        expect(exec.env).toEqual({ SCCACHE_WEBDAV_ENDPOINT: ENDPOINT, SCCACHE_WEBDAV_TOKEN: TOKEN });
+      }
+      expect(handles.sandbox.execs.some((exec) => exec.command.includes("--compile-groups"))).toBe(false);
+      expect(handles.childRuns.spawned).toHaveLength(0);
+      expect(handles.sandbox.clones).toEqual([{ repo: REPO, sha: SHA }]);
+    }).pipe(Effect.provide(layer));
+  });
+
+  it.effect("leaves out the groups the two-tier gate's heavy tier compiles into base on this push", () => {
+    const { layer, handles } = makeCFRuntimeTest({
+      sandboxProgram: { ...keyed, ...listing },
+      config: { ...cacheConfig, [lightLabelsKey(REPO)]: "pins,suite.cli" },
+      github: head,
+      childRuns: { statuses: Object.fromEntries([0, 1, 2].map((i) => [`contextful-cache-warm:${i}`, "success"])) },
+    });
+    return Effect.gen(function* () {
+      yield* contextfulCacheWarm.run(input);
+      const chunks = handles.childRuns.spawned.map((child) => (child.input as { groups: string[] }).groups);
+      // `suite.cli` is light: its members warm. The heavy pull-request parts do not;
+      // the nightly groups, which no heavy tier runs, do.
+      expect(chunks.flat().sort()).toEqual(["evaluate.cli", "features.binary-all", "workspace.cli-formal"]);
     }).pipe(Effect.provide(layer));
   });
 
@@ -96,11 +186,12 @@ describe("contextful-cache-warm", () => {
     name: string,
     opts: Parameters<typeof makeCFRuntimeTest>[0],
     reason: string,
+    extra: { groups?: string[] } = {},
   ) =>
     it.effect(name, () => {
       const { layer, handles } = makeCFRuntimeTest({ sandboxProgram: keyed, ...opts });
       return Effect.gen(function* () {
-        const exit = yield* Effect.exit(contextfulCacheWarm.run(input));
+        const exit = yield* Effect.exit(contextfulCacheWarm.run({ ...input, ...extra }));
         expect(Exit.isFailure(exit)).toBe(true);
         if (Exit.isFailure(exit)) {
           expect(Cause.pretty(exit.cause)).toContain("RunSkipped");
@@ -127,11 +218,25 @@ describe("contextful-cache-warm", () => {
     "compile cache not injected",
   );
   skipsBeforeCheckout(
-    "skips when the two-tier gate's heavy tier already compiles the part on this push",
-    { config: { ...cacheConfig, [lightLabelsKey(REPO)]: "pins,formal" }, github: head },
-    "heavy tier",
+    "a child skips a head the default branch has moved past",
+    { config: cacheConfig, github: { branchHeads: { [`${REPO}:main`]: "d".repeat(40) } } },
+    "no longer the head of main",
+    { groups: ["workspace.compile"] },
   );
 
+  it.effect("skips when the two-tier gate's heavy tier already compiles every group on this push", () => {
+    const { layer, handles } = makeCFRuntimeTest({
+      sandboxProgram: keyed,
+      config: { ...cacheConfig, [lightLabelsKey(REPO)]: "pins,formal" },
+      github: head,
+    });
+    return Effect.gen(function* () {
+      const exit = yield* Effect.exit(contextfulCacheWarm.run(input));
+      expect(Exit.isFailure(exit) && Cause.pretty(exit.cause).includes("heavy tier")).toBe(true);
+      expect(handles.sandbox.execs.filter((exec) => exec.command.includes("gate --predecessors"))).toHaveLength(0);
+    }).pipe(Effect.provide(layer));
+  });
+
   it.effect("warms when the two-tier gate lists the part as light", () => {
     const { layer } = makeCFRuntimeTest({
       sandboxProgram: keyed,
@@ -139,7 +244,7 @@ describe("contextful-cache-warm", () => {
       github: head,
     });
     return Effect.gen(function* () {
-      expect(yield* contextfulCacheWarm.run(input)).toEqual({ part: WARM_PART, exitCode: 0 });
+      expect(yield* contextfulCacheWarm.run(input)).toEqual({ parts: [{ part: WARM_PART, exitCode: 0 }], unstarted: [] });
     }).pipe(Effect.provide(layer));
   });
 });
diff --git a/runs/contextful-cache-warm.ts b/runs/contextful-cache-warm.ts
index bdda93d..994571d 100644
--- a/runs/contextful-cache-warm.ts
+++ b/runs/contextful-cache-warm.ts
@@ -2,17 +2,34 @@
 // default-branch head, so a pull request's first gate reads compiled crates
 // instead of compiling cold.
 //
-// One container per head: checkout, the gate's prebuilt `contextful-ci`, then
-// the gate's compile part under sccache. The part runs through the same
-// command, checkout path, install and cache wrapper as a gate part, because
-// sccache keys an entry on the compile's arguments, working directory and
-// `CARGO_*` environment: any difference turns every pull-request read into a
-// miss. No child runs and no part check-runs.
+// The head lists its compile groups (`contextful-ci stages --parts
+// --compile-groups`): one gate part per distinct set of `cargo test`
+// invocations. Each group compiles through `gate --stage <part>
+// --compile-only`, which runs the part's own cargo invocations with `--no-run`,
+// under the same command, checkout path, install and cache wrapper as a gate
+// part, because sccache keys an entry on the compile's arguments, working
+// directory and `CARGO_*` environment: any difference turns every
+// pull-request read into a miss. The groups spread over at most
+// `WARM_CHILDREN` children of this run, each compiling its share in one
+// container; a tree whose `contextful-ci` lists no groups compiles the gate's
+// `workspace.compile` part in the parent's container. No part check-runs.
 //
 // Spec: specs/adr/0007-cost-efficient-execution.md § Base-lane warm.
 
-import { Effect, Schema } from "effect";
-import { config, defineRun, github, io, RunSkipped, step } from "@fractalboxdev/flare-dispatch-core";
+import { Effect, Exit, Schema } from "effect";
+import {
+  ChildRuns,
+  config,
+  defineRun,
+  github,
+  handoffChildAdmission,
+  io,
+  RunSkipped,
+  sandbox,
+  spawnChildRun,
+  step,
+  type ChildStatusRecord,
+} from "@fractalboxdev/flare-dispatch-core";
 import {
   compileCacheCommand,
   compileCacheEnv,
@@ -22,11 +39,22 @@ import {
   ensureWorkspace,
   prebuildCargoBinary,
   restorePrebuilt,
+  waitForChildrenDurably,
   workspace,
   type PrebuiltBinary,
   type Workspace,
 } from "@fractalboxdev/flare-dispatch-core/primitives";
-import { CI_PACKAGE, lightLabelsKey, parseLightLabels, STAGE_TIMEOUT_SEC, stageCommand } from "./contextful-gate";
+import {
+  CI_PACKAGE,
+  ciCommand,
+  lightLabelsKey,
+  parseLightLabels,
+  parseStages,
+  STAGE_TIMEOUT_SEC,
+  stageCommand,
+} from "./contextful-gate";
+
+const NAME = "contextful-cache-warm";
 
 const REPO = "fractalboxdev/contextful";
 const BRANCH = "main";
@@ -34,12 +62,49 @@ const SHA40 = /^[a-f0-9]{40}$/i;
 const ZERO_SHA = "0".repeat(40);
 
 /**
- * The gate part this run compiles: `cargo test --workspace --no-run` in the
- * workspace stage's target directory, the build every `workspace.*` part
- * links against.
+ * The gate part a tree without compile groups warms: `cargo test --workspace
+ * --no-run` in the workspace stage's target directory, the build every
+ * `workspace.*` part links against.
  */
 export const WARM_PART = "workspace.compile";
 
+/** Children the compile groups spread over, round-robin in run order. */
+export const WARM_CHILDREN = 4;
+/** Queue age a run of this definition, parent or child, may wait before it starts. */
+const WARM_QUEUE_SEC = 90 * 60;
+/**
+ * A child starts no group past this many seconds after it starts: with the last
+ * group's own `STAGE_TIMEOUT_SEC`, a child ends within ~2.75 h.
+ */
+const GROUP_START_CUTOFF_SEC = 2 * 3600;
+/** The parent's join: a child's queue age, its start cutoff and its last group's deadline. */
+const CHILD_WAIT_SEC = WARM_QUEUE_SEC + GROUP_START_CUTOFF_SEC + STAGE_TIMEOUT_SEC + 600;
+
+/** `stages --folds` lines, `<label> <member>…`, as each member's fold label. */
+export const parseFolds = (stdout: string): ReadonlyMap<string, string> =>
+  new Map(
+    stdout
+      .split(/\r?\n/)
+      .map((line) => line.trim().split(/\s+/))
+      .filter((fields) => fields.length > 1)
+      .flatMap(([label, ...members]) => members.map((member): [string, string] => [member, label!])),
+  );
+
+/**
+ * The groups the heavy tier does not compile into `base` on this push. With
+ * `gate.lightLabels:<repo>` set, a pull-request group is heavy unless it, or
+ * the fold that dispatches it, is light; the heavy tier runs no nightly part.
+ */
+export const warmableGroups = (
+  pr: readonly string[],
+  nightly: readonly string[],
+  folds: ReadonlyMap<string, string>,
+  light: readonly string[] | null,
+): readonly string[] =>
+  light === null
+    ? [...pr, ...nightly]
+    : [...pr.filter((group) => light.includes(group) || light.includes(folds.get(group) ?? group)), ...nightly];
+
 const Input = Schema.Struct({
   repo: Schema.Literal(REPO),
   sha: Schema.String.pipe(Schema.pattern(SHA40)),
@@ -47,18 +112,31 @@ const Input = Schema.Struct({
   baseSha: Schema.String.pipe(Schema.pattern(SHA40)),
   /** The pushed head commit's timestamp in ms: the rank within the supersession group. */
   revisedAt: Schema.optional(Schema.Number.pipe(Schema.int(), Schema.nonNegative())),
+  /** A child's share of the compile groups, compiled in order. Absent: the parent. */
+  groups: Schema.optional(
+    Schema.Array(Schema.String.pipe(Schema.pattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/))).pipe(
+      Schema.minItems(1),
+      Schema.maxItems(64),
+    ),
+  ),
 });
 
 type InputType = Schema.Schema.Type<typeof Input>;
 
 const Output = Schema.Struct({
-  part: Schema.String,
-  exitCode: Schema.Number,
+  /** Each group this execution compiled, with the compile's exit code. */
+  parts: Schema.Array(Schema.Struct({ part: Schema.String, exitCode: Schema.Number })),
+  /** The groups past the start cutoff, left uncompiled. */
+  unstarted: Schema.Array(Schema.String),
+  /** The parent's children: each one's groups and terminal status. */
+  children: Schema.optional(Schema.Array(Schema.Struct({ parts: Schema.Array(Schema.String), status: Schema.String }))),
 });
 
+type OutputType = Schema.Schema.Type<typeof Output>;
+
 export const contextfulCacheWarm = defineRun({
-  name: "contextful-cache-warm",
-  version: "1.0.0",
+  name: NAME,
+  version: "1.1.0",
   inputs: Input,
   outputs: Output,
   triggers: [
@@ -87,22 +165,25 @@ export const contextfulCacheWarm = defineRun({
   // Only default-branch heads write `base`; the body refuses any other sha
   // before the token reaches a container.
   compileCache: () => "base",
-  // A newer head cancels the older warm, queued or running: its entries
-  // already written stay, and the newer head's compile reads them.
-  supersede: (input) => ({ group: `contextful-cache-warm:${input.repo}:${BRANCH}`, order: input.revisedAt ?? 0 }),
-  limits: { maxDurationSec: 5400, admissionMaxQueueAgeSec: 90 * 60 },
+  // A newer head cancels the older warm, queued or running, with its
+  // children: its entries already written stay, and the newer head's compile
+  // reads them. A child joins no group; its parent's cancellation reaches it.
+  supersede: (input) =>
+    input.groups !== undefined
+      ? undefined
+      : { group: `${NAME}:${input.repo}:${BRANCH}`, order: input.revisedAt ?? 0 },
+  joinsChildren: true,
+  limits: { maxDurationSec: 6 * 3600, admissionMaxQueueAgeSec: WARM_QUEUE_SEC },
   run: (input) =>
     Effect.gen(function* () {
+      const child = input.groups !== undefined;
       // A configured two-tier gate compiles its heavy parts on this push into
-      // `base` already; warm only when the compile part is light.
-      const lightLabels = yield* step("resolve-tiers", () =>
-        config.get(lightLabelsKey(input.repo)).pipe(Effect.map((raw) => parseLightLabels(raw) ?? null)),
-      );
-      if (lightLabels !== null && !lightLabels.includes(WARM_PART)) {
-        return yield* Effect.fail(
-          new RunSkipped({ reason: `the two-tier gate's heavy tier compiles ${WARM_PART} into base on this push` }),
-        );
-      }
+      // `base` already; the parent warms only the light ones.
+      const lightLabels = child
+        ? null
+        : yield* step("resolve-tiers", () =>
+            config.get(lightLabelsKey(input.repo)).pipe(Effect.map((raw) => parseLightLabels(raw) ?? null)),
+          );
       const current = yield* step("read-head", () =>
         github.branchHead({ repo: input.repo, branch: BRANCH }).pipe(
           Effect.map((sha): string | null => sha),
@@ -141,26 +222,116 @@ export const contextfulCacheWarm = defineRun({
         prebuilt === null
           ? Effect.succeed(ws)
           : restorePrebuilt({ container: ws.container, dir: ws.dir, entry: prebuilt }).pipe(Effect.as(ws));
-      const { result } = yield* durableExec({
-        name: "warm",
-        workspace: { container, dir },
-        ensure: (ws) =>
-          ensureWorkspace({ current: ws, repo: input.repo, sha: input.sha, install: true }).pipe(
-            Effect.flatMap((next) => (next === ws ? Effect.succeed(next) : restore(next))),
+      const ensure = (ws: Workspace) =>
+        ensureWorkspace({ current: ws, repo: input.repo, sha: input.sha, install: true }).pipe(
+          Effect.flatMap((next) => (next === ws ? Effect.succeed(next) : restore(next))),
+        );
+
+      // Compile `groups` in order in this container, each under its own
+      // deadline, starting none past the cutoff. A failed or timed-out compile
+      // still leaves every entry it wrote; the gate gives the verdict.
+      const compile = (groups: readonly string[], compileOnly: boolean) =>
+        Effect.gen(function* () {
+          const startedAt = yield* step("warm-started", () => io.now);
+          let ws: Workspace = { container, dir };
+          const parts: { part: string; exitCode: number }[] = [];
+          const unstarted: string[] = [];
+          for (const [index, part] of groups.entries()) {
+            const now = yield* step(`warm-clock-${index}`, () => io.now);
+            if (now - startedAt > GROUP_START_CUTOFF_SEC * 1000) {
+              unstarted.push(part);
+              continue;
+            }
+            const outcome = yield* durableExec({
+              name: index === 0 ? "warm" : `warm-${index}`,
+              workspace: ws,
+              ensure,
+              exec: (current) => ({
+                cwd: current.dir,
+                command: compileCacheCommand(stageCommand(part, input.baseSha, prebuilt, { compileOnly }), input.repo),
+                env: compileCacheEnv({ endpoint, token }),
+                redactValues: [token],
+                timeoutSec: STAGE_TIMEOUT_SEC,
+              }),
+            }).pipe(
+              Effect.map(({ result, workspace: next }) => ({ exitCode: result.exitCode, next })),
+              Effect.catchTag("ExecTimeout", () => Effect.succeed({ exitCode: 124, next: ws })),
+            );
+            ws = outcome.next;
+            if (outcome.exitCode !== 0) {
+              yield* io.log("warn", `${NAME}: ${part} exited ${outcome.exitCode}; base holds what it compiled`);
+            }
+            parts.push({ part, exitCode: outcome.exitCode });
+          }
+          if (unstarted.length > 0) {
+            yield* io.log("warn", `${NAME}: past the ${GROUP_START_CUTOFF_SEC / 3600} h start cutoff, left ${unstarted.join(", ")}`);
+          }
+          return { parts, unstarted } satisfies OutputType;
+        });
+
+      if (input.groups !== undefined) return yield* compile(input.groups, true);
+
+      // The head's compile groups per tier, and the folds that dispatch them.
+      // A tree whose `contextful-ci` lists none warms the gate's compile part.
+      const listed = yield* step(
+        "discover-groups",
+        () =>
+          ensure({ container, dir }).pipe(
+            Effect.flatMap((ws) =>
+              Effect.forEach(
+                ["stages --parts --compile-groups --tier pr", "stages --parts --compile-groups --tier nightly", "stages --folds"],
+                (args) =>
+                  sandbox
+                    .exec({ container: ws.container, cwd: ws.dir, command: ciCommand(args, prebuilt), timeoutSec: 1800 })
+                    .pipe(Effect.map((result) => (result.exitCode === 0 ? result.stdout : null))),
+              ),
+            ),
           ),
-        exec: (ws) => ({
-          cwd: ws.dir,
-          command: compileCacheCommand(stageCommand(WARM_PART, input.baseSha, prebuilt), input.repo),
-          env: compileCacheEnv({ endpoint, token }),
-          redactValues: [token],
-          timeoutSec: STAGE_TIMEOUT_SEC,
-        }),
-      });
-      // The gate gives the verdict on this head; a failed compile still
-      // leaves every entry it wrote.
-      if (result.exitCode !== 0) {
-        yield* io.log("warn", `contextful-cache-warm: ${WARM_PART} exited ${result.exitCode}; base holds what it compiled`);
+        { timeoutSec: 1920, retries: 3, retryOn: ["ExecFailed", "StepFailed", "CheckoutFailed"] },
+      );
+      const [prListed, nightlyListed, foldsListed] = listed;
+      const pr = prListed === null || prListed === undefined ? undefined : parseStages(prListed);
+      const nightly = nightlyListed === null || nightlyListed === undefined ? undefined : parseStages(nightlyListed);
+      const folds = parseFolds(foldsListed ?? "");
+      const groups =
+        pr === undefined
+          ? warmableGroups([WARM_PART], [], folds, lightLabels)
+          : warmableGroups(pr, nightly ?? [], folds, lightLabels);
+      if (groups.length === 0) {
+        return yield* Effect.fail(
+          new RunSkipped({ reason: "the two-tier gate's heavy tier compiles every compile group into base on this push" }),
+        );
       }
-      return { part: WARM_PART, exitCode: result.exitCode };
+      if (pr === undefined || groups.length === 1) return yield* compile(groups, pr !== undefined);
+
+      // The parent's container and admission slot go to the children rather
+      // than idling through the join. Either release failing costs capacity only.
+      yield* Effect.exit(step("release-warm-container", () => sandbox.destroy({ container })));
+      yield* Effect.exit(step("handoff-admission", () => handoffChildAdmission()));
+      const width = Math.min(WARM_CHILDREN, groups.length);
+      const chunks = Array.from({ length: width }, (_, i) => groups.filter((_, j) => j % width === i));
+      const handles = yield* step("spawn-groups", () =>
+        Effect.forEach(chunks, (share) => spawnChildRun({ run: NAME, input: { ...input, groups: share } }), {
+          concurrency: chunks.length,
+        }),
+      );
+      const ids = handles.map((handle) => handle.executionId);
+      const waited = yield* Effect.exit(
+        waitForChildrenDurably({ name: "await-groups", ids, timeout: `${CHILD_WAIT_SEC / 60} minutes` }),
+      );
+      // A join that outlives its deadline reads the children once more.
+      const records = Exit.isSuccess(waited)
+        ? waited.value
+        : yield* step("settle-groups", () => Effect.flatMap(ChildRuns, (children) => children.poll({ ids }))).pipe(
+            Effect.orElseSucceed(() => ids.map((executionId): ChildStatusRecord => ({ executionId, status: "missing" }))),
+          );
+      return {
+        parts: [],
+        unstarted: [],
+        children: chunks.map((share, i) => ({
+          parts: share,
+          status: records.find((record) => record.executionId === ids[i])?.status ?? "missing",
+        })),
+      } satisfies OutputType;
     }),
 });
diff --git a/runs/contextful-gate.ts b/runs/contextful-gate.ts
index 0cec264..1148f43 100644
--- a/runs/contextful-gate.ts
+++ b/runs/contextful-gate.ts
@@ -274,12 +274,15 @@ export const stageCommand = (
   stage: string,
   baseSha: string,
   prebuilt: PrebuiltBinary | null,
-): string => {
-  const args = `gate --predecessors --stage ${stage} --base ${baseSha}`;
-  return prebuilt === null
+  opts: { readonly compileOnly?: boolean } = {},
+): string =>
+  ciCommand(`gate --predecessors --stage ${stage} --base ${baseSha}${opts.compileOnly === true ? " --compile-only" : ""}`, prebuilt);
+
+/** `contextful-ci <args>`: the prebuilt binary when there is one, `cargo run` otherwise. */
+export const ciCommand = (args: string, prebuilt: PrebuiltBinary | null): string =>
+  prebuilt === null
     ? `${CARGO_RUN_CI} ${args}`
     : prebuiltCommand({ path: prebuilt.path, fallback: CARGO_RUN_CI, args });
-};
 
 /**
  * The `--affected` subset of the head's required parts. Empty output is a valid
diff --git a/specs/adr/0007-cost-efficient-execution.md b/specs/adr/0007-cost-efficient-execution.md
index e0621b5..fe76a07 100644
--- a/specs/adr/0007-cost-efficient-execution.md
+++ b/specs/adr/0007-cost-efficient-execution.md
@@ -105,23 +105,35 @@ so a budget buys more checks.
 
 - Every push to contextful's default branch starts `contextful-cache-warm`,
   whatever the two-tier opt-in. It needs no `CONFIG_KV` key.
-- One container per head: checkout with install, the gate's prebuilt
-  `contextful-ci`, then the gate's `workspace.compile` part
-  (`cargo test --workspace --no-run`) under the compile-cache wrapper, with
-  the identical command, checkout path and environment a gate part uses. It
-  spawns no child and posts no part check-run.
-- Its token's lane is `base`. Before any checkout the run reads the default
-  branch's head and skips unless it equals the run's head; an unreadable head
-  skips too. Pull-request gates keep reading `@pr-<n>` then `@base` and
-  writing `@pr-<n>`.
+- The head lists its compile groups with `contextful-ci stages --parts
+  --compile-groups`, once per tier: one gate part per distinct set of
+  `cargo test` invocations, so one CLI shard stands for all eight. Each group
+  compiles through `gate --stage <part> --compile-only`, the part's own cargo
+  invocations with `--no-run`. The command, checkout path, install,
+  prebuilt `contextful-ci` and environment are the ones a gate part uses.
+- The groups spread round-robin, in run order, over at most four children of
+  the run. Each child checks out the head and compiles its share in one
+  container, and it starts no group more than 2 h after it starts. The parent
+  gives its container and admission slot to the children and joins them. No
+  warm posts a part check-run.
+- A tree whose `contextful-ci` lists no groups compiles `workspace.compile`
+  (`cargo test --workspace --no-run`) in the parent's container, as does a
+  head with one group.
+- Its token's lane is `base`. Before any checkout, the run and each child read
+  the default branch's head. Each skips unless that head equals its own, and
+  an unreadable head skips too. Pull-request gates keep reading `@pr-<n>` then
+  `@base` and writing `@pr-<n>`.
 - One supersession group per repository and default branch, ranked by the
-  head commit's timestamp: a newer head cancels the older warm, queued or
-  running. The idempotency key is the head, so an equal head warms once.
-- It skips when the deploy injects no compile-cache access, and when
-  `gate.lightLabels:<repo>` omits `workspace.compile`: the heavy tier then
-  compiles that part into `@base` on the same push.
-- A failed compile concludes the warm green with its exit code; the gate
-  owns the verdict on the head.
+  head commit's timestamp: a newer head cancels the older warm and its
+  children, queued or running. The idempotency key is the head, so an equal
+  head warms once.
+- It skips when the deploy injects no compile-cache access. With
+  `gate.lightLabels:<repo>` set, it leaves out each pull-request group that is
+  heavy, meaning neither the group nor its fold label is light, because the
+  heavy tier compiles that group into `@base` on the same push. Nightly groups
+  always warm.
+- A failed or timed-out compile leaves the warm green with its exit code, and
+  the next group still runs. The gate owns the verdict on the head.
 
 ## Rationale