thunderjar 0.1.3-preview-eee7160 → 0.1.3-preview-e09ffa1

package/src/api/parameterNames.ts

@@ -0,0 +1,19 @@
+// The names a project declares under `.thunderjar/test-case-parameters/`. `thunderjar generate`
+// writes them to `.thunderjar/_generated/parameterNames.d.ts` as global types, e.g.
+// `type TaskName = "is-prime"`, and fills in `ThunderjarParameterNames` with them. Until it
+// has run, every name is any string.
+
+declare global {
+  interface ThunderjarParameterNames {}
+}
+
+type Generated<K extends string, Fallback> = ThunderjarParameterNames extends { [P in K]: infer T } ? T : Fallback;
+
+export type BaseImageNames = Generated<"baseImage", string>;
+export type CodeStateNames = Generated<"codeState", string>;
+export type PromptSetNames = Generated<"promptSet", string>;
+export type TaskNames = Generated<"task", string>;
+/** The initial prompts of each task, by task name. */
+export type InitialPromptNamesByTask = Generated<"initialPrompt", Record<string, string>>;
+/** `<harness>@<version>/<model>`. */
+export type HarnessModelNames = Generated<"harnessModel", string>;

package/src/AGENTS.md

@@ -1,156 +0,0 @@
-# src/
-
-Thunderjar's source, in layers. Each layer imports only from the layers below it, and the lint enforces it: `scripts/layout.ts` lists the layers in order, and `bun run lint` fails an import that points upward or a file in a folder the layout doesn't know.
-
-## Layers
-
-```mermaid
-flowchart TD
-    cli --> commands["cli/commands"]
-    commands --> images & running & measuring & store
-    images --> matrix
-    running --> matrix
-    measuring --> running & store & matrix
-    store --> matrix
-    matrix --> project & instruments
-    project --> instruments
-    instruments --> api
-```
-
-The diagram shows the imports that exist today. What the lint allows is any layer lower in this order, lowest first:
-
-```
-api → instruments → project → matrix → store → running → images → measuring → cli/commands → cli
-```
-
-Every layer may also import `platform`, `adapters/docker` and `testing`.
-
-## Folders
-
-```
-src/
-  index.ts          the `thunderjar` package: re-exports api/
-  api/
-  instruments/
-  project/
-  matrix/
-  store/
-  running/
-  images/
-  measuring/
-  cli/
-    index.ts
-    program.ts
-    commands/
-      format.ts
-      <command>/
-  platform/
-  adapters/docker/
-  testing/
-```
-
-- `index.ts`
-  - The package entry users import `thunderjar` from. It only re-exports `api/`.
-- `api/`
-  - What users' configuration files import.
-  - `declarations.ts`: the `declareX()` functions. At runtime each returns its argument; the types give `config` and `ctx` their shape.
-  - `fragments.ts`: ready-made Dockerfile fragments for `applyParameter`, such as `checkoutCommit`.
-  - `parameter-names.d.ts`: fallback types for parameter names. A real project sees its `_generated/` file instead.
-- `instruments/`
-  - The built-in measuring instruments (`fileCreated`, `grep`, `templateTest`), and the aggregate methods that fit each one's values.
-- `project/`
-  - `config.ts`: finds `.thunderjar/`, and loads and checks a test case and its measurements against the files on disk. Configuration errors come from here.
-- `matrix/`
-  - Working out what to run. Nothing here runs anything.
-  - `permutations.ts`: a test case's cross product, in a stable order.
-  - `hashing.ts`: parameter and permutation hashes, from content, never names.
-  - `resolve.ts`: every permutation of a test case, with its hash.
-  - `execution.ts`: one execution laid out, with each container run's tags and harness command.
-  - `tags.ts`: prerun and postrun image tags. `ulid.ts`: execution IDs.
-- `store/`
-  - `run-data-store.ts`: where executions, container runs and aggregation results are kept. It's an interface; for now the only store is a JSON file.
-- `running/`
-  - `runner.ts`: runs one container run in a container from its prerun image, committing it into its postrun image, and opens the measurement context that instruments read a run through. A host runner stands in for Docker in tests of `run`.
-- `images/`
-  - `prerun.ts`: renders a permutation's prerun Dockerfile from its parameters' fragments, checks the commits it reads, and writes its build context.
-  - `prerun-builds.ts`: builds a test case's missing prerun images, for both `build` and `run`, after checking everything the builds need.
-  - `repository.ts`: read-only access to the user's git repository.
-- `measuring/`
-  - `measure.ts`: applies a task's measurements to one container run.
-  - `aggregate.ts`: combines a permutation's iterations into its aggregation result.
-  - `remeasure.ts`: for a backfill, whether a stored measure is missing, stale or current, which measurements each container run needs, and each execution's measurement statuses and deleted names.
-  - `remeasure-templates/`: two versions of a bundled template, static test data for `remeasure.test.ts`.
-- `cli/commands/`
-  - One folder per command, holding the command and its tests, e.g.
-    ```
-    cli/commands/build/
-      build.ts
-      build.test.ts
-      build.docker.test.ts
-    ```
-  - `<command>.ts` exports the command's function, e.g. `build()`, and `createBuildCommand()`, which declares its arguments and options as a Commander `Command` and calls that function.
-  - A command's tests drive the CLI against a checked-in `fixtureTests/` scenario, unchanged, and assert only on what the command produced. Every expected result lives in the test. See "Fixture tests" in the root `AGENTS.md`.
-  - `format.ts`: how commands print what they share, such as counts and durations.
-  - Tests that cut across commands sit directly in `cli/commands/`: configuration errors (`validation.test.ts`) and typed parameter names (`declarations.typecheck.test.ts`).
-- `cli/`
-  - `program.ts`: `createProgram()`, the Commander program, which adds every command's `createXCommand()`.
-  - `index.ts`: the `thunderjar` entry point. It parses the arguments with `createProgram()`.
-- `platform/`
-  - Stands in for `node:path`, `node:fs` and `node:os`, which this repository doesn't use (see "Use Bun" in the root `AGENTS.md`). It imports nothing else from `src/`.
-  - `path.ts`: POSIX path functions, such as `join`, `resolve` and `relative`.
-  - `fs.ts`: file helpers on Bun's APIs and shell, such as `makeTempDir`, `remove` and `listEntries`. To read or write a file, use `Bun.file` and `Bun.write` directly.
-- `adapters/docker/`
-  - The real Docker, behind the seam tests swap out. It imports nothing else from `src/` but `platform/`.
-- `testing/`
-  - Test helpers, shared by tests in every layer.
-  - `cli.ts`: runs the CLI in a `fixtureTests/` scenario, the way `bun run fixture` does. `scenario()` names a scenario's project; `copyOfFixtures()` copies it for `init` only, the one command that writes into the project; a real `run` passes `--data-dir` instead.
-  - `fake-docker.ts`: the recording fake Docker, so a test can say which images exist, and which postrun images' saved files `docker create` and `docker cp` read. It never runs a container.
-  - `measurement-context.ts`: the host measurement context, for instrument tests.
-  - `test-setup.ts`, which every `bun test` preloads.
-  - NOT ENDORSED: `fixture-project.ts` and `seed-repo.ts` generate throwaway projects. Older tests still use them while they move to scenarios; new tests don't.
-
-## Rules
-
-### Never import upward
-
-✅ **Do** import only from a layer below, or from `platform`, `adapters/docker` or `testing`.
-
-❌ **Don't** import from a layer above, even for one function. Move the function down instead.
-
-**Why:** the layers are what keep each part testable on its own, and readable without the parts above it. One upward import makes two layers depend on each other.
-
-e.g. `config.ts` checks a measurement's aggregate methods. It used to import them from `measuring/aggregate.ts`, above it, so the list moved down into `instruments/`, which both use.
-
-### Put a new module in the lowest layer that can hold it
-
-✅ **Do** pick the layer by what the module needs to import: the lowest layer whose imports suffice.
-
-❌ **Don't** put it in `cli/commands/` because a command is its first user.
-
-**Why:** a module placed too high can't be used by the layers that will later need it, and the next person moves it.
-
-### Keep tests beside their code
-
-✅ **Do** put `<module>.test.ts` in the same folder as `<module>.ts`, and real-Docker tests in `<module>.docker.test.ts`.
-
-❌ **Don't** gather tests in a separate tree.
-
-**Why:** a module and its tests change together, and the folder shows at a glance what is tested.
-
-A test of a lower layer that needs something from a higher one gets it through `testing/`, e.g. `instruments.test.ts` gets the host measurement context from `testing/measurement-context.ts`. That keeps `testing/` the one place where tests reach across layers.
-
-### Share between commands through format.ts
-
-✅ **Do** put anything two commands print alike in `cli/commands/format.ts`, or lower if it isn't about printing.
-
-❌ **Don't** import one command from another in a command's own code.
-
-**Why:** commands are siblings. If one imports another, changing how `run` prints breaks `show`.
-
-The lint can't tell a command's code from its tests, so it allows command folders to import each other. A test shouldn't need to: one that needs, say, a recorded execution to `show` starts from a scenario with a checked-in run data store instead of running `run`.
-
-### Adding a layer or a command
-
-- A command: add a folder under `cli/commands/` whose `<command>.ts` exports `createXCommand()`, add its name to `COMMANDS` in `scripts/layout.ts`, and add the command to `createProgram()` in `cli/program.ts`.
-- A layer: add it to `LAYERS` in `scripts/layout.ts`, in order, then update the diagram and this file.
-- Then run `bun run lint`, which regenerates the rules in `.oxlintrc.json`.

package/src/adapters/docker/docker.ts

@@ -1,117 +0,0 @@
-// The Docker seam — spec/120-test-boundaries.md#principles. Everything Thunderjar asks of
-// Docker goes through a `Docker`; the real one runs the `docker` CLI. Tests swap the binary,
-// not the code path: `THUNDERJAR_DOCKER` names the executable to run in place of `docker`, such
-// as fixtureTests/fake-docker.ts, which records the commands it is given
-// (spec/120-test-boundaries.md#2-cli-with-recording-adapters).
-//
-// Thunderjar builds prerun images, runs a container run in a container from one and commits it
-// into a postrun image, and copies files out of a postrun image to measure it.
-
-export interface Docker {
-  /** Why the Docker daemon can't be reached, or undefined when it can. */
-  unreachable(): Promise<string | undefined>;
-  imageExists(ref: string): Promise<boolean>;
-  /**
-   * Builds the Dockerfile in `contextDir` and tags the image `ref`. Docker's own output goes to
-   * stderr. Throws if the build fails.
-   */
-  build(contextDir: string, ref: string): Promise<void>;
-  /**
-   * Runs `script` with `sh -c` in a new container named `name` from the image `ref`, and
-   * leaves the container once it stops. Returns its stdout; its stderr goes to stderr.
-   */
-  run(ref: string, name: string, script: string): Promise<{ exitCode: number; stdout: string }>;
-  /**
-   * Commits the stopped container `name` into the image `ref`, with the entrypoint and command
-   * of the image `like` (the one it ran from), so starting it doesn't run `run`'s script again.
-   */
-  commit(name: string, ref: string, like: string): Promise<void>;
-  /** Creates, without starting it, a container named `name` from the image `ref`. */
-  create(ref: string, name: string): Promise<void>;
-  /** Copies `path` out of the container `name` to `dest` on the host, as `docker cp` does. */
-  copyFrom(name: string, path: string, dest: string): Promise<void>;
-  /** Removes the container `name`, stopped or not. */
-  removeContainer(name: string): Promise<void>;
-}
-
-export class DockerBuildError extends Error {
-  constructor(
-    readonly ref: string,
-    readonly exitCode: number,
-  ) {
-    super(`docker build of ${ref} exited ${exitCode}`);
-  }
-}
-
-/** A docker command that exited non-zero, with what it wrote to stderr. */
-export class DockerCommandError extends Error {
-  constructor(
-    readonly args: string[],
-    readonly exitCode: number,
-    readonly stderr: string,
-  ) {
-    super(`docker ${args[0]} exited ${exitCode}${stderr.trim() ? `: ${stderr.trim().split("\n").at(-1)}` : ""}`);
-  }
-}
-
-/**
- * Runs `binary` with `args`. "collect" discards stdout and collects stderr; "stderr" passes all
- * of its output to our stderr, keeping stdout for Thunderjar's own; "stdout" collects stdout and
- * passes stderr to ours.
- */
-async function docker(binary: string, args: string[], output: "collect" | "stderr" | "stdout") {
-  const stdio: Record<typeof output, { stdout: "ignore" | "pipe" | number; stderr: "pipe" | number }> = {
-    collect: { stdout: "ignore", stderr: "pipe" },
-    stderr: { stdout: 2, stderr: 2 },
-    stdout: { stdout: "pipe", stderr: 2 },
-  };
-  const child = Bun.spawn([binary, ...args], { stdin: "ignore", ...stdio[output] });
-  const text = (stream: unknown) => (stream instanceof ReadableStream ? new Response(stream).text() : Promise.resolve(""));
-  const [stdout, stderr] = await Promise.all([text(child.stdout), text(child.stderr), child.exited]);
-  return { exitCode: child.exitCode ?? 1, stdout, stderr };
-}
-
-/** A Docker that runs the `docker` CLI, or `binary` in its place. */
-export function dockerCli(binary: string = process.env.THUNDERJAR_DOCKER || "docker"): Docker {
-  /** Runs a command whose output isn't needed, throwing if it fails. */
-  const must = async (args: string[]) => {
-    const { exitCode, stderr } = await docker(binary, args, "collect");
-    if (exitCode !== 0) throw new DockerCommandError(args, exitCode, stderr);
-  };
-  return {
-    async unreachable() {
-      try {
-        const { exitCode, stderr } = await docker(binary, ["version", "--format", "{{.Server.Version}}"], "collect");
-        if (exitCode === 0) return undefined;
-        return stderr.trim().split("\n").at(-1) || `\`${binary} version\` exited ${exitCode}`;
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "ENOENT") return `\`${binary}\` was not found`;
-        throw error;
-      }
-    },
-    async imageExists(ref) {
-      return (await docker(binary, ["image", "inspect", "--format", "{{.Id}}", ref], "collect")).exitCode === 0;
-    },
-    async build(contextDir, ref) {
-      const { exitCode } = await docker(binary, ["build", "--tag", ref, contextDir], "stderr");
-      if (exitCode !== 0) throw new DockerBuildError(ref, exitCode);
-    },
-    async run(ref, name, script) {
-      // The image's own entrypoint isn't run: the script is all that runs.
-      const { exitCode, stdout } = await docker(binary, ["run", "--name", name, "--entrypoint", "sh", ref, "-c", script], "stdout");
-      return { exitCode, stdout };
-    },
-    async commit(name, ref, like) {
-      const format = "{{json .Config.Entrypoint}}\t{{json .Config.Cmd}}";
-      const inspected = await docker(binary, ["image", "inspect", "--format", format, like], "stdout");
-      if (inspected.exitCode !== 0) throw new DockerCommandError(["image", "inspect", like], inspected.exitCode, "");
-      const [entrypoint, cmd] = inspected.stdout.trim().split("\t");
-      // `ENTRYPOINT []` is ignored; `[""]` clears it.
-      const changes = [`ENTRYPOINT ${entrypoint === "null" ? '[""]' : entrypoint}`, `CMD ${cmd === "null" ? '["sh"]' : cmd}`];
-      await must(["commit", ...changes.flatMap((change) => ["--change", change]), name, ref]);
-    },
-    create: (ref, name) => must(["create", "--name", name, "--entrypoint", "sh", ref]),
-    copyFrom: (name, path, dest) => must(["cp", `${name}:${path}`, dest]),
-    removeContainer: (name) => must(["rm", "--force", name]),
-  };
-}

package/src/api/fragments.ts

@@ -1,30 +0,0 @@
-// Dockerfile fragments a parameter's `applyParameter` can use, exported from `thunderjar`.
-
-import type { GitBuildContext } from "./declarations.ts";
-
-/**
- * Checks `commit` out into /workspace as a real repository — spec/062-code-state.md#how-the-code-gets-into-the-image:
- * cloned from a bundle of the commit and its ancestors only (so `git log --all` shows the agent
- * nothing after it), detached, with no remote, and a git identity so the agent can commit.
- *
- * ```ts
- * export default declareCodeState({
- *   config: { commit: "a1b2c3" },
- *   applyParameter: (config, ctx) => `${checkoutCommit(ctx, config.commit)}\nRUN npm ci`,
- * });
- * ```
- */
-export function checkoutCommit(ctx: { git: GitBuildContext }, commit: string): string {
-  return [
-    `COPY ${ctx.git.bundle(commit)} /tmp/code.bundle`,
-    [
-      "RUN git clone --quiet /tmp/code.bundle /workspace",
-      `git -C /workspace checkout --quiet --detach ${commit}`,
-      "git -C /workspace branch --quiet --delete --force code-state",
-      "git -C /workspace remote remove origin",
-      `git -C /workspace config user.name "Thunderjar agent"`,
-      "git -C /workspace config user.email agent@thunderjar.invalid",
-      "rm /tmp/code.bundle",
-    ].join(" \\\n  && "),
-  ].join("\n");
-}

package/src/api/parameter-names.d.ts

@@ -1,16 +0,0 @@
-// Fallback ambient types for the parameter names a test case selects.
-//
-// `thunderjar generate` writes a project-specific `_generated/parameter-names.d.ts`
-// declaring these same global names as literal unions (see
-// spec/055-declaring-test-cases.md#typed-names). A real project's own TypeScript
-// program sees only that generated file, never this one — this file exists solely so
-// that this package's own declarations (which reference these names directly, with no
-// import) type-check on their own, and so a program that hasn't run `generate` yet
-// still compiles, permissively.
-
-type BaseImageName = string;
-type CodeStateName = string;
-type PromptSetName = string;
-type TaskName = string;
-type InitialPromptNames = Record<string, string>;
-type HarnessModelName = string;

package/src/cli/commands/build/build.docker.test.ts

@@ -1,173 +0,0 @@
-// Docker image tests for `build` — spec/120-test-boundaries.md#31-generating-the-pre-run-image.
-// Docker and the images are real; the agent is the fake one. Skipped by `bun test`; run with
-// `bun run test:prepare && bun run test:docker`. Each run passes a throwaway `--image-prefix`
-// and removes every image under it afterwards.
-//
-// Each runs the CLI in place in a checked-in scenario, as by hand:
-//
-//     bun run fixture scenario_4 build two-commits
-
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { makeTempDir, readTextSync } from "../../../platform/fs.ts";
-import { dirname, join } from "../../../platform/path.ts";
-import { dockerCli } from "../../../adapters/docker/docker.ts";
-import { scenario, thunderjar } from "../../../testing/cli.ts";
-
-const BASE_IMAGE = `node:20-bookworm`;
-const docker = dockerCli("docker");
-const prefix = `thunderjar-test-${process.pid}-${Date.now()}`;
-
-/**
- * Runs `thunderjar <command> <testCase> --image-prefix <prefix>` in `project` against real Docker,
- * with build contexts under a fresh $TMPDIR, and durations replaced by a placeholder.
- */
-async function cli(project: string, command: string, testCase: string, env: Record<string, string> = {}) {
-  const tmpDir = await makeTempDir("thunderjar-build-docker-");
-  const result = await thunderjar(project, [command, testCase, "--image-prefix", prefix], {
-    THUNDERJAR_DOCKER: "docker",
-    TMPDIR: tmpDir,
-    ...env,
-  });
-  const normalise = (text: string) =>
-    text.replaceAll(tmpDir, "$TMPDIR").replaceAll(prefix, "<prefix>").replace(/ built \(\d+\.\d\ds\)$/gm, " built (<t>s)");
-  return { ...result, stdout: normalise(result.stdout), stderr: normalise(result.stderr) };
-}
-
-/** Runs `script` with sh in a throwaway container from `ref`. */
-function inImage(ref: string, script: string) {
-  const result = Bun.spawnSync(["docker", "run", "--rm", ref, "sh", "-c", script], { stdout: "pipe", stderr: "pipe" });
-  expect(result.stderr.toString()).toBe("");
-  return result.stdout.toString().trim();
-}
-
-const prefixed = (tag: string) => `${prefix}:${tag}`;
-
-describe.skipIf(!process.env.THUNDERJAR_TEST_DOCKER)("build, against real Docker", () => {
-  beforeAll(async () => {
-    const unreachable = await docker.unreachable();
-    if (unreachable) throw new Error(`Docker can't be reached (${unreachable}).`);
-    if (!(await docker.imageExists(BASE_IMAGE))) {
-      throw new Error(`The fixture image ${BASE_IMAGE} is missing. Run \`bun run test:prepare\` first.`);
-    }
-  });
-
-  afterAll(() => {
-    const images = Bun.spawnSync(["docker", "image", "ls", "--format", "{{.Repository}}:{{.Tag}}", prefix], { stdout: "pipe" })
-      .stdout.toString()
-      .split("\n")
-      .filter(Boolean);
-    if (images.length > 0) Bun.spawnSync(["docker", "image", "rm", "--force", ...images]);
-  });
-
-  describe("scenario_1_minimal_initial_setup", () => {
-    const fixtures = scenario("scenario_1_minimal_initial_setup");
-    const REF = prefixed("prerun-h8ffdda6e");
-
-    test("build example: /workspace holds the code state's and prompt set's files, and node; a second build reuses it", async () => {
-      // Outside any git repository, too: its parameters read no commits.
-      const built = await cli(fixtures, "build", "example", { GIT_CEILING_DIRECTORIES: dirname(fixtures) });
-
-      expect(built.exitCode).toBe(0);
-      expect(built.stdout).toBe(`Building 1 prerun image for example (1 permutation)
-Build contexts in $TMPDIR/thunderjar/builds
-
- 1  node20 | baseline | snerk | fake-harness-alpha@1.0.0/fake-model-small | plain
-    <prefix>:prerun-h8ffdda6e  built (<t>s)
-
-1 prerun image: 1 built, 0 reused
-`);
-      expect(inImage(REF, "pwd && ls -A")).toBe("/workspace\nFAKE_INSTRUCTIONS.md\npackage-lock.json\npackage.json");
-      expect(inImage(REF, "head -1 FAKE_INSTRUCTIONS.md")).toBe("# Snerk");
-      expect(inImage(REF, "node --version")).toStartWith("v20.");
-
-      const again = await cli(fixtures, "build", "example");
-      expect(again.stdout).toBe(`Every prerun image for example exists (1 permutation)
-
- 1  node20 | baseline | snerk | fake-harness-alpha@1.0.0/fake-model-small | plain
-    <prefix>:prerun-h8ffdda6e  reused
-
-1 prerun image: 0 built, 1 reused
-`);
-    }, 300_000);
-  });
-
-  describe("scenario_2_typical_project", () => {
-    const fixtures = scenario("scenario_2_typical_project");
-    const ALPHA = prefixed("prerun-hefe85dda");
-
-    test("build two-pairs: builds each missing prerun image; with one removed, builds only that one, and plan shows both reused", async () => {
-      const built = await cli(fixtures, "build", "two-pairs");
-
-      expect(built.exitCode).toBe(0);
-      // The tags are those `thunderjar plan two-pairs` shows.
-      expect(built.stdout).toBe(`Building 2 prerun images for two-pairs (2 permutations)
-Build contexts in $TMPDIR/thunderjar/builds
-
- 1  node20 | baseline | snerk | fake-harness-alpha@1.0.0/fake-model-small | terse
-    <prefix>:prerun-hefe85dda  built (<t>s)
-
- 2  node20 | baseline | snerk | fake-harness-beta@1.0.0/fake-model-large  | terse
-    <prefix>:prerun-h56ea4852  built (<t>s)
-
-2 prerun images: 2 built, 0 reused
-`);
-
-      Bun.spawnSync(["docker", "image", "rm", "--force", ALPHA]);
-      const again = await cli(fixtures, "build", "two-pairs");
-      expect(again.stdout).toContain("    <prefix>:prerun-hefe85dda  built (<t>s)\n");
-      expect(again.stdout).toContain("    <prefix>:prerun-h56ea4852  reused\n");
-      expect(again.stdout).toEndWith("2 prerun images: 1 built, 1 reused\n");
-
-      const plan = await cli(fixtures, "plan", "two-pairs");
-      expect(plan.stdout).toContain("    prerun-hefe85dda (exists, reused)\n");
-      expect(plan.stdout).toContain("    prerun-h56ea4852 (exists, reused)\n");
-    }, 300_000);
-  });
-
-  // Scenario 4's parameters read real commits of this repository, so its images show what only
-  // the copied files can: a prompt file read at its commit, and a bundle with nothing after its commit.
-  describe("scenario_4_git_project", () => {
-    const fixtures = scenario("scenario_4_git_project");
-    const FIRST = "523984c7fd72f047265ab89ce5901605af6acb2b";
-    const SECOND = "952687db16b373d58f79f46690f9c5b0aa1aa141";
-    const PROJECT = "fixtureTests/scenario_4_git_project/fixtures/project";
-    const refs = new Map<string, string>();
-
-    beforeAll(async () => {
-      const { stdout, exitCode } = await cli(fixtures, "build", "two-commits");
-      expect(exitCode).toBe(0);
-      expect(stdout).toEndWith("4 prerun images: 4 built, 0 reused\n");
-      // Each permutation's row, by code state and prompt set, and the image it built.
-      for (const [, codeState, promptSet, tag] of stdout.matchAll(/\| (\w+) +\| ([\w-]+) +\|.*\n {4}<prefix>:(\S+) {2}built/g)) {
-        refs.set(`${codeState}/${promptSet}`, prefixed(tag!));
-      }
-      expect(refs.size).toBe(4);
-    }, 300_000);
-
-    test("the first code state: this repository at the first commit, detached, with nothing after it", () => {
-      const ref = refs.get("first/house-style-second")!;
-      expect(inImage(ref, "pwd && git rev-parse HEAD && git rev-parse --abbrev-ref HEAD")).toBe(`/workspace\n${FIRST}\nHEAD`);
-      expect(inImage(ref, "git remote && git for-each-ref refs/heads")).toBe("");
-      expect(inImage(ref, `git log --all --format=%H | grep -c ${SECOND} || true`)).toBe("0");
-      expect(inImage(ref, `ls ${PROJECT}`)).toBe("greet.js\npackage-lock.json\npackage.json\nprompts");
-      // A git identity for the agent.
-      expect(inImage(ref, "git config user.email")).toBe("agent@thunderjar.invalid");
-    });
-
-    test("the second code state: the second commit, with the file it added", () => {
-      const ref = refs.get("second/house-style-first")!;
-      expect(inImage(ref, "git rev-parse HEAD")).toBe(SECOND);
-      expect(inImage(ref, `ls ${PROJECT}/farewell.js && cat ${PROJECT}/greet.js | tail -1`)).toBe(
-        `${PROJECT}/farewell.js\nexport const greet = (name) => \`Hello, \${name}!\`;`,
-      );
-    });
-
-    test("a prompt file is read at its prompt set's commit, never from the worktree", () => {
-      // The prompt set's commit, whichever the code state's is.
-      expect(inImage(refs.get("first/house-style-second")!, "head -1 HOUSE_STYLE.md")).toBe("# House style (second commit)");
-      expect(inImage(refs.get("second/house-style-first")!, "head -1 HOUSE_STYLE.md")).toBe("# House style (first commit)");
-      // The worktree's copy has moved on from both.
-      expect(readTextSync(join(fixtures, "project", "prompts", "house-style.md"))).toStartWith("# House style (worktree");
-    });
-  });
-});