@cueloop/daemon 0.1.0-alpha.9 → 0.1.0-alpha.90

package/src/harness-delivery.test.ts

@@ -0,0 +1,268 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DaemonCore } from "./api";
+import { harnessStatePath } from "./paths";
+
+let home: string;
+let cores: DaemonCore[];
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-harness-delivery-"));
+  cores = [];
+});
+
+afterEach(() => {
+  for (const core of cores) core.dispose();
+  rmSync(home, { recursive: true, force: true });
+});
+
+function core(): DaemonCore {
+  const instance = new DaemonCore(home);
+
+  cores.push(instance);
+
+  return instance;
+}
+
+function createPlan(instance: DaemonCore) {
+  return instance.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan", meta: {} },
+  });
+}
+
+describe("durable harness delivery", () => {
+  test("delivers Comment without resolving the Thread", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    const sent = instance.sessionSendMessage(thread.id, "comment", "Interim note.");
+    const pending = instance.deliveryPending(binding.id);
+
+    expect(sent.status).toBe("pending");
+    expect(pending).toHaveLength(1);
+    expect(pending[0]!.message.outcome).toBe("comment");
+  });
+
+  test("reload finds only bindings for the active harness conversation", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const current = first.harnessBind({
+      threadId: thread.id,
+      harness: "pi",
+      harnessSessionId: "pi-current",
+    });
+
+    first.harnessBind({ threadId: thread.id, harness: "pi", harnessSessionId: "pi-other" });
+    first.harnessBind({ threadId: thread.id, harness: "codex", harnessSessionId: "pi-current" });
+
+    expect(core().harnessBindingsForSession("pi", "pi-current")).toEqual([current]);
+  });
+
+  test("Thread deletion removes pi, Codex, and Claude harness state", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const bindings = ["pi", "codex", "claude-code"].map((harness) =>
+      instance.harnessBind({
+        threadId: thread.id,
+        harness,
+        harnessSessionId: `${harness}-session`,
+      }),
+    );
+
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+    const deliveryId = instance.deliveryPending(bindings[0]!.id)[0]!.delivery.id;
+
+    instance.sessionDelete(thread.id);
+
+    for (const [index, harness] of ["pi", "codex", "claude-code"].entries()) {
+      expect(instance.harnessBindingsForSession(harness, `${harness}-session`)).toEqual([]);
+      expect(() => instance.harnessGetBinding(bindings[index]!.id)).toThrow("no harness binding");
+    }
+    expect(() => instance.deliveryAcknowledge(deliveryId)).toThrow("no delivery");
+  });
+
+  test("startup removes harness state orphaned by an older deletion", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "codex",
+      harnessSessionId: "codex-orphan",
+    });
+
+    first.sessionSendMessage(thread.id, "approved", "Ready.");
+    const deliveryId = first.deliveryPending(binding.id)[0]!.delivery.id;
+
+    first.store.delete(thread.id);
+    const restarted = core();
+
+    expect(restarted.harnessBindingsForSession("codex", "codex-orphan")).toEqual([]);
+    expect(() => restarted.harnessGetBinding(binding.id)).toThrow("no harness binding");
+    expect(() => restarted.deliveryAcknowledge(deliveryId)).toThrow("no delivery");
+  });
+
+  test("redelivers after reload until the harness acknowledges the Message", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const sent = first.sessionSendMessage(thread.id, "changes_requested", "Add detail.");
+    const initial = first.deliveryPending(binding.id);
+
+    expect(initial).toHaveLength(1);
+    expect(initial[0]!.message).toEqual(sent.message!);
+
+    const reloaded = core();
+    const redelivered = reloaded.deliveryPending(binding.id);
+
+    expect(redelivered).toEqual(initial);
+    reloaded.deliveryAcknowledge(redelivered[0]!.delivery.id);
+
+    expect(core().deliveryPending(binding.id)).toEqual([]);
+  });
+
+  test("retains an expired Thread until its pending Message is acknowledged", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    first.sessionSendMessage(thread.id, "approved", "Ready.");
+    const oldThread = first.sessionGet(thread.id);
+
+    first.store.upsert({ ...oldThread, createdAt: "2020-01-01T00:00:00.000Z" });
+
+    const reloaded = core();
+    const delivery = reloaded.deliveryPending(binding.id)[0];
+
+    expect(delivery?.message.body).toContain("Ready.");
+    reloaded.deliveryAcknowledge(delivery!.delivery.id);
+
+    expect(core().store.get(thread.id)).toBeUndefined();
+  });
+
+  test("rebuilds a delivery if the Thread saved its Message before enqueue", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const sent = first.sessionSendMessage(thread.id, "approved", "Ready.");
+    first.store.upsert({
+      ...first.sessionGet(thread.id),
+      createdAt: "2020-01-01T00:00:00.000Z",
+    });
+
+    writeFileSync(harnessStatePath(home), JSON.stringify({ bindings: [binding], deliveries: [] }));
+
+    const recovered = core().deliveryPending(binding.id);
+
+    expect(recovered).toHaveLength(1);
+    expect(recovered[0]!.message).toEqual(sent.message!);
+  });
+
+  test("routes an approved retry as a new Message", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    instance.sessionSendMessage(thread.id, "changes_requested", "Try once more.");
+    const first = instance.deliveryPending(binding.id)[0]!;
+
+    instance.deliveryAcknowledge(first.delivery.id);
+    instance.sessionSubmitRevision(thread.id, "# Plan");
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+    const retry = instance.deliveryPending(binding.id);
+
+    expect(retry).toHaveLength(1);
+    expect(retry[0]!.message.outcome).toBe("approved");
+    expect(retry[0]!.message.id).not.toBe(first.message.id);
+  });
+
+  test("keeps an older pending Message available after a Thread revision", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    instance.sessionSendMessage(thread.id, "changes_requested", "Add detail.");
+    const first = instance.deliveryPending(binding.id)[0]!;
+
+    instance.sessionSubmitRevision(thread.id, "# Revised plan");
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+
+    const pending = core().deliveryPending(binding.id);
+
+    expect(pending.map((item) => item.message.id)).toEqual([first.message.id, expect.any(String)]);
+    expect(pending[0]!.message.body).toBe(first.message.body);
+  });
+
+  test("defaults delivery to the submitting binding only", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const submitter = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const other = instance.harnessBind({
+      threadId: thread.id,
+      harness: "other",
+      harnessSessionId: "other_1",
+    });
+
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+
+    expect(instance.deliveryPending(submitter.id)).toHaveLength(1);
+    expect(instance.deliveryPending(other.id)).toEqual([]);
+  });
+
+  test("consumes the unchanged approved retry once across daemon reload", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const sent = instance.sessionSendMessage(thread.id, "approved", "Ready.");
+    const messageId = sent.message!.id;
+
+    expect(() => instance.harnessConsumeApprovedRetry(binding.id, messageId, "# Plan")).toThrow(
+      "no unchanged approved plan",
+    );
+
+    const delivery = instance.deliveryPending(binding.id)[0]!.delivery;
+
+    instance.deliveryAcknowledge(delivery.id);
+
+    expect(instance.harnessConsumeApprovedRetry(binding.id, messageId, "# Plan")).toBe(true);
+    expect(core().harnessConsumeApprovedRetry(binding.id, messageId, "# Plan")).toBe(false);
+    expect(() => core().harnessConsumeApprovedRetry(binding.id, messageId, "# Changed")).toThrow(
+      "no unchanged approved plan",
+    );
+  });
+});

package/src/harness-state-store.test.ts

@@ -0,0 +1,93 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { HarnessStateStore } from "./harness-state-store";
+import { harnessStatePath } from "./paths";
+
+let home: string;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-harness-state-"));
+});
+
+afterEach(() => {
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("HarnessStateStore", () => {
+  test("redelivers an unacknowledged Message after reload", () => {
+    const store = new HarnessStateStore(home);
+    const binding = store.bind({
+      threadId: "ses_1",
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const delivery = store.enqueue({ bindingId: binding.id, messageId: "msg_1" });
+
+    expect(store.pending(binding.id)).toEqual([delivery]);
+
+    const reloaded = new HarnessStateStore(home);
+
+    expect(reloaded.pending(binding.id)).toEqual([delivery]);
+  });
+
+  test("does not redeliver an acknowledged Message", () => {
+    const store = new HarnessStateStore(home);
+    const binding = store.bind({
+      threadId: "ses_1",
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const delivery = store.enqueue({ bindingId: binding.id, messageId: "msg_1" });
+
+    store.acknowledge(delivery.id, "2026-09-20T20:00:00.000Z");
+
+    expect(new HarnessStateStore(home).pending(binding.id)).toEqual([]);
+  });
+
+  test("reuses the binding for the same harness session and thread", () => {
+    const store = new HarnessStateStore(home);
+    const input = {
+      threadId: "ses_1",
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    };
+
+    expect(store.bind(input)).toEqual(store.bind(input));
+  });
+
+  test("deletes every harness binding and delivery for a Thread", () => {
+    const store = new HarnessStateStore(home);
+    const bindings = ["pi", "codex", "claude-code"].map((harness) =>
+      store.bind({ threadId: "ses_1", harness, harnessSessionId: `${harness}_1` }),
+    );
+    const deliveries = bindings.map((binding, index) =>
+      store.enqueue({ bindingId: binding.id, messageId: `msg_${index}` }),
+    );
+
+    expect(store.deleteThreadState("ses_1")).toBeTrue();
+    expect(store.deleteThreadState("ses_1")).toBeFalse();
+    const reloaded = new HarnessStateStore(home);
+
+    for (const binding of bindings) expect(reloaded.binding(binding.id)).toBeNull();
+    for (const delivery of deliveries) expect(reloaded.delivery(delivery.id)).toBeNull();
+  });
+
+  test("deletes state for Threads missing at startup", () => {
+    const store = new HarnessStateStore(home);
+
+    store.bind({ threadId: "ses_kept", harness: "pi", harnessSessionId: "pi_1" });
+    store.bind({ threadId: "ses_orphan", harness: "codex", harnessSessionId: "codex_1" });
+
+    expect(store.deleteOrphanedThreadState(new Set(["ses_kept"]))).toEqual(["ses_orphan"]);
+    expect(store.bindingsForSession("pi", "pi_1")).toHaveLength(1);
+    expect(store.bindingsForSession("codex", "codex_1")).toEqual([]);
+  });
+
+  test("does not discard pending deliveries when persisted state is corrupt", () => {
+    writeFileSync(harnessStatePath(home), "{broken");
+
+    expect(() => new HarnessStateStore(home)).toThrow();
+  });
+});

package/src/harness-state-store.ts

@@ -0,0 +1,213 @@
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import type { Delivery, HarnessBinding } from "@cueloop/schema";
+import * as v from "valibot";
+import { harnessStatePath } from "./paths";
+import { DeliverySchema, HarnessBindingSchema } from "./validate";
+
+type BindInput = Pick<HarnessBinding, "threadId" | "harness" | "harnessSessionId">;
+type EnqueueInput = Pick<Delivery, "bindingId" | "messageId">;
+
+const HarnessStateSchema = v.object({
+  bindings: v.array(HarnessBindingSchema),
+  deliveries: v.array(DeliverySchema),
+});
+const FileErrorSchema = v.object({ code: v.string() });
+
+export class HarnessStateStore {
+  private readonly path: string;
+  private bindings = new Map<string, HarnessBinding>();
+  private deliveries = new Map<string, Delivery>();
+
+  constructor(home: string) {
+    this.path = harnessStatePath(home);
+    this.load();
+  }
+
+  bind(input: BindInput): HarnessBinding {
+    const existing = [...this.bindings.values()].find(
+      (binding) =>
+        binding.threadId === input.threadId &&
+        binding.harness === input.harness &&
+        binding.harnessSessionId === input.harnessSessionId,
+    );
+
+    if (existing) return existing;
+    const binding: HarnessBinding = {
+      ...input,
+      id: newRoutingId("bind"),
+      createdAt: new Date().toISOString(),
+    };
+
+    this.bindings.set(binding.id, binding);
+    this.persist();
+
+    return binding;
+  }
+
+  binding(id: string): HarnessBinding | null {
+    return this.bindings.get(id) ?? null;
+  }
+
+  bindingsForSession(harness: string, harnessSessionId: string): HarnessBinding[] {
+    return [...this.bindings.values()].filter(
+      (binding) => binding.harness === harness && binding.harnessSessionId === harnessSessionId,
+    );
+  }
+
+  deleteThreadState(threadId: string): boolean {
+    const bindingIds = new Set(
+      [...this.bindings.values()]
+        .filter((binding) => binding.threadId === threadId)
+        .map((binding) => binding.id),
+    );
+
+    return this.deleteBindingsAndDeliveries(bindingIds);
+  }
+
+  deleteOrphanedThreadState(existingThreadIds: ReadonlySet<string>): string[] {
+    const orphanedBindings = [...this.bindings.values()].filter(
+      (binding) => !existingThreadIds.has(binding.threadId),
+    );
+    const orphanedThreadIds = [...new Set(orphanedBindings.map((binding) => binding.threadId))];
+
+    this.deleteBindingsAndDeliveries(new Set(orphanedBindings.map((binding) => binding.id)));
+
+    return orphanedThreadIds;
+  }
+
+  private deleteBindingsAndDeliveries(bindingIds: ReadonlySet<string>): boolean {
+    if (bindingIds.size === 0) return false;
+    for (const bindingId of bindingIds) this.bindings.delete(bindingId);
+    for (const delivery of this.deliveries.values()) {
+      if (bindingIds.has(delivery.bindingId)) this.deliveries.delete(delivery.id);
+    }
+    this.persist();
+
+    return true;
+  }
+
+  consumeApprovedRetry(bindingId: string, messageId: string): boolean {
+    const binding = this.bindings.get(bindingId);
+
+    if (!binding) throw new Error(`no harness binding ${bindingId}`);
+
+    if (binding.approvedRetryMessageId === messageId) return false;
+
+    this.bindings.set(bindingId, { ...binding, approvedRetryMessageId: messageId });
+    this.persist();
+
+    return true;
+  }
+
+  /** The first binding is the submitter; other bindings need explicit future routing. */
+  submittingBinding(threadId: string): HarnessBinding | null {
+    return [...this.bindings.values()].find((binding) => binding.threadId === threadId) ?? null;
+  }
+
+  enqueue(input: EnqueueInput): Delivery {
+    const existing = [...this.deliveries.values()].find(
+      (delivery) =>
+        delivery.bindingId === input.bindingId && delivery.messageId === input.messageId,
+    );
+
+    if (existing) return existing;
+    const delivery: Delivery = {
+      ...input,
+      id: newRoutingId("del"),
+      status: "pending",
+      createdAt: new Date().toISOString(),
+    };
+
+    this.deliveries.set(delivery.id, delivery);
+    this.persist();
+
+    return delivery;
+  }
+
+  pending(bindingId: string): Delivery[] {
+    return [...this.deliveries.values()].filter(
+      (delivery) => delivery.bindingId === bindingId && delivery.status === "pending",
+    );
+  }
+
+  /** A pending delivery keeps its Thread's immutable Message body available for redelivery. */
+  pendingThreadIds(): Set<string> {
+    const ids = new Set<string>();
+
+    for (const delivery of this.deliveries.values()) {
+      if (delivery.status !== "pending") continue;
+      const binding = this.bindings.get(delivery.bindingId);
+
+      if (binding) ids.add(binding.threadId);
+    }
+
+    return ids;
+  }
+
+  acknowledged(bindingId: string, messageId: string): boolean {
+    return [...this.deliveries.values()].some(
+      (delivery) =>
+        delivery.bindingId === bindingId &&
+        delivery.messageId === messageId &&
+        delivery.status === "acknowledged",
+    );
+  }
+
+  delivery(deliveryId: string): Delivery | null {
+    return this.deliveries.get(deliveryId) ?? null;
+  }
+
+  acknowledge(deliveryId: string, acknowledgedAt = new Date().toISOString()): Delivery {
+    const delivery = this.deliveries.get(deliveryId);
+
+    if (!delivery) throw new Error(`no delivery ${deliveryId}`);
+
+    if (delivery.status === "acknowledged") return delivery;
+    const acknowledged: Delivery = {
+      ...delivery,
+      status: "acknowledged",
+      acknowledgedAt,
+    };
+
+    this.deliveries.set(deliveryId, acknowledged);
+    this.persist();
+
+    return acknowledged;
+  }
+
+  private load(): void {
+    let serialized: string;
+
+    try {
+      serialized = readFileSync(this.path, "utf8");
+    } catch (error) {
+      const parsed = v.safeParse(FileErrorSchema, error);
+
+      if (parsed.success && parsed.output.code === "ENOENT") {
+        return;
+      }
+
+      throw error;
+    }
+
+    const state = v.parse(HarnessStateSchema, JSON.parse(serialized));
+
+    this.bindings = new Map(state.bindings.map((binding) => [binding.id, binding]));
+    this.deliveries = new Map(state.deliveries.map((delivery) => [delivery.id, delivery]));
+  }
+
+  private persist(): void {
+    const temporaryPath = this.path + ".tmp";
+    const state = {
+      bindings: [...this.bindings.values()],
+      deliveries: [...this.deliveries.values()],
+    };
+
+    writeFileSync(temporaryPath, JSON.stringify(state, null, 2));
+    renameSync(temporaryPath, this.path);
+  }
+}
+
+function newRoutingId(prefix: "bind" | "del"): string {
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}

package/src/herdr-split.test.ts

@@ -0,0 +1,106 @@
+/** launchHarnessInSplit: a stubbed herdr binary logs its argv, and the launcher splits the current pane, runs the harness in the new pane, and optionally types the plan-context seed - a no-op outside herdr. */
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { launchHarnessInSplit } from "./herdr-split";
+
+const dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-split-"));
+
+/** A stub herdr binary that logs argv and prints the pane-split result (pane_id of the new split). */
+function makeStub(name: string, splitOk = true) {
+  const logPath = join(dir, `${name}.log`);
+  const binPath = join(dir, `${name}.sh`);
+  const splitResult = splitOk
+    ? `printf '{"result":{"pane":{"pane_id":"w1:p9"}}}'`
+    : `printf '{"result":{}}'`;
+
+  writeFileSync(
+    binPath,
+    `#!/bin/sh
+printf '%s\\n' "$*" >> "${logPath}"
+if [ "$1" = "pane" ] && [ "$2" = "split" ]; then ${splitResult}; fi
+exit 0
+`,
+  );
+  chmodSync(binPath, 0o755);
+
+  return { binPath, logPath };
+}
+
+function readLines(logPath: string): string[] {
+  if (!existsSync(logPath)) return [];
+
+  return readFileSync(logPath, "utf8").split("\n").filter(Boolean);
+}
+
+describe("launchHarnessInSplit", () => {
+  test("splits the current pane and runs the harness in the new pane", () => {
+    // Arrange
+    const stub = makeStub("run");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+
+    // Act
+    const launched = launchHarnessInSplit({ command: "cc", cwd: "/repo/work" }, env);
+
+    // Assert
+    expect(launched).toBeTrue();
+    expect(readLines(stub.logPath)).toEqual([
+      "pane split w1:p1 --direction right --ratio 0.4 --cwd /repo/work",
+      "pane send-text w1:p9 cc",
+      "pane send-keys w1:p9 enter",
+    ]);
+  });
+
+  test("types the plan-context seed into the split after launching", () => {
+    // Arrange
+    const stub = makeStub("seeded");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+
+    // Act
+    launchHarnessInSplit({ command: "pi", cwd: "/repo", seedText: "read plan ses_1" }, env);
+
+    // Assert
+    expect(readLines(stub.logPath)).toEqual([
+      "pane split w1:p1 --direction right --ratio 0.4 --cwd /repo",
+      "pane send-text w1:p9 pi",
+      "pane send-keys w1:p9 enter",
+      "pane send-text w1:p9 read plan ses_1",
+    ]);
+  });
+
+  test("no-op outside herdr - returns false and spawns nothing", () => {
+    // Arrange
+    const stub = makeStub("outside");
+
+    // Act
+    const launched = launchHarnessInSplit(
+      { command: "cc", cwd: "/repo" },
+      { HERDR_BIN_PATH: stub.binPath },
+    );
+
+    // Assert
+    expect(launched).toBeFalse();
+    expect(existsSync(stub.logPath)).toBeFalse();
+  });
+
+  test("returns false when the split yields no pane id", () => {
+    // Arrange
+    const stub = makeStub("nopane", false);
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+
+    // Act
+    const launched = launchHarnessInSplit({ command: "cc", cwd: "/repo" }, env);
+
+    // Assert - the split ran but no harness was launched into a missing pane
+    expect(launched).toBeFalse();
+    expect(readLines(stub.logPath)).toEqual([
+      "pane split w1:p1 --direction right --ratio 0.4 --cwd /repo",
+    ]);
+  });
+});
+
+afterAll(() => {
+  rmSync(dir, { recursive: true, force: true, maxRetries: 3 });
+});