perf(tests): reuse seed git fixtures to cut suite wall time (#1548)

Co-authored-by: Cursor Agent <cursoragent@cursor.com>

Author: kieranklaassen

tests/ce-code-review-mechanics.test.ts

@@ -2,7 +2,9 @@ import { mkdtempSync, mkdirSync, writeFileSync } from "fs"
 import { tmpdir } from "os"
 import path from "path"
 import { spawnSync } from "node:child_process"
-import { describe, expect, test } from "bun:test"
+import { describe, expect, setDefaultTimeout, test } from "bun:test"
+
+setDefaultTimeout(20_000)
 
 const SKILL_DIR = path.join(process.cwd(), "skills", "ce-code-review")
 const SCOPE_SCRIPT = path.join(SKILL_DIR, "scripts", "review-scope.py")

tests/cli.test.ts

@@ -1,9 +1,11 @@
-import { afterAll, describe, expect, test } from "bun:test"
+import { afterAll, describe, expect, setDefaultTimeout, test } from "bun:test"
 import { promises as fs } from "fs"
 import path from "path"
 import os from "os"
 import { materializeClaudePluginFixture } from "./helpers/claude-plugin-fixture"
 
+setDefaultTimeout(20_000)
+
 const fixture = materializeClaudePluginFixture(path.join(import.meta.dir, "fixtures", "sample-plugin"))
 const fixtureRoot = fixture.root
 

tests/codex-dev.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from "bun:test"
+import { afterEach, describe, expect, setDefaultTimeout, test } from "bun:test"
 import { promises as fs } from "node:fs"
 import os from "node:os"
 import path from "node:path"
@@ -21,6 +21,8 @@ import {
   type InstalledPlugin,
 } from "../src/dev/codex-dev"
 
+setDefaultTimeout(20_000)
+
 const tempRoots: string[] = []
 
 afterEach(async () => {

tests/plugin-path.test.ts

@@ -1,9 +1,11 @@
-import { afterAll, describe, expect, test } from "bun:test"
+import { afterAll, describe, expect, setDefaultTimeout, test } from "bun:test"
 import { promises as fs } from "fs"
 import path from "path"
 import os from "os"
 import { materializeClaudePluginFixture } from "./helpers/claude-plugin-fixture"
 
+setDefaultTimeout(20_000)
+
 async function exists(filePath: string): Promise<boolean> {
   try {
     await fs.access(filePath)

tests/skill-eval-cell/extract.test.ts

@@ -1,4 +1,6 @@
-import { afterAll, expect, test } from "bun:test"
+import { afterAll, expect, setDefaultTimeout, test } from "bun:test"
+
+setDefaultTimeout(20_000)
 import { spawnSync } from "node:child_process"
 import fs from "node:fs"
 import path from "node:path"

tests/skill-eval-cell/path-shim.test.ts

@@ -1,4 +1,6 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect, setDefaultTimeout, test } from "bun:test"
+
+setDefaultTimeout(20_000)
 import { spawnSync } from "node:child_process"
 import fs from "node:fs"
 import os from "node:os"

tests/skills/ce-work-cross-model-routes.test.ts

@@ -2,6 +2,7 @@ import { afterAll, describe, expect, setDefaultTimeout, test } from "bun:test"
 import {
   chmodSync,
   copyFileSync,
+  cpSync,
   existsSync,
   mkdirSync,
   mkdtempSync,
@@ -33,32 +34,47 @@ const ROUTE_CONTRACTS = {
   "grok-cursor": { target: "grok", harness: "cursor-agent", intermediaries: ["cursor"], model: "cursor-grok-4.6-high", restriction: "adapter-enforced" },
 } as const
 const roots: string[] = []
+const templateRoots: string[] = []
+let seedCanonical: string | null = null
 
 function temp(prefix: string): string {
   const dir = mkdtempSync(path.join(tmpdir(), prefix))
   roots.push(dir)
   return dir
 }
 
-afterAll(() => roots.forEach((dir) => rmSync(dir, { recursive: true, force: true })))
+afterAll(() => {
+  for (const dir of [...roots, ...templateRoots]) rmSync(dir, { recursive: true, force: true })
+})
+
+function seedCanonicalRepo(): string {
+  if (seedCanonical) return seedCanonical
+  const root = mkdtempSync(path.join(tmpdir(), "ce-work-route-template-"))
+  templateRoots.push(root)
+  const canonical = path.join(root, "canonical")
+  mkdirSync(canonical)
+  mkdirSync(path.join(canonical, "docs", "plans"), { recursive: true })
+  writeFileSync(path.join(canonical, "README.md"), "seed\n")
+  writeFileSync(path.join(canonical, "docs", "plans", "plan.md"), "# Test plan\n")
+  spawnSync("git", ["init", "-q", canonical])
+  spawnSync("git", ["-C", canonical, "config", "user.email", "test@example.com"])
+  spawnSync("git", ["-C", canonical, "config", "user.name", "Test"])
+  spawnSync("git", ["-C", canonical, "add", "."])
+  spawnSync("git", ["-C", canonical, "commit", "-qm", "seed"])
+  seedCanonical = canonical
+  return canonical
+}
 
 function fixture() {
   const root = temp("ce-work-route-")
   const canonical = path.join(root, "canonical")
   const packet = path.join(root, "packet.md")
   const capture = path.join(root, "capture")
   const runs = path.join(root, "runs")
-  mkdirSync(canonical)
+  mkdirSync(root, { recursive: true })
   mkdirSync(capture)
   writeFileSync(packet, "Implement U3 only.\n")
-  spawnSync("git", ["init", "-q", canonical])
-  spawnSync("git", ["-C", canonical, "config", "user.email", "test@example.com"])
-  spawnSync("git", ["-C", canonical, "config", "user.name", "Test"])
-  mkdirSync(path.join(canonical, "docs", "plans"), { recursive: true })
-  writeFileSync(path.join(canonical, "README.md"), "seed\n")
-  writeFileSync(path.join(canonical, "docs", "plans", "plan.md"), "# Test plan\n")
-  spawnSync("git", ["-C", canonical, "add", "."])
-  spawnSync("git", ["-C", canonical, "commit", "-qm", "seed"])
+  cpSync(seedCanonicalRepo(), canonical, { recursive: true })
   return {
     root,
     canonical,
@@ -520,7 +536,7 @@ describe("ce-work fixed write routes", () => {
     const quietBin = temp("ce-work-bin-")
     writeFileSync(path.join(quietBin, "claude"), `#!/bin/sh
 cat > '${quiet.capture}/stdin'
-sleep 2
+sleep 1.1
 exit 7
 `)
     chmodSync(path.join(quietBin, "claude"), 0o755)
@@ -882,14 +898,15 @@ printf '%s' '${prefix}${sentinel}${"y".repeat(maxRawBytes)}'
     const bin = temp("ce-work-bin-")
     writeFileSync(path.join(bin, "claude"), `#!/bin/sh
 cat > '${f.capture}/stdin'
-python3 -c 'import sys; sys.stdout.buffer.write(b"x" * 8388608)'
+python3 -c 'import sys; sys.stdout.buffer.write(b"x" * 65536)'
 `)
     chmodSync(path.join(bin, "claude"), 0o755)
 
     const result = run("claude", f, {
       ...process.env,
       PATH: `${bin}:${process.env.PATH}`,
       CE_WORK_MAX_RAW_BYTES: String(maxRawBytes),
+      CE_WORK_ACTIVITY_POLL_SECS: "1",
     })
 
     expect(result.code).toBe(1)

tests/skills/helpers/ce-work-workspace-harness.ts

@@ -1,7 +1,8 @@
-import { afterEach } from "bun:test"
+import { afterAll, afterEach } from "bun:test"
 import { spawnSync } from "node:child_process"
 import {
   chmodSync,
+  cpSync,
   existsSync,
   linkSync,
   mkdtempSync,
@@ -24,6 +25,12 @@ import { createHash } from "node:crypto"
 export const SCRIPT = path.join(__dirname, "../../../skills/ce-work/scripts/unit-workspace.py")
 export const ADAPTER = path.join(__dirname, "../../../skills/ce-work/scripts/cross-model-work.sh")
 const roots: string[] = []
+const templateRoots: string[] = []
+const seedTemplates = new Map<string, { repo: string; digest: string; base: string }>()
+
+afterAll(() => {
+  for (const root of templateRoots.splice(0)) rmSync(root, { recursive: true, force: true })
+})
 
 export function tmp(prefix: string): string {
   const root = mkdtempSync(path.join(tmpdir(), prefix))
@@ -41,8 +48,12 @@ export function git(cwd: string, ...args: string[]): string {
   return sh(cwd, ["git", ...args]).stdout.trim()
 }
 
-export function makeRepo(objectFormat: "sha1" | "sha256" = "sha1"): { repo: string; plan: string; digest: string; base: string } {
-  const repo = path.join(tmp("ce-work-repo-"), "repo")
+function seedTemplate(objectFormat: "sha1" | "sha256"): { repo: string; digest: string; base: string } {
+  const cached = seedTemplates.get(objectFormat)
+  if (cached) return cached
+  const root = mkdtempSync(path.join(tmpdir(), "ce-work-repo-template-"))
+  templateRoots.push(root)
+  const repo = path.join(root, "repo")
   mkdirSync(repo)
   git(repo, "init", `--object-format=${objectFormat}`, "-b", "main")
   git(repo, "config", "user.name", "CE Work Test")
@@ -56,8 +67,26 @@ export function makeRepo(objectFormat: "sha1" | "sha256" = "sha1"): { repo: stri
   writeFileSync(plan, "# Plan\n")
   git(repo, "add", ".")
   git(repo, "commit", "-m", "seed")
-  const digest = createHash("sha256").update(readFileSync(plan)).digest("hex")
-  return { repo, plan, digest, base: git(repo, "rev-parse", "HEAD") }
+  const template = {
+    repo,
+    digest: createHash("sha256").update(readFileSync(plan)).digest("hex"),
+    base: git(repo, "rev-parse", "HEAD"),
+  }
+  seedTemplates.set(objectFormat, template)
+  return template
+}
+
+export function makeRepo(objectFormat: "sha1" | "sha256" = "sha1"): { repo: string; plan: string; digest: string; base: string } {
+  const template = seedTemplate(objectFormat)
+  const repo = path.join(tmp("ce-work-repo-"), "repo")
+  mkdirSync(path.dirname(repo), { recursive: true })
+  cpSync(template.repo, repo, { recursive: true })
+  return {
+    repo,
+    plan: path.join(repo, "docs", "plans", "plan.md"),
+    digest: template.digest,
+    base: template.base,
+  }
 }
 
 export function packetFile(content: string): string {